notebooks/customizing_architectures.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Colab preamble\n",
    "\n",
    "If this notebook is running on Google CoLab, we need to set up the required dependencies. The cell below checks if we're running on colab and tries to install the needed dependencies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This installs the concacolab package in the colab python distribution\n",
    "try:\n",
    "    import google.colab\n",
    "    # Install required packages.\n",
    "    import os\n",
    "    import torch\n",
    "    os.environ['TORCH'] = torch.__version__\n",
    "    print(torch.__version__)\n",
    "\n",
    "    !pip install -q torch-scatter -f https://data.pyg.org/whl/torch-${TORCH}.html\n",
    "    !pip install -q torch-sparse -f https://data.pyg.org/whl/torch-${TORCH}.html\n",
    "    !pip install -q torch-cluster -f https://data.pyg.org/whl/torch-${TORCH}.html\n",
    "    !pip install -q git+https://github.com/pyg-team/pytorch_geometric.git\n",
    "    !pip install lightning\n",
    "except:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Building the neural network\n",
    "\n",
    "We've now done the lions share of the work - converting the data we have into a graph dataset which can be fed into a neural network. We're now ready to implement our model. We will pose this problem as classification problem where the goal is to correctly classify the ISUP Grade.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The dataset\n",
    "\n",
    "We include the dataset code definition we built in the previous notebook. Note that by setting the variable `FULL_DATASET` to `True`, you can train the models on the full dataset. This will require a lot more memory and time though, so should be done on a more capable computer than the colab virtual machines."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pathlib import Path\n",
    "import zipfile\n",
    "from io import StringIO, BytesIO\n",
    "import multiprocessing\n",
    "from collections import Counter\n",
    "from typing import Sequence, Literal, Optional\n",
    "import copy\n",
    "import json\n",
    "\n",
    "import torch\n",
    "from torch_geometric.data import InMemoryDataset, download_url, Data\n",
    "from torch_geometric.data.dataset import IndexType\n",
    "from tqdm.notebook import tqdm\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from scipy.spatial import cKDTree\n",
    "\n",
    "\n",
    "GEOJSON_DIRECTORY = 'cell_detection.geojson'\n",
    "LABEL_COLUMN = 'isup_grade'\n",
    "ID_COLUMN = 'image_id'\n",
    "MPP = 0.48\n",
    "RADIUS_MICRONS = 20\n",
    "RADIUS = RADIUS_MICRONS / MPP\n",
    "\n",
    "PANDA_FULL_URL = 'https://github.com/eryl/aida-gnn-workshop-code/releases/download/PANDa_workshop_data_full_v1/PANDa_{}.zip'\n",
    "PANDA_SUBSET_URL = 'https://github.com/eryl/aida-gnn-workshop-code/releases/download/PANDa_workshop_data_v1/PANDa_{}.zip'\n",
    "\n",
    "# You can switch to using the full 10615 files by setting this to True. \n",
    "# Warning! It will require a lot of memory to hold it in RAM. \n",
    "# The total download is about 1.5GB for the full set and 300MB for the subset.\n",
    "FULL_DATASET = False\n",
    "if FULL_DATASET:\n",
    "    DATASET_URL = PANDA_FULL_URL\n",
    "    DATASET_DIR = '../datasets/PANDa_full'\n",
    "else:\n",
    "    DATASET_URL = PANDA_SUBSET_URL\n",
    "    DATASET_DIR = '../datasets/PANDa'\n",
    "\n",
    "\n",
    "class PANDaGraphDataset(InMemoryDataset):\n",
    "    data_url = DATASET_URL\n",
    "    data_split = ''\n",
    "    \n",
    "    def __init__(self, root=DATASET_DIR, transform=None, pre_transform=None, pre_filter=None):\n",
    "        super().__init__(root, transform, pre_transform, pre_filter)\n",
    "        self.data, self.slices, self.label_map, self.node_type_map = torch.load(self.processed_paths[0])\n",
    "    \n",
    "    @property\n",
    "    def raw_file_names(self):\n",
    "        return [f'PANDa_{self.data_split}.zip']\n",
    "\n",
    "    @property\n",
    "    def processed_file_names(self):\n",
    "        return [f'PANDa_{self.data_split}.pt']\n",
    "\n",
    "    def download(self):\n",
    "        # Download to `self.raw_dir`.\n",
    "        url = self.data_url.format(self.data_split)\n",
    "        download_url(url, self.raw_dir)\n",
    "\n",
    "    def _transpose_geojson(self, geojson_obj):\n",
    "        node_positions = []\n",
    "        node_types = []\n",
    "        for feature_obj in geojson_obj:\n",
    "            if feature_obj.get('type') == 'Feature':\n",
    "                feature_coordinates = feature_obj['geometry']['coordinates']\n",
    "                node_positions.extend(feature_coordinates)\n",
    "                feature_labels = [feature_obj['properties']['classification']['name']]*len(feature_coordinates)\n",
    "                node_types.extend(feature_labels)\n",
    "        return np.array(node_positions), node_types\n",
    "\n",
    "    def _create_edges(self, node_positions, radius=RADIUS):\n",
    "        spatial_index = cKDTree(node_positions)\n",
    "        sparse_distances = spatial_index.sparse_distance_matrix(spatial_index, radius, output_type='coo_matrix')\n",
    "        sparse_distances.eliminate_zeros()  # We eliminate all zeros from the matrix, we don't want self-loops\n",
    "        pair_indices = np.stack([sparse_distances.row, sparse_distances.col], axis=0)\n",
    "        distances = np.copy(sparse_distances.data)\n",
    "        return pair_indices, distances\n",
    "\n",
    "    def _convert_geojson_to_graph(self, geojson_string):\n",
    "        geojson_object = json.loads(geojson_string)\n",
    "        node_positions, node_classes = self._transpose_geojson(geojson_object)\n",
    "        edges, distances = self._create_edges(node_positions)\n",
    "        return {'edges': edges, 'edge_distance': distances, 'node_positions': node_positions, 'node_types': node_classes}\n",
    "\n",
    "    def _read_geojson_archive(self):\n",
    "        LABEL_COLUMN = 'isup_grade'\n",
    "        ID_COLUMN = 'image_id'  \n",
    "        graphs = dict()\n",
    "\n",
    "        for filename in self.raw_file_names:\n",
    "            file_path = Path(self.raw_dir) / filename\n",
    "            with zipfile.ZipFile(file_path) as zf:\n",
    "                graphs = dict()\n",
    "                csv_file = None\n",
    "                for name in tqdm(zf.namelist(), desc=\"Creating graph data\"):\n",
    "                    if GEOJSON_DIRECTORY in name:\n",
    "                        *_, image_id = name.split('/')\n",
    "                        geojson_string = zf.read(name)\n",
    "                        graph_data = self._convert_geojson_to_graph(geojson_string)\n",
    "                        graph_data['image_id'] = image_id\n",
    "                        graphs[image_id] = graph_data\n",
    "                    elif '.csv' in name:\n",
    "                        csv_string = zf.read(name)\n",
    "                        csv_io = BytesIO(csv_string)\n",
    "                        csv_file = pd.read_csv(csv_io)\n",
    "                        \n",
    "                if csv_file is None:\n",
    "                    raise RuntimeError(\"No csv file in archive\")\n",
    "                else:\n",
    "                    for row in csv_file.to_dict('records'):\n",
    "                        image_id = row[ID_COLUMN]\n",
    "                        if image_id in graphs:\n",
    "                            label = row[LABEL_COLUMN]\n",
    "                            graphs[image_id]['label'] = label \n",
    "        return graphs\n",
    "    \n",
    "    def _convert_labels_inplace(self, graphs):\n",
    "        labels = set()\n",
    "        for graph in graphs.values():\n",
    "            labels.add(graph['label'])\n",
    "        label_map = {node_type: i for i,node_type in enumerate(sorted(labels))}\n",
    "        for graph in graphs.values():\n",
    "            label = graph['label']\n",
    "            encoded_label = torch.tensor(label_map[label])\n",
    "            graph['label'] = encoded_label\n",
    "        return label_map\n",
    "\n",
    "    def _convert_node_types_inplace(self, graphs):\n",
    "        node_types = set()\n",
    "        for graph in graphs.values():\n",
    "            node_types.update(graph['node_types'])\n",
    "        node_type_map = {node_type: i for i,node_type in enumerate(sorted(node_types))}\n",
    "        for graph in graphs.values():\n",
    "            node_types = graph['node_types']\n",
    "            node_types = torch.tensor([node_type_map[node_type] for node_type in node_types])\n",
    "            graph['node_types'] = node_types\n",
    "        return node_type_map\n",
    "\n",
    "    def _convert_to_pyg_data(self, graph):\n",
    "        x=graph['node_types']\n",
    "        edge_index=torch.tensor(graph['edges'])\n",
    "        edge_attr=torch.tensor(graph['edge_distance'])\n",
    "        y=graph['label']\n",
    "        pos=torch.tensor(graph['node_positions'])\n",
    "        return Data(x=x, edge_index=edge_index, edge_attr=edge_attr, y=y, pos=pos)\n",
    "\n",
    "    def process(self):\n",
    "        # Read data huge `Data` list.\n",
    "        graphs = self._read_geojson_archive()\n",
    "        label_map = self._convert_labels_inplace(graphs)\n",
    "        node_type_map = self._convert_node_types_inplace(graphs)\n",
    "\n",
    "        data_list = [self._convert_to_pyg_data(graph) for graph in tqdm(graphs.values(), desc=\"Converting graphs\")]\n",
    "\n",
    "        if self.pre_filter is not None:\n",
    "            data_list = [data for data in data_list if self.pre_filter(data)]\n",
    "\n",
    "        if self.pre_transform is not None:\n",
    "            data_list = [self.pre_transform(data) for data in data_list]\n",
    "\n",
    "        data, slices = self.collate(data_list)\n",
    "        torch.save((data, slices, label_map, node_type_map), self.processed_paths[0])\n",
    "\n",
    "    \n",
    "class PANDaGraphDatasetTrain(PANDaGraphDataset):\n",
    "    data_split = 'train'\n",
    "\n",
    "class PANDaGraphDatasetDev(PANDaGraphDataset):\n",
    "    data_split = 'dev'\n",
    "\n",
    "class PANDaGraphDatasetTest(PANDaGraphDataset):\n",
    "    data_split = 'test'\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_dataset = PANDaGraphDatasetTrain()\n",
    "test_dataset = PANDaGraphDatasetTest()\n",
    "dev_dataset = PANDaGraphDatasetDev()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "PANDaGraphDatasetTrain(1596)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### DataLoaders\n",
    "\n",
    "Pytorch Geometric has its own dataloaders. It allows for efficient batching of graphs by using the fact that all of the PyG operations rely on sparse implementations. By taking all graphs and essentially putting them into on large batch graph, the algorithms dont have to keep special track of batch examples as long as the operations are restricted to follow the graph structure."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torch_geometric.loader import DataLoader\n",
    "batch_size = 32\n",
    "train_dataloader = DataLoader(train_dataset, batch_size=batch_size, drop_last=False, shuffle=True, num_workers=4)\n",
    "dev_dataloader = DataLoader(dev_dataset, batch_size=batch_size, drop_last=False, shuffle=False, num_workers=4)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Predefined models\n",
    "\n",
    "We can build a GNN using the pre-existing [models](https://pytorch-geometric.readthedocs.io/en/latest/modules/nn.html#models) in Pytorch Geometric. These implements a handful of successful models from the litterature. We will look use the updated Graph Attention Networks from [“How Attentive are Graph Attention Networks?”](https://arxiv.org/abs/2105.14491).\n",
    "Below is a the signature of the constructur and an explanation of the arguments:\n",
    "\n",
    "```python\n",
    "class GAT(in_channels: int, hidden_channels: int, num_layers: int, out_channels: Optional[int] = None, dropout: float = 0.0, act: Optional[Union[str, Callable]] = 'relu', act_first: bool = False, act_kwargs: Optional[Dict[str, Any]] = None, norm: Optional[Union[str, Callable]] = None, norm_kwargs: Optional[Dict[str, Any]] = None, jk: Optional[str] = None, **kwargs)\n",
    "```\n",
    "\n",
    " - **in_channels** (int or tuple) – Size of each input sample, or -1 to derive the size from the first input(s) to the forward method. A tuple corresponds to the sizes of source and target dimensionalities.\n",
    " - **hidden_channels** (int) – Size of each hidden sample.\n",
    " - **num_layers** (int) – Number of message passing layers.\n",
    " - **out_channels** (int, optional) – If not set to None, will apply a final linear transformation to convert hidden node embeddings to output size out_channels. (default: None)\n",
    " - **v2** (bool, optional) – If set to True, will make use of GATv2Conv rather than GATConv. (default: False)\n",
    " - **dropout** (float, optional) – Dropout probability. (default: 0.)\n",
    " - **act** (str or Callable, optional) – The non-linear activation function to use. (default: \"relu\")\n",
    " - **act_first** (bool, optional) – If set to True, activation is applied before normalization. (default: False)\n",
    " - **act_kwargs** (Dict[str, Any], optional) – Arguments passed to the respective activation function defined by act. (default: None)\n",
    " - **norm** (str or Callable, optional) – The normalization function to use. (default: None)\n",
    " - **norm_kwargs** (Dict[str, Any], optional) – Arguments passed to the respective normalization function defined by norm. (default: None)\n",
    " - **jk** (str, optional) – The Jumping Knowledge mode. If specified, the model will additionally apply a final linear transformation to transform node embeddings to the expected output feature dimensionality. (None, \"last\", \"cat\", \"max\", \"lstm\"). (default: None)\n",
    " - ****kwargs** (optional) – Additional arguments of conv.GATConv or conv.GATv2Conv.\n",
    "\n",
    "We will create a separate configuration class which encapsulates the important arguments of this class. Many of arguments are shared between different prebuilt models, and you can experiment with replacing the GAT class with some other (e.g. GIN or GCN)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "from dataclasses import dataclass\n",
    "from typing import Type\n",
    "\n",
    "import torch\n",
    "#import lightning.pytorch as pl\n",
    "from torch_geometric.nn import global_mean_pool\n",
    "\n",
    "\n",
    "@dataclass\n",
    "class PANDaGATConfig:\n",
    "    d_model: int\n",
    "    n_layers: int\n",
    "    dropout_rate: float\n",
    "\n",
    "\n",
    "class LightningPANDaGAT(torch.nn.Module):\n",
    "    def __init__(self, node_type_map, num_classes, config: PANDaGATConfig):\n",
    "        super().__init__()\n",
    "        self.node_type_map = node_type_map\n",
    "        self.config = config\n",
    "        self.num_classes = num_classes\n",
    "        \n",
    "        self.node_type_embedding = torch.nn.Embedding(len(node_type_map), config.d_model)\n",
    "        self.gnn_encoder = torch_geometric.nn.GCN(in_channels=config.d_model, \n",
    "                                                  hidden_channels=config.d_model, \n",
    "                                                  num_layers=config.n_layers, \n",
    "                                                  dropout=config.dropout_rate, \n",
    "                                                  norm=None, # Adding a layer norm might be useful\n",
    "                                                  norm_kwargs=None)\n",
    "        self.output_head = torch.nn.Sequential(torch.nn.Linear(config.d_model, config.d_model), \n",
    "                                               torch.nn.ReLU(), \n",
    "                                               torch.nn.Dropout(config.dropout_rate), \n",
    "                                               torch.nn.Linear(config.d_model, num_classes))\n",
    "\n",
    "    def forward(self, batch):\n",
    "        # X contains our node attributes. In our case it's the classes assigned to each node. We need to embed them first:\n",
    "        x = self.node_type_embedding(batch.x)\n",
    "        x = self.gnn_encoder(x=x, edge_index=batch.edge_index)\n",
    "        x = global_mean_pool(x, batch.batch)\n",
    "        \n",
    "        predictions = self.output_head(x)\n",
    "\n",
    "        return predictions\n",
    "\n",
    "    def loss_on_batch(self, batch):\n",
    "        target = batch.y\n",
    "\n",
    "        predictions = self(batch)\n",
    "        loss = torch.nn.functional.cross_entropy(predictions, target)\n",
    "\n",
    "        return loss\n",
    "    \n",
    "    def loss_and_acc_on_batch(self, batch):\n",
    "        target = batch.y\n",
    "\n",
    "        predictions = self(batch)\n",
    "        loss = torch.nn.functional.cross_entropy(predictions, target)\n",
    "\n",
    "        correct_predictions = predictions.detach().argmax(dim=-1) == target\n",
    "        accuracy = torch.mean(correct_predictions.to(dtype=torch.float)).item()\n",
    "\n",
    "        return loss, accuracy\n",
    "    \n",
    "    def training_step(self, batch, batch_idx):\n",
    "        # training_step defines the train loop.\n",
    "        training_loss = self.loss_on_batch(batch)\n",
    "        return training_loss\n",
    "\n",
    "    def configure_optimizers(self):\n",
    "        optimizer = torch.optim.AdamW(self.parameters(), lr=1e-3)\n",
    "        return optimizer\n",
    "\n",
    "    def test_step(self, batch, batch_idx):\n",
    "        # this is the test loop\n",
    "        test_loss = self.loss_on_batch(batch).item()\n",
    "        #self.log(\"test_loss\", test_loss)\n",
    "        return test_loss\n",
    "\n",
    "    def validation_step(self, batch, batch_idx):\n",
    "        # this is the dev/validation loop\n",
    "        val_loss, accuracy = self.loss_and_acc_on_batch(batch)\n",
    "        #self.log(\"val_loss\", val_loss.item())\n",
    "        #self.log(\"val_accuracy\", accuracy)\n",
    "        return val_loss\n",
    "\n",
    "    def predict_step(self, batch, batch_idx):\n",
    "        targets = batch.y\n",
    "        predictions = self(batch)\n",
    "\n",
    "        return (predictions.detach().argmax(dim=-1), targets)\n",
    "        \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LightningPANDaGAT(\n",
       "  (node_type_embedding): Embedding(5, 32)\n",
       "  (gnn_encoder): GCN(32, 32, num_layers=4)\n",
       "  (output_head): Sequential(\n",
       "    (0): Linear(in_features=32, out_features=32, bias=True)\n",
       "    (1): ReLU()\n",
       "    (2): Dropout(p=0.1, inplace=False)\n",
       "    (3): Linear(in_features=32, out_features=6, bias=True)\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import torch_geometric\n",
    "\n",
    "d_model = 32\n",
    "\n",
    "gnn_config = PANDaGATConfig(\n",
    "    d_model=d_model,\n",
    "    n_layers=4,\n",
    "    dropout_rate=0.1,\n",
    ")\n",
    "num_classes = train_dataset.num_classes\n",
    "\n",
    "model = LightningPANDaGAT(train_dataset.node_type_map, num_classes, gnn_config)\n",
    "\n",
    "device = torch.device('cuda')\n",
    "model.to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8ac1b600cf694217baeb1729cce22697",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epoch:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1621d78bb4b94eb5b326223316719c0c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training batch:   0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "04df61976b9b4e2c8754e62eebfddb8e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Dev batch:   0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from tqdm.notebook import tqdm, trange\n",
    "max_epochs = 10\n",
    "optimizer = model.configure_optimizers()\n",
    "\n",
    "epoch_pbar = tqdm(total=max_epochs, desc='Epoch', leave=True)\n",
    "train_pbar = tqdm(total=len(train_dataloader), desc='Training batch', leave=True)\n",
    "dev_pbar = tqdm(total=len(dev_dataloader), desc='Dev batch', leave=True)\n",
    "for epoch in range(max_epochs):\n",
    "    for i,batch in enumerate(train_dataloader):\n",
    "        optimizer.zero_grad()\n",
    "        loss = model.training_step(batch.to(device), i)\n",
    "\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        train_pbar.update()\n",
    "    validation_losses = []\n",
    "    for i,batch in enumerate(dev_dataloader):\n",
    "        with torch.no_grad():\n",
    "            loss = model.validation_step(batch.to(device), i)\n",
    "            validation_losses.append(loss.item())\n",
    "        dev_pbar.update()\n",
    "\n",
    "    validation_loss = np.mean(validation_losses)\n",
    "    epoch_pbar.set_description(f\"Epoch (previous dev loss:{validation_loss})\")\n",
    "    epoch_pbar.update()\n",
    "    train_pbar.reset()\n",
    "    dev_pbar.reset()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7612ead1d1c641fa905684d7aaa1fdd1",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Test batch:   0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "test_dataloader = DataLoader(test_dataset, batch_size=32, drop_last=False, shuffle=False, num_workers=4)\n",
    "predictions = []\n",
    "targets = []\n",
    "for i, test_batch in enumerate(tqdm(test_dataloader, desc=\"Test batch\")):\n",
    "    batch_predictions, batch_targets = model.predict_step(test_batch.to(device), i)\n",
    "    predictions.append(batch_predictions.cpu().numpy())\n",
    "    targets.append(batch_targets.cpu().numpy())\n",
    "predictions = np.concatenate(predictions)\n",
    "targets = np.concatenate(targets)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay\n",
    "import matplotlib.pyplot as plt\n",
    "major_confusion = confusion_matrix(predictions, targets)\n",
    "ConfusionMatrixDisplay(major_confusion).plot()\n",
    "plt.title(\"ISUP Grade confusion matrix\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Finer control with GConvLayers\n",
    "\n",
    "The implemented models in Pytorch Geometric covers some basic cases, but we might often wan't to tweak the architecture of the network. We will now look at how we can implement our own Graph Neural Networks by using the different Graph Convolution Layers of Pytorch Geometric.\n",
    "\n",
    "### Pytorch Lightning\n",
    "\n",
    "We will be using [Pytorch Lightning](https://github.com/Lightning-AI/lightning) to simplify boiler plate code for training. It gives us many features without us having to implement them such as checkpointing, logging, early stopping, learning rate scheduling etc. Unfortunately, the current version doesn't work well with the predefined Pytorch Geometric models, which is the reason why we didn't use them in the example above. The issue seems to be that Pytorch Lightning tries to use the Pytorch JIT decorated functions of the BaseGNN which makes memory consumption blow up."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "from dataclasses import dataclass\n",
    "from typing import Type\n",
    "\n",
    "import torch\n",
    "import lightning.pytorch as pl\n",
    "from torch_geometric.nn import global_mean_pool, global_max_pool\n",
    "\n",
    "@dataclass\n",
    "class LayerConfig:\n",
    "    layer_dim: int    \n",
    "    conv_module: Type\n",
    "    nonlinearity: Type\n",
    "    dropout_rate: float\n",
    "\n",
    "@dataclass\n",
    "class PANDaGNNConfig:\n",
    "    d_model: int\n",
    "    output_head_ffn_dim: int\n",
    "    n_gnn_layers: int\n",
    "    dropout_rate: float\n",
    "    gnn_layer_type: Type\n",
    "    gnn_layer_config: LayerConfig\n",
    "    residual_connections: bool = True\n",
    "    \n",
    "\n",
    "class GNNLayer(torch.nn.Module):\n",
    "    \"Implements a GNN block, including nonlinearity and normalizations\"\n",
    "    def __init__(self, input_dim, config: LayerConfig):\n",
    "        super().__init__()\n",
    "        self.input_dim = input_dim\n",
    "        self.output_dim = config.layer_dim\n",
    "        self.config = config\n",
    "        self.conv_layer = config.conv_module(self.input_dim, self.output_dim)\n",
    "        self.nonlinearity = config.nonlinearity()\n",
    "        self.dropout = torch.nn.Dropout(config.dropout_rate)\n",
    "        \n",
    "    def forward(self, x, batch):\n",
    "        x = self.conv_layer(x, batch.edge_index)\n",
    "        x = self.nonlinearity(x)\n",
    "        x = self.dropout(x)\n",
    "        return x\n",
    "\n",
    "\n",
    "class LightningPANDaGNN(pl.LightningModule):\n",
    "    def __init__(self, node_type_map, num_classes, config: PANDaGNNConfig):\n",
    "        super().__init__()\n",
    "        self.node_type_map = node_type_map\n",
    "        self.config = config\n",
    "        self.num_classes = num_classes\n",
    "        \n",
    "        self.node_type_embedding = torch.nn.Embedding(len(node_type_map), config.d_model)\n",
    "        dim_from_below = config.d_model\n",
    "        self.gnn_layers = torch.nn.ModuleList()\n",
    "\n",
    "        for i in range(config.n_gnn_layers):\n",
    "            layer = self.config.gnn_layer_type(dim_from_below, self.config.gnn_layer_config)\n",
    "            dim_from_below = layer.output_dim\n",
    "            self.gnn_layers.append(layer)\n",
    "\n",
    "        self.output_head = torch.nn.Sequential(torch.nn.Linear(dim_from_below, config.output_head_ffn_dim), torch.nn.ReLU(), torch.nn.Dropout(config.dropout_rate), torch.nn.Linear(config.output_head_ffn_dim, num_classes))\n",
    "\n",
    "    def forward(self, batch):\n",
    "        # X contains our node attributes. In our case it's the classes assigned to each node. We need to embed them first:\n",
    "        x = self.node_type_embedding(batch.x)\n",
    "        for gnn_layer in self.gnn_layers:\n",
    "            if self.config.residual_connections:\n",
    "                x = x + gnn_layer(x, batch)\n",
    "            else:\n",
    "                x = gnn_layer(x, batch)\n",
    "\n",
    "        x = global_mean_pool(x, batch.batch)\n",
    "        \n",
    "        predictions = self.output_head(x)\n",
    "\n",
    "        return predictions\n",
    "\n",
    "    def loss_on_batch(self, batch):\n",
    "        target = batch.y\n",
    "\n",
    "        predictions = self(batch)\n",
    "        loss = torch.nn.functional.cross_entropy(predictions, target)\n",
    "\n",
    "        return loss\n",
    "    \n",
    "    def loss_and_acc_on_batch(self, batch):\n",
    "        target = batch.y\n",
    "\n",
    "        predictions = self(batch)\n",
    "        loss = torch.nn.functional.cross_entropy(predictions, target)\n",
    "\n",
    "        correct_predictions = predictions.detach().argmax(dim=-1) == target\n",
    "        accuracy = torch.mean(correct_predictions.to(dtype=torch.float)).item()\n",
    "\n",
    "        return loss, accuracy\n",
    "    \n",
    "    def training_step(self, batch, batch_idx):\n",
    "        # training_step defines the train loop.\n",
    "        self.train()\n",
    "        training_loss = self.loss_on_batch(batch)\n",
    "        self.log(\"train_loss\", training_loss.item())\n",
    "        return training_loss\n",
    "\n",
    "    def configure_optimizers(self):\n",
    "        optimizer = torch.optim.AdamW(self.parameters(), lr=3e-4)\n",
    "        return optimizer\n",
    "\n",
    "    def test_step(self, batch, batch_idx):\n",
    "        # this is the test loop\n",
    "        self.eval()\n",
    "        test_loss = self.loss_on_batch(batch)\n",
    "        self.log(\"test_loss\", test_loss)\n",
    "\n",
    "    def validation_step(self, batch, batch_idx):\n",
    "        # this is the dev/validation loop\n",
    "        self.eval()\n",
    "        val_loss, accuracy = self.loss_and_acc_on_batch(batch)\n",
    "        self.log(\"val_loss\", val_loss)\n",
    "        self.log(\"val_accuracy\", accuracy)\n",
    "\n",
    "    def predict_step(self, batch, batch_idx):\n",
    "        self.eval()\n",
    "        targets = batch.y\n",
    "        predictions = self(batch)\n",
    "\n",
    "        return (predictions.detach().argmax(dim=-1), targets)\n",
    "        \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch_geometric\n",
    "\n",
    "d_model = 32\n",
    "\n",
    "layer_config = LayerConfig(layer_dim=d_model, \n",
    "                           conv_module=torch_geometric.nn.GCNConv, \n",
    "                          nonlinearity=torch.nn.ReLU, \n",
    "                          dropout_rate=0.1)\n",
    "gnn_config = PANDaGNNConfig(\n",
    "    d_model=d_model,\n",
    "    output_head_ffn_dim=d_model,\n",
    "    n_gnn_layers=4,\n",
    "    dropout_rate=0.1,\n",
    "    gnn_layer_type=GNNLayer,\n",
    "    gnn_layer_config=layer_config,\n",
    "    residual_connections=True\n",
    ")\n",
    "num_classes = train_dataset.num_classes\n",
    "\n",
    "model = LightningPANDaGNN(train_dataset.node_type_map, num_classes, gnn_config)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/erik/mambaforge/envs/aida_workshop_gnn/lib/python3.9/site-packages/lightning/fabric/connector.py:554: UserWarning: 16 is supported for historical reasons but its usage is discouraged. Please set your precision to 16-mixed instead!\n",
      "  rank_zero_warn(\n",
      "Using 16bit Automatic Mixed Precision (AMP)\n",
      "GPU available: True (cuda), used: True\n",
      "TPU available: False, using: 0 TPU cores\n",
      "IPU available: False, using: 0 IPUs\n",
      "HPU available: False, using: 0 HPUs\n"
     ]
    }
   ],
   "source": [
    "from pathlib import Path\n",
    "import sys\n",
    "\n",
    "from lightning import Trainer\n",
    "from lightning.pytorch.callbacks import ModelCheckpoint\n",
    "from lightning.pytorch.callbacks.lr_monitor import LearningRateMonitor\n",
    "from lightning.pytorch.callbacks.early_stopping import EarlyStopping\n",
    "\n",
    "CHECKPOINT_PATH = Path('../models')\n",
    "\n",
    "\n",
    "trainer = Trainer(\n",
    "        default_root_dir = CHECKPOINT_PATH,  # Where to save models\n",
    "        # We run on a single GPU (if possible)\n",
    "        accelerator=\"auto\",\n",
    "        devices=1,\n",
    "        precision=16,\n",
    "        # How many epochs to train for if no patience is set\n",
    "        max_epochs=10,\n",
    "        callbacks=[\n",
    "            ModelCheckpoint(\n",
    "                save_weights_only=True, mode=\"min\", monitor=\"val_loss\"\n",
    "            ),  # Save the best checkpoint based on the maximum val_acc recorded. Saves only weights and not optimizer\n",
    "            LearningRateMonitor(\"epoch\"),\n",
    "        ],  # Log learning rate every epoch\n",
    "    )  # In case your notebook crashes due to the progress bar, consider increasing the refresh rate\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torch_geometric.loader import DataLoader\n",
    "batch_size = 32\n",
    "train_dataloader = DataLoader(train_dataset, batch_size=batch_size, drop_last=False, shuffle=True, num_workers=4)\n",
    "dev_dataloader = DataLoader(dev_dataset, batch_size=batch_size, drop_last=False, shuffle=False, num_workers=4)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Reusing TensorBoard on port 6006 (pid 27641), started 0:02:28 ago. (Use '!kill 27641' to kill it.)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "\n",
       "      <iframe id=\"tensorboard-frame-b9686c93653b3a64\" width=\"100%\" height=\"800\" frameborder=\"0\">\n",
       "      </iframe>\n",
       "      <script>\n",
       "        (function() {\n",
       "          const frame = document.getElementById(\"tensorboard-frame-b9686c93653b3a64\");\n",
       "          const url = new URL(\"http://localhost\");\n",
       "          const port = 6006;\n",
       "          if (port) {\n",
       "            url.port = port;\n",
       "          }\n",
       "          frame.src = url;\n",
       "        })();\n",
       "      </script>\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%reload_ext tensorboard\n",
    "%tensorboard --logdir=../models/lightning_logs/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n",
      "\n",
      "  | Name                | Type       | Params\n",
      "---------------------------------------------------\n",
      "0 | node_type_embedding | Embedding  | 160   \n",
      "1 | gnn_layers          | ModuleList | 4.2 K \n",
      "2 | output_head         | Sequential | 1.3 K \n",
      "---------------------------------------------------\n",
      "5.6 K     Trainable params\n",
      "0         Non-trainable params\n",
      "5.6 K     Total params\n",
      "0.023     Total estimated model params size (MB)\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d5387c7e2eba4f399363e766788df39d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Sanity Checking: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f2498d3802f14d9eb2da62c81f595652",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ea81b7d40ff04706a09db36e5a037211",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validation: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2a5a10a3f6a2429e891d6f7dc566eb4c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validation: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "dce7ae172ef34bacb8600df3007a7a2b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validation: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e981cb5977b24c9eb219246de46a9631",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validation: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "5417fcb8aabc4981927c1d780f61f744",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validation: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "772129187b4948268c3540df555a3ead",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validation: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "27108687c7d0478bb6d50d3db377af1a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validation: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e4888f99037748ba9ea1c464eb7f2c99",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validation: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ed35b1b7de7448fa8c07256529affb43",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validation: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9e60bc1265d2411bbfb0daa8710bbdc2",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validation: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "`Trainer.fit` stopped: `max_epochs=10` reached.\n"
     ]
    }
   ],
   "source": [
    "trainer.fit(model, train_dataloader, dev_dataloader)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/erik/mambaforge/envs/aida_workshop_gnn/lib/python3.9/site-packages/lightning/pytorch/trainer/connectors/checkpoint_connector.py:149: UserWarning: `.predict(ckpt_path=None)` was called without a model. The best model of the previous `fit` call will be used. You can pass `.predict(ckpt_path='best')` to use the best model or `.predict(ckpt_path='last')` to use the last model. If you pass a value, this warning will be silenced.\n",
      "  rank_zero_warn(\n",
      "Restoring states from the checkpoint path at ../models/lightning_logs/version_17/checkpoints/epoch=6-step=350.ckpt\n",
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n",
      "Loaded model weights from the checkpoint at ../models/lightning_logs/version_17/checkpoints/epoch=6-step=350.ckpt\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0632ddb9178746d8992845f478de2562",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Predicting: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "test_dataloader = DataLoader(test_dataset, batch_size=32, drop_last=False, shuffle=False, num_workers=4)\n",
    "predictions = trainer.predict(dataloaders=test_dataloader)\n",
    "predictions, targets = zip(*predictions)\n",
    "predictions = torch.cat(predictions)\n",
    "targets = torch.cat(targets)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay\n",
    "import matplotlib.pyplot as plt\n",
    "major_confusion = confusion_matrix(predictions, targets)\n",
    "ConfusionMatrixDisplay(major_confusion).plot()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Changing Conv layer\n",
    "\n",
    "Here we will look at how we can change the convolution layer we use and whether that will have some effect. A list of available layers can be found at the PyG [documentation](https://pytorch-geometric.readthedocs.io/en/latest/modules/nn.html#convolutional-layers)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch_geometric\n",
    "\n",
    "d_model = 128\n",
    "\n",
    "layer_config = LayerConfig(layer_dim=d_model, \n",
    "                           conv_module=torch_geometric.nn.GATv2Conv, \n",
    "                           nonlinearity=torch.nn.ReLU, \n",
    "                           dropout_rate=0.5)\n",
    "gnn_config = PANDaGNNConfig(\n",
    "    d_model=d_model,\n",
    "    output_head_ffn_dim=d_model,\n",
    "    n_gnn_layers=6,\n",
    "    dropout_rate=0.5,\n",
    "    gnn_layer_type=GNNLayer,\n",
    "    gnn_layer_config=layer_config,\n",
    "    residual_connections=True\n",
    ")\n",
    "num_classes = train_dataset.num_classes\n",
    "\n",
    "model = LightningPANDaGNN(train_dataset.node_type_map, num_classes, gnn_config)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using 16bit Automatic Mixed Precision (AMP)\n",
      "GPU available: True (cuda), used: True\n",
      "TPU available: False, using: 0 TPU cores\n",
      "IPU available: False, using: 0 IPUs\n",
      "HPU available: False, using: 0 HPUs\n"
     ]
    }
   ],
   "source": [
    "from pathlib import Path\n",
    "import sys\n",
    "\n",
    "from lightning import Trainer\n",
    "from lightning.pytorch.callbacks import ModelCheckpoint\n",
    "from lightning.pytorch.callbacks.lr_monitor import LearningRateMonitor\n",
    "from lightning.pytorch.callbacks.early_stopping import EarlyStopping\n",
    "\n",
    "CHECKPOINT_PATH = Path('../models')\n",
    "\n",
    "\n",
    "trainer = Trainer(\n",
    "        default_root_dir = CHECKPOINT_PATH,  # Where to save models\n",
    "        # We run on a single GPU (if possible)\n",
    "        accelerator=\"auto\",\n",
    "        devices=1,\n",
    "        precision=16,\n",
    "        # How many epochs to train for if no patience is set\n",
    "        max_epochs=10,\n",
    "        #enable_progress_bar=False,\n",
    "        callbacks=[\n",
    "            ModelCheckpoint(\n",
    "                save_weights_only=True, mode=\"min\", monitor=\"val_loss\"\n",
    "            ),  # Save the best checkpoint based on the maximum val_acc recorded. Saves only weights and not optimizer\n",
    "            LearningRateMonitor(\"epoch\"),\n",
    "        ],  # Log learning rate every epoch\n",
    "    )  # In case your notebook crashes due to the progress bar, consider increasing the refresh rate\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torch_geometric.loader import DataLoader\n",
    "batch_size = 8\n",
    "train_dataloader = DataLoader(train_dataset, batch_size=batch_size, drop_last=False, shuffle=True, num_workers=6)\n",
    "dev_dataloader = DataLoader(dev_dataset, batch_size=batch_size, drop_last=False, shuffle=False, num_workers=4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "trainer.fit(model, train_dataloader, dev_dataloader)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Reusing TensorBoard on port 6006 (pid 15133), started 0:24:22 ago. (Use '!kill 15133' to kill it.)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "\n",
       "      <iframe id=\"tensorboard-frame-2895aecb3a0619b8\" width=\"100%\" height=\"800\" frameborder=\"0\">\n",
       "      </iframe>\n",
       "      <script>\n",
       "        (function() {\n",
       "          const frame = document.getElementById(\"tensorboard-frame-2895aecb3a0619b8\");\n",
       "          const url = new URL(\"http://localhost\");\n",
       "          const port = 6006;\n",
       "          if (port) {\n",
       "            url.port = port;\n",
       "          }\n",
       "          frame.src = url;\n",
       "        })();\n",
       "      </script>\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%reload_ext tensorboard\n",
    "%tensorboard --logdir=../models/lightning_logs/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/erik/mambaforge/envs/aida_workshop_gnn/lib/python3.9/site-packages/lightning/pytorch/trainer/connectors/checkpoint_connector.py:149: UserWarning: `.predict(ckpt_path=None)` was called without a model. The best model of the previous `fit` call will be used. You can pass `.predict(ckpt_path='best')` to use the best model or `.predict(ckpt_path='last')` to use the last model. If you pass a value, this warning will be silenced.\n",
      "  rank_zero_warn(\n",
      "Restoring states from the checkpoint path at ../models/lightning_logs/version_15/checkpoints/epoch=73-step=14801.ckpt\n",
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n",
      "Loaded model weights from the checkpoint at ../models/lightning_logs/version_15/checkpoints/epoch=73-step=14801.ckpt\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ade78ee175544e36af55c4956e5eed91",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Predicting: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "test_dataloader = DataLoader(test_dataset, batch_size=32, drop_last=False, shuffle=False, num_workers=4)\n",
    "predictions = trainer.predict(dataloaders=test_dataloader)\n",
    "predictions, targets = zip(*predictions)\n",
    "predictions = torch.cat(predictions)\n",
    "targets = torch.cat(targets)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay\n",
    "import matplotlib.pyplot as plt\n",
    "major_confusion = confusion_matrix(predictions, targets)\n",
    "ConfusionMatrixDisplay(major_confusion).plot()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dropping the graph\n",
    "\n",
    "Recall that we started out with a set of coordinates for detected cells in images. This wasn't really a graph, but by taking the distances between all nodes and applying a threshold we induced a graph. We can think of this as _computing_ an adjacency matrix based on some information about the elements of the node set (in this case their positions). We created an adjacency matrix looking something like this:\n",
    "$$\n",
    "\\begin{bmatrix}\n",
    "f(v_1, v_1) & \\dots & f(v_1, v_n)\\\\\n",
    "\\vdots & \\ddots & \\vdots \\\\\n",
    "f(v_n, v_1) & \\dots & f(v_n, v_n)\n",
    "\\end{bmatrix}\n",
    "$$\n",
    "\n",
    "$$\n",
    "\\begin{align*}\n",
    "f(u,v) &= \\begin{cases}\n",
    "    1, & \\text{if } 0 \\lt d(u,v) \\lt r\\\\\n",
    "    0, &\\text{otherwise}\n",
    "\\end{cases}\\\\\n",
    "d(u,v) &= \\lVert u - v \\rVert\n",
    "\\end{align*}\n",
    "$$\n",
    "\n",
    "Where $r$ was the radius we decided on.\n",
    "\n",
    "Instead of thinking of this as a pre-processing step, we can think of it as part of our model, where we recompute the attention matrix after each message propagation. One neural network which implements this idea is the Dynamic Edge Convolution network, which instead of taking a graph of inputs takes a point cloud. Since our dataset already have the positions of all nodes, we don't have to do anything to it, only define a new model.\n",
    "\n",
    "**N.B. the dynamic edge convolution seems to be broken in this implementation, this is left as an illustration**\n",
    "\n",
    "If you are working with point clouds (or similar inputs), have a look at [KeOps](https://www.kernel-operations.io/keops/index.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from dataclasses import dataclass\n",
    "from typing import Type\n",
    "\n",
    "import torch\n",
    "import lightning.pytorch as pl\n",
    "from torch_geometric.nn import global_mean_pool\n",
    "\n",
    "@dataclass\n",
    "class EdgeConvConfig:\n",
    "    d_model: int\n",
    "    ffn_dim: int\n",
    "    dropout_rate: float\n",
    "    k: int = 5\n",
    "\n",
    "@dataclass\n",
    "class PANDaPointNNConfig:\n",
    "    d_model: int\n",
    "    output_head_ffn_dim: int\n",
    "    n_gnn_layers: int\n",
    "    dropout_rate: float\n",
    "    gnn_layer_type: Type\n",
    "    gnn_layer_config: EdgeConvConfig\n",
    "    residual_connections: bool = True\n",
    "    \n",
    "\n",
    "class EdgeConvNNLayer(torch.nn.Module):\n",
    "    \"Implements a Point NN block, including nonlinearity and normalizations\"\n",
    "    def __init__(self, input_dim, config: EdgeConvConfig):\n",
    "        super().__init__()\n",
    "        self.input_dim = config.d_model\n",
    "        self.output_dim = config.d_model\n",
    "        self.config = config\n",
    "        edge_conv_nn = torch.nn.Sequential(torch.nn.Linear(input_dim, config.ffn_dim), \n",
    "                                           torch.nn.ReLU(), \n",
    "                                           torch.nn.Dropout(config.dropout_rate), \n",
    "                                           torch.nn.Linear(config.ffn_dim, self.output_dim))\n",
    "        self.conv_layer = torch_geometric.nn.DynamicEdgeConv(nn=edge_conv_nn, k=config.k)\n",
    "        self.nonlinearity = torch.nn.ReLU()\n",
    "        self.dropout = torch.nn.Dropout(config.dropout_rate)\n",
    "        \n",
    "    def forward(self, x, batch):\n",
    "        x = self.conv_layer(x, batch.batch)\n",
    "        x = self.nonlinearity(x)\n",
    "        x = self.dropout(x)\n",
    "        return x\n",
    "\n",
    "\n",
    "class LightningPANDaPointNN(pl.LightningModule):\n",
    "    def __init__(self, node_type_map, node_feature_dim, num_classes, config: PANDaPointNNConfig):\n",
    "        super().__init__()\n",
    "        self.node_type_map = node_type_map\n",
    "        self.node_feature_dim = node_feature_dim\n",
    "        self.config = config\n",
    "        self.num_classes = num_classes\n",
    "\n",
    "        # We will concatenate the node embeddings with the node positions. We wish to end up with an\n",
    "        # node feature size of d_model, so we need to set the embedding size to d_model - node_feature_dim\n",
    "        self.embedding_dim = config.d_model - node_feature_dim\n",
    "        self.num_embeddings = len(self.node_type_map)\n",
    "        self.node_type_embedding = torch.nn.Embedding(self.num_embeddings, self.embedding_dim)\n",
    "        \n",
    "        dim_from_below = config.d_model\n",
    "        self.gnn_layers = torch.nn.ModuleList()\n",
    "\n",
    "        for i in range(config.n_gnn_layers):\n",
    "            layer = self.config.gnn_layer_type(dim_from_below, self.config.gnn_layer_config)\n",
    "            dim_from_below = layer.output_dim\n",
    "            self.gnn_layers.append(layer)\n",
    "\n",
    "        self.output_head = torch.nn.Sequential(torch.nn.Linear(dim_from_below, config.output_head_ffn_dim), torch.nn.ReLU(), torch.nn.Dropout(config.dropout_rate), torch.nn.Linear(config.output_head_ffn_dim, num_classes))\n",
    "\n",
    "    def forward(self, batch):\n",
    "        # X contains our node attributes. In our case it's the classes assigned to each node. \n",
    "        # We need to embed them first:\n",
    "        x = self.node_type_embedding(batch.x)\n",
    "        # batch.pos are our positional features. We simply concatenate them to the \n",
    "        # node embeddings along the feature dimension\n",
    "        x = torch.cat([x, batch.pos], dim=-1)\n",
    "        for gnn_layer in self.gnn_layers:\n",
    "            if self.config.residual_connections:\n",
    "                x = x + gnn_layer(x, batch)\n",
    "            else:\n",
    "                x = gnn_layer(x, batch)\n",
    "\n",
    "        x = global_mean_pool(x, batch.batch)\n",
    "        \n",
    "        predictions = self.output_head(x)\n",
    "\n",
    "        return predictions\n",
    "\n",
    "    def loss_on_batch(self, batch):\n",
    "        target = batch.y\n",
    "\n",
    "        predictions = self(batch)\n",
    "        loss = torch.nn.functional.cross_entropy(predictions, target)\n",
    "\n",
    "        return loss\n",
    "    \n",
    "    def loss_and_acc_on_batch(self, batch):\n",
    "        target = batch.y\n",
    "\n",
    "        predictions = self(batch)\n",
    "        loss = torch.nn.functional.cross_entropy(predictions, target)\n",
    "\n",
    "        correct_predictions = predictions.detach().argmax(dim=-1) == target\n",
    "        accuracy = torch.mean(correct_predictions.to(dtype=torch.float)).item()\n",
    "\n",
    "        return loss, accuracy\n",
    "    \n",
    "    def training_step(self, batch, batch_idx):\n",
    "        # training_step defines the train loop.\n",
    "        training_loss = self.loss_on_batch(batch)\n",
    "        return training_loss\n",
    "\n",
    "    def configure_optimizers(self):\n",
    "        optimizer = torch.optim.AdamW(self.parameters(), lr=1e-3)\n",
    "        return optimizer\n",
    "\n",
    "    def test_step(self, batch, batch_idx):\n",
    "        # this is the test loop\n",
    "        test_loss = self.loss_on_batch(batch)\n",
    "        self.log(\"test_loss\", test_loss)\n",
    "\n",
    "    def validation_step(self, batch, batch_idx):\n",
    "        # this is the dev/validation loop\n",
    "        val_loss, accuracy = self.loss_and_acc_on_batch(batch)\n",
    "        self.log(\"val_loss\", val_loss)\n",
    "        self.log(\"val_accuracy\", accuracy)\n",
    "\n",
    "    def predict_step(self, batch, batch_idx):\n",
    "        targets = batch.y\n",
    "        predictions = self(batch)\n",
    "\n",
    "        return (predictions.detach().argmax(dim=-1), targets)\n",
    "        \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch_geometric\n",
    "\n",
    "d_model = 128\n",
    "\n",
    "\n",
    "layer_config = EdgeConvConfig(d_model=d_model, ffn_dim=d_model, dropout_rate=0.1)\n",
    "                             \n",
    "gnn_config = PANDaPointNNConfig(\n",
    "    d_model=d_model,\n",
    "    output_head_ffn_dim=d_model,\n",
    "    n_gnn_layers=4,\n",
    "    dropout_rate=0.1,\n",
    "    gnn_layer_type=EdgeConvNNLayer,\n",
    "    gnn_layer_config=layer_config,\n",
    "    residual_connections=True\n",
    ")\n",
    "num_classes = train_dataset.num_classes\n",
    "node_position_dimension = train_dataset[0].pos.shape[1] # We take the position array shape for the first element in our dataset\n",
    "model = LightningPANDaPointNN(train_dataset.node_type_map, node_position_dimension, num_classes, gnn_config)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using 16bit Automatic Mixed Precision (AMP)\n",
      "GPU available: True (cuda), used: True\n",
      "TPU available: False, using: 0 TPU cores\n",
      "IPU available: False, using: 0 IPUs\n",
      "HPU available: False, using: 0 HPUs\n"
     ]
    }
   ],
   "source": [
    "from pathlib import Path\n",
    "\n",
    "from lightning import Trainer\n",
    "from lightning.pytorch.callbacks import ModelCheckpoint\n",
    "from lightning.pytorch.callbacks.lr_monitor import LearningRateMonitor\n",
    "from lightning.pytorch.callbacks.early_stopping import EarlyStopping\n",
    "\n",
    "CHECKPOINT_PATH = Path('../models')\n",
    "\n",
    "trainer = Trainer(\n",
    "        default_root_dir = CHECKPOINT_PATH,  # Where to save models\n",
    "        # We run on a single GPU (if possible)\n",
    "        accelerator=\"auto\",\n",
    "        devices=1,\n",
    "        precision=16,\n",
    "        # How many epochs to train for if no patience is set\n",
    "        max_epochs=10,\n",
    "        callbacks=[\n",
    "            ModelCheckpoint(\n",
    "                save_weights_only=True, mode=\"min\", monitor=\"val_loss\"\n",
    "            ),  # Save the best checkpoint based on the maximum val_acc recorded. Saves only weights and not optimizer\n",
    "            LearningRateMonitor(\"epoch\"),\n",
    "        ],  # Log learning rate every epoch\n",
    "    )  # In case your notebook crashes due to the progress bar, consider increasing the refresh rate\n",
    "trainer.logger._log_graph = True  # If True, we plot the computation graph in tensorboard\n",
    "trainer.logger._default_hp_metric = None  # Optional logging argument that we don't need"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n",
      "\n",
      "  | Name                | Type       | Params\n",
      "---------------------------------------------------\n",
      "0 | node_type_embedding | Embedding  | 630   \n",
      "1 | gnn_layers          | ModuleList | 132 K \n",
      "2 | output_head         | Sequential | 17.3 K\n",
      "---------------------------------------------------\n",
      "150 K     Trainable params\n",
      "0         Non-trainable params\n",
      "150 K     Total params\n",
      "0.600     Total estimated model params size (MB)\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "dc11d6e10c6148d9a59690de8cee74f6",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Sanity Checking: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from torch_geometric.loader import DataLoader\n",
    "batch_size = 32\n",
    "train_dataloader = DataLoader(train_dataset, batch_size=batch_size, drop_last=False, shuffle=True, num_workers=4)\n",
    "dev_dataloader = DataLoader(dev_dataset, batch_size=batch_size, drop_last=False, shuffle=False, num_workers=4)\n",
    "trainer.fit(model, train_dataloader, dev_dataloader)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Restoring states from the checkpoint path at ../models/gnn_model.pt/lightning_logs/version_23/checkpoints/epoch=9-step=720.ckpt\n",
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n",
      "Loaded model weights from the checkpoint at ../models/gnn_model.pt/lightning_logs/version_23/checkpoints/epoch=9-step=720.ckpt\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ec15fb5d1c17479c9f066366a460152c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Predicting: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "test_dataloader = DataLoader(test_dataset, batch_size=32, drop_last=False, shuffle=False, num_workers=4)\n",
    "predictions = trainer.predict(dataloaders=test_dataloader)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "predictions, targets = zip(*predictions)\n",
    "predictions = torch.cat(predictions)\n",
    "targets = torch.cat(targets)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay\n",
    "import matplotlib.pyplot as plt\n",
    "major_confusion = confusion_matrix(predictions, targets)\n",
    "ConfusionMatrixDisplay(major_confusion).plot()\n",
    "plt.title(\"ISUP Grade confusion matrix\")\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "aida_workshop_gnn_v4",
   "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.18"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}