{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6CXmVDnxAI3l"
      },
      "outputs": [],
      "source": [
        "# %%capture\n",
        "!pip install tf_gnns==0.1.9\n",
        "!pip install tqdm\n",
        "!pip install torch_geometric\n",
        "# uncomment if not in local env: (in colab these are available by default)\n",
        "# !pip install 'tensorflow[and-cuda]==2.20' # if locally\n",
        "# !pip install torch\n",
        "# !pip install scikit-learn\n",
        "# !pip install pandas"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {},
      "outputs": [],
      "source": [
        "# !uv pip install ipykernel"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {},
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n",
            "I0000 00:00:1780259636.493385  285530 port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n",
            "I0000 00:00:1780259636.521927  285530 cpu_feature_guard.cc:227] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
            "To enable the following instructions: AVX2 AVX_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
            "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n",
            "I0000 00:00:1780259637.426289  285530 port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "2.21.0\n",
            "0.2.0\n"
          ]
        }
      ],
      "source": [
        "import tensorflow as tf\n",
        "import tf_gnns\n",
        "print(tf.__version__)\n",
        "print(tf_gnns.__version__)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\u001b[2mUsing Python 3.11.14 environment at: /home/charilaos/Workspace/tf_gnns/.venv\u001b[0m\n",
            "\u001b[2K\u001b[2mResolved \u001b[1m11 packages\u001b[0m \u001b[2min 71ms\u001b[0m\u001b[0m                                         \u001b[0m\n",
            "\u001b[2K\u001b[2mInstalled \u001b[1m6 packages\u001b[0m \u001b[2min 14ms\u001b[0m\u001b[0m                                \u001b[0m\n",
            " \u001b[32m+\u001b[39m \u001b[1mcontourpy\u001b[0m\u001b[2m==1.3.3\u001b[0m\n",
            " \u001b[32m+\u001b[39m \u001b[1mcycler\u001b[0m\u001b[2m==0.12.1\u001b[0m\n",
            " \u001b[32m+\u001b[39m \u001b[1mfonttools\u001b[0m\u001b[2m==4.63.0\u001b[0m\n",
            " \u001b[32m+\u001b[39m \u001b[1mkiwisolver\u001b[0m\u001b[2m==1.5.0\u001b[0m\n",
            " \u001b[32m+\u001b[39m \u001b[1mmatplotlib\u001b[0m\u001b[2m==3.10.9\u001b[0m\n",
            " \u001b[32m+\u001b[39m \u001b[1mpillow\u001b[0m\u001b[2m==12.2.0\u001b[0m\n"
          ]
        }
      ],
      "source": [
        "!uv pip install matplotlib"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {},
      "outputs": [],
      "source": [
        "from torch_geometric.loader import DataLoader"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "WoDrnu5QAI3n"
      },
      "outputs": [],
      "source": [
        "import torch\n",
        "import tensorflow as tf\n",
        "from torch_geometric.loader import DataLoader\n",
        "from torch_geometric.datasets import PPI\n",
        "from tqdm import tqdm\n",
        "import matplotlib.pyplot as pplot"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "id": "aI4JTtbNAI3n"
      },
      "outputs": [],
      "source": [
        "## Transformations from pytorch geometric to tf_gnns:\n",
        "def _pt_to_tf(x):\n",
        "    x_dl = torch.utils.dlpack.to_dlpack(x)\n",
        "    return tf.experimental.dlpack.from_dlpack(x_dl)\n",
        "\n",
        "def _infer_n_nodes(dbatch):\n",
        "    n_nodes = tf.cast(\n",
        "        tf.math.segment_sum(tf.ones(tf.shape(dbatch.batch)[0]), dbatch.batch), tf.int64\n",
        "    )\n",
        "    return n_nodes\n",
        "\n",
        "def _infer_n_edges(dbatch, n_nodes):\n",
        "    \"\"\"DGL/PyG batches don't contain n_nodes and n_edges.\n",
        "    When performing global aggregations per-graph, we need these\n",
        "    to correctly aggregate the graph outputs.\n",
        "\n",
        "    This utility function infers from the pyg databatch the n_edges and n_nodes\n",
        "    per graph. The function is fully vectorized and should have minimal overhead.\n",
        "    \"\"\"\n",
        "    nnodes_cumsum = tf.cumsum(n_nodes)[...,tf.newaxis]\n",
        "    _dd1 = dbatch.edge_index[0] < nnodes_cumsum\n",
        "    _dd2 = dbatch.edge_index[1] < nnodes_cumsum\n",
        "    _c1 = tf.reduce_sum(tf.cast(_dd1, tf.int64), axis = 1)\n",
        "    _c2 = tf.reduce_sum(tf.cast(_dd2, tf.int64), axis = 1)\n",
        "    edge_offsets = tf.reduce_max(tf.stack([_c1, _c2]),0)-1\n",
        "    n_edges = tf.concat([edge_offsets[0][tf.newaxis], edge_offsets[1:] - edge_offsets[:-1]], axis = 0)\n",
        "    return n_edges\n",
        "\n",
        "def _dgl_databatch_to_tfgnn_graph_tuple(dbatch, infer_n_edges = False):\n",
        "    \"\"\"TFGNNs uses a simple dictionary of tensorflow tensors for input data.\n",
        "    The TFGNN model constructors will skip creating a global variable and\n",
        "    global message passing (e.g., node-to-global, edge-to-global)\n",
        "    if there is no global variable in the inputs.\n",
        "    \"\"\"\n",
        "    x =  _pt_to_tf(dbatch.x)\n",
        "    y =  _pt_to_tf(dbatch.y)\n",
        "    edges = _pt_to_tf(dbatch.edge_index)\n",
        "    n_graphs = dbatch.num_graphs\n",
        "    n_nodes = _infer_n_nodes(dbatch)\n",
        "\n",
        "    dd = {\n",
        "        'senders' : edges[0],\n",
        "        'receivers' : edges[1],\n",
        "        'edges' : tf.ones((tf.shape(edges)[1],1 ) ),\n",
        "        'nodes' : x,\n",
        "        'n_nodes' : n_nodes,\n",
        "        'n_graphs' : tf.constant(n_graphs)\n",
        "    }\n",
        "    if infer_n_edges:\n",
        "        dd['n_edges'] = _infer_n_edges(dbatch, n_nodes)\n",
        "    return dd, y\n",
        "\n",
        "_ppi_docstring_ = PPI.__doc__\n",
        "\n",
        "class TfgPPI:\n",
        "    __doc__=f\"\"\"A wrapper to the pytorch_geometric (pyg) data classes and data loaders.\n",
        "    It uses the loaders from `pyg` to get pytorch tensors, and `dlpack` to transform\n",
        "    them in-memory to `tensorflow` tensors compatible with tf_gnns.\n",
        "\n",
        "    Because the PPI dataset has a relatively small memory footprint,\n",
        "    the data can be pre-transformed in-memory.\n",
        "\n",
        "    Args:\n",
        "        ppi_root : the root dir to be passed into the wrapped class\n",
        "        split : (str) 'train' or 'test'/'val'.\n",
        "\n",
        "    ----------------------------------------------------------------------------\n",
        "    Wrapped class docstring (parameters of wrapped class are irrelevant)\n",
        "    shown for easier reference:\n",
        "    ----------------------------------------------------------------------------\n",
        "\n",
        "    {_ppi_docstring_}\n",
        "    \"\"\"\n",
        "    def __init__(self, ppi_root : str = '.ppi_cache',split : str= 'train'):\n",
        "        self.ppi_root = ppi_root\n",
        "        self.ppi_obj = PPI(ppi_root, split = split)\n",
        "\n",
        "\n",
        "    def generator(self, batch_size = 1, shuffle = True, for_pyg = False):\n",
        "        for g in DataLoader(self.ppi_obj, batch_size=batch_size, shuffle=shuffle):\n",
        "            if for_pyg:\n",
        "                yield g\n",
        "            else:\n",
        "                yield _dgl_databatch_to_tfgnn_graph_tuple(g)\n",
        "    def get_prepared_data(self,batch_size = 1, shuffle = True, for_pyg = False):\n",
        "        return [gg for gg in self.generator(batch_size=batch_size, shuffle = shuffle, for_pyg = for_pyg)]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "id": "db8hILAUAI3o"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "I0000 00:00:1780259676.005291  285996 gpu_device.cc:2043] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 21207 MB memory:  -> device: 0, name: NVIDIA GeForce RTX 4090, pci bus id: 0000:01:00.0, compute capability: 8.9\n"
          ]
        }
      ],
      "source": [
        "train_data = TfgPPI(ppi_root = '.', split='train').get_prepared_data(batch_size=1, shuffle = True)\n",
        "val_data = TfgPPI(ppi_root = '.', split='val').get_prepared_data(batch_size=2, shuffle = True)\n",
        "test_data = TfgPPI(ppi_root = '.', split='test').get_prepared_data(batch_size=2, shuffle = True)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "id": "gjAdRptWAI3o"
      },
      "outputs": [],
      "source": [
        "from tf_gnns import GraphNetMPNN_MLP, GraphIndep\n",
        "from tf_gnns.lib.gt_ops import _assign_add_tensor_dict"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "id": "9z7BN0TZAI3o"
      },
      "outputs": [],
      "source": [
        "from tf_gnns import GNCellMLP\n",
        "def _assign_add_tensor_dict_noglobals(d_,od):\n",
        "    d_['nodes']       = d_['nodes']       + od['nodes']\n",
        "    d_['edges']       = d_['edges']       + od['edges']\n",
        "    return d_\n",
        "\n",
        "class MPNNNodeClassifier(tf.keras.Model):\n",
        "    def __init__(self, enc_units = 32, mpnn_units = 128, mp_steps = 2, n_classes_out = 121):\n",
        "        super(MPNNNodeClassifier,self).__init__()\n",
        "        self.mp_steps = mp_steps\n",
        "        self.g_enc = GraphIndep(enc_units)\n",
        "        self.core_gns = []\n",
        "\n",
        "        self.mpnn_units = mpnn_units\n",
        "        for c in range(self.mp_steps):\n",
        "            self.core_gns.append(GNCellMLP(self.mpnn_units))\n",
        "\n",
        "        # project nodes to n_classes_out:\n",
        "        self.node_dec = tf.keras.layers.Dense(n_classes_out)\n",
        "\n",
        "    def call(self, graph_in, return_logits = False):\n",
        "        _g = self.g_enc(graph_in)\n",
        "\n",
        "        for m in self.core_gns:\n",
        "            _g_new = m(_g)\n",
        "            _g = _assign_add_tensor_dict_noglobals(_g, _g_new)\n",
        "        res = self.node_dec(_g['nodes'])\n",
        "        if return_logits:\n",
        "            return res\n",
        "        else:\n",
        "            return tf.nn.sigmoid(res)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "id": "ODcTH3QGAI3p"
      },
      "outputs": [],
      "source": [
        "n_classes = train_data[0][1].shape[1]\n",
        "model = MPNNNodeClassifier(enc_units=512, mpnn_units=512, mp_steps = 4, n_classes_out=n_classes)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "id": "slEltM79AI3p"
      },
      "outputs": [],
      "source": [
        "opt = tf.keras.optimizers.Adam(learning_rate=0.0001, clipnorm=1.)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "id": "yWzxI4HJAI3p"
      },
      "outputs": [],
      "source": [
        "train_data = TfgPPI(ppi_root = '.', split='train').get_prepared_data(batch_size=2, shuffle = True, for_pyg = False)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "id": "jx1OSPNxAI3p"
      },
      "outputs": [],
      "source": [
        "@tf.function\n",
        "def train_step(y_true, g_inp):\n",
        "    with tf.GradientTape() as tape:\n",
        "        x_out = model(g_inp, return_logits = True)\n",
        "        loss = tf.nn.sigmoid_cross_entropy_with_logits(y_true, x_out)\n",
        "        grad = tape.gradient(loss, model.weights)\n",
        "        opt.apply_gradients(zip(grad, model.weights))\n",
        "    return tf.reduce_mean(loss)\n",
        "\n",
        "@tf.function\n",
        "def _full_set_loss_comp(which_set = 'train'):\n",
        "    set_dict = {\n",
        "        'train' : train_data,\n",
        "        'test' : test_data,\n",
        "        'val' : val_data\n",
        "    }\n",
        "    losses = []\n",
        "    for g_in , y in set_dict[which_set]:\n",
        "        res = model(g_in, return_logits = True)\n",
        "        loss = tf.nn.sigmoid_cross_entropy_with_logits(y, res)\n",
        "        losses.append(loss)\n",
        "    return tf.reduce_mean(losses)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "id": "yUWbGf9VAI3q"
      },
      "outputs": [],
      "source": [
        "train_losses = []\n",
        "val_losses = []\n",
        "test_losses = []"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 485
        },
        "id": "DwV7GjzQAI3q",
        "outputId": "05670c53-09a5-48db-e5f2-29bfd5d2cfaf"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1000x500 with 2 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "100%|██████████| 500/500 [13:22<00:00,  1.61s/it]\n"
          ]
        }
      ],
      "source": [
        "from IPython.display import clear_output\n",
        "import numpy as np\n",
        "\n",
        "num_epochs = 500\n",
        "for e in tqdm(range(num_epochs)):\n",
        "\n",
        "    _train_losses = []\n",
        "    for graph_inp, labels in tqdm(train_data):\n",
        "        l = train_step( labels, graph_inp)\n",
        "        _train_losses.append(l)\n",
        "    train_losses.append(np.mean(_train_losses))\n",
        "    val_losses.append(_full_set_loss_comp('val'))\n",
        "    test_losses.append(_full_set_loss_comp('test'))\n",
        "    clear_output()\n",
        "    pplot.figure(figsize = (10,5), dpi  =100)\n",
        "    pplot.subplot(1,2,1)\n",
        "    pplot.plot(train_losses)\n",
        "    pplot.title('training loss')\n",
        "    pplot.grid()\n",
        "    pplot.subplot(1,2,2)\n",
        "\n",
        "    pplot.plot(val_losses,label = 'val')\n",
        "    pplot.plot(test_losses,label = 'test')\n",
        "    pplot.title('Test/Val losses')\n",
        "    pplot.grid()\n",
        "    pplot.legend()\n",
        "    pplot.pause(.1)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OFTuQHIlAI3q"
      },
      "source": [
        "## Evaluation"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {
        "id": "PZ3jBXTBAI3r"
      },
      "outputs": [],
      "source": [
        "test_node_vals, test_pred = test_data[0][1], model(test_data[0][0]) # test data contains only 1 graph."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "id": "K-sXT3nHAI3r"
      },
      "outputs": [],
      "source": [
        "from sklearn.metrics import roc_auc_score, f1_score, accuracy_score\n",
        "roc_auc_scores = [roc_auc_score(test_node_vals[:,i], test_pred[:,i]) for i in range(test_node_vals.shape[1])]\n",
        "f1_scores = [f1_score(test_node_vals[:,i], test_pred[:,i]>.5) for i in range(test_node_vals.shape[1])]\n",
        "accuracy_scores = [accuracy_score(test_node_vals[:,i], test_pred[:,i]>.5) for i in range(test_node_vals.shape[1])]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 178
        },
        "id": "YUtETDvED6Vb",
        "outputId": "72dacf89-6733-402b-a705-f463939d8f86"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "roc_auc_scores     0.996229\n",
              "f1_scores          0.977510\n",
              "accuracy_scores    0.988191\n",
              "dtype: float64"
            ]
          },
          "execution_count": 20,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "import pandas as pd\n",
        "pd.set_option('display.max_rows',None)\n",
        "test_set_metrics = pd.DataFrame([roc_auc_scores, f1_scores, accuracy_scores]).T\n",
        "test_set_metrics.columns = ['roc_auc_scores', 'f1_scores', 'accuracy_scores']\n",
        "test_set_metrics.mean()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RNUVrXvFAI3r"
      },
      "source": [
        "## Comparison with other models\n",
        "\n",
        "| Metric | GAT     | this model|\n",
        "|--------|---------|-----------|\n",
        "| F1     |  0.973  |   0.978   |\n",
        "\n",
        "\n",
        "The model performance in F1 score is comparable with the GAT reported in the [Graph Attention Networks](https://arxiv.org/pdf/1710.10903v3) paper.\n",
        "\n",
        "It's possible that with further hyper-parameter tuning or using some self-supervision tricks (e.g., pre-training the newtork on constrastive tasks or as an autoencoder) can bring the performance to state of the art.\n",
        "\n"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "gpuType": "A100",
      "machine_shape": "hm",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "tf_gnns (3.11.14)",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.11.14"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}