{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 24,
      "metadata": {
        "cellView": "form",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "a5o-b8uYkdun",
        "outputId": "fc27e9b6-36d3-45a6-b3f6-da7cf8976a18"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: tf_gnns in /usr/local/lib/python3.11/dist-packages (0.1.7)\n"
          ]
        }
      ],
      "source": [
        "!pip install tf_gnns\n",
        "!pip install --quiet 'networkx<3'"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 25,
      "metadata": {
        "cellView": "form",
        "id": "kL37wyGwkmvX"
      },
      "outputs": [],
      "source": [
        "#@title ##### `tf_gnns` license\n",
        "# Copyright 2021, Mylonas Charilaos. All Rights Reserved.\n",
        "#\n",
        "# Licensed under the Apache License, Version 2.0 (the \"License\");\n",
        "# you may not use this file except in compliance with the License.\n",
        "# You may obtain a copy of the License at\n",
        "#\n",
        "#    http://www.apache.org/licenses/LICENSE-2.0\n",
        "#\n",
        "# Unless required by applicable law or agreed to in writing, software\n",
        "# distributed under the License is distributed on an \"AS IS\" BASIS,\n",
        "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or  implied.\n",
        "# See the License for the specific language governing permissions and\n",
        "# limitations under the License.\n",
        "# ============================================================================\n",
        "\n",
        "\n",
        "# ##### `DeepMind GraphNets` license\n",
        "# Copyright 2018 The GraphNets Authors. All Rights Reserved.\n",
        "#\n",
        "# Licensed under the Apache License, Version 2.0 (the \"License\");\n",
        "# you may not use this file except in compliance with the License.\n",
        "# You may obtain a copy of the License at\n",
        "#\n",
        "#    http://www.apache.org/licenses/LICENSE-2.0\n",
        "#\n",
        "# Unless required by applicable law or agreed to in writing, software\n",
        "# distributed under the License is distributed on an \"AS IS\" BASIS,\n",
        "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or  implied.\n",
        "# See the License for the specific language governing permissions and\n",
        "# limitations under the License.\n",
        "# ============================================================================\n",
        "\n",
        "###############################################################################\n",
        "# Changes to the original file:\n",
        "# ------------------------------\n",
        "# This notebook is a modified version of the `deepmind/graph_nets` example code\n",
        "# which demonstrates the use of graph nets to list sorting. The parts of code\n",
        "# from the original file are the sampling of GraphTuples which contain the input\n",
        "# and output graphs. The parts that are different are the parts needed to use\n",
        "# the tf_gnns library instead of the graph nets. More speciffically, a function\n",
        "# that casts graphtuples to tensor_dicts is created, and an EncodeProcessDecode\n",
        "# network almost identical to the one used in the paper is created.\n",
        "# Visualization is also different from the original file, yet very similar.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RwPNgY5llFZk"
      },
      "source": [
        "# List sorting with GNNs\n",
        "A large part of the code for this example is taken from the [deepmind/graph_nets](https://github.com/deepmind/graph_nets/blob/master/graph_nets/) library (the Apache licence of `graph_nets` is also attached). In this notebook, the exact code that generates the data used in the DeepMind `graph_nets` example is used, but the GN used for processing is usgin the `tf_gnns` functionality (no tf 1.x or Sonnet)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 26,
      "metadata": {
        "cellView": "form",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "m-xnfADflH5n",
        "outputId": "ecfa6b89-9619-4b6f-8696-ae7bf07333c5"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Installing Graph Nets library and dependencies:\n",
            "Output message from command:\n",
            "\n",
            "Requirement already satisfied: graph_nets>=1.1 in /usr/local/lib/python3.11/dist-packages (1.1.0)\n",
            "Requirement already satisfied: dm-sonnet>=2.0.0b0 in /usr/local/lib/python3.11/dist-packages (2.0.2)\n",
            "Requirement already satisfied: absl-py in /usr/local/lib/python3.11/dist-packages (from graph_nets>=1.1) (1.4.0)\n",
            "Requirement already satisfied: dm-tree in /usr/local/lib/python3.11/dist-packages (from graph_nets>=1.1) (0.1.9)\n",
            "Requirement already satisfied: future in /usr/local/lib/python3.11/dist-packages (from graph_nets>=1.1) (1.0.0)\n",
            "Requirement already satisfied: networkx in /usr/local/lib/python3.11/dist-packages (from graph_nets>=1.1) (2.8.8)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.11/dist-packages (from graph_nets>=1.1) (2.0.2)\n",
            "Requirement already satisfied: setuptools in /usr/local/lib/python3.11/dist-packages (from graph_nets>=1.1) (75.2.0)\n",
            "Requirement already satisfied: six in /usr/local/lib/python3.11/dist-packages (from graph_nets>=1.1) (1.17.0)\n",
            "Requirement already satisfied: tabulate>=0.7.5 in /usr/local/lib/python3.11/dist-packages (from dm-sonnet>=2.0.0b0) (0.9.0)\n",
            "Requirement already satisfied: wrapt>=1.11.1 in /usr/local/lib/python3.11/dist-packages (from dm-sonnet>=2.0.0b0) (1.17.2)\n",
            "Requirement already satisfied: attrs>=18.2.0 in /usr/local/lib/python3.11/dist-packages (from dm-tree->graph_nets>=1.1) (25.3.0)\n"
          ]
        }
      ],
      "source": [
        "install_graph_nets_library = \"Yes\"  #@param [\"Yes\", \"No\"]\n",
        "\n",
        "if install_graph_nets_library.lower() == \"yes\":\n",
        "  print(\"Installing Graph Nets library and dependencies:\")\n",
        "  print(\"Output message from command:\\n\")\n",
        "  !pip install \"graph_nets>=1.1\" \"dm-sonnet>=2.0.0b0\"\n",
        "else:\n",
        "  print(\"Skipping installation of Graph Nets library\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 27,
      "metadata": {
        "id": "CZ_q7g_OlJDa"
      },
      "outputs": [],
      "source": [
        "#@title Imports\n",
        "\n",
        "## Needed for manipulating the samplers from the graph_nets library (and making\n",
        "#  a 1-to-1 comparisson of the two frameworks)\n",
        "\n",
        "from graph_nets import utils_np\n",
        "from graph_nets import utils_tf\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "import tensorflow as tf\n",
        "\n",
        "from tf_gnns.models.graphnet import GraphNetMLP, GNCellMLP, GraphIndep\n",
        "import tensorflow as tf\n",
        "\n",
        "SEED = 1\n",
        "np.random.seed(SEED)\n",
        "tf.random.set_seed(SEED)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 27,
      "metadata": {
        "id": "KpDbLnPs15PZ"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "code",
      "execution_count": 28,
      "metadata": {
        "cellView": "form",
        "id": "VtKMsM0ElM4D"
      },
      "outputs": [],
      "source": [
        "#@title Helper functions  { form-width: \"30%\" }\n",
        "\n",
        "# pylint: disable=redefined-outer-name\n",
        "\n",
        "def create_graph_dicts_tf(num_examples, num_elements_min_max):\n",
        "  \"\"\"Generate graphs for training.\n",
        "\n",
        "  Args:\n",
        "    num_examples: total number of graphs to generate\n",
        "    num_elements_min_max: a 2-tuple with the minimum and maximum number of\n",
        "      values allowable in a graph. The number of values for a graph is\n",
        "      uniformly sampled withing this range. The upper bound is exclusive, and\n",
        "      should be at least 2 more than the lower bound.\n",
        "\n",
        "  Returns:\n",
        "    inputs: contains the generated random numbers as node values.\n",
        "    sort_indices: contains the sorting indices as nodes. Concretely\n",
        "      inputs.nodes[sort_indices.nodes] will be a sorted array.\n",
        "    ranks: the rank of each value in inputs normalized to the range [0, 1].\n",
        "  \"\"\"\n",
        "  num_elements = tf.random.uniform(\n",
        "      [num_examples],\n",
        "      minval=num_elements_min_max[0],\n",
        "      maxval=num_elements_min_max[1],\n",
        "      dtype=tf.int32)\n",
        "  inputs_graphs = []\n",
        "  sort_indices_graphs = []\n",
        "  ranks_graphs = []\n",
        "  for i in range(num_examples):\n",
        "    values = tf.random.uniform(shape=[num_elements[i]])\n",
        "    sort_indices = tf.cast(\n",
        "        tf.argsort(values, axis=-1), tf.float32)\n",
        "    ranks = tf.cast(\n",
        "        tf.argsort(sort_indices, axis=-1), tf.float32) / (\n",
        "            tf.cast(num_elements[i], tf.float32) - 1.0)\n",
        "    inputs_graphs.append({\"nodes\": values[:, None]})\n",
        "    sort_indices_graphs.append({\"nodes\": sort_indices[:, None]})\n",
        "    ranks_graphs.append({\"nodes\": ranks[:, None]})\n",
        "  return inputs_graphs, sort_indices_graphs, ranks_graphs\n",
        "\n",
        "\n",
        "def create_linked_list_target(batch_size, input_graphs):\n",
        "  \"\"\"Creates linked list targets.\n",
        "\n",
        "  Returns a graph with the same number of nodes as `input_graph`. Each node\n",
        "  contains a 2d vector with targets for a 1-class classification where only one\n",
        "  node is `True`, the smallest value in the array. The vector contains two\n",
        "  values: [prob_true, prob_false].\n",
        "  It also contains edges connecting all nodes. These are again 2d vectors with\n",
        "  softmax targets [prob_true, prob_false]. An edge is True\n",
        "  if n+1 is the element immediately after n in the sorted list.\n",
        "\n",
        "  Args:\n",
        "    batch_size: batch size for the `input_graphs`.\n",
        "    input_graphs: a `graphs.GraphsTuple` which contains a batch of inputs.\n",
        "\n",
        "  Returns:\n",
        "    A `graphs.GraphsTuple` with the targets, which encode the linked list.\n",
        "  \"\"\"\n",
        "  target_graphs = []\n",
        "  for i in range(batch_size):\n",
        "    input_graph = utils_tf.get_graph(input_graphs, i)\n",
        "    num_elements = tf.shape(input_graph.nodes)[0]\n",
        "    si = tf.cast(tf.squeeze(input_graph.nodes), tf.int32)\n",
        "    nodes = tf.reshape(tf.one_hot(si[:1], num_elements), (-1, 1))\n",
        "    x = tf.stack((si[:-1], si[1:]))[None]\n",
        "    y = tf.stack(\n",
        "        (input_graph.senders, input_graph.receivers), axis=1)[:, :, None]\n",
        "    edges = tf.reshape(\n",
        "        tf.cast(\n",
        "            tf.reduce_any(tf.reduce_all(tf.equal(x, y), axis=1), axis=1),\n",
        "            tf.float32), (-1, 1))\n",
        "    target_graphs.append(input_graph._replace(nodes=nodes, edges=edges))\n",
        "  return utils_tf.concat(target_graphs, axis=0)\n",
        "\n",
        "\n",
        "def compute_accuracy(target, output):\n",
        "  \"\"\"Calculate model accuracy.\n",
        "\n",
        "  Returns the number of correctly predicted links and the number\n",
        "  of completely solved list sorts (100% correct predictions).\n",
        "\n",
        "  Args:\n",
        "    target: A `graphs.GraphsTuple` that contains the target graph.\n",
        "    output: A `graphs.GraphsTuple` that contains the output graph.\n",
        "\n",
        "  Returns:\n",
        "    correct: A `float` fraction of correctly labeled nodes/edges.\n",
        "    solved: A `float` fraction of graphs that are completely correctly labeled.\n",
        "  \"\"\"\n",
        "  tdds = utils_np.graphs_tuple_to_data_dicts(target)\n",
        "  odds = utils_np.graphs_tuple_to_data_dicts(output)\n",
        "  cs = []\n",
        "  ss = []\n",
        "  for td, od in zip(tdds, odds):\n",
        "    num_elements = td[\"nodes\"].shape[0]\n",
        "    xn = np.argmax(td[\"nodes\"], axis=-1)\n",
        "    yn = np.argmax(od[\"nodes\"], axis=-1)\n",
        "\n",
        "    xe = np.reshape(\n",
        "        np.argmax(\n",
        "            np.reshape(td[\"edges\"], (num_elements, num_elements, 2)), axis=-1),\n",
        "        (-1,))\n",
        "    ye = np.reshape(\n",
        "        np.argmax(\n",
        "            np.reshape(od[\"edges\"], (num_elements, num_elements, 2)), axis=-1),\n",
        "        (-1,))\n",
        "    c = np.concatenate((xn == yn, xe == ye), axis=0)\n",
        "    s = np.all(c)\n",
        "    cs.append(c)\n",
        "    ss.append(s)\n",
        "  correct = np.mean(np.concatenate(cs, axis=0))\n",
        "  solved = np.mean(np.stack(ss))\n",
        "  return correct, solved\n",
        "\n",
        "\n",
        "def create_data(batch_size, num_elements_min_max):\n",
        "  \"\"\"Returns graphs containing the inputs and targets for classification.\n",
        "\n",
        "  Refer to create_data_dicts_tf and create_linked_list_target for more details.\n",
        "\n",
        "  Args:\n",
        "    batch_size: batch size for the `input_graphs`.\n",
        "    num_elements_min_max: a 2-`tuple` of `int`s which define the [lower, upper)\n",
        "      range of the number of elements per list.\n",
        "\n",
        "  Returns:\n",
        "    inputs: a `graphs.GraphsTuple` which contains the input list as a graph.\n",
        "    targets: a `graphs.GraphsTuple` which contains the target as a graph.\n",
        "    sort_indices: a `graphs.GraphsTuple` which contains the sort indices of\n",
        "      the list elements a graph.\n",
        "    ranks: a `graphs.GraphsTuple` which contains the ranks of the list\n",
        "      elements as a graph.\n",
        "  \"\"\"\n",
        "  inputs, sort_indices, ranks = create_graph_dicts_tf(\n",
        "      batch_size, num_elements_min_max)\n",
        "  inputs = utils_tf.data_dicts_to_graphs_tuple(inputs)\n",
        "  sort_indices = utils_tf.data_dicts_to_graphs_tuple(sort_indices)\n",
        "  ranks = utils_tf.data_dicts_to_graphs_tuple(ranks)\n",
        "\n",
        "  inputs = utils_tf.fully_connect_graph_dynamic(inputs)\n",
        "  sort_indices = utils_tf.fully_connect_graph_dynamic(sort_indices)\n",
        "  ranks = utils_tf.fully_connect_graph_dynamic(ranks)\n",
        "\n",
        "  targets = create_linked_list_target(batch_size, sort_indices)\n",
        "  nodes = tf.concat((targets.nodes, 1.0 - targets.nodes), axis=1)\n",
        "  edges = tf.concat((targets.edges, 1.0 - targets.edges), axis=1)\n",
        "  targets = targets._replace(nodes=nodes, edges=edges)\n",
        "\n",
        "  return inputs, targets, sort_indices, ranks\n",
        "\n",
        "\n",
        "def create_loss(target, outputs):\n",
        "  \"\"\"Returns graphs containing the inputs and targets for classification.\n",
        "\n",
        "  Refer to create_data_dicts_tf and create_linked_list_target for more details.\n",
        "\n",
        "  Args:\n",
        "    target: a `graphs.GraphsTuple` which contains the target as a graph.\n",
        "    outputs: a `list` of `graphs.GraphsTuple`s which contains the model\n",
        "      outputs for each processing step as graphs.\n",
        "\n",
        "  Returns:\n",
        "    A `list` of ops which are the loss for each processing step.\n",
        "  \"\"\"\n",
        "  # if not isinstance(outputs, collections.Sequence):\n",
        "  #   outputs = [outputs]\n",
        "  losss = [\n",
        "      tf.compat.v1.losses.softmax_cross_entropy(target.nodes, output.nodes) +\n",
        "      tf.compat.v1.losses.softmax_cross_entropy(target.edges, output.edges)\n",
        "      for output in outputs\n",
        "  ]\n",
        "  return tf.stack(losss)\n",
        "\n",
        "\n",
        "\n",
        "def plot_linked_list(ax, graph, sort_indices):\n",
        "  \"\"\"Plot a networkx graph containing weights for the linked list probability.\"\"\"\n",
        "  nd = len(graph.nodes())\n",
        "  probs = np.zeros((nd, nd))\n",
        "  for edge in graph.edges(data=True):\n",
        "    probs[edge[0], edge[1]] = edge[2][\"features\"][0]\n",
        "  ax.matshow(probs[sort_indices][:, sort_indices], cmap=\"viridis\")\n",
        "  ax.grid(False)\n",
        "\n",
        "\n",
        "# pylint: enable=redefined-outer-name"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 29,
      "metadata": {
        "cellView": "form",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 611
        },
        "id": "qdT-cxjolP-M",
        "outputId": "a59c9e8d-d322-4c85-9186-6e11e5b8ff0a"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 400x400 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x200 with 3 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "#@title Visualize the sort task  { form-width: \"30%\" }\n",
        "num_elements_min_max = (5, 10)\n",
        "\n",
        "inputs, targets, sort_indices, ranks = create_data(\n",
        "    1, num_elements_min_max)\n",
        "\n",
        "inputs_nodes = inputs.nodes.numpy()\n",
        "targets = utils_tf.nest_to_numpy(targets)\n",
        "sort_indices_nodes = sort_indices.nodes.numpy()\n",
        "ranks_nodes = ranks.nodes.numpy()\n",
        "\n",
        "sort_indices = np.squeeze(sort_indices_nodes).astype(int)\n",
        "\n",
        "# Plot sort linked lists.\n",
        "# The matrix plots show each element from the sorted list (rows), and which\n",
        "# element they link to as next largest (columns). Ground truth is a diagonal\n",
        "# offset toward the upper-right by one.\n",
        "fig = plt.figure(1, figsize=(4, 4))\n",
        "fig.clf()\n",
        "ax = fig.add_subplot(1, 1, 1)\n",
        "plot_linked_list(ax,\n",
        "                 utils_np.graphs_tuple_to_networkxs(targets)[0], sort_indices)\n",
        "ax.set_title(\"Element-to-element links for sorted elements\")\n",
        "ax.set_axis_off()\n",
        "\n",
        "fig = plt.figure(2, figsize=(10, 2))\n",
        "fig.clf()\n",
        "ax1 = fig.add_subplot(1, 3, 1)\n",
        "ax2 = fig.add_subplot(1, 3, 2)\n",
        "ax3 = fig.add_subplot(1, 3, 3)\n",
        "\n",
        "i = 0\n",
        "num_elements = ranks_nodes.shape[0]\n",
        "inputs = np.squeeze(inputs_nodes)\n",
        "ranks = np.squeeze(ranks_nodes * (num_elements - 1.0)).astype(int)\n",
        "x = np.arange(inputs.shape[0])\n",
        "\n",
        "ax1.set_title(\"Inputs\")\n",
        "ax1.barh(x, inputs, color=\"b\")\n",
        "ax1.set_xlim(-0.01, 1.01)\n",
        "\n",
        "ax2.set_title(\"Sorted\")\n",
        "ax2.barh(x, inputs[sort_indices], color=\"k\")\n",
        "ax2.set_xlim(-0.01, 1.01)\n",
        "\n",
        "ax3.set_title(\"Ranks\")\n",
        "ax3.barh(x, ranks, color=\"r\")\n",
        "_ = ax3.set_xlim(0, len(ranks) + 0.5)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 30,
      "metadata": {
        "id": "uZ0o-4iQlTvb"
      },
      "outputs": [],
      "source": [
        "from tf_gnns.lib.gt_ops import _concat_tensordicts\n",
        "from tf_gnns.lib.gt_ops import _add_gt\n",
        "class EncodeProcessDecode(tf.keras.Model):\n",
        "    \"\"\"\n",
        "    The same model as in graph_nets library (16 layer wide, 2-layer ReLU MLPs\n",
        "    with activation at the last layer and layer normalization as MLPs):\n",
        "\n",
        "    Graphic from `graph_nets` library:\n",
        "\n",
        "                        Hidden(t)   Hidden(t+1)\n",
        "                         |            ^\n",
        "            *---------*  |  *------*  |  *---------*\n",
        "            |         |  |  |      |  |  |         |\n",
        "  Input --->| Encoder |  *->| Core |--*->| Decoder |---> Output(t)\n",
        "            |         |---->|      |     |         |\n",
        "            *---------*     *------*     *---------*\n",
        "\n",
        "    In deepmind/graph_nets there is an additional linear GraphIndependent layer\n",
        "    to the decoder with dense MLPs than the ones shown here.\n",
        "    \"\"\"\n",
        "    def __init__(self, num_processing_steps = 10, num_units=16):\n",
        "\n",
        "        super(EncodeProcessDecode,self).__init__()\n",
        "        self.gn_enc = GraphIndep(num_units, gn_mlp_units = [num_units,num_units],\n",
        "                                  layernorm_last_layer = True,\n",
        "                                  activate_last_layer = True)\n",
        "\n",
        "        self.gn_core   = GNCellMLP(num_units, core_size=num_units,\n",
        "                                  aggregation_function = 'sum',\n",
        "                                layernorm_last_layer = True,\n",
        "                                activate_last_layer = True)\n",
        "\n",
        "        # The following two layers are used to make an implementation closer\n",
        "        # to what the deepmind/graph_nets library implements.\n",
        "        # In tf_gnns one may alteratively use a single decoder that outputs\n",
        "        # 2-dim outputs using ... \"gn_mlp_units = [num_units, num_units, 2]\"\n",
        "        self.gn_dec = GraphIndep(num_units,gn_mlp_units = [num_units,num_units],\n",
        "                                 layernorm_last_layer = True,\n",
        "                                  activate_last_layer = True)\n",
        "\n",
        "        self.gn_output_transform = GraphIndep(2, []) # nodes and edges are both with output\n",
        "                                        # size 2.\n",
        "\n",
        "        self.num_processing_steps = num_processing_steps\n",
        "\n",
        "    def call(self, graph_in):\n",
        "\n",
        "        g_ = self.gn_enc(graph_in)\n",
        "        g_0_ = g_.copy()\n",
        "\n",
        "        outputs = [];\n",
        "        for ii in range(self.num_processing_steps):\n",
        "            g_ = self.gn_core(_concat_tensordicts(g_, g_0_))\n",
        "            g_to_dec = self.gn_dec(g_)\n",
        "            outputs.append(self.gn_output_transform(g_to_dec))\n",
        "\n",
        "        return outputs\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 31,
      "metadata": {
        "id": "ET7VvKGKlT5y"
      },
      "outputs": [],
      "source": [
        "#@title Set up model training and evaluation  { form-width: \"30%\" }\n",
        "\n",
        "\n",
        "# Model parameters.\n",
        "# Number of processing (message-passing) steps.\n",
        "num_processing_steps = 10\n",
        "# Data / training parameters.\n",
        "num_training_iterations = 6000\n",
        "batch_size_tr = 32\n",
        "batch_size_ge = 100\n",
        "# Number of elements in each list is sampled uniformly from this range.\n",
        "num_elements_min_max_tr = (8, 17)\n",
        "num_elements_min_max_ge = (16, 33)\n",
        "\n",
        "# Data.\n",
        "if 'get_data' not in  locals().keys():\n",
        "    @tf.function\n",
        "    def get_data():\n",
        "        inputs_tr, targets_tr, sort_indices_tr, _ = create_data(\n",
        "            batch_size_tr, num_elements_min_max_tr)\n",
        "        inputs_tr = utils_tf.set_zero_edge_features(inputs_tr, 1)\n",
        "        inputs_tr = utils_tf.set_zero_global_features(inputs_tr, 1)\n",
        "        # Test/generalization.\n",
        "        inputs_ge, targets_ge, sort_indices_ge, _ = create_data(\n",
        "            batch_size_ge, num_elements_min_max_ge)\n",
        "        inputs_ge = utils_tf.set_zero_edge_features(inputs_ge, 1)\n",
        "        inputs_ge = utils_tf.set_zero_global_features(inputs_ge, 1)\n",
        "\n",
        "        targets_tr = utils_tf.set_zero_global_features(targets_tr, 1)\n",
        "        targets_ge = utils_tf.set_zero_global_features(targets_ge, 1)\n",
        "\n",
        "        return inputs_tr, targets_tr, sort_indices_tr, inputs_ge, targets_ge, sort_indices_ge\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 32,
      "metadata": {
        "id": "prnMotaBxJXF"
      },
      "outputs": [],
      "source": [
        "inputs_tr, targets_tr, sort_indices_tr, inputs_ge, targets_ge, sort_indices_ge = get_data()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 33,
      "metadata": {
        "id": "lY9bUGUVxYT4"
      },
      "outputs": [],
      "source": [
        "def to_tensor_dict(v):\n",
        "    vout = {'senders' : v.senders,\n",
        "    'receivers' : v.receivers,\n",
        "    'edges' : v.edges,\n",
        "    'nodes' : v.nodes,\n",
        "    'n_nodes' : v.n_node,\n",
        "    'n_edges' : v.n_edge,\n",
        "    'global_attr':v.globals,\n",
        "    'global_reps_for_nodes' : tf.repeat(tf.range(v.n_node.shape[0]),v.n_node),\n",
        "    'global_reps_for_edges' : tf.repeat(tf.range(v.n_edge.shape[0]), v.n_edge),\n",
        "    'n_graphs' : tf.shape(v.n_node)[0]\n",
        "    }\n",
        "    return vout\n",
        "\n",
        "def get_data_td():\n",
        "    in_tr, out_tr, sort_tr, in_ge, out_ge, inds_ge = get_data()\n",
        "    return to_tensor_dict(in_tr), to_tensor_dict(out_tr), sort_tr, to_tensor_dict(in_ge), to_tensor_dict(out_ge), inds_ge"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 34,
      "metadata": {
        "id": "Xerm1l8EHwcd"
      },
      "outputs": [],
      "source": [
        "model = EncodeProcessDecode(num_processing_steps=num_processing_steps)\n",
        "\n",
        "in_tr, out_tr, _,_,_,_ = get_data_td()\n",
        "out = model(in_tr)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 35,
      "metadata": {
        "id": "k2uy776FIe_m"
      },
      "outputs": [],
      "source": [
        "losses = []\n",
        "accuracy_train, accuracy_test = [[],[]]\n",
        "opt = tf.keras.optimizers.Adam(learning_rate = 1e-3, epsilon = 1e-8, clipnorm=1.)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 36,
      "metadata": {
        "id": "oDhFYIJxEk5S"
      },
      "outputs": [],
      "source": [
        "def accuracy_correct_sort(nbatches = 1):\n",
        "    \"\"\"\n",
        "    Computes for the train and test set how many complete sequences are correctly\n",
        "    sorted.\n",
        "    \"\"\"\n",
        "    pct_correct_graphs_g = pct_correct_graphs_t = 0.\n",
        "    for tt in range(nbatches):\n",
        "        in_t, out_t, s_t, in_g, out_g, s_g = get_data_td()\n",
        "        out_g_hat = model(in_g)[-1]\n",
        "        out_t_hat = model(in_t)[-1]\n",
        "        pct_correct_graphs_g += tf.reduce_sum(tf.math.unsorted_segment_prod(tf.cast(tf.argmax(out_g_hat['edges'],1) == tf.argmax(out_g['edges'],1), tf.int32),out_g['global_reps_for_edges'], out_g['n_graphs']))/out_g['n_graphs']\n",
        "        pct_correct_graphs_t += tf.reduce_sum(tf.math.unsorted_segment_prod(tf.cast(tf.argmax(out_t_hat['edges'],1) == tf.argmax(out_t['edges'],1), tf.int32),out_t['global_reps_for_edges'], out_t['n_graphs']))/out_t['n_graphs']\n",
        "    return pct_correct_graphs_g/nbatches, pct_correct_graphs_t/nbatches\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 37,
      "metadata": {
        "id": "RoRZOEKox1KW"
      },
      "outputs": [],
      "source": [
        "import IPython\n",
        "@tf.function\n",
        "def eval_loss(input, target):\n",
        "    out = model(input)\n",
        "    edge_loss = 0.\n",
        "    node_loss = 0.\n",
        "    for o in out:\n",
        "        edge_loss += tf.nn.softmax_cross_entropy_with_logits(target['edges'],o['edges'])\n",
        "        node_loss += tf.nn.softmax_cross_entropy_with_logits(target['nodes'],o['nodes'])\n",
        "    return tf.reduce_mean(node_loss) + tf.reduce_mean(edge_loss)\n",
        "\n",
        "@tf.function\n",
        "def train_step():\n",
        "    in_t, out_t, out_inds_t,in_v,out_v, out_inds_g = get_data_td()\n",
        "\n",
        "    with tf.GradientTape() as tape:\n",
        "        loss = eval_loss(in_t, out_t)\n",
        "        grad = tape.gradient(loss, model.weights)\n",
        "        opt.apply_gradients(zip(grad, model.weights))\n",
        "    return loss"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 38,
      "metadata": {
        "id": "-ivXS5UFI6ng"
      },
      "outputs": [],
      "source": [
        "import matplotlib.pyplot as pplot\n",
        "from tqdm import tqdm\n",
        "from IPython.display import clear_output"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 39,
      "metadata": {
        "id": "bYoCBg7UTUQi"
      },
      "outputs": [],
      "source": [
        "in_,out_, s_ , _,_,_ = get_data_td()\n",
        "out_h_ = model(in_)[-1]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 40,
      "metadata": {
        "id": "uzYnmdSLun4f"
      },
      "outputs": [],
      "source": [
        "step = 0"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 41,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 707
        },
        "collapsed": true,
        "id": "y6S48_JkFoyK",
        "outputId": "49447af1-12bb-4c12-84ae-b7a59a1e44a9"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1500x750 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 6000/6000 [11:47<00:00,  8.48it/s]\n"
          ]
        }
      ],
      "source": [
        "\n",
        "if 'start_iteration' not in locals():\n",
        "    start_iteration = 0\n",
        "else:\n",
        "    start_iteration = step\n",
        "\n",
        "for step in tqdm(range(start_iteration,num_training_iterations)):\n",
        "    loss = train_step()\n",
        "    losses.append(loss)\n",
        "    if step % 100 == 0:\n",
        "        clear_output()\n",
        "        pplot.figure(figsize = (10,5), dpi = 150)\n",
        "        test_acc, train_acc = accuracy_correct_sort()\n",
        "        accuracy_test.append( test_acc)\n",
        "        accuracy_train.append(train_acc)\n",
        "        pplot.subplot(1,2,1)\n",
        "        pplot.plot(losses)\n",
        "        pplot.title(\"Loss (cross entropy)\")\n",
        "        pplot.subplot(1,2,2)\n",
        "        pplot.plot(accuracy_train, label = \"train acc\")\n",
        "        pplot.grid()\n",
        "        pplot.plot(accuracy_test, label = \"test acc\")\n",
        "        pplot.grid()\n",
        "\n",
        "        pplot.legend()\n",
        "        pplot.title(\"correctly sorted ratio\")\n",
        "        pplot.pause(0.1)\n",
        "        pplot.show()\n",
        ""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Uf0YMrk315Pc"
      },
      "source": [
        "# Note\n",
        "In earlier versions of this notebook there was a comparisson with DeepMind GraphNets showing comparable performance.\n",
        "\n",
        "DeepMind does not seem to maintain the repo anymore, so there is no comparisson."
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "name": "tf_gnns_sorting_example.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "display_name": ".venv",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.10.12"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}