examples/notebooks/graph_network_shortest_path.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ScitaPqhKtuW"
      },
      "source": [
        "##### Copyright 2022 The TensorFlow GNN Authors.\n",
        "\n",
        "Licensed under the Apache License, Version 2.0 (the \"License\");"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "hMqWDc_m6rUC"
      },
      "outputs": [],
      "source": [
        "# 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",
        "# https://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."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "k8YbHjortqre"
      },
      "source": [
        "# Learning shortest paths with GraphNetworks in TF-GNN\n",
        "\n",
        "Forked from [graph_nets library](https://github.com/deepmind/graph_nets) example [\"shortest path demo\"](https://colab.research.google.com/github/deepmind/graph_nets/blob/master/graph_nets/demos/shortest_path.ipynb)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NzNClAUwtqfl"
      },
      "source": [
        "\u003ctable class=\"tfo-notebook-buttons\" align=\"left\"\u003e\n",
        "  \u003ctd\u003e\n",
        "  \u003ctd\u003e\n",
        "    \u003ca target=\"_blank\" href=\"https://colab.research.google.com/github/tensorflow/gnn/blob/master/examples/notebooks/graph_network_shortest_path.ipynb\"\u003e\u003cimg src=\"https://www.tensorflow.org/images/colab_logo_32px.png\" /\u003eRun in Google Colab\u003c/a\u003e\n",
        "  \u003c/td\u003e\n",
        "  \u003ctd\u003e\n",
        "    \u003ca target=\"_blank\" href=\"https://github.com/tensorflow/gnn/blob/main/examples/notebooks/graph_network_shortest_path.ipynb\"\u003e\u003cimg src=\"https://www.tensorflow.org/images/GitHub-Mark-32px.png\" /\u003eView on GitHub\u003c/a\u003e\n",
        "  \u003c/td\u003e\n",
        "\u003c/table\u003e"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qr1_8ttC08vu"
      },
      "source": [
        "### Task description\n",
        "Given:\n",
        "* a graph representing some cities\n",
        "* some edges representing roads connecting the cities\n",
        "* a \"start\" and an \"end\" city\n",
        "\n",
        "the task consists of finding the shortest path that connect the \"start\" and \"end\" cities.\n",
        "\n",
        "### Model description\n",
        "\n",
        "The model performs message pasing using a`GraphNetwork` as defined in:\n",
        "\n",
        "\"[Relational inductive biases, deep learning, and graph networks](https://arxiv.org/abs/1806.01261 )\" Battaglia et al., arXiv 2018.\n",
        "\n",
        "The deep graph neural network used is built similarly to the `EncodeProcessDecode` architecture as defined in:\n",
        "\n",
        "\"[Learning to Simulate Complex Physics with Graph Networks](https://arxiv.org/abs/2002.09405)\" Sanchez-Gonzalez et al., ICML 2020.\n",
        "\n",
        "where the `InteractionNetwork`s are replaced by `GraphNetwork`s, to allow global\n",
        "updates.\n",
        "\n",
        "This `EncodeProcessDecode` model is general purpose and can be used for any\n",
        "node, edge, and/or context prediction task.\n",
        "\n",
        "### Model training\n",
        "\n",
        "For simplitity we train the model to predict a binary output for each city (binary node classification) and for each road (binary edge classification), indicating whether they are in the shortest path or not. The model trains to almost perfect accuracy in a few thousand training steps.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "Nq8vwtsSrbgS"
      },
      "outputs": [],
      "source": [
        "# @title Installing TF-GNN. { form-width: \"30%\" }\n",
        "\n",
        "!pip install -q tensorflow-gnn || echo \"Ignoring version conflicts, continuing...\""
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "e1lfOmd0N70A"
      },
      "outputs": [],
      "source": [
        "# @title Imports. { form-width: \"30%\" }\n",
        "\n",
        "import collections\n",
        "import functools\n",
        "import itertools\n",
        "import os\n",
        "from typing import Callable, Optional, Mapping, Tuple\n",
        "os.environ[\"TF_USE_LEGACY_KERAS\"] = \"1\"  # For TF2.16+.\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "import networkx as nx\n",
        "import numpy as np\n",
        "from scipy import signal\n",
        "from scipy import spatial\n",
        "import tensorflow as tf\n",
        "import tensorflow_gnn as tfgnn"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "6PRYzQZyTeiJ"
      },
      "outputs": [],
      "source": [
        "# @title GNN architectures. { form-width: \"30%\" }\n",
        "\n",
        "def GraphNetworkGraphUpdate(\n",
        "    *,\n",
        "    edges_next_state_factory: Callable[..., tf.keras.layers.Layer],\n",
        "    nodes_next_state_factory: Callable[..., tf.keras.layers.Layer],\n",
        "    context_next_state_factory: Optional[Callable[..., tf.keras.layers.Layer]],\n",
        "    receiver_tag: Optional[tfgnn.IncidentNodeTag] = tfgnn.TARGET,\n",
        "    reduce_type_to_nodes: str = \"sum\",\n",
        "    reduce_type_to_context: str = \"sum\",\n",
        "    use_input_context_state: bool = True,\n",
        "    name: str = \"graph_network\"):\n",
        "  \"\"\"Returns a GraphUpdate to run a GraphNetwork on all node sets and edge sets.\n",
        "\n",
        "  The returned layer implements a Graph Network, as described by\n",
        "  Battaglia et al.: [\"Relational inductive biases, deep learning, and\n",
        "  graph networks\"](https://arxiv.org/abs/1806.01261), 2018, generalized\n",
        "  to heterogeneous graphs.\n",
        "\n",
        "  It expects an input GraphTensor with a `tfgnn.HIDDEN_STATE` feature on all\n",
        "  node sets and edge sets, and also context if `use_input_context_state=True`.\n",
        "  It runs edge, node, and context updates, in this order, separately for each\n",
        "  edge set, node set (regardless whether it has an incoming edge set), and also\n",
        "  context if `context_next_state_factory` is set. Finally, it returns a\n",
        "  GraphTensor with updated hidden states, incl. a context state, if\n",
        "  `context_next_state_factory` is set.\n",
        "\n",
        "  The model can also behave as an Interaction Network ([Battaglia et al., NIPS\n",
        "  2016](https://proceedings.neurips.cc/paper/2016/hash/3147da8ab4a0437c15ef51a5cc7f2dc4-Abstract.html))\n",
        "  by setting\n",
        "    * `use_input_context_state = False`\n",
        "    * `context_next_state_factory = None`\n",
        "\n",
        "  Args:\n",
        "    edges_next_state_factory: Called with keyword argument `edge_set_name=`\n",
        "      for each edge set to return the NextState layer for use in the respective\n",
        "      `tfgnn.keras.layers.EdgeSetUpdate`.\n",
        "    nodes_next_state_factory: Called with keyword argument `node_set_name=`\n",
        "      for each node set to return the NextState layer for use in the respective\n",
        "      `tfgnn.keras.layers.NodeSetUpdate`.\n",
        "    context_next_state_factory: If set, a `tfgnn.keras.layers.ContextUpdate`\n",
        "      is included with the NextState layer returned by calling this factory.\n",
        "    receiver_tag: The incident node tag at which each edge set is used to\n",
        "      update node sets. Defaults to `tfgnn.TARGET`.\n",
        "    reduce_type_to_nodes: Controls how incident edges at a node are aggregated\n",
        "      within each EdgeSet. Defaults to `\"sum\"`. (The aggregates of the various\n",
        "      incident EdgeSets are then concatenated.)\n",
        "    reduce_type_to_context: Controls how the nodes of a NodeSet or the edges of\n",
        "      an EdgeSet are aggregated for the context update. Defaults to `\"sum\"`.\n",
        "      (The aggregates of the various NodeSets/EdgeSets are then concatenated.)\n",
        "    use_input_context_state: If true, the input `GraphTensor.context` must have\n",
        "      a `tfgnn.HIDDEN_STATE` feature that gets used as input in all edge, node\n",
        "      and context updates.\n",
        "    name: A name for the returned layer.\n",
        "  \"\"\"\n",
        "  def deferred_init_callback(graph_spec):\n",
        "    context_input_feature = (\n",
        "        tfgnn.HIDDEN_STATE if use_input_context_state else None)\n",
        "\n",
        "    # To keep track node types that receive each edge type.\n",
        "    incoming_edge_sets = collections.defaultdict(list)\n",
        "\n",
        "    # For every edge set, create an EdgeSetUpdate.\n",
        "    edge_set_updates = {}\n",
        "    for edge_set_name in sorted(graph_spec.edge_sets_spec.keys()):\n",
        "      next_state = edges_next_state_factory(edge_set_name=edge_set_name)\n",
        "      edge_set_updates[edge_set_name] = tfgnn.keras.layers.EdgeSetUpdate(\n",
        "          next_state=next_state,\n",
        "          edge_input_feature=tfgnn.HIDDEN_STATE,\n",
        "          node_input_feature=tfgnn.HIDDEN_STATE,\n",
        "          context_input_feature=context_input_feature)\n",
        "      # Keep track of which node set is the receiver for this edge type\n",
        "      # as we will need it later.\n",
        "      target_name = graph_spec.edge_sets_spec[\n",
        "          edge_set_name].adjacency_spec.node_set_name(receiver_tag)\n",
        "      incoming_edge_sets[target_name].append(edge_set_name)\n",
        "\n",
        "    # For every node set, create a NodeSetUpdate.\n",
        "    node_set_updates = {}\n",
        "    for node_set_name in sorted(graph_spec.node_sets_spec.keys()):\n",
        "      # Apply a node update, after summing *all* of the received edges\n",
        "      # for that node set.\n",
        "      next_state = nodes_next_state_factory(node_set_name=node_set_name)\n",
        "      node_set_updates[node_set_name] = tfgnn.keras.layers.NodeSetUpdate(\n",
        "          next_state=next_state,\n",
        "          edge_set_inputs={\n",
        "              edge_set_name: tfgnn.keras.layers.Pool(\n",
        "                  receiver_tag, reduce_type_to_nodes,\n",
        "                  feature_name=tfgnn.HIDDEN_STATE)\n",
        "              for edge_set_name in incoming_edge_sets[node_set_name]},\n",
        "          node_input_feature=tfgnn.HIDDEN_STATE,\n",
        "          context_input_feature=context_input_feature)\n",
        "\n",
        "    # Create a ContextUpdate, if requested.\n",
        "    context_update = None\n",
        "    if context_next_state_factory is not None:\n",
        "      next_state = context_next_state_factory()\n",
        "      context_update = tfgnn.keras.layers.ContextUpdate(\n",
        "          next_state=next_state,\n",
        "          edge_set_inputs={\n",
        "              edge_set_name: tfgnn.keras.layers.Pool(\n",
        "                  tfgnn.CONTEXT, reduce_type_to_context,\n",
        "                  feature_name=tfgnn.HIDDEN_STATE)\n",
        "              for edge_set_name in sorted(graph_spec.edge_sets_spec.keys())},\n",
        "          node_set_inputs={\n",
        "              node_set_name: tfgnn.keras.layers.Pool(\n",
        "                  tfgnn.CONTEXT, reduce_type_to_context,\n",
        "                  feature_name=tfgnn.HIDDEN_STATE)\n",
        "              for node_set_name in sorted(graph_spec.node_sets_spec.keys())},\n",
        "          context_input_feature=context_input_feature)\n",
        "    return dict(edge_sets=edge_set_updates,\n",
        "                node_sets=node_set_updates,\n",
        "                context=context_update)\n",
        "\n",
        "  return tfgnn.keras.layers.GraphUpdate(\n",
        "      deferred_init_callback=deferred_init_callback, name=name)\n",
        "\n",
        "\n",
        "def build_mlp(num_hidden_layers: int,\n",
        "              hidden_size: int,\n",
        "              output_size: int,\n",
        "              use_layer_norm: bool,\n",
        "              activation: str = \"relu\",\n",
        "              activate_final: bool = False,\n",
        "              name: str = \"mlp\"):\n",
        "  \"\"\"Builds an MLP.\"\"\"\n",
        "  output_sizes = [hidden_size] * num_hidden_layers + [output_size]\n",
        "  mlp = tf.keras.Sequential(name=\"mlp\")\n",
        "  for layer_i, size in enumerate(output_sizes):\n",
        "    layer_activation = activation\n",
        "    if not activate_final and layer_i == len(output_sizes) - 1:\n",
        "      layer_activation = None\n",
        "    mlp.add(tf.keras.layers.Dense(\n",
        "        size,\n",
        "        activation=layer_activation,\n",
        "        use_bias=True,\n",
        "        kernel_initializer=\"variance_scaling\",\n",
        "        bias_initializer=\"zeros\",\n",
        "        name=f\"{name}/dense_{layer_i}\"))\n",
        "  if use_layer_norm:\n",
        "    mlp.add(tf.keras.layers.LayerNormalization(\n",
        "        name=f\"{name}/layer_norm\"))\n",
        "  return mlp\n",
        "\n",
        "\n",
        "class EncodeProcessDecode(tf.keras.layers.Layer):\n",
        "  \"\"\"Implements EncodeProcessDecode from https://arxiv.org/abs/2002.09405.\n",
        "\n",
        "  It is extended to:\n",
        "  * run with global updates.\n",
        "  * use shared or unshared weights when using message passing.\n",
        "  * produce per node, per edge and/or context outputs.\n",
        "\n",
        "  It requires node sets, edge sets and context with the\n",
        "  `tfgnn.HIDDEN_STATE` feature.\n",
        "  \"\"\"\n",
        "  def __init__(\n",
        "      self,\n",
        "      edge_output_size: Optional[int],\n",
        "      node_output_size: Optional[int],\n",
        "      context_output_size: Optional[int],\n",
        "      num_message_passing_steps: int,\n",
        "      num_mlp_hidden_layers: int,\n",
        "      mlp_hidden_size: int,\n",
        "      latent_size: int,\n",
        "      use_layer_norm: bool,\n",
        "      shared_processors: bool,\n",
        "      reduce_type_to_nodes: str = \"sum\",\n",
        "      reduce_type_to_context: str = \"sum\",\n",
        "      name: str = \"encode_process_decode\"):\n",
        "    super().__init__(name=name)\n",
        "\n",
        "    # Build graph encoder.\n",
        "    def encoder_fn(graph_piece, *, edge_set_name=None, node_set_name=None):\n",
        "      piece_name = (f\"edges_{edge_set_name}\" if edge_set_name else\n",
        "                    f\"nodes_{node_set_name}\" if node_set_name else \"context\")\n",
        "      mlp = build_mlp(num_hidden_layers=num_mlp_hidden_layers,\n",
        "                      hidden_size=mlp_hidden_size,\n",
        "                      output_size=latent_size,\n",
        "                      use_layer_norm=use_layer_norm,\n",
        "                      name=f\"{self.name}/encoder/{piece_name}\")\n",
        "      return mlp(graph_piece[tfgnn.HIDDEN_STATE])\n",
        "\n",
        "    self._encoder = tfgnn.keras.layers.MapFeatures(\n",
        "        edge_sets_fn=encoder_fn, node_sets_fn=encoder_fn, context_fn=encoder_fn)\n",
        "\n",
        "    # Build graph processor(s).\n",
        "    # We will just concatenate all inputs to each edge update, node update\n",
        "    # and context upcate, and run an MLP on it.\n",
        "\n",
        "    def processor_fn(*, processor_name, edge_set_name=None, node_set_name=None):\n",
        "      if edge_set_name is not None:\n",
        "        mlp_name = f\"{processor_name}/edges_{edge_set_name}\"\n",
        "      elif node_set_name is not None:\n",
        "        mlp_name = f\"{processor_name}/nodes_{node_set_name}\"\n",
        "      else:\n",
        "        mlp_name = f\"{processor_name}/context\"\n",
        "      mlp = build_mlp(name=mlp_name,\n",
        "                      num_hidden_layers=num_mlp_hidden_layers,\n",
        "                      hidden_size=mlp_hidden_size,\n",
        "                      output_size=latent_size,\n",
        "                      use_layer_norm=use_layer_norm)\n",
        "      return tfgnn.keras.layers.NextStateFromConcat(mlp)\n",
        "\n",
        "    num_processors = (1 if shared_processors else num_message_passing_steps)\n",
        "\n",
        "    processors = []\n",
        "    for processor_i in range(num_processors):\n",
        "      processor_name = f\"{self.name}/processor_{processor_i}\"\n",
        "      processor_fn_named = functools.partial(processor_fn,\n",
        "                                             processor_name=processor_name)\n",
        "      processors.append(GraphNetworkGraphUpdate(\n",
        "          edges_next_state_factory=processor_fn_named,\n",
        "          nodes_next_state_factory=processor_fn_named,\n",
        "          context_next_state_factory=processor_fn_named,\n",
        "          reduce_type_to_nodes=reduce_type_to_nodes,\n",
        "          reduce_type_to_context=reduce_type_to_context,\n",
        "          name=processor_name))\n",
        "\n",
        "    if shared_processors:\n",
        "      self._processors = processors * num_message_passing_steps\n",
        "    else:\n",
        "      self._processors = processors\n",
        "\n",
        "    # Build graph decoder.\n",
        "    def decoder_fn(graph_piece, *, edge_set_name=None, node_set_name=None):\n",
        "      piece_name = (f\"edges_{edge_set_name}\" if edge_set_name else\n",
        "                    f\"nodes_{node_set_name}\" if node_set_name else \"context\")\n",
        "      if edge_set_name:\n",
        "        output_size = edge_output_size\n",
        "      elif node_set_name:\n",
        "        output_size = node_output_size\n",
        "      else:\n",
        "        output_size = context_output_size\n",
        "      mlp = build_mlp(num_hidden_layers=num_mlp_hidden_layers,\n",
        "                      hidden_size=mlp_hidden_size,\n",
        "                      output_size=output_size,\n",
        "                      use_layer_norm=False,  # Never LayerNorm for the outputs.\n",
        "                      name=f\"{self.name}/decoder/{piece_name}\")\n",
        "      return mlp(graph_piece[tfgnn.HIDDEN_STATE])\n",
        "\n",
        "    self._decoder = tfgnn.keras.layers.MapFeatures(\n",
        "        edge_sets_fn=decoder_fn if edge_output_size else None,\n",
        "        node_sets_fn=decoder_fn if node_output_size else None,\n",
        "        context_fn=decoder_fn if context_output_size else None)\n",
        "\n",
        "  def call(self, input_graph: tfgnn.GraphTensor) -\u003e tfgnn.GraphTensor:\n",
        "    latent_graph = self._encoder(input_graph)\n",
        "    for processor in self._processors:\n",
        "      residual_graph = processor(latent_graph)\n",
        "      latent_graph = sum_graphs(residual_graph, latent_graph)\n",
        "    output_graph = self._decoder(latent_graph)\n",
        "    return output_graph"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "CPksUWs4ejdQ"
      },
      "outputs": [],
      "source": [
        "# @title Utils for GraphTensor. { form-width: \"30%\" }\n",
        "\n",
        "# TODO(b/234563300): Consider supporting `MapFeatures` for multiple graphs.\n",
        "def sum_graphs(graph_1: tfgnn.GraphTensor, graph_2: tfgnn.GraphTensor,\n",
        "               ) -\u003e  tfgnn.GraphTensor:\n",
        "  \"\"\"Sums all features in two identical graphs.\"\"\"\n",
        "  assert set(graph_1.edge_sets.keys()) == set(graph_2.edge_sets.keys())\n",
        "  new_edge_set_features = {}\n",
        "  for set_name in graph_1.edge_sets.keys():\n",
        "    new_edge_set_features[set_name] = _sum_feature_dict(\n",
        "        graph_1.edge_sets[set_name].get_features_dict(),\n",
        "        graph_2.edge_sets[set_name].get_features_dict())\n",
        "\n",
        "  assert set(graph_1.node_sets.keys()) == set(graph_2.node_sets.keys())\n",
        "  new_node_set_features = {}\n",
        "  for set_name in graph_1.node_sets.keys():\n",
        "    new_node_set_features[set_name] = _sum_feature_dict(\n",
        "        graph_1.node_sets[set_name].get_features_dict(),\n",
        "        graph_2.node_sets[set_name].get_features_dict())\n",
        "\n",
        "  new_context_features = _sum_feature_dict(\n",
        "      graph_1.context.get_features_dict(),\n",
        "      graph_2.context.get_features_dict())\n",
        "  return graph_1.replace_features(\n",
        "      edge_sets=new_edge_set_features,\n",
        "      node_sets=new_node_set_features,\n",
        "      context=new_context_features)\n",
        "\n",
        "\n",
        "def _sum_feature_dict(\n",
        "    features_1: Mapping[str, tf.Tensor],\n",
        "    features_2: Mapping[str, tf.Tensor]\n",
        "    ) -\u003e Mapping[str, tf.Tensor]:\n",
        "  tf.nest.assert_same_structure(features_1, features_2)\n",
        "  return tf.nest.map_structure(lambda x, y: x + y, features_1, features_2)\n",
        "\n",
        "\n",
        "def nest_to_numpy(nest):\n",
        "  return tf.nest.map_structure(lambda x: x.numpy(), nest)\n",
        "\n",
        "# TODO(b/205123804): Provide a library function for this.\n",
        "def graph_tensor_spec_from_sample_graph(sample_graph):\n",
        "  \"\"\"Build variable node/edge spec given a sample graph without batch axes.\"\"\"\n",
        "  tfgnn.check_scalar_graph_tensor(sample_graph)\n",
        "  sample_graph_spec = sample_graph.spec\n",
        "  node_sets_spec = {}\n",
        "  for node_set_name, node_set_spec in sample_graph_spec.node_sets_spec.items():\n",
        "    new_features_spec = {}\n",
        "    for feature_name, feature_spec in node_set_spec.features_spec.items():\n",
        "      new_features_spec[feature_name] = _to_none_leading_dim(feature_spec)\n",
        "    node_sets_spec[node_set_name] = tfgnn.NodeSetSpec.from_field_specs(\n",
        "        features_spec=new_features_spec,\n",
        "        sizes_spec=tf.TensorSpec(shape=(1,), dtype=tf.int32))\n",
        "\n",
        "  edge_sets_spec = {}\n",
        "  for edge_set_name, edge_set_spec in sample_graph_spec.edge_sets_spec.items():\n",
        "    new_features_spec = {}\n",
        "    for feature_name, feature_spec in edge_set_spec.features_spec.items():\n",
        "      new_features_spec[feature_name] = _to_none_leading_dim(feature_spec)\n",
        "\n",
        "    adjacency_spec = tfgnn.AdjacencySpec.from_incident_node_sets(\n",
        "        source_node_set=edge_set_spec.adjacency_spec.source_name,\n",
        "        target_node_set=edge_set_spec.adjacency_spec.target_name,\n",
        "        index_spec=_to_none_leading_dim(edge_set_spec.adjacency_spec.target))\n",
        "\n",
        "    edge_sets_spec[edge_set_name] = tfgnn.EdgeSetSpec.from_field_specs(\n",
        "        features_spec=new_features_spec,\n",
        "        sizes_spec=tf.TensorSpec(shape=(1,), dtype=tf.int32),\n",
        "        adjacency_spec=adjacency_spec)\n",
        "\n",
        "  context_spec = sample_graph_spec.context_spec\n",
        "\n",
        "  return tfgnn.GraphTensorSpec.from_piece_specs(\n",
        "      node_sets_spec=node_sets_spec,\n",
        "      edge_sets_spec=edge_sets_spec,\n",
        "      context_spec=context_spec,\n",
        "  )\n",
        "\n",
        "def _to_none_leading_dim(spec):\n",
        "  new_shape = list(spec.shape)\n",
        "  new_shape[0] = None\n",
        "  return tf.TensorSpec(shape=new_shape, dtype=spec.dtype)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "kF51Ch4-SriY"
      },
      "outputs": [],
      "source": [
        "# @title Defining the shortest path task. { form-width: \"30%\" }\n",
        "\n",
        "def generate_task_graph(\n",
        "    random_state,\n",
        "    num_nodes_min_max: Tuple[int, int],\n",
        "    dimensions: int = 2,\n",
        "    theta: float = 1000.0,\n",
        "    min_length: int = 1,\n",
        "    rate: float = 1.0) -\u003e tfgnn.GraphTensor:\n",
        "  \"\"\"Creates a connected graph.\n",
        "\n",
        "  The graphs are geographic threshold graphs, but with added edges via a\n",
        "  minimum spanning tree algorithm, to ensure all nodes are connected.\n",
        "\n",
        "  Args:\n",
        "    random_state: A random seed for the graph generator. Default= None.\n",
        "    num_nodes_min_max: A sequence [lower, upper) number of nodes per graph.\n",
        "    dimensions: (optional) An `int` number of dimensions for the positions.\n",
        "      Default= 2.\n",
        "    theta: (optional) A `float` threshold parameters for the geographic\n",
        "      threshold graph's threshold. Large values (1000+) make mostly trees. Try\n",
        "      20-60 for good non-trees. Default=1000.0.\n",
        "    min_length: (optional) An `int` minimum number of edges in the shortest\n",
        "      path. Default= 1.\n",
        "    rate: (optional) A rate parameter for the node weight exponential sampling\n",
        "      distribution. Default= 1.0.\n",
        "\n",
        "  Returns:\n",
        "    The graph.\n",
        "  \"\"\"\n",
        "  graph = _generate_base_graph(\n",
        "      random_state, num_nodes_min_max=num_nodes_min_max, dimensions=dimensions,\n",
        "      theta=theta, rate=rate)\n",
        "  graph = _add_shortest_path(random_state, graph, min_length=min_length)\n",
        "  return _convert_to_graph_tensor(graph)\n",
        "\n",
        "\n",
        "def task_graph_generator(random_seed: int, **task_kwargs):\n",
        "  random_state = np.random.RandomState(random_seed)\n",
        "  while True:\n",
        "    yield generate_task_graph(random_state, **task_kwargs)\n",
        "\n",
        "\n",
        "def get_dataset(random_seed: int, **task_kwargs):\n",
        "  def generator_fn():\n",
        "    return task_graph_generator(random_seed, **task_kwargs)\n",
        "  graph_spec = graph_tensor_spec_from_sample_graph(next(generator_fn()))\n",
        "  return tf.data.Dataset.from_generator(\n",
        "      generator_fn, output_signature=graph_spec)\n",
        "\n",
        "\n",
        "def _generate_base_graph(rand,\n",
        "                         num_nodes_min_max,\n",
        "                         dimensions,\n",
        "                         theta,\n",
        "                         rate):\n",
        "  \"\"\"Generates the base graph for the task.\"\"\"\n",
        "  # Sample num_nodes.\n",
        "  num_nodes = rand.randint(*num_nodes_min_max)\n",
        "\n",
        "  # Create geographic threshold graph.\n",
        "  pos_array = rand.uniform(size=(num_nodes, dimensions))\n",
        "  pos = dict(enumerate(pos_array))\n",
        "  weight = dict(enumerate(rand.exponential(rate, size=num_nodes)))\n",
        "  geo_graph = nx.geographical_threshold_graph(\n",
        "      num_nodes, theta, pos=pos, weight=weight)\n",
        "\n",
        "  # Create minimum spanning tree across geo_graph's nodes.\n",
        "  distances = spatial.distance.squareform(spatial.distance.pdist(pos_array))\n",
        "  i_, j_ = np.meshgrid(range(num_nodes), range(num_nodes), indexing=\"ij\")\n",
        "  weighted_edges = list(zip(i_.ravel(), j_.ravel(), distances.ravel()))\n",
        "  mst_graph = nx.Graph()\n",
        "  mst_graph.add_weighted_edges_from(weighted_edges, weight=\"weight\")\n",
        "  mst_graph = nx.minimum_spanning_tree(mst_graph, weight=\"weight\")\n",
        "  # Put geo_graph's node attributes into the mst_graph.\n",
        "  for i in mst_graph.nodes():\n",
        "    mst_graph.nodes[i].update(geo_graph.nodes[i])\n",
        "\n",
        "  # Compose the graphs.\n",
        "  combined_graph = nx.compose_all((mst_graph, geo_graph.copy()))\n",
        "  # Put all distance weights into edge attributes.\n",
        "  for i, j in combined_graph.edges():\n",
        "    combined_graph.get_edge_data(i, j).setdefault(\"weight\",\n",
        "                                                  distances[i, j])\n",
        "  return combined_graph\n",
        "\n",
        "\n",
        "def _pairwise(iterable):\n",
        "  \"\"\"s -\u003e (s0,s1), (s1,s2), (s2, s3), ...\"\"\"\n",
        "  a, b = itertools.tee(iterable)\n",
        "  next(b, None)\n",
        "  return zip(a, b)\n",
        "\n",
        "\n",
        "def _set_diff(seq0, seq1):\n",
        "  \"\"\"Return the set difference between 2 sequences as a list.\"\"\"\n",
        "  return list(set(seq0) - set(seq1))\n",
        "\n",
        "\n",
        "def _add_shortest_path(rand, graph, min_length=1):\n",
        "  \"\"\"Samples a shortest path in the graph.\"\"\"\n",
        "  # Map from node pairs to the length of their shortest path.\n",
        "  pair_to_length_dict = {}\n",
        "  lengths = list(nx.all_pairs_shortest_path_length(graph))\n",
        "  for x, yy in lengths:\n",
        "    for y, l in yy.items():\n",
        "      if l \u003e= min_length:\n",
        "        pair_to_length_dict[x, y] = l\n",
        "  if max(pair_to_length_dict.values()) \u003c min_length:\n",
        "    raise ValueError(\"All shortest paths are below the minimum length\")\n",
        "  # The node pairs which exceed the minimum length.\n",
        "  node_pairs = list(pair_to_length_dict)\n",
        "\n",
        "  # Computes probabilities per pair, to enforce uniform sampling of each\n",
        "  # shortest path lengths.\n",
        "  # The counts of pairs per length.\n",
        "  counts = collections.Counter(pair_to_length_dict.values())\n",
        "  prob_per_length = 1.0 / len(counts)\n",
        "  probabilities = [\n",
        "      prob_per_length / counts[pair_to_length_dict[x]] for x in node_pairs\n",
        "  ]\n",
        "\n",
        "  # Choose the start and end points.\n",
        "  i = rand.choice(len(node_pairs), p=probabilities)\n",
        "  start, end = node_pairs[i]\n",
        "  path = nx.shortest_path(\n",
        "      graph, source=start, target=end, weight=\"length\")\n",
        "\n",
        "  # Creates a directed graph, to store the directed path from start to end.\n",
        "  digraph = graph.to_directed()\n",
        "\n",
        "  # Add the \"start\", \"end\", and \"solution\" attributes to the nodes and edges.\n",
        "  digraph.add_node(start, is_start=True)\n",
        "  digraph.add_node(end, is_end=True)\n",
        "  digraph.add_nodes_from(_set_diff(digraph.nodes(), [start]), is_start=False)\n",
        "  digraph.add_nodes_from(_set_diff(digraph.nodes(), [end]), is_end=False)\n",
        "  digraph.add_nodes_from(_set_diff(digraph.nodes(), path), is_in_path=False)\n",
        "  digraph.add_nodes_from(path, is_in_path=True)\n",
        "  path_edges = list(_pairwise(path))\n",
        "  digraph.add_edges_from(_set_diff(digraph.edges(), path_edges), is_in_path=False)\n",
        "  digraph.add_edges_from(path_edges, is_in_path=True)\n",
        "\n",
        "  return digraph\n",
        "\n",
        "\n",
        "def _convert_to_graph_tensor(graph_nx):\n",
        "  \"\"\"Converts the graph to a GraphTensor.\"\"\"\n",
        "  number_of_nodes = graph_nx.number_of_nodes()\n",
        "  nodes_data = [data for _, data in graph_nx.nodes(data=True)]\n",
        "  node_features = tf.nest.map_structure(\n",
        "      lambda *n: np.stack(n, axis=0), *nodes_data)\n",
        "\n",
        "  number_of_edges = graph_nx.number_of_edges()\n",
        "  source_indices, target_indices, edges_data = zip(*graph_nx.edges(data=True))\n",
        "  source_indices = np.array(source_indices, dtype=np.int32)\n",
        "  target_indices = np.array(target_indices, dtype=np.int32)\n",
        "  edge_features = tf.nest.map_structure(\n",
        "      lambda *e: np.stack(e, axis=0), *edges_data)\n",
        "  context_features = dict(graph_nx.graph)\n",
        "  return tfgnn.GraphTensor.from_pieces(\n",
        "      node_sets={\n",
        "          \"cities\": tfgnn.NodeSet.from_fields(\n",
        "              sizes=[number_of_nodes],\n",
        "              features=node_features,\n",
        "              )},\n",
        "      edge_sets={\n",
        "          \"roads\": tfgnn.EdgeSet.from_fields(\n",
        "              sizes=[number_of_edges],\n",
        "              features=edge_features,\n",
        "              adjacency=tfgnn.Adjacency.from_indices(\n",
        "                  source=(\"cities\", source_indices),\n",
        "                  target=(\"cities\", target_indices))\n",
        "              )},\n",
        "      context=tfgnn.Context.from_fields(features=context_features),\n",
        "      )\n",
        "\n",
        "def draw_graph(ax, task_graph):\n",
        "\n",
        "  tfgnn.check_scalar_graph_tensor(task_graph)\n",
        "  assert task_graph.num_components == 1\n",
        "\n",
        "  ax.set_xticks([])\n",
        "  ax.set_yticks([])\n",
        "  node_set = task_graph.node_sets[\"cities\"]\n",
        "  node_positions = node_set[\"pos\"].numpy()\n",
        "\n",
        "  start_node_mask = node_set[\"is_start\"].numpy()\n",
        "  end_node_mask = node_set[\"is_end\"].numpy()\n",
        "  other_nodes_mask = ~ (start_node_mask + end_node_mask)\n",
        "\n",
        "  in_path_node_mask = node_set[\"is_in_path\"].numpy()\n",
        "\n",
        "  for label, mask, kwargs in [\n",
        "      (\"Cities\", other_nodes_mask, dict(color=\"lightgrey\")),\n",
        "      (\"Start city\", start_node_mask, dict(color=\"red\")),\n",
        "      (\"End city\", end_node_mask, dict(color=\"blue\")),\n",
        "      (\"Cities in shortest path\", in_path_node_mask,\n",
        "       dict(color=\"None\", markeredgecolor=\"black\")),\n",
        "      ]:\n",
        "    ax.plot(\n",
        "        node_positions[mask, 0], node_positions[mask, 1], \"o\",\n",
        "        zorder=100, ms=10, markeredgewidth=2, label=label, **kwargs)\n",
        "\n",
        "  edge_positions = np.stack(\n",
        "      [node_positions[task_graph.edge_sets[\"roads\"].adjacency.source.numpy()],\n",
        "       node_positions[task_graph.edge_sets[\"roads\"].adjacency.target.numpy()]\n",
        "       ], axis=0)\n",
        "\n",
        "  in_path_edges_mask = task_graph.edge_sets[\"roads\"][\"is_in_path\"].numpy()\n",
        "  other_edges_mask = ~in_path_edges_mask\n",
        "  for label, mask, kwargs in [\n",
        "      (\"Roads\", other_edges_mask, dict(color=\"lightgrey\", linewidth=2)),\n",
        "      (\"Roads in shortest path\", in_path_edges_mask, dict(color=\"black\", linewidth=5)),\n",
        "      ]:\n",
        "    ax.plot(\n",
        "        edge_positions[:, mask, 0], edge_positions[:, mask, 1], **kwargs)\n",
        "    ax.plot(np.nan, np.nan, label=label, **kwargs)  # Single legend element."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 321
        },
        "executionInfo": {
          "elapsed": 4104,
          "status": "ok",
          "timestamp": 1656410303285,
          "user": {
            "displayName": "",
            "userId": ""
          },
          "user_tz": -120
        },
        "id": "jhJEq1RmS8TK",
        "outputId": "a5de338b-04ae-44ca-cdb7-c55591bf82f0"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "GraphTensor(\n",
            "  context=Context(features={}, sizes=[1], shape=(), indices_dtype=tf.int32),\n",
            "  node_set_names=['cities'],\n",
            "  edge_set_names=['roads'])\n",
            "cities NodeSetSpec({'features': {'weight': TensorSpec(shape=(16,), dtype=tf.float64, name=None), 'pos': TensorSpec(shape=(16, 2), dtype=tf.float64, name=None), 'is_start': TensorSpec(shape=(16,), dtype=tf.bool, name=None), 'is_end': TensorSpec(shape=(16,), dtype=tf.bool, name=None), 'is_in_path': TensorSpec(shape=(16,), dtype=tf.bool, name=None)}, 'sizes': TensorSpec(shape=(1,), dtype=tf.int32, name=None)}, TensorShape([]), tf.int32, None)\n",
            "roads EdgeSetSpec({'features': {'weight': TensorSpec(shape=(70,), dtype=tf.float64, name=None), 'is_in_path': TensorSpec(shape=(70,), dtype=tf.bool, name=None)}, 'sizes': TensorSpec(shape=(1,), dtype=tf.int32, name=None), 'adjacency': AdjacencySpec({'#index.0': TensorSpec(shape=(70,), dtype=tf.int32, name=None), '#index.1': TensorSpec(shape=(70,), dtype=tf.int32, name=None)}, TensorShape([]), tf.int32, {'#index.0': 'cities', '#index.1': 'cities'})}, TensorShape([]), tf.int32, None)\n"
          ]
        },
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "\u003cFigure size 864x216 with 4 Axes\u003e"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "#@title Visualizing the task. { form-width: \"30%\" }\n",
        "generator = task_graph_generator(\n",
        "    random_seed=0, num_nodes_min_max=(9, 17), theta=20)\n",
        "fig, axes = plt.subplots(1, 4, figsize=(12, 3))\n",
        "for ax in axes.flatten():\n",
        "  task_graph = next(generator)\n",
        "  draw_graph(ax, task_graph)\n",
        "axes[-1].legend(loc=\"upper left\", bbox_to_anchor=[1., 1.], frameon=False)\n",
        "\n",
        "print(task_graph)\n",
        "print(\"cities\", task_graph.node_sets[\"cities\"].spec)\n",
        "print(\"roads\", task_graph.edge_sets[\"roads\"].spec)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "JExsSQ-UgCZq"
      },
      "outputs": [],
      "source": [
        "# @title Build utils to convert back and forth between task graph, and graph the hidden state.  { form-width: \"30%\" }\n",
        "\n",
        "# Initial hidden states can be set up with MapFeatures as follows.\n",
        "\n",
        "def _set_initial_node_state(cities_set, *, node_set_name):\n",
        "  assert node_set_name == \"cities\"\n",
        "  return tf.concat(\n",
        "      [tf.cast(cities_set[\"weight\"], tf.float32)[..., None],\n",
        "       tf.cast(cities_set[\"is_start\"], tf.float32)[..., None],\n",
        "       tf.cast(cities_set[\"is_end\"], tf.float32)[..., None],\n",
        "       # Don't provide the position for better generalization.\n",
        "       # tf.cast(city_features[\"pos\"], tf.float32),\n",
        "       # Do not give the answer, unless debugging!\n",
        "       # tf.cast(city_features[\"is_in_path\"], tf.float32)[..., None],\n",
        "       ],\n",
        "      axis=-1)\n",
        "\n",
        "def _set_initial_edge_state(road_set, *, edge_set_name):\n",
        "  assert edge_set_name == \"roads\"\n",
        "  return tf.concat(\n",
        "      [tf.cast(road_set[\"weight\"], tf.float32)[..., None],\n",
        "       # Do not give the answer, unless debugging!\n",
        "       # tf.cast(road_features[\"is_in_path\"], tf.float32)[..., None],\n",
        "       ],\n",
        "      axis=-1)\n",
        "\n",
        "def _set_initial_context_state(context):\n",
        "  return tfgnn.keras.layers.MakeEmptyFeature()(context)\n",
        "\n",
        "build_initial_hidden_state = tfgnn.keras.layers.MapFeatures(\n",
        "      node_sets_fn=_set_initial_node_state,\n",
        "      edge_sets_fn=_set_initial_edge_state,\n",
        "      context_fn=_set_initial_context_state)\n",
        "\n",
        "\n",
        "# Final predictions can often just be read out of the GraphTensor. This colab\n",
        "# copies them back from the network's output into the input GraphTensor, so that\n",
        "# consumers of shortest paths (e.g., `draw_graph()`) can be agnostic of whether\n",
        "# the shortest path is a prediction or a label.\n",
        "# TODO(b/234563300): Consider supporting `MapFeatures` for multiple graphs,\n",
        "# to express feature copying with that.\n",
        "\n",
        "def predict_from_final_hidden_state(task_graph, output_graph):\n",
        "  \"\"\"Transforms output logits into \"is_in_path\" prediction.\"\"\"\n",
        "\n",
        "  city_features = task_graph.node_sets[\"cities\"].get_features_dict()\n",
        "  node_logits = output_graph.node_sets[\"cities\"][\n",
        "      tfgnn.HIDDEN_STATE]\n",
        "  city_features[\"is_in_path\"] = tf.cast(\n",
        "      tf.argmax(node_logits, axis=-1), tf.bool)\n",
        "\n",
        "  road_features = task_graph.edge_sets[\"roads\"].get_features_dict()\n",
        "  edge_logits = output_graph.edge_sets[\"roads\"][\n",
        "      tfgnn.HIDDEN_STATE]\n",
        "  road_features[\"is_in_path\"] = tf.cast(\n",
        "      tf.argmax(edge_logits, axis=-1), tf.bool)\n",
        "\n",
        "  return task_graph.replace_features(\n",
        "      node_sets={\"cities\": city_features},\n",
        "      edge_sets={\"roads\": road_features})"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "executionInfo": {
          "elapsed": 10977,
          "status": "ok",
          "timestamp": 1656410314244,
          "user": {
            "displayName": "",
            "userId": ""
          },
          "user_tz": -120
        },
        "id": "QDDhYqxun02s",
        "outputId": "fc10f5b3-4817-405b-ac22-83109f642453"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "WARNING:tensorflow:Mapping types may not work well with tf.nest. Prefer using MutableMapping for \u003cclass 'tensorflow_gnn.graph.graph_tensor._ImmutableMapping'\u003e\n",
            "WARNING:tensorflow:Mapping types may not work well with tf.nest. Prefer using MutableMapping for \u003cclass 'tensorflow_gnn.graph.graph_tensor._ImmutableMapping'\u003e\n",
            "WARNING:tensorflow:Mapping types may not work well with tf.nest. Prefer using MutableMapping for \u003cclass 'tensorflow_gnn.graph.graph_tensor._ImmutableMapping'\u003e\n",
            "encode_process_decode/encoder/context/dense_0/kernel:0 (0, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/encoder/context/dense_0/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/encoder/context/dense_1/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/encoder/context/dense_1/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/encoder/context/dense_2/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/encoder/context/dense_2/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/encoder/context/layer_norm/gamma:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/encoder/context/layer_norm/beta:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/encoder/nodes_cities/dense_0/kernel:0 (3, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/encoder/nodes_cities/dense_0/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/encoder/nodes_cities/dense_1/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/encoder/nodes_cities/dense_1/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/encoder/nodes_cities/dense_2/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/encoder/nodes_cities/dense_2/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/encoder/nodes_cities/layer_norm/gamma:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/encoder/nodes_cities/layer_norm/beta:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/encoder/edges_roads/dense_0/kernel:0 (1, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/encoder/edges_roads/dense_0/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/encoder/edges_roads/dense_1/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/encoder/edges_roads/dense_1/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/encoder/edges_roads/dense_2/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/encoder/edges_roads/dense_2/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/encoder/edges_roads/layer_norm/gamma:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/encoder/edges_roads/layer_norm/beta:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_0/edges_roads/dense_0/kernel:0 (512, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_0/edges_roads/dense_0/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_0/edges_roads/dense_1/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_0/edges_roads/dense_1/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_0/edges_roads/dense_2/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_0/edges_roads/dense_2/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_0/edges_roads/layer_norm/gamma:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_0/edges_roads/layer_norm/beta:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_0/nodes_cities/dense_0/kernel:0 (384, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_0/nodes_cities/dense_0/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_0/nodes_cities/dense_1/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_0/nodes_cities/dense_1/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_0/nodes_cities/dense_2/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_0/nodes_cities/dense_2/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_0/nodes_cities/layer_norm/gamma:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_0/nodes_cities/layer_norm/beta:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_0/context/dense_0/kernel:0 (384, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_0/context/dense_0/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_0/context/dense_1/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_0/context/dense_1/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_0/context/dense_2/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_0/context/dense_2/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_0/context/layer_norm/gamma:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_0/context/layer_norm/beta:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_1/edges_roads/dense_0/kernel:0 (512, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_1/edges_roads/dense_0/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_1/edges_roads/dense_1/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_1/edges_roads/dense_1/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_1/edges_roads/dense_2/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_1/edges_roads/dense_2/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_1/edges_roads/layer_norm/gamma:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_1/edges_roads/layer_norm/beta:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_1/nodes_cities/dense_0/kernel:0 (384, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_1/nodes_cities/dense_0/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_1/nodes_cities/dense_1/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_1/nodes_cities/dense_1/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_1/nodes_cities/dense_2/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_1/nodes_cities/dense_2/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_1/nodes_cities/layer_norm/gamma:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_1/nodes_cities/layer_norm/beta:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_1/context/dense_0/kernel:0 (384, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_1/context/dense_0/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_1/context/dense_1/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_1/context/dense_1/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_1/context/dense_2/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_1/context/dense_2/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_1/context/layer_norm/gamma:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_1/context/layer_norm/beta:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_2/edges_roads/dense_0/kernel:0 (512, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_2/edges_roads/dense_0/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_2/edges_roads/dense_1/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_2/edges_roads/dense_1/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_2/edges_roads/dense_2/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_2/edges_roads/dense_2/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_2/edges_roads/layer_norm/gamma:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_2/edges_roads/layer_norm/beta:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_2/nodes_cities/dense_0/kernel:0 (384, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_2/nodes_cities/dense_0/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_2/nodes_cities/dense_1/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_2/nodes_cities/dense_1/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_2/nodes_cities/dense_2/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_2/nodes_cities/dense_2/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_2/nodes_cities/layer_norm/gamma:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_2/nodes_cities/layer_norm/beta:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_2/context/dense_0/kernel:0 (384, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_2/context/dense_0/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_2/context/dense_1/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_2/context/dense_1/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_2/context/dense_2/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_2/context/dense_2/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_2/context/layer_norm/gamma:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_2/context/layer_norm/beta:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_3/edges_roads/dense_0/kernel:0 (512, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_3/edges_roads/dense_0/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_3/edges_roads/dense_1/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_3/edges_roads/dense_1/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_3/edges_roads/dense_2/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_3/edges_roads/dense_2/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_3/edges_roads/layer_norm/gamma:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_3/edges_roads/layer_norm/beta:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_3/nodes_cities/dense_0/kernel:0 (384, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_3/nodes_cities/dense_0/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_3/nodes_cities/dense_1/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_3/nodes_cities/dense_1/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_3/nodes_cities/dense_2/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_3/nodes_cities/dense_2/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_3/nodes_cities/layer_norm/gamma:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_3/nodes_cities/layer_norm/beta:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_3/context/dense_0/kernel:0 (384, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_3/context/dense_0/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_3/context/dense_1/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_3/context/dense_1/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_3/context/dense_2/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_3/context/dense_2/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_3/context/layer_norm/gamma:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_3/context/layer_norm/beta:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_4/edges_roads/dense_0/kernel:0 (512, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_4/edges_roads/dense_0/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_4/edges_roads/dense_1/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_4/edges_roads/dense_1/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_4/edges_roads/dense_2/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_4/edges_roads/dense_2/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_4/edges_roads/layer_norm/gamma:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_4/edges_roads/layer_norm/beta:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_4/nodes_cities/dense_0/kernel:0 (384, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_4/nodes_cities/dense_0/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_4/nodes_cities/dense_1/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_4/nodes_cities/dense_1/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_4/nodes_cities/dense_2/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_4/nodes_cities/dense_2/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_4/nodes_cities/layer_norm/gamma:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_4/nodes_cities/layer_norm/beta:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_4/context/dense_0/kernel:0 (384, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_4/context/dense_0/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_4/context/dense_1/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_4/context/dense_1/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_4/context/dense_2/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_4/context/dense_2/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_4/context/layer_norm/gamma:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_4/context/layer_norm/beta:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_5/edges_roads/dense_0/kernel:0 (512, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_5/edges_roads/dense_0/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_5/edges_roads/dense_1/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_5/edges_roads/dense_1/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_5/edges_roads/dense_2/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_5/edges_roads/dense_2/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_5/edges_roads/layer_norm/gamma:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_5/edges_roads/layer_norm/beta:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_5/nodes_cities/dense_0/kernel:0 (384, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_5/nodes_cities/dense_0/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_5/nodes_cities/dense_1/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_5/nodes_cities/dense_1/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_5/nodes_cities/dense_2/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_5/nodes_cities/dense_2/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_5/nodes_cities/layer_norm/gamma:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_5/nodes_cities/layer_norm/beta:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_5/context/dense_0/kernel:0 (384, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_5/context/dense_0/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_5/context/dense_1/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_5/context/dense_1/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_5/context/dense_2/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_5/context/dense_2/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_5/context/layer_norm/gamma:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_5/context/layer_norm/beta:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_6/edges_roads/dense_0/kernel:0 (512, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_6/edges_roads/dense_0/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_6/edges_roads/dense_1/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_6/edges_roads/dense_1/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_6/edges_roads/dense_2/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_6/edges_roads/dense_2/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_6/edges_roads/layer_norm/gamma:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_6/edges_roads/layer_norm/beta:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_6/nodes_cities/dense_0/kernel:0 (384, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_6/nodes_cities/dense_0/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_6/nodes_cities/dense_1/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_6/nodes_cities/dense_1/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_6/nodes_cities/dense_2/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_6/nodes_cities/dense_2/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_6/nodes_cities/layer_norm/gamma:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_6/nodes_cities/layer_norm/beta:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_6/context/dense_0/kernel:0 (384, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_6/context/dense_0/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_6/context/dense_1/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_6/context/dense_1/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_6/context/dense_2/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_6/context/dense_2/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_6/context/layer_norm/gamma:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_6/context/layer_norm/beta:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_7/edges_roads/dense_0/kernel:0 (512, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_7/edges_roads/dense_0/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_7/edges_roads/dense_1/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_7/edges_roads/dense_1/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_7/edges_roads/dense_2/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_7/edges_roads/dense_2/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_7/edges_roads/layer_norm/gamma:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_7/edges_roads/layer_norm/beta:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_7/nodes_cities/dense_0/kernel:0 (384, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_7/nodes_cities/dense_0/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_7/nodes_cities/dense_1/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_7/nodes_cities/dense_1/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_7/nodes_cities/dense_2/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_7/nodes_cities/dense_2/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_7/nodes_cities/layer_norm/gamma:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_7/nodes_cities/layer_norm/beta:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_7/context/dense_0/kernel:0 (384, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_7/context/dense_0/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_7/context/dense_1/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_7/context/dense_1/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_7/context/dense_2/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_7/context/dense_2/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_7/context/layer_norm/gamma:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_7/context/layer_norm/beta:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_8/edges_roads/dense_0/kernel:0 (512, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_8/edges_roads/dense_0/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_8/edges_roads/dense_1/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_8/edges_roads/dense_1/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_8/edges_roads/dense_2/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_8/edges_roads/dense_2/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_8/edges_roads/layer_norm/gamma:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_8/edges_roads/layer_norm/beta:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_8/nodes_cities/dense_0/kernel:0 (384, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_8/nodes_cities/dense_0/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_8/nodes_cities/dense_1/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_8/nodes_cities/dense_1/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_8/nodes_cities/dense_2/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_8/nodes_cities/dense_2/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_8/nodes_cities/layer_norm/gamma:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_8/nodes_cities/layer_norm/beta:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_8/context/dense_0/kernel:0 (384, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_8/context/dense_0/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_8/context/dense_1/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_8/context/dense_1/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_8/context/dense_2/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_8/context/dense_2/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_8/context/layer_norm/gamma:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_8/context/layer_norm/beta:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_9/edges_roads/dense_0/kernel:0 (512, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_9/edges_roads/dense_0/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_9/edges_roads/dense_1/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_9/edges_roads/dense_1/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_9/edges_roads/dense_2/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_9/edges_roads/dense_2/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_9/edges_roads/layer_norm/gamma:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_9/edges_roads/layer_norm/beta:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_9/nodes_cities/dense_0/kernel:0 (384, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_9/nodes_cities/dense_0/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_9/nodes_cities/dense_1/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_9/nodes_cities/dense_1/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_9/nodes_cities/dense_2/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_9/nodes_cities/dense_2/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_9/nodes_cities/layer_norm/gamma:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_9/nodes_cities/layer_norm/beta:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_9/context/dense_0/kernel:0 (384, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_9/context/dense_0/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_9/context/dense_1/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_9/context/dense_1/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_9/context/dense_2/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_9/context/dense_2/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_9/context/layer_norm/gamma:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_9/context/layer_norm/beta:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_10/edges_roads/dense_0/kernel:0 (512, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_10/edges_roads/dense_0/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_10/edges_roads/dense_1/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_10/edges_roads/dense_1/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_10/edges_roads/dense_2/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_10/edges_roads/dense_2/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_10/edges_roads/layer_norm/gamma:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_10/edges_roads/layer_norm/beta:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_10/nodes_cities/dense_0/kernel:0 (384, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_10/nodes_cities/dense_0/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_10/nodes_cities/dense_1/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_10/nodes_cities/dense_1/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_10/nodes_cities/dense_2/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_10/nodes_cities/dense_2/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_10/nodes_cities/layer_norm/gamma:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_10/nodes_cities/layer_norm/beta:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_10/context/dense_0/kernel:0 (384, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_10/context/dense_0/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_10/context/dense_1/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_10/context/dense_1/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_10/context/dense_2/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_10/context/dense_2/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_10/context/layer_norm/gamma:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_10/context/layer_norm/beta:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_11/edges_roads/dense_0/kernel:0 (512, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_11/edges_roads/dense_0/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_11/edges_roads/dense_1/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_11/edges_roads/dense_1/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_11/edges_roads/dense_2/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_11/edges_roads/dense_2/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_11/edges_roads/layer_norm/gamma:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_11/edges_roads/layer_norm/beta:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_11/nodes_cities/dense_0/kernel:0 (384, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_11/nodes_cities/dense_0/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_11/nodes_cities/dense_1/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_11/nodes_cities/dense_1/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_11/nodes_cities/dense_2/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_11/nodes_cities/dense_2/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_11/nodes_cities/layer_norm/gamma:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_11/nodes_cities/layer_norm/beta:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_11/context/dense_0/kernel:0 (384, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_11/context/dense_0/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_11/context/dense_1/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_11/context/dense_1/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_11/context/dense_2/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_11/context/dense_2/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_11/context/layer_norm/gamma:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/processor_11/context/layer_norm/beta:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/decoder/nodes_cities/dense_0/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/decoder/nodes_cities/dense_0/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/decoder/nodes_cities/dense_1/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/decoder/nodes_cities/dense_1/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/decoder/nodes_cities/dense_2/kernel:0 (128, 2) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/decoder/nodes_cities/dense_2/bias:0 (2,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/decoder/edges_roads/dense_0/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/decoder/edges_roads/dense_0/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/decoder/edges_roads/dense_1/kernel:0 (128, 128) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/decoder/edges_roads/dense_1/bias:0 (128,) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/decoder/edges_roads/dense_2/kernel:0 (128, 2) \u003cdtype: 'float32'\u003e\n",
            "encode_process_decode/decoder/edges_roads/dense_2/bias:0 (2,) \u003cdtype: 'float32'\u003e\n"
          ]
        }
      ],
      "source": [
        "# @title Build dataset, model and optimizer, inspecting variables. { form-width: \"30%\" }\n",
        "tf.keras.backend.clear_session()\n",
        "\n",
        "task_dataset = get_dataset(random_seed=0, num_nodes_min_max=(8, 17), theta=20)\n",
        "trainable_gnn = EncodeProcessDecode(\n",
        "    edge_output_size=2,  # Binary edge classification.\n",
        "    node_output_size=2,  # Binary node classification.\n",
        "    context_output_size=None,  # Don't need this output.\n",
        "    # Other configurable hyperparameters (most combinations should train).\n",
        "    num_message_passing_steps=12,\n",
        "    num_mlp_hidden_layers=2,\n",
        "    mlp_hidden_size=128,\n",
        "    latent_size=128,\n",
        "    use_layer_norm=True,\n",
        "    shared_processors=False,\n",
        "    )\n",
        "optimizer = tf.keras.optimizers.Adam(\n",
        "    learning_rate=tf.keras.optimizers.schedules.ExponentialDecay(\n",
        "        initial_learning_rate=1e-3,\n",
        "        decay_steps=1500,\n",
        "        decay_rate=0.1),\n",
        "    )\n",
        "\n",
        "# For plotting learning curves.\n",
        "steps_curve = []\n",
        "losses_curve = []\n",
        "accuracies_curve = []\n",
        "\n",
        "# Call the model once to inspect all of the variables.\n",
        "task_graph = next(iter(task_dataset))\n",
        "trainable_gnn(build_initial_hidden_state(task_graph))\n",
        "for var in trainable_gnn.variables:\n",
        "  print(var.name, var.shape, var.dtype)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "5zio3X1uvgnZ"
      },
      "outputs": [],
      "source": [
        "# @title Build loss and update fn.  { form-width: \"30%\" }\n",
        "\n",
        "def loss_fn(task_graph):\n",
        "  \"\"\"Build loss, and accuracy functions.\"\"\"\n",
        "\n",
        "  # Run forward pass and get logits.\n",
        "  input_graph = build_initial_hidden_state(task_graph)\n",
        "  output_graph = trainable_gnn(input_graph)\n",
        "\n",
        "  node_logits = output_graph.node_sets[\"cities\"][\n",
        "      tfgnn.HIDDEN_STATE]\n",
        "  edge_logits = output_graph.edge_sets[\"roads\"][\n",
        "      tfgnn.HIDDEN_STATE]\n",
        "\n",
        "  # Get ground truth labels.\n",
        "  node_labels = tf.cast(\n",
        "      task_graph.node_sets[\"cities\"][\"is_in_path\"], tf.int64)\n",
        "  edge_labels = tf.cast(\n",
        "      task_graph.edge_sets[\"roads\"][\"is_in_path\"], tf.int64)\n",
        "\n",
        "  # Simultaneously optimize the edge an node classification problem.\n",
        "  losses = {\n",
        "      \"edges\": tf.nn.sparse_softmax_cross_entropy_with_logits(\n",
        "          edge_labels, edge_logits),\n",
        "      \"nodes\": tf.nn.sparse_softmax_cross_entropy_with_logits(\n",
        "          node_labels, node_logits),\n",
        "  }\n",
        "\n",
        "  # We will also track the prediction accuracy.\n",
        "  predicted_graph = predict_from_final_hidden_state(task_graph, output_graph)\n",
        "  predicted_node_labels = tf.cast(\n",
        "      predicted_graph.node_sets[\"cities\"][\"is_in_path\"], tf.int64)\n",
        "  predicted_edge_labels = tf.cast(\n",
        "      predicted_graph.edge_sets[\"roads\"][\"is_in_path\"], tf.int64)\n",
        "  accuracy = {\n",
        "      \"edges\": tf.cast(\n",
        "          node_labels == predicted_node_labels, tf.float32),\n",
        "      \"nodes\": tf.cast(\n",
        "          edge_labels == predicted_edge_labels, tf.float32),\n",
        "  }\n",
        "\n",
        "  return tf.nest.map_structure(tf.reduce_mean, (losses, accuracy))\n",
        "\n",
        "\n",
        "def update_step(task_graph):\n",
        "  \"\"\"Step of optimization of the loss.\"\"\"\n",
        "  with tf.GradientTape() as g:\n",
        "    losses, accuracies = loss_fn(task_graph)\n",
        "  grads = g.gradient(losses, trainable_gnn.variables)\n",
        "  apply_op = optimizer.apply_gradients(zip(grads, trainable_gnn.variables))\n",
        "  with tf.control_dependencies([apply_op]):\n",
        "    return tf.nest.map_structure(tf.identity, (losses, accuracies))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "xLizjDnRmmZz"
      },
      "outputs": [],
      "source": [
        "# @title Run training (can be interrupted and continued).  { form-width: \"30%\" }\n",
        "\n",
        "NUM_ITERATIONS = 2000\n",
        "TRAIN_BATCH_SIZE = 64\n",
        "\n",
        "ds = task_dataset.batch(TRAIN_BATCH_SIZE, drop_remainder=True)\n",
        "ds = ds.map(lambda x: x.merge_batch_to_components())\n",
        "\n",
        "update_step_compiled = tf.function(update_step, input_signature=(ds.element_spec,))\n",
        "\n",
        "try:\n",
        "  for batch in ds:\n",
        "    iteration = optimizer.iterations.numpy()\n",
        "    if iteration \u003e= NUM_ITERATIONS:\n",
        "      break\n",
        "    losses, accuracies = update_step_compiled(batch)\n",
        "    steps_curve.append(iteration)\n",
        "    losses_curve.append(losses)\n",
        "    accuracies_curve.append(accuracies)\n",
        "    if iteration % 10 == 0:\n",
        "      print(f\"Iteration {iteration}. \"\n",
        "            f\"Losses {nest_to_numpy(losses)}. \"\n",
        "            f\"Accuracies {nest_to_numpy(accuracies)}\")\n",
        "except KeyboardInterrupt:\n",
        "  pass"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 215
        },
        "executionInfo": {
          "elapsed": 948,
          "status": "ok",
          "timestamp": 1656411725309,
          "user": {
            "displayName": "",
            "userId": ""
          },
          "user_tz": -120
        },
        "id": "TfvZSbE9uDI3",
        "outputId": "bcd222f3-7cce-419b-aa22-087ae452baf9"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "\u003cmatplotlib.legend.Legend at 0x7fea5772c510\u003e"
            ]
          },
          "execution_count": 12,
          "metadata": {},
          "output_type": "execute_result"
        },
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "\u003cFigure size 720x180 with 2 Axes\u003e"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "# @title Plot learning curves. { form-width: \"30%\" }\n",
        "\n",
        "smoooth_window_half_width = 3\n",
        "\n",
        "fig, axes = plt.subplots(1, 2, figsize=(10, 2.5))\n",
        "for ax, metric, data_list in zip(\n",
        "    axes, [\"Loss\", \"Accuracy\"], [losses_curve, accuracies_curve]):\n",
        "  for k in [\"edges\", \"nodes\"]:\n",
        "    x = steps_curve\n",
        "    y = [d[k] for d in data_list]\n",
        "\n",
        "    window = signal.triang(1 + 2 * smoooth_window_half_width)\n",
        "    window /= window.sum()\n",
        "    y = signal.convolve(y, window, mode=\"valid\")\n",
        "    x = x[smoooth_window_half_width:-smoooth_window_half_width]\n",
        "    ax.plot(x, y, label=k)\n",
        "  ax.set_ylabel(metric)\n",
        "  ax.set_xlabel(\"Training Iteration\")\n",
        "\n",
        "axes[0].set_yscale(\"log\")\n",
        "axes[0].set_ylim(0.00801, 4.5)\n",
        "axes[1].set_ylim(0.79, 1.01)\n",
        "axes[0].legend()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 497
        },
        "executionInfo": {
          "elapsed": 2974,
          "status": "ok",
          "timestamp": 1656411728277,
          "user": {
            "displayName": "",
            "userId": ""
          },
          "user_tz": -120
        },
        "id": "nTD2aR7m7fRF",
        "outputId": "6fc3f04a-8220-448c-cb76-f0039b40c07b"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "\u003cmatplotlib.legend.Legend at 0x7fea56ee4e90\u003e"
            ]
          },
          "execution_count": 13,
          "metadata": {},
          "output_type": "execute_result"
        },
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "\u003cFigure size 1440x576 with 10 Axes\u003e"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# @title Visualize model predictions. { form-width: \"30%\" }\n",
        "\n",
        "iterator = iter(task_dataset.take(5))\n",
        "fig, axes = plt.subplots(2, 5, figsize=(20, 8))\n",
        "for example_i, task_graph in enumerate(iterator):\n",
        "  input_graph = build_initial_hidden_state(task_graph)\n",
        "  output_graph = trainable_gnn(input_graph)\n",
        "\n",
        "  predicted_task_graph = predict_from_final_hidden_state(\n",
        "      task_graph, output_graph)\n",
        "  axes[0, example_i].set_title(f\"Example #{example_i}\")\n",
        "  draw_graph(axes[0, example_i], task_graph)\n",
        "  draw_graph(axes[1, example_i], predicted_task_graph)\n",
        "\n",
        "axes[0, 0].set_ylabel(\"Ground Truth\")\n",
        "axes[1, 0].set_ylabel(\"Prediction\")\n",
        "axes[0, -1].legend(loc=\"upper left\", bbox_to_anchor=[1., 1.], frameon=False)"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "collapsed_sections": [
        "ScitaPqhKtuW"
      ],
      "name": "graph_network_shortest_path.ipynb",
      "provenance": [
        {
          "file_id": "1hf2aqHbjj4N3btQyhS1bZRrXpxbhulYf",
          "timestamp": 1656411857824
        },
        {
          "file_id": "16jb5dCJEekOY7p3uIFgZjfBjP57cDfFB",
          "timestamp": 1649096685519
        }
      ]
    },
    "gpuClass": "standard",
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}