{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lab PyG\n",
    "\n",
    "### Andrea Passerini, Antonio Longa \n",
    "### andrea.passerini@unitn.it, antonio.longa@unitn.it"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pytorch Geometric (PyG) \n",
    "\n",
    "Pytorch Geometric (PyG) is a geometric deep learning extension library for PyTorch. It consists of various methods for deep learning on graphs and other irregular structures. It implements plenty of graph neural networks from the literature and allows to easily prototype new ones.\n",
    "\n",
    "Adapted from tutorials and notebooks from https://github.com/rusty1s/pytorch_geometric"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating Message Passing Networks\n",
    "\n",
    "\n",
    "![title](img/img1.png)\n",
    "\n",
    "\n",
    "Graph neural networks can be defined in terms of a *neighborhood aggregation* or *message passing* scheme.\n",
    "With $\\mathbf{x}^{(k-1)}_i \\in \\mathbb{R}^F$ denoting node features of node $i$ in layer $(k-1)$ and $\\mathbf{e}_{j,i} \\in \\mathbb{R}^D$ denoting (optional) edge features from node $j$ to node $i$, message passing graph neural networks can be described as\n",
    "\n",
    "\n",
    "\n",
    "$$\n",
    "  \\mathbf{x}_i^{(k)} = \\gamma^{(k)} \\left( \\mathbf{x}_i^{(k-1)}, \\square_{j \\in \\mathcal{N}(i)} \\, \\phi^{(k)}\\left(\\mathbf{x}_i^{(k-1)}, \\mathbf{x}_j^{(k-1)},\\mathbf{e}_{j,i}\\right) \\right),\n",
    "$$\n",
    "\n",
    "where $\\square$ denotes a differentiable, permutation invariant function, *e.g.*, sum, mean or max, and $\\gamma$ and $\\phi$ denote differentiable functions such as MLPs (Multi Layer Perceptrons)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The \"MessagePassing\" Base Class\n",
    "\n",
    "PyTorch Geometric provides the `MessagePassing` base class, which helps in creating such kinds of message passing graph neural networks by automatically taking care of message propagation.\n",
    "The user only has to define the functions $\\phi$ , *i.e.* `message`, and $\\gamma$ , *i.e.* `update`, as well as the aggregation scheme to use, *i.e.* `aggr=\"add\"`, `aggr=\"mean\"` or `aggr=\"max\"`.\n",
    "\n",
    "<div>\n",
    "<img src=\"img/img2.png\" width=\"500\"/>\n",
    "</div>\n",
    "\n",
    "\n",
    "This is done with the help of the following methods:\n",
    "\n",
    "\n",
    "* `MessagePassing(aggr=\"add\", flow=\"source_to_target\", node_dim=-2)`: Defines the aggregation scheme to use (`\"add\"`, `\"mean\"` or `\"max\"`) and the flow direction of message passing (either `\"source_to_target\"` or `\"target_to_source\"`).\n",
    "  Furthermore, the `node_dim` attribute indicates along which axis to propagate.\n",
    "* `MessagePassing.propagate(edge_index, ...)`:\n",
    "  The initial call to start propagating messages.\n",
    "  Takes in the edge indices and all additional data which is needed to construct messages and to update node embeddings. \n",
    "* `MessagePassing.message(...)`: Constructs messages to node $i$ in analogy to $\\phi$ for each edge in $(j,i) \\in \\mathcal{E}$ if `flow=\"source_to_target\"` and $(i,j) \\in \\mathcal{E}$ if `flow=\"target_to_source\"`.\n",
    "* `MessagePassing.update(aggr_out, ...)`: Updates node embeddings in analogy to $\\gamma$ for each node $i \\in \\mathcal{V}$.\n",
    "  Takes in the output of aggregation as first argument and any argument which was initially passed to `MessagePassing.propagate`.\n",
    "\n",
    "Let us verify this by re-implementing two popular GNN variants, the `GCN layer from Kipf and Welling <https://arxiv.org/abs/1609.02907>`_ "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Edges are represented as a sparse list of edge indices, where each column reports the coordinates of an edge:  \n",
    "\n",
    "\\begin{equation}\n",
    "Adj = \n",
    "\\begin{pmatrix}\n",
    "1 & 1 & 0\\\\\n",
    "1 & 1 & 0\\\\\n",
    "0 & 0 & 1\n",
    "\\end{pmatrix}\n",
    "\\end{equation}\n",
    "\n",
    "\\begin{equation}\n",
    "edgeIndex = \n",
    "\\begin{pmatrix}\n",
    "0 & 0 & 1 & 1 & 2\\\\\n",
    "0 & 1 & 0 & 1 & 2\n",
    "\\end{pmatrix}\n",
    "\\end{equation}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Implementing the GCN Layer\n",
    "\n",
    "The GCN layer from Kipf and Welling is a popular GNN that was the first \n",
    "to bring the idea of layerwise convolutions to graphs processing. The layer\n",
    "is mathematically defined as\n",
    "\n",
    "$$\n",
    "    \\mathbf{x}_i^{(k)} = \\sum_{j \\in \\mathcal{N}(i) \\cup \\{ i \\}} \\frac{1}{\\sqrt{\\deg(i)} \\cdot \\sqrt{\\deg(j)}} \\cdot \\left( \\mathbf{\\Theta} \\cdot \\mathbf{x}_j^{(k-1)} \\right),\n",
    "$$\n",
    "\n",
    "where neighboring node features are first transformed by a weight matrix $\\mathbf{\\Theta}$, normalized by their degree, and finally summed up.\n",
    "This formula can be divided into the following steps:\n",
    "\n",
    "1. Add self-loops to the adjacency matrix.\n",
    "2. Linearly transform node feature matrix.\n",
    "3. Compute normalization coefficients.\n",
    "4. Normalize node features in $\\phi$.\n",
    "5. Sum up neighboring node features (`\"add\"` aggregation).\n",
    "\n",
    "Steps 1-3 are typically computed before message passing takes place.\n",
    "Steps 4-5 can be easily processed using the `MessagePassing` base class.\n",
    "The full layer implementation is shown below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Install required packages.\n",
    "!pip install -q torch-scatter -f https://pytorch-geometric.com/whl/torch-1.9.0+cu102.html\n",
    "!pip install -q torch-sparse -f https://pytorch-geometric.com/whl/torch-1.9.0+cu102.html\n",
    "!pip install -q torch-geometric\n",
    "\n",
    "import torch\n",
    "from torch_geometric.nn import MessagePassing\n",
    "from torch_geometric.utils import add_self_loops, degree\n",
    "\n",
    "class myGCNConv(MessagePassing):\n",
    "    def __init__(self, in_channels, out_channels):\n",
    "        super(myGCNConv, self).__init__(aggr='add')  # \"Add\" aggregation (Step 5).\n",
    "        self.lin = torch.nn.Linear(in_channels, out_channels)\n",
    "\n",
    "    def forward(self, x, edge_index):\n",
    "        # x has shape [N, in_channels]\n",
    "        # edge_index has shape [2, E] (sparse adjacency matrix as a list of edges)\n",
    "\n",
    "        # Step 1: Add self-loops to the adjacency matrix [edge list].\n",
    "        edge_index, _ = add_self_loops(edge_index, num_nodes=x.size(0))\n",
    "\n",
    "        # Step 2: Linearly transform node feature matrix.\n",
    "        x = self.lin(x)\n",
    "\n",
    "        # Step 3: Compute normalization.\n",
    "        row, col = edge_index # row and column indices of edges\n",
    "        deg = degree(col, x.size(0), dtype=x.dtype) # just count number of repetitions per index \n",
    "        deg_inv_sqrt = deg.pow(-0.5)\n",
    "        deg_inv_sqrt[deg_inv_sqrt == float('inf')] = 0\n",
    "        norm = deg_inv_sqrt[row] * deg_inv_sqrt[col] # row index deg_inv_sqrt times col index deg_inv_sqrt\n",
    "\n",
    "        # Step 4-5: Start propagating messages.\n",
    "        return self.propagate(edge_index, x=x, norm=norm)\n",
    "\n",
    "    def message(self, x_j, norm):\n",
    "        # x_j has shape [E, out_channels]\n",
    "\n",
    "        # Step 4: Normalize node features.\n",
    "        return norm.view(-1, 1) * x_j # broadcast normalization coefficient multiplication to all channels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "zF5bw3m9UrMy"
   },
   "outputs": [],
   "source": [
    "# Helper function for visualization.\n",
    "%matplotlib inline\n",
    "import torch\n",
    "import networkx as nx\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "def visualize(h, color, epoch=None, loss=None):\n",
    "    plt.figure(figsize=(7,7))\n",
    "    plt.xticks([])\n",
    "    plt.yticks([])\n",
    "\n",
    "    if torch.is_tensor(h):\n",
    "        h = h.detach().cpu().numpy()\n",
    "        plt.scatter(h[:, 0], h[:, 1], s=140, c=color, cmap=\"Set2\")\n",
    "        if epoch is not None and loss is not None:\n",
    "            plt.xlabel(f'Epoch: {epoch}, Loss: {loss.item():.4f}', fontsize=16)\n",
    "    else:\n",
    "        nx.draw_networkx(G, pos=nx.spring_layout(G, seed=42), with_labels=False,\n",
    "                         node_color=color, cmap=\"Set2\")\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "qoW2Z7P70LNQ"
   },
   "source": [
    "# Example: node classification\n",
    "\n",
    "Following [Kipf et al. (2017)](https://arxiv.org/abs/1609.02907), let's dive into the world of GNNs by looking at a simple graph-structured example, the well-known [**Zachary's karate club network**](https://en.wikipedia.org/wiki/Zachary%27s_karate_club). This graph describes a social network of 34 members of a karate club and documents links between members who interacted outside the club. Here, we are interested in detecting communities that arise from the member's interaction.\n",
    "\n",
    "PyTorch Geometric provides an easy access to this dataset via the [`torch_geometric.datasets`](https://pytorch-geometric.readthedocs.io/en/latest/modules/datasets.html#torch_geometric.datasets) subpackage:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "H_VTFHd0uFz6",
    "outputId": "e9472a23-e3c8-4ef2-86c1-64282d80de5d"
   },
   "outputs": [],
   "source": [
    "from torch_geometric.datasets import KarateClub\n",
    "\n",
    "dataset = KarateClub()\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}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(dataset.data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "7cjjyFVnpKB0"
   },
   "source": [
    "After initializing the [`KarateClub`](https://pytorch-geometric.readthedocs.io/en/latest/modules/datasets.html#torch_geometric.datasets.KarateClub) dataset, we first can inspect some of its properties.\n",
    "For example, we can see that this dataset holds exactly **one graph**, and that each node in this dataset is assigned a **34-dimensional feature vector** (which uniquely describes the members of the karate club).\n",
    "Furthermore, the graph holds exactly **4 classes**, which represent the community each node belongs to.\n",
    "\n",
    "Let's now look at the underlying graph in more detail:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "gUFSrDPxuQ23",
    "outputId": "98c222c0-d955-4607-8b0e-cb98c012cb79"
   },
   "outputs": [],
   "source": [
    "data = dataset[0]  # Get the first graph object.\n",
    "\n",
    "print(data)\n",
    "print('==============================================================')\n",
    "\n",
    "# Gather some statistics about the 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'Number of training nodes: {data.train_mask.sum()}')\n",
    "print(f'Training node label rate: {int(data.train_mask.sum()) / data.num_nodes:.2f}')\n",
    "print(f'Contains isolated nodes: {data.has_isolated_nodes()}')\n",
    "print(f'Contains self-loops: {data.has_self_loops()}')\n",
    "print(f'Is undirected: {data.is_undirected()}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "MY4pZma9p3Ax"
   },
   "source": [
    "Each graph in PyTorch Geometric is represented by a single [`Data`](https://pytorch-geometric.readthedocs.io/en/latest/modules/data.html#torch_geometric.data.Data) object, which holds all the information to describe its graph representation.\n",
    "We can print the data object anytime via `print(data)` to receive a short summary about its attributes and their shapes:\n",
    "```\n",
    "Data(edge_index=[2, 156], x=[34, 34], y=[34], train_mask=[34])\n",
    "```\n",
    "We can see that this `data` object holds 4 attributes:\n",
    "(1) The `edge_index` property holds the information about the **graph connectivity**, *i.e.*, a tuple of source and destination node indices for each edge.\n",
    "PyG further refers to (2) **node features** as `x` (each of the 34 nodes is assigned a 34-dim feature vector), and to (3) **node labels** as `y` (each node is assigned to exactly one class).\n",
    "(4) There also exists an additional attribute called `train_mask`, which describes for which nodes we already know their community assigments.\n",
    "In total, we are only aware of the ground-truth labels of 4 nodes (one for each community), and the task is to infer the community assignment for the remaining nodes.\n",
    "\n",
    "\n",
    "We can further visualize the graph by converting it to the `networkx` library format, which implements, in addition to graph manipulation functionalities, powerful tools for visualization:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**to networkx**\n",
    "<div>\n",
    "<img src=\"img/img3.png\" width=\"500\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 411
    },
    "id": "Y9MOs8iSwKFD",
    "outputId": "7bd4a2ef-08a4-458c-dfb5-09ea82fed059"
   },
   "outputs": [],
   "source": [
    "from torch_geometric.utils import to_networkx\n",
    "\n",
    "G = to_networkx(data,node_attrs=[\"x\"], to_undirected=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import networkx as nx\n",
    "\n",
    "G.nodes(data=True)[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "G = to_networkx(data, to_undirected=True)\n",
    "\n",
    "visualize(G, color=data.y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**What we did so far...**\n",
    "\n",
    "1) define our conv: myGCNConv  \n",
    "2) download karate dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "kPbYXBn1yYIJ"
   },
   "source": [
    "## Implementing a GCN \n",
    "\n",
    "We implement a GCN as a `torch.nn.Module` class that contains a sequence of GCNConv layers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "AkQAVluLuxT_",
    "outputId": "b049292d-b2da-4926-f974-776012a3ec60"
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "from torch.nn import Linear\n",
    "#from torch_geometric.nn import GCNConv\n",
    "\n",
    "class GCN(torch.nn.Module):\n",
    "    def __init__(self):\n",
    "        super(GCN, self).__init__()\n",
    "        torch.manual_seed(112233)\n",
    "        self.conv1 = myGCNConv(dataset.num_features, 4)\n",
    "        self.conv2 = myGCNConv(4, 4)\n",
    "        self.conv3 = myGCNConv(4, 2)\n",
    "        self.classifier = Linear(2, dataset.num_classes)\n",
    "\n",
    "    def forward(self, x, edge_index):\n",
    "        h = self.conv1(x, edge_index)\n",
    "        h = h.tanh()\n",
    "        h = self.conv2(h, edge_index)\n",
    "        h = h.tanh()\n",
    "        h = self.conv3(h, edge_index)\n",
    "        h = h.tanh()  # Final GNN embedding space.\n",
    "        \n",
    "        # Apply a final (linear) classifier.\n",
    "        out = self.classifier(h)\n",
    "\n",
    "        return out, h\n",
    "\n",
    "model = GCN()\n",
    "print(model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "hjsb3Fst2P8k"
   },
   "source": [
    "Here, we first initialize all of our building blocks in `__init__` and define the computation flow of our network in `forward`.\n",
    "We first define and stack **three graph convolution layers**, which corresponds to aggregating 3-hop neighborhood information around each node (all nodes up to 3 \"hops\" away).\n",
    "In addition, the `myGCNConv` layers reduce the node feature dimensionality to $2$, *i.e.*, $34 \\rightarrow 4 \\rightarrow 4 \\rightarrow 2$. Each `myGCNConv` layer is enhanced by a [tanh](https://pytorch.org/docs/stable/generated/torch.nn.Tanh.html?highlight=tanh#torch.nn.Tanh) non-linearity.\n",
    "\n",
    "After that, we apply a single linear transformation ([`torch.nn.Linear`](https://pytorch.org/docs/stable/generated/torch.nn.Linear.html?highlight=linear#torch.nn.Linear)) that acts as a classifier to map our nodes to 1 out of the 4 classes/communities.\n",
    "\n",
    "We return both the output of the final classifier as well as the final node embeddings produced by our GNN.\n",
    "We proceed to initialize our final model via `GCN()`, and printing our model produces a summary of all its used sub-modules.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Dt8fPEmc4m5l"
   },
   "source": [
    "### Embedding the Karate Club Network\n",
    "\n",
    "Let's take a look at the node embeddings produced by our GNN.\n",
    "Here, we pass in the initial node features `x` and the graph connectivity information `edge_index` to the model, and visualize its 2-dimensional embedding."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 433
    },
    "id": "nwHtX5siwe2v",
    "outputId": "080bbcb1-8278-4dc5-dd4c-f163e9bb8372"
   },
   "outputs": [],
   "source": [
    "model = GCN()\n",
    "\n",
    "out, h = model(data.x, data.edge_index)\n",
    "print(f'Embedding shape: {list(h.shape)}')\n",
    "\n",
    "visualize(h, color=data.y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "out #.argmax(-1)\n",
    "\n",
    "out.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1-W5Kfhu5I-P"
   },
   "source": [
    "Remarkably, even before training the weights of our model, the model produces an embedding of nodes that closely resembles the community-structure of the graph.\n",
    "Nodes of the same color (community) are already closely clustered together in the embedding space, although the weights of our model are initialized **completely at random** and we have not yet performed any training so far!\n",
    "This leads to the conclusion that GNNs introduce a strong inductive bias, leading to similar embeddings for nodes that are close to each other in the input graph.\n",
    "\n",
    "### Training on the Karate Club Network\n",
    "\n",
    "But can we do better? Let's look at an example on how to train our network parameters based on the knowledge of the community assignments of 4 nodes in the graph (one for each community):\n",
    "\n",
    "Since everything in our model is differentiable and parameterized, we can add some labels, train the model and observe how the embeddings react.\n",
    "Here, we make use of a semi-supervised or transductive learning procedure: We simply train with one labelled node per class, but are allowed to use the complete input graph data.\n",
    "\n",
    "\n",
    "\n",
    "Training our model is very similar to any other PyTorch model.\n",
    "In addition to defining our network architecture, we define a loss criterion (here, [`CrossEntropyLoss`](https://pytorch.org/docs/stable/generated/torch.nn.CrossEntropyLoss.html)) and initialize a stochastic gradient optimizer (here, [`Adam`](https://pytorch.org/docs/stable/optim.html?highlight=adam#torch.optim.Adam)).\n",
    "\n",
    "Note that our semi-supervised learning scenario is achieved by the following line:\n",
    "```\n",
    "loss = criterion(out[data.train_mask], data.y[data.train_mask])\n",
    "```\n",
    "While we compute node embeddings for all of our nodes, we **only use the training nodes for computing the loss**.\n",
    "Here, this is implemented by filtering the output of the classifier `out` and ground-truth labels `data.y` to only contain the nodes in the `train_mask`.\n",
    "\n",
    "Let us now start training and see how our node embeddings evolve over time (best experienced by explicitely running the code):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 430
    },
    "id": "etxOsz8QIbMO",
    "outputId": "a961884c-7520-460a-d591-94834563c4a2",
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import time\n",
    "#from IPython.display import Javascript  # Restrict height of output cell.\n",
    "#display(Javascript('''google.colab.output.setIframeHeight(0, true, {maxHeight: 430})'''))\n",
    "\n",
    "model = GCN()\n",
    "criterion = torch.nn.CrossEntropyLoss()  # Define loss criterion.\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=0.01)  # Define optimizer.\n",
    "\n",
    "def train(data):\n",
    "    optimizer.zero_grad()  # Clear gradients.\n",
    "    out, h = model(data.x, data.edge_index)  # Perform a single forward pass.\n",
    "    loss = criterion(out[data.train_mask], data.y[data.train_mask])  # Compute the loss solely based on the training nodes.\n",
    "    loss.backward()  # Derive gradients.\n",
    "    optimizer.step()  # Update parameters based on gradients.\n",
    "    return loss, h\n",
    "\n",
    "for epoch in range(401):\n",
    "    loss, h = train(data)\n",
    "    if epoch % 10 == 0:\n",
    "        visualize(h, color=data.y, epoch=epoch, loss=loss)\n",
    "        time.sleep(0.3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "NgcpV4rjAWy-"
   },
   "source": [
    "As one can see, our 3-layer GCN model manages to linearly separating the communities and classifying most of the nodes correctly.\n",
    "\n",
    "Note that we do not need to reimplement standard GNN architectures, the library provides implementations for the most popular ones, including the GCN Layer:\n",
    "\n",
    "`torch_geometric.nn.GCNConv`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Example: graph classification \n",
    "\n",
    "Let's now have a closer look at how to apply **Graph Neural Networks (GNNs) to the task of graph classification**.\n",
    "Graph classification refers to the problem of classifiying entire graphs (in contrast to nodes), given a **dataset of graphs**, based on some structural graph properties.\n",
    "Here, we want to embed entire graphs, and we want to embed those graphs in such a way so that they are linearly separable given a task at hand."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Screen Shot 2020-08-27 at 13.13.26.png](data:image/png;base64,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)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The most common task for graph classification is **molecular property prediction**, in which molecules are represented as graphs, and the task may be to infer whether a molecule inhibits HIV virus replication or not.\n",
    "\n",
    "The TU Dortmund University has collected a wide range of different graph classification datasets, known as the [**TUDatasets**](https://chrsmrrs.github.io/datasets/), which are also accessible via [`torch_geometric.datasets.TUDataset`](https://pytorch-geometric.readthedocs.io/en/latest/modules/datasets.html#torch_geometric.datasets.TUDataset) in PyTorch Geometric.\n",
    "Let's load and inspect one of the smaller ones, the **MUTAG dataset**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "from torch_geometric.datasets import TUDataset\n",
    "\n",
    "dataset = TUDataset(root='data/TUDataset', name='MUTAG')\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()}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This dataset provides **188 different graphs**, and the task is to classify each graph into **one out of two classes**.\n",
    "\n",
    "By inspecting the first graph object of the dataset, we can see that it comes with **17 nodes (with 7-dimensional feature vectors)** and **38 edges** (leading to an average node degree of 2.24).\n",
    "It also comes with exactly **one graph label** (`y=[1]`), and, in addition to previous datasets, provides addtional **4-dimensional edge features** (`edge_attr=[38, 4]`).\n",
    "However, for the sake of simplicity, we will not use edge features.\n",
    "\n",
    "PyTorch Geometric provides some useful utilities for working with graph datasets, *e.g.*, we can shuffle the dataset and use the first 150 graphs as training graphs, while using the remaining ones for testing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.manual_seed(12345)\n",
    "dataset = dataset.shuffle()\n",
    "\n",
    "train_dataset = dataset[:150]\n",
    "test_dataset = dataset[150:]\n",
    "\n",
    "print(f'Number of training graphs: {len(train_dataset)}')\n",
    "print(f'Number of test graphs: {len(test_dataset)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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",
    "**NOT A GOOD IDEA**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "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": {},
   "source": [
    "![Screen Shot 2020-08-27 at 13.11.53.png](data:image/png;base64,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)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This procedure has some crucial advantages over other batching procedures:\n",
    "\n",
    "1. GNN operators that rely on a message passing scheme do not need to be modified since messages are not exchanged between two nodes that belong to different graphs.\n",
    "\n",
    "2. There is no computational or memory overhead since adjacency matrices are saved in a sparse fashion holding only non-zero entries, *i.e.*, the edges.\n",
    "\n",
    "PyTorch Geometric automatically takes care of **batching multiple graphs into a single giant graph** with the help of the [`torch_geometric.data.DataLoader`](https://pytorch-geometric.readthedocs.io/en/latest/modules/data.html#torch_geometric.data.DataLoader) class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# test batch_size = 147\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# show G"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# show adj"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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",
    "class GCN(torch.nn.Module):\n",
    "    def __init__(self, hidden_channels):\n",
    "        super(GCN, self).__init__()\n",
    "        torch.manual_seed(12345678)\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)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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",
    "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",
    "\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",
    "for epoch in range(1, 51):\n",
    "    train()\n",
    "    train_acc = test(train_loader)\n",
    "    test_acc = test(test_loader)\n",
    "    if epoch % 10 == 0:\n",
    "        print(f'Epoch: {epoch:03d}, Train Acc: {train_acc:.4f}, Test Acc: {test_acc:.4f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Other datasets?\n",
    "\n",
    "\n",
    "Doc https://pytorch-geometric.readthedocs.io/en/latest/modules/datasets.html  \n",
    "OGB https://ogb.stanford.edu/docs/dataset_overview/\n",
    "\n",
    "# Other architectures?\n",
    "\n",
    "Doc https://pytorch-geometric.readthedocs.io/en/latest/modules/nn.html#convolutional-layers\n",
    "\n",
    "# Other resources?\n",
    "Doc https://pytorch-geometric.readthedocs.io/en/latest/notes/colabs.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# let's move higher order [super fast]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torch.nn import Linear\n",
    "import torch.nn.functional as F\n",
    "from torch_geometric.nn import GraphConv, GINConv, GINEConv, GATConv # ......\n",
    "from torch_geometric.nn import global_mean_pool\n",
    "\n",
    "class GCN(torch.nn.Module):\n",
    "    def __init__(self, hidden_channels):\n",
    "        super(GCN, self).__init__()\n",
    "        torch.manual_seed(12345678)\n",
    "        self.conv1 = GraphConv(dataset.num_node_features, hidden_channels)\n",
    "        self.conv2 = GraphConv(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",
    "        \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)\n",
    "\n",
    "\n",
    "#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.001)\n",
    "criterion = torch.nn.CrossEntropyLoss()\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",
    "\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",
    "for epoch in range(1, 51):\n",
    "    train()\n",
    "    train_acc = test(train_loader)\n",
    "    test_acc = test(test_loader)\n",
    "    if epoch % 10 == 0:\n",
    "        print(f'Epoch: {epoch:03d}, Train Acc: {train_acc:.4f}, Test Acc: {test_acc:.4f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "1. Introduction.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}