Bioimage_Graph_Classification_Pipeline.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "name": "Bioimage_Graph_Classification_Pipeline.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true,
      "machine_shape": "hm"
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IRqP7TDzx-Oz"
      },
      "source": [
        "Adapted Heavily from [pytorch-geometric documentation](https://pytorch-geometric.readthedocs.io). \n",
        "\n",
        "Written by Simon Levine-Gottreich, 2020\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "5VvAnS9jB-es",
        "outputId": "dffa6b71-221e-42b0-dc9a-d840cb263601"
      },
      "source": [
        "import torch\n",
        "torch.version.cuda"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'10.1'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zn5U4EE6K86v",
        "outputId": "ede4366f-62f0-4098-933c-645c3c7a58a9"
      },
      "source": [
        "!pip install -q torch-scatter==latest+cu101 -f https://pytorch-geometric.com/whl/torch-1.7.0.html\n",
        "!pip install -q torch-sparse==latest+cu101 -f https://pytorch-geometric.com/whl/torch-1.7.0.html\n",
        "!pip install -q torch-geometric"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\u001b[K     |████████████████████████████████| 11.9MB 7.4MB/s \n",
            "\u001b[K     |████████████████████████████████| 24.3MB 1.3MB/s \n",
            "\u001b[K     |████████████████████████████████| 184kB 5.4MB/s \n",
            "\u001b[K     |████████████████████████████████| 235kB 8.9MB/s \n",
            "\u001b[K     |████████████████████████████████| 2.2MB 10.4MB/s \n",
            "\u001b[K     |████████████████████████████████| 51kB 7.2MB/s \n",
            "\u001b[?25h  Building wheel for torch-geometric (setup.py) ... \u001b[?25l\u001b[?25hdone\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yFNWOPMftyFI"
      },
      "source": [
        "import os\n",
        "import os.path as osp\n",
        "import shutil\n",
        "\n",
        "import torch\n",
        "from torch_geometric.data import InMemoryDataset, download_url, extract_zip\n",
        "from torch_geometric.data import Dataset\n",
        "\n",
        "from tqdm.notebook import tqdm\n",
        "\n",
        "from torch_geometric.io import read_tu_data\n",
        "\n",
        "class CellGraphDataset(Dataset):\n",
        "    r\"\"\"\n",
        "\n",
        "    .. note::\n",
        "        Some datasets may not come with any node labels.\n",
        "        You can then either make use of the argument :obj:`use_node_attr`\n",
        "        to load additional continuous node attributes (if present) or provide\n",
        "        synthetic node features using transforms such as\n",
        "        like :class:`torch_geometric.transforms.Constant` or\n",
        "        :class:`torch_geometric.transforms.OneHotDegree`.\n",
        "\n",
        "    Args:\n",
        "        root (string;optional): Root directory where the dataset should be saved.\n",
        "        name (string): The name of the\n",
        "            dataset.\n",
        "        transform (callable, optional): A function/transform that takes in an\n",
        "            :obj:`torch_geometric.data.Data` object and returns a transformed\n",
        "            version. The data object will be transformed before every access.\n",
        "            (default: :obj:`None`)\n",
        "        pre_transform (callable, optional): A function/transform that takes in\n",
        "            an :obj:`torch_geometric.data.Data` object and returns a\n",
        "            transformed version. The data object will be transformed before\n",
        "            being saved to disk. (default: :obj:`None`)\n",
        "        pre_filter (callable, optional): A function that takes in an\n",
        "            :obj:`torch_geometric.data.Data` object and returns a boolean\n",
        "            value, indicating whether the data object should be included in the\n",
        "            final dataset. (default: :obj:`None`)\n",
        "        use_node_attr (bool, optional): If :obj:`True`, the dataset will\n",
        "            contain additional continuous node attributes (if present).\n",
        "            (default: :obj:`False`)\n",
        "        use_edge_attr (bool, optional): If :obj:`True`, the dataset will\n",
        "            contain additional continuous edge attributes (if present).\n",
        "            (default: :obj:`False`)\n",
        "        cleaned: (bool, optional): If :obj:`True`, the dataset will\n",
        "            contain only non-isomorphic graphs. (default: :obj:`False`)\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(self, root, name=None, transform=None, pre_transform=None,\n",
        "                 pre_filter=None, use_node_attr=False, use_edge_attr=False,\n",
        "                 cleaned=False):\n",
        "        self.name = name\n",
        "        self.cleaned = cleaned\n",
        "        super(CellGraphDataset, self).__init__(root, transform, pre_transform,\n",
        "                                        pre_filter)\n",
        "        \n",
        "        self.data, self.slices = torch.load(self.processed_paths[0])\n",
        "        if self.data.x is not None and not use_node_attr:\n",
        "            num_node_attributes = self.num_node_attributes\n",
        "            self.data.x = self.data.x[:, num_node_attributes:]\n",
        "        if self.data.edge_attr is not None and not use_edge_attr:\n",
        "            num_edge_attributes = self.num_edge_attributes\n",
        "            self.data.edge_attr = self.data.edge_attr[:, num_edge_attributes:]\n",
        "\n",
        "    @property\n",
        "    def raw_dir(self):\n",
        "        name = ''.format('_cleaned' if self.cleaned else '')\n",
        "        return osp.join(self.root, self.name, name)\n",
        "\n",
        "    @property\n",
        "    def processed_dir(self):\n",
        "        name = 'processed{}'.format('_cleaned' if self.cleaned else '')\n",
        "        return osp.join(self.root, self.name, name)\n",
        "\n",
        "    @property\n",
        "    def num_node_labels(self):\n",
        "        if self.data.x is None:\n",
        "            return 0\n",
        "        for i in trange(self.data.x.size(1)):\n",
        "            x = self.data.x[:, i:]\n",
        "            if ((x == 0) | (x == 1)).all() and (x.sum(dim=1) == 1).all():\n",
        "                return self.data.x.size(1) - i\n",
        "        return 0\n",
        "\n",
        "    @property\n",
        "    def num_node_attributes(self):\n",
        "        if self.data.x is None:\n",
        "            return 0\n",
        "        return self.data.x.size(1) - self.num_node_labels\n",
        "\n",
        "    @property\n",
        "    def num_edge_labels(self):\n",
        "        if self.data.edge_attr is None:\n",
        "            return 0\n",
        "        for i in trange(self.data.edge_attr.size(1)):\n",
        "            if self.data.edge_attr[:, i:].sum() == self.data.edge_attr.size(0):\n",
        "                return self.data.edge_attr.size(1) - i\n",
        "        return 0\n",
        "\n",
        "    @property\n",
        "    def num_edge_attributes(self):\n",
        "        if self.data.edge_attr is None:\n",
        "            return 0\n",
        "        return self.data.edge_attr.size(1) - self.num_edge_labels\n",
        "\n",
        "    @property\n",
        "    def raw_file_names(self):\n",
        "        names = ['A', 'graph_indicator']\n",
        "        return ['{}_{}.txt'.format(self.name, name) for name in names]\n",
        "\n",
        "    @property\n",
        "    def processed_file_names(self):\n",
        "        return 'data.pt'\n",
        "\n",
        "    def load_data(self):\n",
        "        folder = osp.join(self.root, self.name)\n",
        "        os.rename(osp.join(folder, self.name)) #, self.raw_dir)\n",
        "\n",
        "    def process(self):\n",
        "        self.data, self.slices = read_tu_data(self.raw_dir, self.name)\n",
        "\n",
        "        if self.pre_filter is not None:\n",
        "            data_list = [self.get(idx) for idx in trange(len(self))]\n",
        "            data_list = [data for data in data_list if self.pre_filter(data)]\n",
        "            self.data, self.slices = self.collate(data_list)\n",
        "\n",
        "        if self.pre_transform is not None:\n",
        "            data_list = [self.get(idx) for idx in trange(len(self))]\n",
        "            data_list = [self.pre_transform(data) for data in data_list]\n",
        "            self.data, self.slices = self.collate(data_list)\n",
        "\n",
        "        torch.save((self.data, self.slices), self.processed_paths[0])\n",
        "\n",
        "    def __repr__(self):\n",
        "        return '{}({})'.format(self.name, len(self))\n"
      ],
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wPRn_893vnTJ",
        "outputId": "5a94107e-2f65-4c67-d989-1bccaad00b1b"
      },
      "source": [
        "processed_dataset = CellGraphDataset(root='/content/data', name = 'DS',use_node_attr=True,use_edge_attr=True)\n",
        "processed_dataset"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Processing...\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MUCeeOoi4hOr"
      },
      "source": [
        "!gsutil cp -r /content/data/DS/processed gs://new-bucket-fall2020/data"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "f5Oye_qNqEVu"
      },
      "source": [
        "# from google.colab import auth\n",
        "# auth.authenticate_user()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_5FBQ9gXpL-W"
      },
      "source": [
        "Loading the data into pt-geometric:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mHSP6-RBOqCE"
      },
      "source": [
        "import torch\n",
        "\n",
        "print()\n",
        "print(f'Dataset: {dataset}:')\n",
        "print('====================')\n",
        "print(f'Number of graphs: {len(dataset)}')\n",
        "print(f'Number of features: {dataset.num_features}')\n",
        "print(f'Number of classes: {dataset.num_classes}')\n",
        "\n",
        "data = dataset[0]  # Get the first graph object.\n",
        "\n",
        "print()\n",
        "print(data)\n",
        "print('=============================================================')\n",
        "\n",
        "# Gather some statistics about the first graph.\n",
        "print(f'Number of nodes: {data.num_nodes}')\n",
        "print(f'Number of edges: {data.num_edges}')\n",
        "print(f'Average node degree: {data.num_edges / data.num_nodes:.2f}')\n",
        "print(f'Contains isolated nodes: {data.contains_isolated_nodes()}')\n",
        "print(f'Contains self-loops: {data.contains_self_loops()}')\n",
        "print(f'Is undirected: {data.is_undirected()}')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YzBVDncFJn-Z"
      },
      "source": [
        "data"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "j11WiUr-PRH_",
        "outputId": "d8ccfdb4-e78f-43ae-c7cf-b5f10f961786"
      },
      "source": [
        "torch.manual_seed(12345)\n",
        "dataset = dataset.shuffle()\n",
        "\n",
        "n_trn = (int(round(.67*len(dataset))))\n",
        "\n",
        "train_dataset = dataset[:n_trn]\n",
        "test_dataset = dataset[n_trn:]\n",
        "\n",
        "print(f'Number of training graphs: {len(train_dataset)}')\n",
        "print(f'Number of test graphs: {len(test_dataset)}')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Number of training graphs: 402\n",
            "Number of test graphs: 198\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qeORu4Zrs8Zy"
      },
      "source": [
        "## Mini-batching of graphs\n",
        "\n",
        "Since graphs in graph classification datasets are usually small, a good idea is to **batch the graphs** before inputting them into a Graph Neural Network to guarantee full GPU utilization.\n",
        "In the image or language domain, this procedure is typically achieved by **rescaling** or **padding** each example into a set of equally-sized shapes, and examples are then grouped in an additional dimension.\n",
        "The length of this dimension is then equal to the number of examples grouped in a mini-batch and is typically referred to as the `batch_size`.\n",
        "\n",
        "However, for GNNs the two approaches described above are either not feasible or may result in a lot of unnecessary memory consumption.\n",
        "Therefore, PyTorch Geometric opts for another approach to achieve parallelization across a number of examples. Here, adjacency matrices are stacked in a diagonal fashion (creating a giant graph that holds multiple isolated subgraphs), and node and target features are simply concatenated in the node dimension:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2owRWKcuoALo"
      },
      "source": [
        "![Screen Shot 2020-08-27 at 13.11.53.png](data:image/png;base64,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)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0gZ-l0npPIca",
        "outputId": "3fc8cab0-d99a-4501-a83c-03c586eb8303"
      },
      "source": [
        "from torch_geometric.data import DataLoader\n",
        "\n",
        "train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)\n",
        "test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False)\n",
        "\n",
        "for step, data in enumerate(train_loader):\n",
        "    print(f'Step {step + 1}:')\n",
        "    print('=======')\n",
        "    print(f'Number of graphs in the current batch: {data.num_graphs}')\n",
        "    print(data)\n",
        "    print()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Step 1:\n",
            "=======\n",
            "Number of graphs in the current batch: 64\n",
            "Batch(batch=[2010], edge_index=[2, 7636], x=[2010, 3], y=[64])\n",
            "\n",
            "Step 2:\n",
            "=======\n",
            "Number of graphs in the current batch: 64\n",
            "Batch(batch=[2180], edge_index=[2, 7984], x=[2180, 3], y=[64])\n",
            "\n",
            "Step 3:\n",
            "=======\n",
            "Number of graphs in the current batch: 64\n",
            "Batch(batch=[2095], edge_index=[2, 8194], x=[2095, 3], y=[64])\n",
            "\n",
            "Step 4:\n",
            "=======\n",
            "Number of graphs in the current batch: 64\n",
            "Batch(batch=[1986], edge_index=[2, 7660], x=[1986, 3], y=[64])\n",
            "\n",
            "Step 5:\n",
            "=======\n",
            "Number of graphs in the current batch: 64\n",
            "Batch(batch=[2108], edge_index=[2, 8170], x=[2108, 3], y=[64])\n",
            "\n",
            "Step 6:\n",
            "=======\n",
            "Number of graphs in the current batch: 64\n",
            "Batch(batch=[2316], edge_index=[2, 8692], x=[2316, 3], y=[64])\n",
            "\n",
            "Step 7:\n",
            "=======\n",
            "Number of graphs in the current batch: 18\n",
            "Batch(batch=[554], edge_index=[2, 2144], x=[554, 3], y=[18])\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OfQmEavtvOcN"
      },
      "source": [
        "Here, we opt for a `batch_size` of 64, leading to 7 (randomly shuffled) mini-batches, containing all graphs.\n",
        "\n",
        "Furthermore, each `Batch` object is equipped with a **`batch` vector**, which maps each node to its respective graph in the batch:\n",
        "\n",
        "$$\n",
        "\\textrm{batch} = [ 0, \\ldots, 0, 1, \\ldots, 1, 2, \\ldots ]\n",
        "$$"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0pq-VyzUwPpw"
      },
      "source": [
        "## Training a Graph Neural Network (GNN)\n",
        "\n",
        "Training a GNN for graph classification usually follows a simple recipe:\n",
        "\n",
        "1. Embed each node by performing multiple rounds of message passing\n",
        "2. Aggregate node embeddings into a unified graph embedding (**readout layer**)\n",
        "3. Train a final classifier on the graph embedding\n",
        "\n",
        "There exists multiple **readout layers** in literature, but the most common one is to simply take the average of node embeddings:\n",
        "\n",
        "$$\n",
        "\\mathbf{x}_{\\mathcal{G}} = \\frac{1}{|\\mathcal{V}|} \\sum_{v \\in \\mathcal{V}} \\mathcal{x}^{(L)}_v\n",
        "$$\n",
        "\n",
        "PyTorch Geometric provides this functionality via [`torch_geometric.nn.global_mean_pool`](https://pytorch-geometric.readthedocs.io/en/latest/modules/nn.html#torch_geometric.nn.glob.global_mean_pool), which takes in the node embeddings of all nodes in the mini-batch and the assignment vector `batch` to compute a graph embedding of size `[batch_size, hidden_channels]` for each graph in the batch.\n",
        "\n",
        "The final architecture for applying GNNs to the task of graph classification then looks as follows and allows for complete end-to-end training:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CN3sRVuaQ88l",
        "outputId": "aebee46d-db3e-4d4a-e568-c77eb36cf8df"
      },
      "source": [
        "from torch.nn import Linear\n",
        "import torch.nn.functional as F\n",
        "from torch_geometric.nn import GCNConv\n",
        "from torch_geometric.nn import global_mean_pool\n",
        "\n",
        "\n",
        "class GCN(torch.nn.Module):\n",
        "    def __init__(self, hidden_channels):\n",
        "        super(GCN, self).__init__()\n",
        "        torch.manual_seed(12345)\n",
        "        self.conv1 = GCNConv(dataset.num_node_features, hidden_channels)\n",
        "        self.conv2 = GCNConv(hidden_channels, hidden_channels)\n",
        "        self.conv3 = GCNConv(hidden_channels, hidden_channels)\n",
        "        self.lin = Linear(hidden_channels, dataset.num_classes)\n",
        "\n",
        "    def forward(self, x, edge_index, batch):\n",
        "        # 1. Obtain node embeddings \n",
        "        x = self.conv1(x, edge_index)\n",
        "        x = x.relu()\n",
        "        x = self.conv2(x, edge_index)\n",
        "        x = x.relu()\n",
        "        x = self.conv3(x, edge_index)\n",
        "\n",
        "        # 2. Readout layer\n",
        "        x = global_mean_pool(x, batch)  # [batch_size, hidden_channels]\n",
        "\n",
        "        # 3. Apply a final classifier\n",
        "        x = F.dropout(x, p=0.5, training=self.training)\n",
        "        x = self.lin(x)\n",
        "        \n",
        "        return x\n",
        "\n",
        "model = GCN(hidden_channels=64)\n",
        "print(model)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "GCN(\n",
            "  (conv1): GCNConv(3, 64)\n",
            "  (conv2): GCNConv(64, 64)\n",
            "  (conv3): GCNConv(64, 64)\n",
            "  (lin): Linear(in_features=64, out_features=6, bias=True)\n",
            ")\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "V2Q37tbHyQ6A"
      },
      "source": [
        "Here, we again make use of the [`GCNConv`](https://pytorch-geometric.readthedocs.io/en/latest/modules/nn.html#torch_geometric.nn.conv.GCNConv) with $\\mathrm{ReLU}(x) = \\max(x, 0)$ activation for obtaining localized node embeddings, before we apply our final classifier on top of a graph readout layer.\n",
        "\n",
        "Let's train our network for a few epochs to see how well it performs on the training as well as test set:"
      ]
    },
    {
      "source": [
        "from IPython.display import Javascript\n",
        "display(Javascript('''google.colab.output.setIframeHeight(0, true, {maxHeight: 300})'''))\n",
        "\n",
        "model = GCN(hidden_channels=64)\n",
        "optimizer = torch.optim.Adam(model.parameters(), lr=0.01)\n",
        "criterion = torch.nn.CrossEntropyLoss()\n",
        "\n",
        "trn_losses=[]\n",
        "\n",
        "def train():\n",
        "    model.train()\n",
        "\n",
        "    for data in train_loader:  # Iterate in batches over the training dataset.\n",
        "         out = model(data.x, data.edge_index, data.batch)  # Perform a single forward pass.\n",
        "         loss = criterion(out, data.y)  # Compute the loss.\n",
        "         loss.backward()  # Derive gradients.\n",
        "         optimizer.step()  # Update parameters based on gradients.\n",
        "         optimizer.zero_grad()  # Clear gradients.\n",
        "         trn_losses.append(loss)\n",
        "\n",
        "def test(loader):\n",
        "     model.eval()\n",
        "\n",
        "     correct = 0\n",
        "     for data in loader:  # Iterate in batches over the training/test dataset.\n",
        "         out = model(data.x, data.edge_index, data.batch)  \n",
        "         pred = out.argmax(dim=1)  # Use the class with highest probability.\n",
        "         correct += int((pred == data.y).sum())  # Check against ground-truth labels.\n",
        "     return correct / len(loader.dataset)  # Derive ratio of correct predictions.\n",
        "\n",
        "\n",
        "\n",
        "for epoch in range(1, 201):\n",
        "    train()\n",
        "    train_acc = test(train_loader)\n",
        "    test_acc = test(test_loader)\n",
        "    print(f'Epoch: {epoch:03d}, Train Acc: {train_acc:.4f}, Test Acc: {test_acc:.4f}')"
      ],
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 300
        },
        "id": "HvhgQoO8Svw4",
        "outputId": "c2696419-9165-42e9-8458-9dc174a969fa"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9mTJL0WfzeBq"
      },
      "source": [
        "As one can see, our model reaches around **76% test accuracy**.\n",
        "Reasons for the fluctations in accuracy can be explained by the rather small dataset (only 38 test graphs), and usually disappear once one applies GNNs to larger datasets.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ecJCNRmT2RsF"
      },
      "source": [
        "## Further Exercise\n",
        "\n",
        "Can we do better than this?\n",
        "As multiple papers pointed out ([Xu et al. (2018)](https://arxiv.org/abs/1810.00826), [Morris et al. (2018)](https://arxiv.org/abs/1810.02244)), applying **neighborhood normalization decreases the expressivity of GNNs in distinguishing certain graph structures**.\n",
        "An alternative formulation ([Morris et al. (2018)](https://arxiv.org/abs/1810.02244)) omits neighborhood normalization completely and adds a simple skip-connection to the GNN layer in order to preserve central node information:\n",
        "\n",
        "$$\n",
        "\\mathbf{x}_v^{(\\ell+1)} = \\mathbf{W}^{(\\ell + 1)}_1 \\mathbf{x}_v^{(\\ell)} + \\mathbf{W}^{(\\ell + 1)}_2 \\sum_{w \\in \\mathcal{N}(v)} \\mathbf{x}_w^{(\\ell)}\n",
        "$$\n",
        "\n",
        "This layer is implemented under the name [`GraphConv`](https://pytorch-geometric.readthedocs.io/en/latest/modules/nn.html#torch_geometric.nn.conv.GraphConv) in PyTorch Geometric.\n",
        "\n",
        "As an exercise, you are invited to complete the following code to the extent that it makes use of PyG's `GraphConv` rather than `GCNConv`.\n",
        "This should bring you close to **82% test accuracy**."
      ]
    },
    {
      "source": [
        "from torch_geometric.nn import GraphConv\n",
        "\n",
        "\n",
        "class GNN(torch.nn.Module):\n",
        "    def __init__(self, hidden_channels):\n",
        "        super(GNN, self).__init__()\n",
        "        torch.manual_seed(12345)\n",
        "        self.conv1 = GraphConv(dataset.num_node_features, hidden_channels)\n",
        "        self.conv2 = GraphConv(hidden_channels, hidden_channels)\n",
        "        self.conv3 = GraphConv(hidden_channels, hidden_channels)\n",
        "        self.lin = Linear(hidden_channels, dataset.num_classes)\n",
        "\n",
        "    def forward(self, x, edge_index, batch):\n",
        "        x = self.conv1(x, edge_index)\n",
        "        x = x.relu()\n",
        "        x = self.conv2(x, edge_index)\n",
        "        x = x.relu()\n",
        "        x = self.conv3(x, edge_index)\n",
        "\n",
        "        x = global_mean_pool(x, batch)\n",
        "\n",
        "        x = F.dropout(x, p=0.5, training=self.training)\n",
        "        x = self.lin(x)\n",
        "        \n",
        "        return x\n",
        "\n",
        "model = GNN(hidden_channels=64)\n",
        "print(model)"
      ],
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cNgkR8SRaU_P",
        "outputId": "ea87f6f2-31c9-4191-d3fa-3caef6e956f8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "source": [
        "from IPython.display import Javascript\n",
        "display(Javascript('''google.colab.output.setIframeHeight(0, true, {maxHeight: 300})'''))\n",
        "\n",
        "model = GNN(hidden_channels=64)\n",
        "print(model)\n",
        "optimizer = torch.optim.Adam(model.parameters(), lr=0.01)\n",
        "\n",
        "for epoch in range(1, 201):\n",
        "    train()\n",
        "    train_acc = test(train_loader)\n",
        "    test_acc = test(test_loader)\n",
        "    print(f'Epoch: {epoch:03d}, Train Acc: {train_acc:.4f}, Test Acc: {test_acc:.4f}')"
      ],
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 300
        },
        "id": "xs5D713Ia_Sv",
        "outputId": "ef582be4-a9c4-4206-cd8a-83dda9971f02"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GKN1kyAlyy87"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}