gnn.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "from torch.nn import Linear, Parameter\n",
    "import torch_geometric\n",
    "from torch_geometric.nn import MessagePassing\n",
    "from torch_geometric.utils import add_self_loops, degree, softmax, dropout_edge\n",
    "from torch_geometric.data import Data\n",
    "import torch.nn.functional as F\n",
    "import matplotlib.pyplot as plt\n",
    "from einops import rearrange\n",
    "from typing import Literal\n",
    "import networkx as nx\n",
    "import copy\n",
    "import matplotlib.cm as cm\n",
    "from utils import draw_graph"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Graph Neural Networks "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Disclaimer\n",
    "\n",
    "What is presented here focuses on the **spatial graph (convolutional) neural networks**, which only represent a subset of the GNNs architectures. \n",
    "\n",
    "The other major cathegory of GNNs is **spectral graph convolutional neural networks** and their approximations that use  polynomial  filters (e.g. ChebNet (Defferrard et al., 2016), BernNet (He et al., 2021)).\n",
    "\n",
    "Check out the famous GCN paper to understand the connection between the two: \"Semi-supervised classification with Graph Convolutional Network\" by Kipft & Welling (2016)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Base concepts\n",
    "\n",
    "- A graph $\\mathcal{G}=(X,A)$ is an object representing a set of entities (or nodes) $\\{i\\}_{i=0}^{N}$, their features grouped into a feature matrix $X\\in \\mathbb{R}^{N\\times d_x}$, and an adjacency matrix $A\\in \\mathbb{R}^{N\\times N}$, encoding their relationships.\n",
    "\n",
    "- $\\mathcal{G}_1=(X,A)$ is the same graph as $\\mathcal{G}_2=(PX, PAP^T)$ for any permutation matrix $P$.\n",
    "\n",
    "- An element $a_{ij}$ of $A$ is set to $1$ if there is an edge (a \"relationship\") between entity $i$ and entity $j$, otherwise it is set to $0$.\n",
    "\n",
    "- With GNNs, we aim to learn a function $$H=f(X,A) \\in \\mathbb{R}^{N\\times d_h}$$ that learns latent representations $H$ of the nodes taking into account the relationships that exist between them. That is, we want to design a model whose predictions are conditioned on the connectivity. \n",
    "\n",
    "- Note the difference with a classical FFNN: \n",
    "    - A FFNN would treat each entity individually to learn $h_i=f(x_i)$\n",
    "    - A GNN considers the connectivity of the graph $h_i = f(X, A)_i$ as an **inductive bias**: the assumption that a graph's structure and node relationships (such as locality and permutation invariance) are key to understanding and predicting its properties.\n",
    "\n",
    "- Function $f$ must be **permutation equivariant**, since the node features are grouped into $X$ in an arbitrary order (i.e, if $X[i]$ are the features of node $i$, $H[i]$ will be its latent features.).\n",
    "\n",
    "- Internally, nodes must propagate/diffuse information using a **permutation invariant** function that operates on a certain neighborhood $\\mathcal{N}_i$ for each node $i$ (i.e, no matter the order in which I process the neighborhood, the output will be the same).\n",
    "\n",
    "- Typically the 1-hop neighborood is considered for $\\mathcal{N}_i$. To increase the receptive field of the network, we usually stack layers: \n",
    "$$\n",
    "\\begin{aligned}\n",
    "H^{(0)} &= X \\\\ \n",
    "H^{(k)} & = f^{(k)}(H^{(k-1)}, A)\n",
    "\\end{aligned}\n",
    "$$\n",
    "\n",
    "With a GNN with $k$ layers, nodes at a distance larger than $k$ are unaware of eachother. If there is useful latent interaction for the downstream taks between nodes at a greater distance than $k$, such network is not able to learn them. \n",
    "\n",
    "\n",
    "\n",
    "- The typical tasks are:\n",
    "    - Node-level tasks: learn something about individual nodes\n",
    "    - Graph-level tasks: learn something about the whole graph\n",
    "    - Edge-level tasks: infer something about existing relationships\n",
    "\n",
    "\n",
    "**Node classification/regression**\n",
    "\n",
    "  <img src=\"./imgs/node_task.png\" alt=\"nt\" width=\"800\"/>\n",
    "\n",
    "\n",
    "**Graph classification/regression**\n",
    "\n",
    "  <img src=\"./imgs/graph_task.png\" alt=\"gt\" width=\"1000\"/>\n",
    "\n",
    "\n",
    "**Link prediction**\n",
    "\n",
    "  <img src=\"./imgs/edge_task.png\" alt=\"et\" width=\"800\"/>\n",
    "\n",
    "### Other concepts\n",
    "\n",
    "- GNNs have some shortcomings, such as:\n",
    "    - Over-smoothing: convolutions act as a low-pass filter, and deep networks risk to produce indistinguishable features for each node. \n",
    "    - Over-squashing: as the network becomes deep, an exponentially growing amount of information needs to be compressed into finite vectors. This makes learning interactions between distant nodes quite difficult. \n",
    "\n",
    "- The graph does not need to be know as a prior. It can be learned alongside the downstream task.\n",
    "\n",
    "- As an alterative to stacks of layers that consider the 1-hop neighborhood, one could use powers of a graph shift-operator $\\tilde{A}$ (eg, the normalized Laplacian) to propagate information to a larger neighborhood in a single layer using polynomial filters (see `graph_shift.ipynb`): \n",
    "$$\n",
    "H = \\sigma \\left( \\sum_{k=0}^K \\tilde{A}^k X \\Theta^{(k)} \\right)\n",
    "$$\n",
    "\n",
    "- Fun fact: Transformers can be seen as a special case of attentional GNNs that use a full graph! See this nice blog post: [Transformers are graph neural networks](https://thegradient.pub/transformers-are-graph-neural-networks/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Message Passing\n",
    "\n",
    "\n",
    "A typical GNN layer $h_i=f(X,A)_i$ can be written in the **message passing (MP)** form:\n",
    "\n",
    "$$h_i = \\phi_{up} \\left(x_i, \\bigoplus_{j \\in \\mathcal{N}_i} \\phi_{msg}(x_i,x_j)\\right)$$\n",
    "\n",
    "where $\\phi_{up}$ and $\\phi_{msg}$ are learnable functions (**update** and **message** function respectively). $\\bigoplus$ instead is some kind of permutation-invariant **aggregation** function (e.g sum, mean, max). This is important because graphs do not have an order, and by processing edges in a different order, the output should be the same.\n",
    "\n",
    "If there are edge features, those can be included in the message computattion: $\\phi_{msg}(x_i,x_j, e_{ij})$\n",
    "\n",
    "#### Intuition: \n",
    "\n",
    "- Each node collects *messages* computed by a learnable function for each of its neighbours (eg, those that are 1 edge away).\n",
    "- As the order and number of messages should not matter, the receiving node aggregates them into a single vector (eg sum, mean, max).\n",
    "- Given their previous representation and the aggregated messages, each node updates its new latent representation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<p align=\"center\">\n",
    "  <img src=\"./imgs/message_passing.png\" alt=\"mp\" width=\"400\"/>\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### The connection between convolutional and message passing layers\n",
    "\n",
    "Note the similarity between a MP layer: \n",
    "\n",
    "$$h_i = \\phi_{up} \\left(x_i, \\bigoplus_{j \\in \\mathcal{N}_i} \\phi_{msg}(x_i,x_j)\\right)$$\n",
    "\n",
    "\n",
    "and a convolutional layer (see `graph_shift.ipynb`):\n",
    "\n",
    "$$\n",
    "h_i = \\phi_{up} \\left(x_i, \\bigoplus_{j \\in \\mathcal{N}_i} \\tilde{a}_{ij} x_jW\\right)\n",
    "$$\n",
    "\n",
    "While the convolutional layer performs a **non-trainable weighted average** of the transformed neighbouring features, the message passing allows to **learn whole vectors** to be exchanged between nodes. \n",
    "\n",
    "In fact: $\\{\\text{Conv. layers} \\} \\sub \\{ \\text{MP layers}\\}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pytorch geometric (PyG) \n",
    "\n",
    "It is a library consisting of various methods for deep learning on graphs (known as geometric deep learning).\n",
    "\n",
    "PyG reflects the message passing formulation. To define a custom layer we need to:\n",
    "- define the **aggregation** type $\\bigoplus$. It can be `sum`, `mean` or `max`.\n",
    "- implement the **message** function $\\phi_{msg}$ (as well as the usual forward function). `forward` function should call `MessagePassing.propagate`, which will start propagating the messages and can take any extra argument needed to compute your message. When implementing `MessagePassing.message`, we have access to all arguments passed to `propagate`. Those arguments can additionally be mapped to the respective sending or receiving nodes by appending `_i` or `_j` to the variable name. For example we can map a `x` which is a $[N,d_x]$ tensor, into `x_i` with shape $[E,d_x]$. Note that we can use any naming for the variables!\n",
    "- implement the **update** function $\\phi_{up}$ (optional). It takes the aggregated outputs of the messages and any argument that was passed to `propagate()`. \n",
    "\n",
    "The adjacency matrix $A$ of the graph is stored in its sparse form, by means of a $2\\times E$ tensor, i.e, each entry is an $(i,j)$ pair representing an edge.\n",
    "\n",
    "Batching multiple graphs is possible by grouping the graphs into a single graph with disconnected components. There is then an index assigning each element to its corresponding graph in the batch.\n",
    "\n",
    "$$\n",
    "\\mathbf{A}_{\\text{batched}} =\n",
    "\\begin{bmatrix}\n",
    "A_1 & 0 & 0 & \\cdots & 0 \\\\\n",
    "0 & A_2 & 0 & \\cdots & 0 \\\\\n",
    "0 & 0 & A_3 & \\cdots & 0 \\\\\n",
    "\\vdots & \\vdots & \\vdots & \\ddots & \\vdots \\\\\n",
    "0 & 0 & 0 & \\cdots & A_n\n",
    "\\end{bmatrix}\n",
    "\n",
    "\\mathbf{X}_{\\text{batched}} =\n",
    "\\begin{bmatrix}\n",
    "X_1 \\\\\n",
    "X_2 \\\\\n",
    "X_3 \\\\\n",
    "\\vdots \\\\\n",
    "X_n \\\\\n",
    "\\end{bmatrix}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data(x=[4, 2], edge_index=[2, 8], edge_attr=[8, 1])\n",
      "tensor([[0, 0, 0, 1, 1, 2, 2, 3],\n",
      "        [1, 2, 3, 0, 2, 1, 0, 0]])\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "edge_index = torch.tensor([[0, 1],[0,2],[0,3],[1,0],[1,2],[2,1],[2,0],[3,0]], dtype=torch.long)\n",
    "edge_index = edge_index.T\n",
    "\n",
    "x = torch.tensor([[0,1], [1,1], [2,1], [3,1]], dtype=torch.float)\n",
    "\n",
    "edge_attr = torch.tensor([1,2,3,4,5,6,7,8], dtype=torch.float32).reshape(-1,1)\n",
    "\n",
    "data = Data(x=x, edge_index=edge_index, edge_attr=edge_attr)\n",
    "\n",
    "# Print the created graph\n",
    "print(data)\n",
    "print(edge_index)\n",
    "print(data.validate())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 316,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "draw_graph(edge_index=edge_index, edge_values=edge_attr.reshape(-1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 317,
   "metadata": {},
   "outputs": [],
   "source": [
    "class dummy_GNN(MessagePassing):\n",
    "    def __init__(self, feat_shape, out_shape, edge_shape, aggr = \"add\", **kwargs):\n",
    "        super().__init__(aggr, **kwargs)\n",
    "\n",
    "        self.edge_encoder = torch.nn.Linear(edge_shape, out_shape)\n",
    "        self.node_encoder = torch.nn.Linear(feat_shape, out_shape)\n",
    "\n",
    "    def forward(self, x, edge_index, edge_attr):\n",
    "        print(\"-\"*50)\n",
    "        print(f'[forward] \\t Shape of x: \\t\\t{x.shape}')\n",
    "        print(f'[forward] \\t Shape of edge_index: \\t{edge_index.shape}')\n",
    "\n",
    "        # bring node features in another space with a linear transformation \n",
    "        x = self.node_encoder(x) \n",
    "        print(f'[forward] \\t Shape of encoded x: \\t{x.shape}') \n",
    "        \n",
    "        # start propagating the messages\n",
    "        out = self.propagate(edge_index=edge_index, x=x, edge_attr=edge_attr)\n",
    "        \n",
    "        print(f'[forward] \\t Shape of out: \\t\\t{out.shape}')\n",
    "        print(\"-\"*50)\n",
    "    \n",
    "\n",
    "    def message(self, x_i, x_j, x, edge_index, edge_attr):\n",
    "        print(\"-\"*50)\n",
    "        print(f'[message]\\t Shape of x_i: \\t\\t{x_i.shape}')\n",
    "        print(f'[message]\\t Shape of x: \\t\\t{x.shape}')\n",
    "        print(f'[message]\\t Shape of edge_attr: \\t{edge_attr.shape}')\n",
    "        print(\"-\"*50)\n",
    "        return x_i + x_j + self.edge_encoder(edge_attr)# dummy message\n",
    "\n",
    "\n",
    "    def update(self, aggr_out, x):\n",
    "        print(\"-\"*50)\n",
    "        print(f'[update]\\t Shape of aggr_out: \\t{aggr_out.shape}')\n",
    "        print(f'[update]\\t Shape of x: \\t\\t{x.shape}')\n",
    "        print(\"-\"*50)\n",
    "        return aggr_out + x # like a skip connection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 318,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--------------------------------------------------\n",
      "[forward] \t Shape of x: \t\ttorch.Size([4, 2])\n",
      "[forward] \t Shape of edge_index: \ttorch.Size([2, 8])\n",
      "[forward] \t Shape of encoded x: \ttorch.Size([4, 6])\n",
      "--------------------------------------------------\n",
      "[message]\t Shape of x_i: \t\ttorch.Size([8, 6])\n",
      "[message]\t Shape of x: \t\ttorch.Size([4, 6])\n",
      "[message]\t Shape of edge_attr: \ttorch.Size([8, 1])\n",
      "--------------------------------------------------\n",
      "--------------------------------------------------\n",
      "[update]\t Shape of aggr_out: \ttorch.Size([4, 6])\n",
      "[update]\t Shape of x: \t\ttorch.Size([4, 6])\n",
      "--------------------------------------------------\n",
      "[forward] \t Shape of out: \t\ttorch.Size([4, 6])\n",
      "--------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "gnn = dummy_GNN(feat_shape=2, edge_shape=1, out_shape=6)\n",
    "gnn(data.x, data.edge_index, data.edge_attr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example of GNN layer: Graph Attention Networks (GAT) by Veličković et. al, 2018\n",
    "\n",
    "First, features are linearly transformed via a learnable weight matrix $\\mathbf{W} \\in \\mathbb{R}^{F' \\times F}$.\n",
    "\n",
    "Then we compute masked self-attention coefficients. It is masked since only connected nodes are considered, and it is self-attentive because nodes attend to themselves and the neighbors.\n",
    "\n",
    "$$e_{ij} = \\text{a}(\\mathbf{W}h_{i}, \\mathbf{W}h_j), \\quad \\text{a}: \\mathbb{R}^{F'} \\times \\mathbb{R}^{F'} \\rightarrow \\mathbb{R}$$\n",
    "\n",
    "$$\\alpha_{ij}=\\text{softmax}_j(e_{ij})= \\frac{\\exp(e_{ij})}{\\sum_{k\\in \\mathcal{N}_i} \\exp(e_{ik})}$$\n",
    "\n",
    "In the original paper proposes the following attention mechanism:\n",
    "\n",
    "$$\\alpha_{ij}= \\frac{\\exp\\left(\\text{LeakyReLU}(a^T[\\mathbf{W}h_i \\mid\\mid \\mathbf{W}h_j])\\right)}{\\sum_{k\\in \\mathcal{N}_i} \\exp\\left(\\text{LeakyReLU}(a^T[\\mathbf{W}h_i \\mid\\mid \\mathbf{W}h_k])\\right)}, \\quad a \\in \\mathbb{R}^{2F'}$$\n",
    "\n",
    "#### TLDR: \n",
    "\n",
    "This layer is spatial GNN layer where the diffusion/propagation/message-passing uses an attention mechanism to scale the (transformed) features of neighboring nodes before aggregating them. \n",
    "\n",
    "In the message-passing framework we have:\n",
    "\n",
    "$$h_i = \\text{LeakyReLU} \\left(\\sum_{j \\in \\mathcal{N}_i} \\text{att}(x_i,x_j)\\mathbf{W}x_j\\right)$$\n",
    "\n",
    "- The message function: $\\phi_{msg}(x_i, x_j) = \\text{att}(x_i,x_j)\\mathbf{W}x_j$\n",
    "- The aggregation function: $\\bigoplus = \\sum$\n",
    "- The update function: $\\phi_{up} \\left( \\cdot \\right) = \\text{LeakyReLU} \\left( \\cdot \\right)$\n",
    "\n",
    "Attentional GNNs are very similar to convolutional GNNs, with the additional ability to perform a **learnable** weighted average, as opposed to a non-learnable weighted average which depends on the graph's connectivity.\n",
    "\n",
    "<!-- $$h_i = \\phi_{up} \\left(x_i, \\bigoplus_{j \\in \\mathcal{N}_i} \\phi_{msg}(x_i,x_j)\\right)$$ -->"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn.functional as F\n",
    "from torch_geometric.nn import MessagePassing\n",
    "from torch_geometric.utils import add_self_loops, degree\n",
    "\n",
    "class GATConv(MessagePassing):\n",
    "    def __init__(self, in_channels, out_channels, \n",
    "                 dropout=0.1, \n",
    "                 negative_slope: float = 0.2, \n",
    "                 attention_heads: int = 1,\n",
    "                 handle_attention_heads: Literal['concat', 'sum'] = 'concat',\n",
    "                 **kwargs):\n",
    "        super(GATConv, self).__init__(aggr='add', **kwargs)\n",
    "\n",
    "        self.in_channels = in_channels\n",
    "        self.out_channels = out_channels\n",
    "        self.dropout = dropout\n",
    "        self.negative_slope = negative_slope\n",
    "        self.attention_heads = attention_heads\n",
    "        self.handle_attention_heads = handle_attention_heads\n",
    "\n",
    "        self.weight = torch.nn.Parameter(torch.Tensor(in_channels, out_channels*attention_heads))\n",
    "        self.att = torch.nn.Parameter(torch.Tensor(2*out_channels, 1*attention_heads))\n",
    "\n",
    "        self.up = torch.nn.LeakyReLU(negative_slope=self.negative_slope)\n",
    "\n",
    "\n",
    "        self.reset_parameters()\n",
    "        \n",
    "\n",
    "    def reset_parameters(self):\n",
    "        torch.nn.init.xavier_uniform_(self.weight)\n",
    "        torch.nn.init.xavier_uniform_(self.att)\n",
    "\n",
    "        print('Initialized parameters.')\n",
    "\n",
    "    def forward(self, x, edge_index, plot_attentions=False):\n",
    "        x_ = torch.mm(x, self.weight) # Apply transformation F -> F' to all nodes features\n",
    "        x_ = F.dropout(x_, p=self.dropout, training=self.training) # Dropnout never hurts to slow down the overfit \n",
    "        # edge_index, _ = dropout_edge(edge_index, p=self.dropout) # we could also drop out some edges\n",
    "        out = self.propagate(edge_index=edge_index, x=x_, plot_attentions=plot_attentions) # Start propagating messages\n",
    "\n",
    "        return out\n",
    "\n",
    "    def message(self, x_i, x_j, edge_index, plot_attentions=False):\n",
    "        # Concatenate src & tgt features\n",
    "        \n",
    "        # x_j and x_i have shape [E, out*heads] \n",
    "        # x_j = [h1, h2, h3, ...]\n",
    "        # x_i = [h1, h2, h3, ...]\n",
    "\n",
    "        xs = []\n",
    "        for h in range(self.attention_heads):\n",
    "            x_ = torch.cat([x_i[:,h*self.out_channels:(h+1)*self.out_channels],\n",
    "                            x_j[:,h*self.out_channels:(h+1)*self.out_channels]], dim=1)\n",
    "            xs.append(x_)\n",
    "\n",
    "        xs = torch.stack(xs, dim=1)\n",
    "        # xs = F.dropout(xs, p=self.dropout, training=self.training)\n",
    "\n",
    "\n",
    "        e_ij = torch.einsum('ehf,fh->eh', xs, self.att) # Compute the attention coeffs for each head\n",
    "\n",
    "        # shape [E, H]\n",
    "        attention_scalars = F.leaky_relu(e_ij, self.negative_slope)\n",
    "        attention_scalars = softmax(attention_scalars, edge_index[0]) # Normalize them for each neighborhood\n",
    "\n",
    "        if plot_attentions:\n",
    "            draw_graph(edge_index=edge_index, edge_values=attention_scalars[:,0].detach())\n",
    "\n",
    "        # attention_scalars = F.dropout(attention_scalars, p=self.dropout, training=self.training)\n",
    "\n",
    "        # For each edge, scale each receiving node feature by the corrisponding attention coeffs \n",
    "        x_with_att = torch.einsum('EH, EHF->EHF', attention_scalars, xs[...,self.out_channels:]) # msg_ij = att(x_i,x_j)(W x_j)\n",
    "\n",
    "\n",
    "        if self.handle_attention_heads == 'concat':\n",
    "            return x_with_att.reshape(x_with_att.shape[0], -1)\n",
    "        elif self.handle_attention_heads == 'sum':\n",
    "            return x_with_att.sum(dim=-2)\n",
    "        else:\n",
    "            raise NotImplementedError('invalid handling of attentions heads')\n",
    "\n",
    "    \n",
    "    def update(self, aggr_out):\n",
    "        # Apply an activation to the aggregated messages before outputting the new features.\n",
    "        # Here we could add a skip connection as self.up(aggr_out + x)\n",
    "        # Every variable passed to propagate() can be accessed here \n",
    "        out = self.up(aggr_out)\n",
    "        return out\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is an untrained GAT layer. On each edge $(i,j)$ we plot the attention coefficients $\\text{att}(x_i, x_j)$. \n",
    "\n",
    "Note how $\\sum_{j \\in \\mathcal{N}_i}\\text{att}(x_i, x_j)=1$ for each node $i$ and its neighborhood $\\mathcal{N}_i$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initialized parameters.\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "dummy_GATConv = GATConv(in_channels=2, out_channels=3, attention_heads=4)\n",
    "h = dummy_GATConv(data.x, data.edge_index, plot_attentions=True) # This is h=f(x,A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Semi-supervised node classification\n",
    "\n",
    "We will put our GAT layer to the test with a semi-supervised node classification task on the Cora citation network, a well known benchmark for graph representation learning. \n",
    "\n",
    "Each node $i$ has features $x_i \\in \\mathbb{R}^{1433}$ representing a bag-of-word contained in the document. Only a small subset of nodes are labelled, however this is not an issue, we can perform message-passing on our graph and only compute the loss function on the labelled nodes. \n",
    "\n",
    "As we will see there are only $140$ labelled nodes in the training set, out of the $2700+$ nodes in the whole graph. \n",
    "\n",
    "For each node $i$, the task is to predict its label $y_i \\in \\{0, \\dots, 6\\}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torch_geometric.datasets import Planetoid\n",
    "from torch_geometric.transforms import NormalizeFeatures\n",
    "\n",
    "dataset = Planetoid(root='data/Planetoid', name='Cora', transform=NormalizeFeatures())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are 140 labelled nodes for training.\n",
      "There are 500 labelled nodes for validation.\n",
      "There are 1000 labelled nodes for testing.\n",
      "There are 2708 nodes in the overall graph.\n",
      "There are 10556 edges in the overall graph.\n"
     ]
    }
   ],
   "source": [
    "print(f'There are {(dataset[0].train_mask).sum().item()} labelled nodes for training.')\n",
    "print(f'There are {(dataset[0].val_mask).sum().item()} labelled nodes for validation.')\n",
    "print(f'There are {(dataset[0].test_mask).sum().item()} labelled nodes for testing.')\n",
    "\n",
    "print(f'There are {(dataset[0].num_nodes)} nodes in the overall graph.')\n",
    "print(f'There are {(dataset[0].num_edges)} edges in the overall graph.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can stack together some GAT layers, to make a GAT model:\n",
    "\n",
    "$$\n",
    "\\begin{aligned}\n",
    "H^{(0)} &= X \\\\ \n",
    "H^{(k)} & = \\text{GatLayer}^{(k)}(H^{(k-1)}, A)\n",
    "\\end{aligned}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class GATModel(torch.nn.Module):\n",
    "    def __init__(self, hidden_size: int,\n",
    "                 num_layers: int = 1,\n",
    "                 attention_heads=1,\n",
    "                 dropout = 0):\n",
    "        super().__init__()\n",
    "        torch.manual_seed(12345)\n",
    "\n",
    "\n",
    "        self.mpnns = torch.nn.ModuleList()\n",
    "        self.skip_conn = torch.nn.ModuleList()\n",
    "        self.classifier = Linear(hidden_size*attention_heads, dataset.num_classes)\n",
    "        self.dropout = torch.nn.Dropout(p=dropout)\n",
    "\n",
    "        for l in range(num_layers):\n",
    "            in_size = dataset.num_features if l == 0 else hidden_size*attention_heads\n",
    "\n",
    "            mpnn = GATConv(in_size, hidden_size, dropout=dropout, attention_heads=attention_heads)\n",
    "            self.mpnns.append(mpnn)\n",
    "\n",
    "\n",
    "    def forward(self, x, edge_index):\n",
    "         \n",
    "        x = self.dropout(x)\n",
    "        for i,mpnn in enumerate(self.mpnns):\n",
    "            x = mpnn(x, edge_index)\n",
    "\n",
    "\n",
    "        out = self.classifier(x)\n",
    "        return out\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = dataset[0] # there is only 1 graph "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Let's train the GAT model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "class EarlyStopping:\n",
    "\n",
    "    def __init__(self, patience=10, mode: Literal['max', 'min'] = 'min'):\n",
    "        self.patience = patience\n",
    "\n",
    "        self.best_score = float('inf') if mode == 'min' else float('-inf')\n",
    "        self.best_model = None\n",
    "        self.mode = mode\n",
    "\n",
    "        self.counter = 0\n",
    "        self.call_counter = 0\n",
    "        self.best_score_iteration = 0\n",
    "\n",
    "    def better(self, new, current):\n",
    "        if self.mode == 'min':\n",
    "            return new < current\n",
    "        return new > current\n",
    "\n",
    "    def __call__(self, score, model):\n",
    "        self.call_counter += 1\n",
    "\n",
    "        if self.better(new=score, current=self.best_score):\n",
    "            self.best_score = score\n",
    "            self.best_model = copy.deepcopy(model)\n",
    "            self.counter = 0\n",
    "            self.best_score_iteration = self.call_counter\n",
    "            return False\n",
    "        \n",
    "        self.counter += 1\n",
    "\n",
    "        if self.counter > self.patience:\n",
    "            return True\n",
    "        return False\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 555,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initialized parameters.\n",
      "Initialized parameters.\n"
     ]
    }
   ],
   "source": [
    "model = GATModel(hidden_size=8, attention_heads=8, num_layers=2, dropout=0.2)\n",
    "\n",
    "early_stopper = EarlyStopping(patience=50, mode='min')\n",
    "model.eval()\n",
    "criterion = torch.nn.CrossEntropyLoss()\n",
    "optimizer = torch.optim.Adam(model.parameters(),\n",
    "                             lr=0.003, weight_decay=5e-4) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "losses = []\n",
    "accuracies = []\n",
    "val_losses = []\n",
    "val_accuracies = []\n",
    "\n",
    "def train():\n",
    "      model.train()\n",
    "      optimizer.zero_grad()\n",
    "      \n",
    "      out = model(data.x, data.edge_index) # H = f(X, A) \n",
    "\n",
    "      pred = out.argmax(dim=1)\n",
    "      train_correct = pred[data.train_mask] == data.y[data.train_mask]\n",
    "      train_acc = int(train_correct.sum()) / int(data.train_mask.sum())\n",
    "      accuracies.append(train_acc)\n",
    "\n",
    "      loss = criterion(out[data.train_mask], data.y[data.train_mask])\n",
    "      losses.append(loss.item())\n",
    "      loss.backward()\n",
    "      optimizer.step()\n",
    "      return loss\n",
    "\n",
    "def test(mask):\n",
    "      model.eval()\n",
    "      with torch.no_grad():\n",
    "            out = model(data.x, data.edge_index)\n",
    "\n",
    "            pred = out.argmax(dim=1)\n",
    "            test_correct = pred[mask] == data.y[mask]\n",
    "            test_acc = int(test_correct.sum()) / int(mask.sum())\n",
    "\n",
    "            loss = criterion(out[mask], data.y[mask])\n",
    "            val_losses.append(loss.item())\n",
    "            val_accuracies.append(test_acc)\n",
    "            return test_acc, loss\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 557,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 010 - Training loss: 1.9317 - Validation accuracy: 7.40%\n",
      "Epoch: 020 - Training loss: 1.8672 - Validation accuracy: 42.80%\n",
      "Epoch: 030 - Training loss: 1.6942 - Validation accuracy: 60.60%\n",
      "Epoch: 040 - Training loss: 1.3487 - Validation accuracy: 72.80%\n",
      "Epoch: 050 - Training loss: 0.9264 - Validation accuracy: 76.80%\n",
      "Epoch: 060 - Training loss: 0.5167 - Validation accuracy: 78.40%\n",
      "Epoch: 070 - Training loss: 0.2943 - Validation accuracy: 79.40%\n",
      "Epoch: 080 - Training loss: 0.1770 - Validation accuracy: 80.60%\n",
      "Epoch: 090 - Training loss: 0.1198 - Validation accuracy: 79.40%\n",
      "Epoch: 100 - Training loss: 0.0885 - Validation accuracy: 79.60%\n",
      "Epoch: 110 - Training loss: 0.0824 - Validation accuracy: 79.40%\n",
      "Epoch: 120 - Training loss: 0.0737 - Validation accuracy: 80.20%\n",
      "Epoch: 130 - Training loss: 0.0839 - Validation accuracy: 78.00%\n",
      "Epoch: 140 - Training loss: 0.0565 - Validation accuracy: 79.20%\n",
      "Epoch: 150 - Training loss: 0.0504 - Validation accuracy: 78.00%\n",
      "Epoch: 160 - Training loss: 0.0580 - Validation accuracy: 79.00%\n",
      "Epoch: 170 - Training loss: 0.0438 - Validation accuracy: 79.40%\n",
      "Early stopped. Best iteration = 120 with score = 0.7458258271217346\n"
     ]
    }
   ],
   "source": [
    "for epoch in range(1, 2000):\n",
    "    train_loss = train()\n",
    "    val_acc, val_loss = test(data.val_mask)\n",
    "\n",
    "    if early_stopper(val_loss, model):\n",
    "         print(f'Early stopped. Best iteration = {early_stopper.best_score_iteration} with score = {early_stopper.best_score}')\n",
    "         break\n",
    "    if epoch % 10 == 0:\n",
    "      print(f'Epoch: {epoch:03d} - Training loss: {train_loss:.4f} - '\n",
    "            f'Validation accuracy: {val_acc * 100:.2f}%')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 558,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1500x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axes = plt.subplots(1, 2, figsize=(15, 5))\n",
    "axes[0].plot(losses, label='Train loss', color='forestgreen')\n",
    "axes[0].plot(val_losses, label='Val loss', color='tomato')\n",
    "axes[1].plot(accuracies, label='Train accuracy', color='forestgreen')\n",
    "axes[1].plot(val_accuracies, label='Val accuracy', color='tomato')\n",
    "axes[0].axvline(x=early_stopper.best_score_iteration, color='royalblue', linestyle='--', label='early stop')\n",
    "axes[1].axvline(x=early_stopper.best_score_iteration, color='royalblue', linestyle='--', label='early stop')\n",
    "\n",
    "axes[0].legend()\n",
    "axes[1].legend()\n",
    "axes[0].grid()\n",
    "axes[1].grid()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 559,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We obtained a test accuracy of 76.9 %\n"
     ]
    }
   ],
   "source": [
    "test_acc, test_loss = test(data.test_mask)\n",
    "print(f'We obtained a test accuracy of {test_acc* 100} %')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Good news:\n",
    "\n",
    "PyG comes with pre-defined GNN model and layer architectures and we do not always need to implement everything at the MessagePassing layer level. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### How does it compare with a FFNN?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MLP(torch.nn.Module):\n",
    "\n",
    "    def __init__(self, in_size, hidden_sizes, out_size, p=0.1, *args, **kwargs):\n",
    "        super().__init__(*args, **kwargs)\n",
    "\n",
    "        self.layers = torch.nn.ModuleList()\n",
    "        for hs in hidden_sizes:\n",
    "            self.layers.append(torch.nn.Linear(in_size, hs))\n",
    "            self.layers.append(torch.nn.Tanh())\n",
    "            self.layers.append(torch.nn.Dropout(p=p))\n",
    "\n",
    "            in_size = hs\n",
    "        \n",
    "        self.classifier = torch.nn.Linear(hidden_sizes[-1], out_size)\n",
    "\n",
    "    def forward(self, x):\n",
    "        for l in self.layers:\n",
    "            x = l(x)\n",
    "\n",
    "        return self.classifier(x)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Try it yourself, it seems that a shallow mlp gives the best result. \n",
    "mlp = MLP(dataset.num_features, hidden_sizes=[16], out_size=dataset.num_classes, p=0.2)\n",
    "\n",
    "losses = []\n",
    "accuracies = []\n",
    "val_losses = []\n",
    "val_accuracies = []\n",
    "\n",
    "def train_mlp():\n",
    "      mlp.train()\n",
    "      optimizer.zero_grad()\n",
    "      # We now give as input also the graph connectivity\n",
    "      out = mlp(data.x)\n",
    "\n",
    "      pred = out.argmax(dim=1)\n",
    "      train_correct = pred[data.train_mask] == data.y[data.train_mask]\n",
    "      train_acc = int(train_correct.sum()) / int(data.train_mask.sum())\n",
    "      accuracies.append(train_acc)\n",
    "\n",
    "      loss = criterion(out[data.train_mask], data.y[data.train_mask])\n",
    "      losses.append(loss.item())\n",
    "      loss.backward()\n",
    "      optimizer.step()\n",
    "      return loss\n",
    "\n",
    "def test_mlp(mask):\n",
    "      mlp.eval()\n",
    "      with torch.no_grad():\n",
    "            out = mlp(data.x)\n",
    "\n",
    "            pred = out.argmax(dim=1)\n",
    "            test_correct = pred[mask] == data.y[mask]\n",
    "            test_acc = int(test_correct.sum()) / int(mask.sum())\n",
    "\n",
    "            loss = criterion(out[mask], data.y[mask])\n",
    "            val_losses.append(loss.item())\n",
    "            val_accuracies.append(test_acc)\n",
    "            return test_acc, loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [],
   "source": [
    "early_stopper = EarlyStopping(patience=50, mode='min')\n",
    "mlp.eval()\n",
    "criterion = torch.nn.CrossEntropyLoss()\n",
    "optimizer = torch.optim.Adam(mlp.parameters(),\n",
    "                             lr=0.008, weight_decay=5e-4) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 010 - Training loss: 1.8664 - Validation accuracy: 19.80%\n",
      "Epoch: 020 - Training loss: 1.7073 - Validation accuracy: 55.40%\n",
      "Epoch: 030 - Training loss: 1.4787 - Validation accuracy: 47.80%\n",
      "Epoch: 040 - Training loss: 1.1702 - Validation accuracy: 51.60%\n",
      "Epoch: 050 - Training loss: 0.9050 - Validation accuracy: 54.60%\n",
      "Epoch: 060 - Training loss: 0.6628 - Validation accuracy: 54.40%\n",
      "Epoch: 070 - Training loss: 0.4952 - Validation accuracy: 54.60%\n",
      "Epoch: 080 - Training loss: 0.4194 - Validation accuracy: 57.40%\n",
      "Epoch: 090 - Training loss: 0.3207 - Validation accuracy: 56.80%\n",
      "Epoch: 100 - Training loss: 0.2837 - Validation accuracy: 57.00%\n",
      "Epoch: 110 - Training loss: 0.2679 - Validation accuracy: 57.40%\n",
      "Epoch: 120 - Training loss: 0.2329 - Validation accuracy: 57.40%\n",
      "Epoch: 130 - Training loss: 0.2131 - Validation accuracy: 57.80%\n",
      "Epoch: 140 - Training loss: 0.2157 - Validation accuracy: 56.80%\n",
      "Epoch: 150 - Training loss: 0.1889 - Validation accuracy: 57.20%\n",
      "Epoch: 160 - Training loss: 0.1914 - Validation accuracy: 57.40%\n",
      "Epoch: 170 - Training loss: 0.1692 - Validation accuracy: 57.20%\n",
      "Epoch: 180 - Training loss: 0.1702 - Validation accuracy: 58.00%\n",
      "Epoch: 190 - Training loss: 0.1758 - Validation accuracy: 57.80%\n",
      "Epoch: 200 - Training loss: 0.1537 - Validation accuracy: 57.20%\n",
      "Epoch: 210 - Training loss: 0.1438 - Validation accuracy: 58.00%\n",
      "Epoch: 220 - Training loss: 0.1448 - Validation accuracy: 57.40%\n",
      "Epoch: 230 - Training loss: 0.1429 - Validation accuracy: 57.60%\n",
      "Epoch: 240 - Training loss: 0.1370 - Validation accuracy: 57.40%\n",
      "Epoch: 250 - Training loss: 0.1339 - Validation accuracy: 56.40%\n",
      "Epoch: 260 - Training loss: 0.1319 - Validation accuracy: 57.80%\n",
      "Epoch: 270 - Training loss: 0.1226 - Validation accuracy: 58.00%\n",
      "Epoch: 280 - Training loss: 0.1283 - Validation accuracy: 57.60%\n",
      "Epoch: 290 - Training loss: 0.1197 - Validation accuracy: 57.80%\n",
      "Epoch: 300 - Training loss: 0.1122 - Validation accuracy: 58.40%\n",
      "Epoch: 310 - Training loss: 0.1109 - Validation accuracy: 58.00%\n",
      "Epoch: 320 - Training loss: 0.1168 - Validation accuracy: 57.80%\n",
      "Epoch: 330 - Training loss: 0.1214 - Validation accuracy: 58.00%\n",
      "Epoch: 340 - Training loss: 0.1050 - Validation accuracy: 57.60%\n",
      "Epoch: 350 - Training loss: 0.1085 - Validation accuracy: 58.40%\n",
      "Epoch: 360 - Training loss: 0.1045 - Validation accuracy: 57.00%\n",
      "Epoch: 370 - Training loss: 0.1137 - Validation accuracy: 58.00%\n",
      "Epoch: 380 - Training loss: 0.0925 - Validation accuracy: 56.40%\n",
      "Epoch: 390 - Training loss: 0.0996 - Validation accuracy: 58.20%\n",
      "Early stopped. Best iteration = 348 with score = 1.3087505102157593\n"
     ]
    }
   ],
   "source": [
    "for epoch in range(1, 2000):\n",
    "    train_loss = train_mlp()\n",
    "    val_acc, val_loss = test_mlp(data.val_mask)\n",
    "\n",
    "    if early_stopper(val_loss, mlp):\n",
    "         print(f'Early stopped. Best iteration = {early_stopper.best_score_iteration} with score = {early_stopper.best_score}')\n",
    "         break\n",
    "    if epoch % 10 == 0:\n",
    "      print(f'Epoch: {epoch:03d} - Training loss: {train_loss:.4f} - '\n",
    "            f'Validation accuracy: {val_acc * 100:.2f}%')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1500x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axes = plt.subplots(1, 2, figsize=(15, 5))\n",
    "axes[0].plot(losses, label='Train loss', color='rebeccapurple')\n",
    "axes[0].plot(val_losses, label='Val loss', color='seagreen')\n",
    "axes[1].plot(accuracies, label='Train accuracy', color='rebeccapurple')\n",
    "axes[1].plot(val_accuracies, label='Val accuracy', color='seagreen')\n",
    "axes[0].axvline(x=early_stopper.best_score_iteration, color='royalblue', linestyle='--', label='early stop')\n",
    "axes[1].axvline(x=early_stopper.best_score_iteration, color='royalblue', linestyle='--', label='early stop')\n",
    "\n",
    "axes[0].legend()\n",
    "axes[1].legend()\n",
    "axes[0].grid()\n",
    "axes[1].grid()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The MLP obtained a test accuracy of 59.8 %\n"
     ]
    }
   ],
   "source": [
    "test_acc, test_loss = test_mlp(data.test_mask)\n",
    "print(f'The MLP obtained a test accuracy of {test_acc* 100} %')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It seems that the inductive bias of the graph is helpful!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Do you like to read? Check these papers out:\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In no particular order, here is a list of papers I consider important (by no means exhaustive):\n",
    "\n",
    "- *\"The Graph Neural Network Model\"*, Scarselli et. al (2008)\n",
    "- *\"Relational inductive biases, deep learning, and graph networks\"*, Battaglia et. al (2018)\n",
    "- *\"Neural Message Passing for Quantum Chemistry\"*, Gilmer et. al (2017)\n",
    "- *\"Convolutional Neural Networks on Graphs with Fast Localized Spectral Filtering\"*, Defferrard et. al (2016)\n",
    "- *\"Spectral Networks and Locally Connected Networks on Graphs\"*, Bruna et. al (2013)\n",
    "- *\"Geometric Deep Learning Grids, Groups, Graphs, Geodesics, and Gauges\"*, Bronstein et. al (2021)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You made it till the end! Thanks for reading. "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "gkf-env",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.15"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}