04_1_Graph_Classification_RDKit_GCNN.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "04.1: Graph_Classification_RDKit_GCNN.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "cSTDAc0jZTON",
        "HBodIcNlfqOF",
        "lhJYtenTje8-",
        "Axl1fpt1N_dv",
        "BQnbktyWU3r3"
      ],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/gulabpatel/Graph_Neural_Network/blob/main/04.1%3A%20Graph_Classification_RDKit_GCNN.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7oJF8jEXZP5v"
      },
      "source": [
        "# Hands on with Graph Neural Networks"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L2MmB_8Lzojr"
      },
      "source": [
        "![image.png](data:image/png;base64,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)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "c02WfHo9ZU51"
      },
      "source": [
        "## Installing Pytorch Geometric and RDKit\n",
        "\n",
        "Video walkthrugh the code : https://www.youtube.com/watch?v=0YLZXjMHA-8"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o4TLPMJGVDQy"
      },
      "source": [
        "- Pytorch Geometric => Build Graph Neural Network\n",
        "- RDKit => Handle Molecule Data\n",
        "\n",
        "\n",
        "_Note: Currently I didn't find a way to set a specific python version in colab. However, when installing rdkit, only specific python versions are supported... Hence it cannot be ensured that the notebook runs properly. For example Python 3.7.10 is not supported._"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pxmMjZ240wob",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e402ebba-ee39-4e51-e20c-725a4dce245b"
      },
      "source": [
        "# Enforce pytorch version 1.6.0\n",
        "import torch\n",
        "if torch.__version__ != '1.6.0':\n",
        "  !pip uninstall torch -y\n",
        "  !pip uninstall torchvision -y\n",
        "  !pip install torch==1.6.0\n",
        "  !pip install torchvision==0.7.0\n",
        "\n",
        "# Check pytorch version and make sure you use a GPU Kernel\n",
        "!python -c \"import torch; print(torch.__version__)\"\n",
        "!python -c \"import torch; print(torch.version.cuda)\"\n",
        "!python --version\n",
        "!nvidia-smi"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1.6.0\n",
            "10.2\n",
            "Python 3.7.11\n",
            "Wed Jul 21 05:30:31 2021       \n",
            "+-----------------------------------------------------------------------------+\n",
            "| NVIDIA-SMI 470.42.01    Driver Version: 460.32.03    CUDA Version: 11.2     |\n",
            "|-------------------------------+----------------------+----------------------+\n",
            "| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\n",
            "| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n",
            "|                               |                      |               MIG M. |\n",
            "|===============================+======================+======================|\n",
            "|   0  Tesla T4            Off  | 00000000:00:04.0 Off |                    0 |\n",
            "| N/A   47C    P8    10W /  70W |      0MiB / 15109MiB |      0%      Default |\n",
            "|                               |                      |                  N/A |\n",
            "+-------------------------------+----------------------+----------------------+\n",
            "                                                                               \n",
            "+-----------------------------------------------------------------------------+\n",
            "| Processes:                                                                  |\n",
            "|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |\n",
            "|        ID   ID                                                   Usage      |\n",
            "|=============================================================================|\n",
            "|  No running processes found                                                 |\n",
            "+-----------------------------------------------------------------------------+\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-DT7bk5cxfDy"
      },
      "source": [
        "> Make sure you clicked \"RESTART RUNTIME\" above (if torch version was different)!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gcGz5ZGMdGx-",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "613d4638-5145-4c92-8568-b8ca95604e50"
      },
      "source": [
        "import sys\n",
        "import os\n",
        "import requests\n",
        "import subprocess\n",
        "import shutil\n",
        "from logging import getLogger, StreamHandler, INFO\n",
        " \n",
        " \n",
        "logger = getLogger(__name__)\n",
        "logger.addHandler(StreamHandler())\n",
        "logger.setLevel(INFO)\n",
        " \n",
        " \n",
        "def install(\n",
        "        chunk_size=4096,\n",
        "        file_name=\"Miniconda3-latest-Linux-x86_64.sh\",\n",
        "        url_base=\"https://repo.continuum.io/miniconda/\",\n",
        "        conda_path=os.path.expanduser(os.path.join(\"~\", \"miniconda\")),\n",
        "        rdkit_version=None,\n",
        "        add_python_path=True,\n",
        "        force=False):\n",
        "    \"\"\"install rdkit from miniconda\n",
        "    ```\n",
        "    import rdkit_installer\n",
        "    rdkit_installer.install()\n",
        "    ```\n",
        "    \"\"\"\n",
        " \n",
        "    python_path = os.path.join(\n",
        "        conda_path,\n",
        "        \"lib\",\n",
        "        \"python{0}.{1}\".format(*sys.version_info),\n",
        "        \"site-packages\",\n",
        "    )\n",
        " \n",
        "    if add_python_path and python_path not in sys.path:\n",
        "        logger.info(\"add {} to PYTHONPATH\".format(python_path))\n",
        "        sys.path.append(python_path)\n",
        " \n",
        "    if os.path.isdir(os.path.join(python_path, \"rdkit\")):\n",
        "        logger.info(\"rdkit is already installed\")\n",
        "        if not force:\n",
        "            return\n",
        " \n",
        "        logger.info(\"force re-install\")\n",
        " \n",
        "    url = url_base + file_name\n",
        "    python_version = \"{0}.{1}.{2}\".format(*sys.version_info)\n",
        " \n",
        "    logger.info(\"python version: {}\".format(python_version))\n",
        " \n",
        "    if os.path.isdir(conda_path):\n",
        "        logger.warning(\"remove current miniconda\")\n",
        "        shutil.rmtree(conda_path)\n",
        "    elif os.path.isfile(conda_path):\n",
        "        logger.warning(\"remove {}\".format(conda_path))\n",
        "        os.remove(conda_path)\n",
        " \n",
        "    logger.info('fetching installer from {}'.format(url))\n",
        "    res = requests.get(url, stream=True)\n",
        "    res.raise_for_status()\n",
        "    with open(file_name, 'wb') as f:\n",
        "        for chunk in res.iter_content(chunk_size):\n",
        "            f.write(chunk)\n",
        "    logger.info('done')\n",
        " \n",
        "    logger.info('installing miniconda to {}'.format(conda_path))\n",
        "    subprocess.check_call([\"bash\", file_name, \"-b\", \"-p\", conda_path])\n",
        "    logger.info('done')\n",
        " \n",
        "    logger.info(\"installing rdkit\")\n",
        "    subprocess.check_call([\n",
        "        os.path.join(conda_path, \"bin\", \"conda\"),\n",
        "        \"install\",\n",
        "        \"--yes\",\n",
        "        \"-c\", \"rdkit\",\n",
        "        \"python==3.7.3\",\n",
        "        \"rdkit\" if rdkit_version is None else \"rdkit=={}\".format(rdkit_version)])\n",
        "    logger.info(\"done\")\n",
        " \n",
        "    import rdkit\n",
        "    logger.info(\"rdkit-{} installation finished!\".format(rdkit.__version__))\n",
        " \n",
        " \n",
        "if __name__ == \"__main__\":\n",
        "    install()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "add /root/miniconda/lib/python3.7/site-packages to PYTHONPATH\n",
            "python version: 3.7.11\n",
            "fetching installer from https://repo.continuum.io/miniconda/Miniconda3-latest-Linux-x86_64.sh\n",
            "done\n",
            "installing miniconda to /root/miniconda\n",
            "done\n",
            "installing rdkit\n",
            "done\n",
            "rdkit-2020.09.1 installation finished!\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P4yyXJZqpqjC"
      },
      "source": [
        ""
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YnRp-W6y5K1f"
      },
      "source": [
        "# If something breaks in the notebook it is probably related to a mismatch between the Python version, CUDA or torch\n",
        "import torch\n",
        "pytorch_version = f\"torch-{torch.__version__}+cu{torch.version.cuda.replace('.', '')}.html\"\n",
        "!pip install --no-index torch-scatter -f https://pytorch-geometric.com/whl/$pytorch_version\n",
        "!pip install --no-index torch-sparse -f https://pytorch-geometric.com/whl/$pytorch_version\n",
        "!pip install --no-index torch-cluster -f https://pytorch-geometric.com/whl/$pytorch_version\n",
        "!pip install --no-index torch-spline-conv -f https://pytorch-geometric.com/whl/$pytorch_version\n",
        "!pip install torch-geometric"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cSTDAc0jZTON"
      },
      "source": [
        "## Background info on the Dataset"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "14WFDVy3Zd21"
      },
      "source": [
        "In the following we will use a dataset provided in the dataset collection of PyTorch Geometric ([Here you find all datasets](https://pytorch-geometric.readthedocs.io/en/latest/modules/datasets.html)). The Dataset comes from the MoleculeNet collection, which can be found [here](http://moleculenet.ai/datasets-1).\n",
        "\n",
        "\n",
        ">\"ESOL is a small dataset consisting of water solubility data for 1128 compounds. The dataset\n",
        "has been used to train models that estimate solubility directly from chemical structures (as\n",
        "encoded in SMILES strings). Note that these structures don’t include 3D coordinates, since\n",
        "solubility is a property of a molecule and not of its particular conformers.\"\n",
        "\n",
        "**>>> Machine Learning task: How are different molecules dissolving in water?**\n",
        "\n",
        "\n",
        "![image.png](data:image/png;base64,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)\n",
        "\n",
        "Source: https://www.differencebetween.com/difference-between-solubility-and-solubility-product/"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q7xQrRYlbL_x"
      },
      "source": [
        "### SMILES representation and important sidenodes\n",
        "\n",
        "![image.png](data:image/png;base64,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)\n",
        " \n",
        " Source: https://medium.com/@sunitachoudhary103/generating-molecules-using-a-char-rnn-in-pytorch-16885fd9394b"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tL-YRWW0nGPu"
      },
      "source": [
        "- Using the plain SMILES string as input is not suitable\n",
        "- This will not consider the molecule structure but rather the grammar of the SMILES string\n",
        "- The SMILES string can be different for a molecule, depending on the notation ( a unique molecule can have multiple SMILES strings )\n",
        "- Chemical graphs however, are invariant to permutations --> Graph Neural Networks"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GMDvh1OKeuYP"
      },
      "source": [
        "\n",
        "## Looking into the Dataset"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kL8_Pkmt07WM",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "71813144-63b4-4764-f016-3ead70ba551c"
      },
      "source": [
        "import rdkit\n",
        "from torch_geometric.datasets import MoleculeNet\n",
        " \n",
        "# Load the ESOL dataset\n",
        "data = MoleculeNet(root=\".\", name=\"ESOL\")\n",
        "data"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Downloading https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/delaney-processed.csv\n",
            "Processing...\n",
            "Done!\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "ESOL(1128)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-bGynPDD2pOp",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "388a51ec-2361-44cb-e7aa-79bb877b40ba"
      },
      "source": [
        "# Investigating the dataset\n",
        "print(\"Dataset type: \", type(data))\n",
        "print(\"Dataset features: \", data.num_features)\n",
        "print(\"Dataset target: \", data.num_classes)\n",
        "print(\"Dataset length: \", data.len)\n",
        "print(\"Dataset sample: \", data[0])\n",
        "print(\"Sample  nodes: \", data[0].num_nodes)\n",
        "print(\"Sample  edges: \", data[0].num_edges)\n",
        "\n",
        "# edge_index = graph connections\n",
        "# smiles = molecule with its atoms\n",
        "# x = node features (32 nodes have each 9 features)\n",
        "# y = labels (dimension)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Dataset type:  <class 'torch_geometric.datasets.molecule_net.MoleculeNet'>\n",
            "Dataset features:  9\n",
            "Dataset target:  734\n",
            "Dataset length:  <bound method InMemoryDataset.len of ESOL(1128)>\n",
            "Dataset sample:  Data(edge_attr=[68, 3], edge_index=[2, 68], smiles=\"OCC3OC(OCC2OC(OC(C#N)c1ccccc1)C(O)C(O)C2O)C(O)C(O)C3O \", x=[32, 9], y=[1, 1])\n",
            "Sample  nodes:  32\n",
            "Sample  edges:  68\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mvOSFVE8tyyd",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1860809a-55d4-4545-a4cd-f4674c8a552a"
      },
      "source": [
        "# Investigating the features\n",
        "# Shape: [num_nodes, num_node_features]\n",
        "data[0].x"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[8, 0, 2, 5, 1, 0, 4, 0, 0],\n",
              "        [6, 0, 4, 5, 2, 0, 4, 0, 0],\n",
              "        [6, 0, 4, 5, 1, 0, 4, 0, 1],\n",
              "        [8, 0, 2, 5, 0, 0, 4, 0, 1],\n",
              "        [6, 0, 4, 5, 1, 0, 4, 0, 1],\n",
              "        [8, 0, 2, 5, 0, 0, 4, 0, 0],\n",
              "        [6, 0, 4, 5, 2, 0, 4, 0, 0],\n",
              "        [6, 0, 4, 5, 1, 0, 4, 0, 1],\n",
              "        [8, 0, 2, 5, 0, 0, 4, 0, 1],\n",
              "        [6, 0, 4, 5, 1, 0, 4, 0, 1],\n",
              "        [8, 0, 2, 5, 0, 0, 4, 0, 0],\n",
              "        [6, 0, 4, 5, 1, 0, 4, 0, 0],\n",
              "        [6, 0, 2, 5, 0, 0, 2, 0, 0],\n",
              "        [7, 0, 1, 5, 0, 0, 2, 0, 0],\n",
              "        [6, 0, 3, 5, 0, 0, 3, 1, 1],\n",
              "        [6, 0, 3, 5, 1, 0, 3, 1, 1],\n",
              "        [6, 0, 3, 5, 1, 0, 3, 1, 1],\n",
              "        [6, 0, 3, 5, 1, 0, 3, 1, 1],\n",
              "        [6, 0, 3, 5, 1, 0, 3, 1, 1],\n",
              "        [6, 0, 3, 5, 1, 0, 3, 1, 1],\n",
              "        [6, 0, 4, 5, 1, 0, 4, 0, 1],\n",
              "        [8, 0, 2, 5, 1, 0, 4, 0, 0],\n",
              "        [6, 0, 4, 5, 1, 0, 4, 0, 1],\n",
              "        [8, 0, 2, 5, 1, 0, 4, 0, 0],\n",
              "        [6, 0, 4, 5, 1, 0, 4, 0, 1],\n",
              "        [8, 0, 2, 5, 1, 0, 4, 0, 0],\n",
              "        [6, 0, 4, 5, 1, 0, 4, 0, 1],\n",
              "        [8, 0, 2, 5, 1, 0, 4, 0, 0],\n",
              "        [6, 0, 4, 5, 1, 0, 4, 0, 1],\n",
              "        [8, 0, 2, 5, 1, 0, 4, 0, 0],\n",
              "        [6, 0, 4, 5, 1, 0, 4, 0, 1],\n",
              "        [8, 0, 2, 5, 1, 0, 4, 0, 0]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Eg8YUFLZo2bc"
      },
      "source": [
        "![image.png](data:image/png;base64,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)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eJgV2WdKuqky",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "bb332a73-b0ce-47fc-efa2-abf1edfc9a0a"
      },
      "source": [
        "# Investigating the edges in sparse COO format\n",
        "# Shape [2, num_edges]\n",
        "data[0].edge_index.t()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[ 0,  1],\n",
              "        [ 1,  0],\n",
              "        [ 1,  2],\n",
              "        [ 2,  1],\n",
              "        [ 2,  3],\n",
              "        [ 2, 30],\n",
              "        [ 3,  2],\n",
              "        [ 3,  4],\n",
              "        [ 4,  3],\n",
              "        [ 4,  5],\n",
              "        [ 4, 26],\n",
              "        [ 5,  4],\n",
              "        [ 5,  6],\n",
              "        [ 6,  5],\n",
              "        [ 6,  7],\n",
              "        [ 7,  6],\n",
              "        [ 7,  8],\n",
              "        [ 7, 24],\n",
              "        [ 8,  7],\n",
              "        [ 8,  9],\n",
              "        [ 9,  8],\n",
              "        [ 9, 10],\n",
              "        [ 9, 20],\n",
              "        [10,  9],\n",
              "        [10, 11],\n",
              "        [11, 10],\n",
              "        [11, 12],\n",
              "        [11, 14],\n",
              "        [12, 11],\n",
              "        [12, 13],\n",
              "        [13, 12],\n",
              "        [14, 11],\n",
              "        [14, 15],\n",
              "        [14, 19],\n",
              "        [15, 14],\n",
              "        [15, 16],\n",
              "        [16, 15],\n",
              "        [16, 17],\n",
              "        [17, 16],\n",
              "        [17, 18],\n",
              "        [18, 17],\n",
              "        [18, 19],\n",
              "        [19, 14],\n",
              "        [19, 18],\n",
              "        [20,  9],\n",
              "        [20, 21],\n",
              "        [20, 22],\n",
              "        [21, 20],\n",
              "        [22, 20],\n",
              "        [22, 23],\n",
              "        [22, 24],\n",
              "        [23, 22],\n",
              "        [24,  7],\n",
              "        [24, 22],\n",
              "        [24, 25],\n",
              "        [25, 24],\n",
              "        [26,  4],\n",
              "        [26, 27],\n",
              "        [26, 28],\n",
              "        [27, 26],\n",
              "        [28, 26],\n",
              "        [28, 29],\n",
              "        [28, 30],\n",
              "        [29, 28],\n",
              "        [30,  2],\n",
              "        [30, 28],\n",
              "        [30, 31],\n",
              "        [31, 30]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JLLbZhpBvAnG",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ba5986f1-5f54-4fcd-ae1e-922675223b53"
      },
      "source": [
        "data[0].y"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[-0.7700]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "t2aqwJJ_bUC_"
      },
      "source": [
        "In the following we will perform predictions based on the graph level. This means we have one y-label for the whole graph, as shown on the left image below. The right image would be node-level-predictions."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8ERVZZo3bHub"
      },
      "source": [
        "![image.png](data:image/png;base64,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)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HBodIcNlfqOF"
      },
      "source": [
        "## Converting SMILES to RDKit molecules - Visualizing molecules"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZJtIR3mmsBHq"
      },
      "source": [
        "Next we want to have our SMILES molecules as graphs..."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Qvn0uNqksE5q",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "c19b7a99-4cc8-40e7-ec67-a3c5e88f8fa8"
      },
      "source": [
        "data[0][\"smiles\"]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'OCC3OC(OCC2OC(OC(C#N)c1ccccc1)C(O)C(O)C2O)C(O)C(O)C3O '"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "df-9E4kbgOuU",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 167
        },
        "outputId": "2d86784a-30f1-4e61-d9ce-d5a58a4084ed"
      },
      "source": [
        "from rdkit import Chem\n",
        "from rdkit.Chem.Draw import IPythonConsole\n",
        "molecule = Chem.MolFromSmiles(data[0][\"smiles\"])\n",
        "molecule"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<rdkit.Chem.rdchem.Mol at 0x7f95590c6170>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KwoLnhIBsN_t",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "10c6eeea-357c-4114-b535-70264a3707c0"
      },
      "source": [
        "type(molecule)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "rdkit.Chem.rdchem.Mol"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dlvYBt9Szd8o"
      },
      "source": [
        "- We can also obtain the features from this RDKit representation\n",
        "- It tells us everything we need to know e.g. atom features (type, ...), edges, ... \n",
        "- **In our case however, It's even easier as we have the information explicitly given already in the dataset**\n",
        "- Otherwise we would calculate the node features from those atom properties\n",
        "\n",
        "-> For datasets containing SMILES representations this would be the way to go"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lhJYtenTje8-"
      },
      "source": [
        "## Implementing the Graph Neural Network "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EoqT0XdzU9K1"
      },
      "source": [
        "Building a Graph Neural Network works the same way as building a Convolutional Neural Network, we simple add some layers.\n",
        "\n",
        "The GCN simply extends torch.nn.Module.\n",
        "GCNConv expects:\n",
        "- in_channels = Size of each input sample.\n",
        "- out_channels = Size of each output sample.\n",
        "\n",
        "We apply three convolutional layers, which means we learn the information about 3 neighbor hops. After that we apply a pooling layer to combine the information of the individual nodes, as we want to perform graph-level prediction.\n",
        "\n",
        "Always keep in mind that different learning problems (node, edge or graph prediction) require different GNN architectures.\n",
        "\n",
        "For example for node-level prediction you will often encounter masks. For graph-level predictions on the other hand you need to combine the node embeddings."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "45raJzPsjhU7",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c6526dde-829b-47b5-9175-909490b75545"
      },
      "source": [
        "import torch\n",
        "from torch.nn import Linear\n",
        "import torch.nn.functional as F \n",
        "from torch_geometric.nn import GCNConv, TopKPooling, global_mean_pool\n",
        "from torch_geometric.nn import global_mean_pool as gap, global_max_pool as gmp\n",
        "embedding_size = 64\n",
        "\n",
        "class GCN(torch.nn.Module):\n",
        "    def __init__(self):\n",
        "        # Init parent\n",
        "        super(GCN, self).__init__()\n",
        "        torch.manual_seed(42)\n",
        "\n",
        "        # GCN layers\n",
        "        self.initial_conv = GCNConv(data.num_features, embedding_size)\n",
        "        self.conv1 = GCNConv(embedding_size, embedding_size)\n",
        "        self.conv2 = GCNConv(embedding_size, embedding_size)\n",
        "        self.conv3 = GCNConv(embedding_size, embedding_size)\n",
        "\n",
        "        # Output layer\n",
        "        self.out = Linear(embedding_size*2, data.num_classes)\n",
        "\n",
        "    def forward(self, x, edge_index, batch_index):\n",
        "        # First Conv layer\n",
        "        hidden = self.initial_conv(x, edge_index)\n",
        "        hidden = F.tanh(hidden)\n",
        "\n",
        "        # Other Conv layers\n",
        "        hidden = self.conv1(hidden, edge_index)\n",
        "        hidden = F.tanh(hidden)\n",
        "        hidden = self.conv2(hidden, edge_index)\n",
        "        hidden = F.tanh(hidden)\n",
        "        hidden = self.conv3(hidden, edge_index)\n",
        "        hidden = F.tanh(hidden)\n",
        "          \n",
        "        # Global Pooling (stack different aggregations)\n",
        "        hidden = torch.cat([gmp(hidden, batch_index), \n",
        "                            gap(hidden, batch_index)], dim=1)\n",
        "\n",
        "        # Apply a final (linear) classifier.\n",
        "        out = self.out(hidden)\n",
        "\n",
        "        return out, hidden\n",
        "\n",
        "model = GCN()\n",
        "print(model)\n",
        "print(\"Number of parameters: \", sum(p.numel() for p in model.parameters()))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "GCN(\n",
            "  (initial_conv): GCNConv(9, 64)\n",
            "  (conv1): GCNConv(64, 64)\n",
            "  (conv2): GCNConv(64, 64)\n",
            "  (conv3): GCNConv(64, 64)\n",
            "  (out): Linear(in_features=128, out_features=734, bias=True)\n",
            ")\n",
            "Number of parameters:  107806\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aWatgsREliPY"
      },
      "source": [
        "- We could also reduce the embeddings, but as we have large molecules we use 64\n",
        "- The more layers we add, the more information we get about the graph\n",
        "- For the regression problem we use a Linear layer as final output layer\n",
        "- We try to use not too many parameters, as we only have ~1k samples"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vf_KuYZmnRgn"
      },
      "source": [
        "## Training the GNN"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xDra7-J-k0EB",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4b7e4c92-dd2a-484b-e234-6a0e81f747d5"
      },
      "source": [
        "from torch_geometric.data import DataLoader\n",
        "import warnings\n",
        "warnings.filterwarnings(\"ignore\")\n",
        "\n",
        "# Root mean squared error\n",
        "loss_fn = torch.nn.MSELoss()\n",
        "optimizer = torch.optim.Adam(model.parameters(), lr=0.0007)  \n",
        "\n",
        "# Use GPU for training\n",
        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
        "model = model.to(device)\n",
        "\n",
        "# Wrap data in a data loader\n",
        "data_size = len(data)\n",
        "NUM_GRAPHS_PER_BATCH = 64\n",
        "loader = DataLoader(data[:int(data_size * 0.8)], \n",
        "                    batch_size=NUM_GRAPHS_PER_BATCH, shuffle=True)\n",
        "test_loader = DataLoader(data[int(data_size * 0.8):], \n",
        "                         batch_size=NUM_GRAPHS_PER_BATCH, shuffle=True)\n",
        "\n",
        "def train(data):\n",
        "    # Enumerate over the data\n",
        "    for batch in loader:\n",
        "      # Use GPU\n",
        "      batch.to(device)  \n",
        "      # Reset gradients\n",
        "      optimizer.zero_grad() \n",
        "      # Passing the node features and the connection info\n",
        "      pred, embedding = model(batch.x.float(), batch.edge_index, batch.batch) \n",
        "      # Calculating the loss and gradients\n",
        "      loss = torch.sqrt(loss_fn(pred, batch.y))       \n",
        "      loss.backward()  \n",
        "      # Update using the gradients\n",
        "      optimizer.step()   \n",
        "    return loss, embedding\n",
        "\n",
        "print(\"Starting training...\")\n",
        "losses = []\n",
        "for epoch in range(2000):\n",
        "    loss, h = train(data)\n",
        "    losses.append(loss)\n",
        "    if epoch % 100 == 0:\n",
        "      print(f\"Epoch {epoch} | Train Loss {loss}\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Starting training...\n",
            "Epoch 0 | Train Loss 2.930453300476074\n",
            "Epoch 100 | Train Loss 1.271768569946289\n",
            "Epoch 200 | Train Loss 0.7536897659301758\n",
            "Epoch 300 | Train Loss 1.1294102668762207\n",
            "Epoch 400 | Train Loss 0.7376656532287598\n",
            "Epoch 500 | Train Loss 0.7355490922927856\n",
            "Epoch 600 | Train Loss 1.1771525144577026\n",
            "Epoch 700 | Train Loss 0.513200044631958\n",
            "Epoch 800 | Train Loss 1.0926283597946167\n",
            "Epoch 900 | Train Loss 0.18909108638763428\n",
            "Epoch 1000 | Train Loss 0.5418731570243835\n",
            "Epoch 1100 | Train Loss 0.2848357856273651\n",
            "Epoch 1200 | Train Loss 0.29715093970298767\n",
            "Epoch 1300 | Train Loss 0.4412524402141571\n",
            "Epoch 1400 | Train Loss 0.30055713653564453\n",
            "Epoch 1500 | Train Loss 0.30303889513015747\n",
            "Epoch 1600 | Train Loss 0.2385137975215912\n",
            "Epoch 1700 | Train Loss 1.0703727006912231\n",
            "Epoch 1800 | Train Loss 0.2721845805644989\n",
            "Epoch 1900 | Train Loss 0.42385920882225037\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Axl1fpt1N_dv"
      },
      "source": [
        "### Visualizing the Training loss"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Z3Eh6uL15AYX",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 282
        },
        "outputId": "7372adc3-2a7f-4cf4-ec76-21799c00f45b"
      },
      "source": [
        "# Visualize learning (training loss)\n",
        "import seaborn as sns\n",
        "losses_float = [float(loss.cpu().detach().numpy()) for loss in losses] \n",
        "loss_indices = [i for i,l in enumerate(losses_float)] \n",
        "plt = sns.lineplot(loss_indices, losses_float)\n",
        "plt"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.axes._subplots.AxesSubplot at 0x7f95123d05d0>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 14
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "plirCWZL3RAQ"
      },
      "source": [
        "### Getting a test prediction"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mpnH7cf03Uxi",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 419
        },
        "outputId": "190afbe0-2116-4508-93fb-8096bceda248"
      },
      "source": [
        "import pandas as pd \n",
        "\n",
        "# Analyze the results for one batch\n",
        "test_batch = next(iter(test_loader))\n",
        "with torch.no_grad():\n",
        "    test_batch.to(device)\n",
        "    pred, embed = model(test_batch.x.float(), test_batch.edge_index, test_batch.batch) \n",
        "    df = pd.DataFrame()\n",
        "    df[\"y_real\"] = test_batch.y.tolist()\n",
        "    df[\"y_pred\"] = pred.tolist()\n",
        "df[\"y_real\"] = df[\"y_real\"].apply(lambda row: row[0])\n",
        "df[\"y_pred\"] = df[\"y_pred\"].apply(lambda row: row[0])\n",
        "df"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>y_real</th>\n",
              "      <th>y_pred</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>-3.240</td>\n",
              "      <td>-3.567490</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>-8.400</td>\n",
              "      <td>-7.892982</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>-0.364</td>\n",
              "      <td>-1.043183</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>-2.460</td>\n",
              "      <td>-2.185588</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>-1.710</td>\n",
              "      <td>-2.169898</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>...</th>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>59</th>\n",
              "      <td>-2.120</td>\n",
              "      <td>-1.167926</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>60</th>\n",
              "      <td>-5.115</td>\n",
              "      <td>-6.111000</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>61</th>\n",
              "      <td>0.150</td>\n",
              "      <td>0.162094</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>62</th>\n",
              "      <td>-4.554</td>\n",
              "      <td>-2.753661</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>63</th>\n",
              "      <td>-0.170</td>\n",
              "      <td>-1.206974</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "<p>64 rows × 2 columns</p>\n",
              "</div>"
            ],
            "text/plain": [
              "    y_real    y_pred\n",
              "0   -3.240 -3.567490\n",
              "1   -8.400 -7.892982\n",
              "2   -0.364 -1.043183\n",
              "3   -2.460 -2.185588\n",
              "4   -1.710 -2.169898\n",
              "..     ...       ...\n",
              "59  -2.120 -1.167926\n",
              "60  -5.115 -6.111000\n",
              "61   0.150  0.162094\n",
              "62  -4.554 -2.753661\n",
              "63  -0.170 -1.206974\n",
              "\n",
              "[64 rows x 2 columns]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1BEIQNTF8Qei",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 301
        },
        "outputId": "d767cbe8-f753-4aa5-b885-ec3a85a46d32"
      },
      "source": [
        "plt = sns.scatterplot(data=df, x=\"y_real\", y=\"y_pred\")\n",
        "plt.set(xlim=(-7, 2))\n",
        "plt.set(ylim=(-7, 2))\n",
        "plt"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.axes._subplots.AxesSubplot at 0x7f94d4b16e50>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 16
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAELCAYAAAA2mZrgAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAdHUlEQVR4nO3de5Bc5Xnn8e8zQmIWXQxIo8siBjFYIAQ4gAchry0nYKJVFBIBCTgki0Pi3bEpg/DilB1bSUyZ2ME4xrXyLRG2ko2XGJHlYq+tAOZSjpISgpGQQUI4AiFsEV1GAiQNYpBEP/tHdx/19PTlzEx3v+d0/z5VU6Xu6e55+kCd57zv857nNXdHREQEoC10ACIikhxKCiIiElFSEBGRiJKCiIhElBRERCSipCAiIpGgScHMTjWzJ8zseTPbbGY3h4xHRKTVWcj7FMxsBjDD3TeY2URgPXCFuz8fLCgRkRYWdKTg7jvdfUPu3weBLcApIWMSEWllx4UOIM/MZgEXAOtK/K4H6AEYP378e+fMmdPQ2ERE0m79+vV73b2j2uuCTh9FQZhNAH4KfNHd76/02u7ubu/t7W1MYCIiTcLM1rt7d7XXBV99ZGZjgfuAu6slBBERqa/Qq48M+C6wxd3vDBmLiIiEHym8H7gOuNTMNuZ+FgeOSUSkZQUtNLv7vwIWMgYRETkm9EhBREQSRElBREQiSgoiIhJRUhARkYiSgoiIRJQUREQkoqQgIiIRJQUREYkoKYiISCQxrbNFRNIuk3G273uT3QcGmDapnVmTx9PWlq6mDUoKIiI1kMk4D23exS33bmTgSIb2sW3cec35LDpneqoSg6aPRERqYPu+N6OEADBwJMMt925k+743A0c2PEoKIiI1sPvAQJQQ8gaOZNhzcCBQRCOj6SMRSYS0z8dPm9RO+9i2QYmhfWwbUye2B4xq+DRSEJHg8vPxi5ev4dq71rF4+Roe2ryLTCb8dsFxzZo8njuvOZ/2sdnTar6mMGvy+MCRDU/wPZrNbCVwObDH3c+t9nrt0SzSfLb19bN4+ZohV9mrly6gq2NCwMiGJz/a2XNwgKkTkzXaSc0ezcDfA4tCByEi4TTLfHxbm9HVMYH5XVPo6piQmIQwHMGTgrv/C/Ba6DhEJJz8fHyhNM7HN4PgSUFEpFnm45tBKlYfmVkP0APQ2dkZOBoRqbW2NmPROdOZs3RBIufjW0kqkoK7rwBWQLbQHDgcEamD/Hx8mgrLzUjTRyIiEgmeFMzs+8Ba4Cwz22FmHw0dk4hIqwo+feTu14aOQUREsoKPFEREJDmUFEREJKKkICIiESUFERGJKCmIiEhESUFERCJKCiIiElFSEBGRiJKCiIhElBRERCSipCAiIhElBRERiQRviCciUiuZjLN935vsPjDAtEnaqGcklBREJPHinOwzGeehzbu45d6NDBzJRFt6LjpnuhLDMGj6SEQSLX+yX7x8DdfetY7Fy9fw0OZdZDKDN2Hcvu/NKCEADBzJcMu9G9m+780QYaeWkoKIJFrck/3uAwPRa/IGjmTYc3CATMbZ1tfP2pf2sq2vf0hCkWOCJwUzW2RmPzezF83sT0PHIyLJUulkX2japHbaxw4+pbWPbaNjQnuskYZkBU0KZjYG+CbwG8Bc4FozmxsyJhFJlnIn+6kT2wc9N2vyeO685vzotfmawpg2NK00DKELzfOAF919G4CZ3QMsAZ4PGpWIJEb+ZF9cQJ41efyg17W1GYvOmc6cpQvYc3CAqROzBel1L+8rO9Lo6pjQyK+SCqGTwinALwse7wAuLn6RmfUAPQCdnZ2NiUxEEqHcyb7UiqK2NqOrY8Kgk31+pFGYGEqNNCQreE0hDndf4e7d7t7d0dEROhwRabD8yX5+1xS6OiYMa4lpuWml4pGGZIUeKbwKnFrweGbuORGRmhjOSEPCJ4WngdlmdjrZZPB7wO+HDUlEmk2paSUpLWhScPejZnYj8DAwBljp7ptDxiQi0spCjxRw99XA6tBxiIhISgrNIiLSGEoKIiISUVIQEZGIkoKIiESUFEREJKKkICIiESUFERGJKCmIiEgk+M1rIiIjEWffZhk+JQURiS0pJ+L8vs3FeywsOme6EsMoKSmIJExSTryl4io+EX/j9y/g9MkT2HOwsbGW27d5ztIFano3SkoKIgmStCvgwgR1wrgxg07EJ50wjq27+7nxH59peKyV9m1WUhgdFZpFEqTcFXCI/YTzCSq/4f1jL+wZdCK+6sKZ/K/HtgaJNe6+zTJ8SgoiCVLpCrjRihNUxhl0IjYjWKzaTa1+NH0kkiBJ2k+4OEHdt34HSy+dzfLHs6ODMUawWIezm1pSazRJFSwpmNnVwK3A2cA8d+8NFYtIUuSvgItrCiGugIsT1M79A6zq/QWreubz1pF3mD6pnbOmTxpxrKM9WcfZTS1pNZo0MHcP84fNzgYywN8CfxI3KXR3d3tvr/KHNK/8yTL0fsJxTqgjjbXUZ3/pyvO4sPNEOk+u3ffd1tfP4uVrhoxmVrfgKiUzW+/u3dVeF2yk4O5bAMyUrUUKJWU/4ThTNCONtVRB/XMPPEfPB7uYM31Sza7ktUpp+FJRaDazHjPrNbPevr6+0OGItIz8SX9+1xS6OibU7Aq+3Mk649R0BZNWKQ1fXZOCmT1qZptK/CwZzue4+wp373b37o6OjnqFK9JQmYyzra+ftS/tZVtfP5lMmKncEMqdrN1ru4JJq5SGr67TR+5+WT0/XyStWr0AWqqgvvTS2XzvyVcGXcnXohgdd5WSZGlJqkgAods0hF6mmT9Zn3XTArbsOsC/7z7I9558hdcPHY6u5GuVOJNSo0mLkEtSrwS+DnQAPzazje7+X0PFI9JIIQugSRmltLUZZ0ydwOlTxjN3xiT+yxmTB13Jb+vrV3+jAIIVmt39AXef6e7Hu/s0JQRpJSELoElqpQHli9lJuru7laRi9ZFIswlZAE3LyVYrh8JQTUEkgJAF0CS10qgkSXd3t5JgdzSPlO5oFhmdSjUFIFF9gpJyd3cziHtHs5KCSAsqdbIFElGAlvqImxRUUxBpQaWKu0krQEsYSgoiAqSnAC31pUKzSJMa7g1qaSlAS31ppCCJ1sr9gUajeCvNxcvX8NDmXRWPn/oECajQLAmWlDtv06JwZHDCuONYes8GXtn3VvT7OPsIaLVP80r8fgoi1YTuD5RUpaaFYOjKoXyDuZ37szWBOG001CdIlBQksVp9g5S4J/87rzmfs6ZNHJJAlz++lY9+oItvPvEioPqAxKOkkEKhO1w2SisXPstNnc2dMfTkf8u9G/nWH1xYMoGOyVUNVR+QuJQUUqaV5tnjtDlohgRZ6juUmzr73380r+TJf/zxx5VMoB+aM3VI91GRSpQUUqaV5tmr9QdqhgRZ7jt0TBxX8uR/6PDRkif/aROPL5lAzzvlxNQcC0kGJYWUabV59kqFz2ZIkOW+w6qe+SVP/p0nZ0dPX35oC5e/5xTGtMFFp53MzBNPoPPk8dphTEYt5CY7XwF+CzgMvAT8kbu/ESqetGjlefZizZAgy32HQ4ffKXnlf/qU8Zx28gkceSfDZ+57dsgIKZ9Am2FaTcIIOVL4CfBZdz9qZl8GPgt8JmA8qaB2wsc0Q4Is9x2mTWrn4tMnl7zy377vzSghwNARUjNMq0k4FZOCmX0dKHt3m7svHekfdvdHCh4+CfzuSD+rlWgj8mOaIUFW+g7lps6qjZCaYVpNwqk2UsjfOvx+YC6wKvf4auD5GsbxxwWfPYSZ9QA9AJ2dnTX8s+mkG4yymiFBjuQ7VBshNcO0moQTq82FmT0JfMDdj+YejwXWuPv8Ku97FJhe4lfL3P0HudcsA7qBqzxGMGpzIa2u1PTQHb/zHs475V3sGkWLC2lutW5zcRIwCXgt93hC7rmK3P2ySr83s+uBy4EPxUkIIknWqOJuW5ux8OxprLium95XXmPcmDbeOHSY31i+JkoSf3nFuXz98a28su+tVE6rSThxk8LtwDNm9gRgwAeBW0fzh81sEfBp4Ffd/dBoPksktEYXd3/x+iF6vtfLwJEMn7jk3XzjiRcG1RD+7MFNrOqZz1tH3knltJqEEyspuPvfmdk/AxfnnvqMu+8a5d/+BnA88BMzA3jS3T8+ys8UaZjirqRffmhL1eJurUYThXUDM0rWEN468g7zu6aM4htKK4qVFCx71r4M6HL3L5hZp5nNc/enRvqH3f3dI32vyEjUcnqn1MigWlfSWo4miovNaV+aK8kRd5OdbwHvA67NPT4IfLMuEYnUwUg2nakkv+zzpBPG8YlL3s1/X9DF20ff4SPvOy16TfGJuZZ7IBduiHPf+h3c/KHZ2hxHaiJuTeFid7/QzJ4BcPfXzWxcHeMSqalar93ffWCAk04Yx3XzT2P541ujK/8/v3wuM97VzuuHDg85MddyqWjxUtbpk9pZOHc6ff3pXJoryRE3KRwxszHkbmQzsw4gU/ktkhat0BKh1mv3p01q5+rumVFCyH/ebT96nrs+0s2k9rGcM2MSbW0WHd82s5pO85S6X+WMqVpyKqMTd/poOfAAMNXMvgj8K/ClukUlDVPraZWkys/BFxrNCXnW5PGcOXViyUSz7uXX+PCKtTyyZTdHj2ai4/vJVRs1zSOJVzUpmFkb8DLZ5aN/BewErnD3f6pzbNIAtZznTrJab0rf1macPWNSyUTjfuw4bt65Pzq+O/cP8A9rX6Hng1383fXdrF66QP2IJHGqTh+5e8bMvunuFwAvNCAmaaBmbYlQakqs1i0xTp8ytG9RfgUSECWCwuO7c/8Ayx97kXt6Lk718ZXmFbem8JiZ/Q5wv+48bi7N0Gm0WKWln7XsGVVY7H1l35s888s3Bi1JbR/bxox3/aemO77S3OLWFD4G/BNw2MwO5n4O1DEuaZBaT6skQSOnxPLF3l89cypzpk/i9UOHgWPH8ZwZk5ru+Epzi3tH88R6ByJhNEOn0WIhpsQqHcdmO77S3GJvsmNmVwEfILssdY27P1i3qKShipc2ZjLOtr7+1C5RrdeUWLmlu8XPz5s1edDxUqtzSZO4bS6+Bbwb+H7uqY+b2a+7+yfqFpkE0Qy7dtVj851yx2Xh2dN4ZMvuVB8vkUJx91N4ATg7X2TOLVPd7O5n1zm+IbSfQn1t6+tnca4Fc14ae/Hnr95rNWVT7ris6pnPh1c8mfrjJc0v7n4KcQvNLwKFW56dmntOmkyl+fg0yU/ZzO+aQlfHhFFftZc7LsVLTvPPp+14ieTFrSlMBLaY2VNkawrzgF4z+yGAu/92neKTBguxRDUNbTbKHRctOZVmEzcp/EVdo5DEqMd8fCVpqWGUOy75JaeNOl4i9RarplD1Q8zWuvv7hvme24AlZBvr7QGud/f/qPY+1RTqr9bz8ZWkqYZR7rg08niJjFSt92iuZiRj5a+4+58DmNlSsqMR7byWAI1cQpmmNhvljouWnEozqVVSGPZww90L74geP5LPkPSrRQ0jDTUJkbSoVVIYkVwb7o8A+4FLKryuB+gB6OzsLPcySaHR1jDSUpMQSYu49yncBPwfd3+9zO+fyXVRLX7+UWB6ibcsc/cfFLzus0C7u3++WiyqKTSf0czJp6kmIRJSrWsK04CnzWwDsBJ4uKhb6nWl3uTul8X8/LuB1UDVpCDNZzRz8mmqSYikQayb19z9z4DZwHeB64GtZvYlMzsj9/tNw/3DZja74OEStFeDjECtd1QTaXVx72gmNzLYlfs5CpwE/F8zu2OEf/t2M9tkZs8CC4GbR/g5LSffsG7tS3vZ1tffdFtnDkcztv4WCSluTeFmsgXhvcB3gAfd/UiuB9JWdz+jvmEe0+o1hVYvrJZaaQToPgGRKmpdUzgZuMrdXyl8MrdV5+UjCVBGptwGMnNaoLDaqB3VRFpZ3JrC54sTQsHvttQ2JKmkWRrWjUQjd1QTaVWxawqSDGkurI62FtLKCVGkUYLevCbD1+iGdbVSrRYS567kenZw1V3RIlk1aYjXSK1eaIbGNqyrlUo3mc2aPD5W8bxeRfZWL95La2h0QzxpoDQ2YKs29ROneN7WZiw6Zzpzli4YlBCBIXtKA7Gv/Fu5eC9STElBGqLS1M9w7kouTojlrvLHHWfc+I/PxLry113RIseo0CwNUekms9EUz8td5T+7Y3/sVUppLt6L1JqSgjREfupn9dIF3NNzMauXLoiu3EdzV3K5q/zihU2VVinprmiRYzR9JA1TaZOaUrWCOEXectNSxW+tdOU/mr8v0myUFCQRRlo8L7dEd9xxFiWLOFf+aSzei9SDlqRK6pVaogvqhyRSSEtSZVTSdDNXuat8XfmLDJ+Sggyhm7lEWpdWH8kQw2k8p70dRJpL8JGCmX0K+Gugw933ho5H4t/MpRGFSPMJOlIws1PJ7rr2i5BxyGBxb+ZSK2uR5hN6+uhrwKcBzTkkSNybudTKWqT5BJs+MrMlwKvu/jOzylMNZtYD9AB0dnY2ILrkasSqoLg3c9WrlXWaVj6JNJu63qdgZo8C00v8ahnwOWChu+83s+1Ad5yaQivfp5C0Ofx6xJO07yjSLOLepxDk5jUzOw94DDiUe2om8B/APHffVem9rZwUKu1JEGo9fq33dkjidxRpBom+ec3dnwOm5h8PZ6TQypLY4rnW7SGS+B1FWknoQrMMQyu0eG6F7yiSZIlICu4+S6OE6lqhxXMrfEeRJFNDvJRJ4/7Mw9UK31Gk0RJdU5CRa9YWz6WWoTbbdxRJAyUFCU7LUEWSIxE1BWltapchkhxKChKc2mWIJIemj5pYWtpF1KtdhogMn0YKTSo/T794+RquvWsdi5ev4aHNuxK534GWoYokh5akNqm0tYvQMlSR+tKS1BaXtnYRzbrUViRtNH3UpNQuQkRGQkmhSWmeXkRGQtNHTSruRjkiIoWUFJpYqHn6tCyFFZGhlBSkptSyQiTdVFNIiUzG2dbXz9qX9rKtrz+R9xuAWlaIpF2wkYKZ3Qr8D6Av99Tn3H11qHiSLE1X32lbCisig4UeKXzN3c/P/SghlJGmq28thRVJt9BJQWJIU8M4LYUVSbfQheYbzewjQC/wKXd/PXA8iZSmhnFaCiuSbnUdKZjZo2a2qcTPEuDbwBnA+cBO4KsVPqfHzHrNrLevr6/cy5pW2q6+80th53dNoatjghKCSIokoiGemc0CfuTu51Z7bas2xFPDOBEZjcQ3xDOzGe6+M/fwSmBTqFjSQA3jRKQRQtYU7jCz8wEHtgMfCxiLiIgQMCm4+3Wh/raIiJSmJakiIhIJvSRVWpga54kkj5KCBJGm1h0irUTTRxJEmlp3iLQSJQUJIk2tO0RaiZKCBKHGeSLJpKQgQaStdYdIq1ChWYJQ4zyRZFJSkGDUukMkeTR9JCIiESUFERGJKCmIiEhESUFERCJKCiIiElFSEBGRSNCkYGY3mdkLZrbZzO4IGYuIiITdjvMSYAnwK+7+tplNDRULqI2ziAiEvXntBuB2d38bwN33hApEbZxFRLJCTh+dCSwws3Vm9lMzuyhUIGlu45zJONv6+ln70l629fWTyXjokEQkxeo6UjCzR4HpJX61LPe3TwbmAxcB95pZl7sPOauZWQ/QA9DZ2VnzOCu1cS5uwZCkaSaNcESk1uqaFNz9snK/M7MbgPtzSeApM8sAU4C+Ep+zAlgB0N3dXfNL4Xwb58LEUKqNc9JOwuVGOHOWLlA/IREZkZDTRw8ClwCY2ZnAOGBviEDitnFO2jSTNqoRkVoLWWheCaw0s03AYeAPS00dNULcNs7DmWZqhLgjHBGRuIIlBXc/DPy3UH+/WJw2zkk7CedHOMXTWdqoRkRGSvspDEPSTsLaqEZEas0CzdiMWHd3t/f29gb7+/nVRzoJi0iamNl6d++u9jqNFIZJu4WJSDNTQzwREYkoKYiISERJQUREIkoKIiISUVIQEZGIkoKIiESUFEREJKKkICIiESUFERGJKCmIiEhESUFERCJKCiIiElFSEBGRSLAuqWa2Cjgr9/BE4A13Pz9UPCIiEnbntQ/n/21mXwX2h4pFRESygu+nYGYGXANcGjoWEZFWFzwpAAuA3e6+tdwLzKwH6Mk9fNvMNjUksvimAHtDB1FEMcWXxLgUUzyKKb6zqr+kzttxmtmjwPQSv1rm7j/IvebbwIvu/tWYn9kbZ0u5RlJM8SQxJkhmXIopHsUUX9y46jpScPfLKv3ezI4DrgLeW884REQkntBLUi8DXnD3HYHjEBERwieF3wO+P8z3rKhHIKOkmOJJYkyQzLgUUzyKKb5YcdW1piAiIukSeqQgIiIJoqQgIiKRVCYFM1tlZhtzP9vNbGPomADM7CYze8HMNpvZHQmI51Yze7XgWC0OHVOemX3KzNzMpiQgltvM7NncMXrEzP5z6JgAzOwruf+fnjWzB8zsxATEdHXu/++MmQVddmlmi8zs52b2opn9achYcvGsNLM9SbqPysxONbMnzOz53H+3m6u+J+01hXyLDHf/QuA4LgGWAb/p7m+b2VR33xM4pluBfnf/65BxFDOzU4HvAHOA97p70Bt9zGySux/I/XspMNfdPx4yplwsC4HH3f2omX0ZwN0/Ezims4EM8LfAn7h7b6A4xgD/Dvw6sAN4GrjW3Z8PEU8upg8C/cA/uPu5oeIoZGYzgBnuvsHMJgLrgSsqHadUjhTyClpkDHcFUz3cANzu7m8DhE4ICfc14NNAIq5I8gkhZzzJiesRdz+ae/gkMDNkPADuvsXdfx46DmAe2Ztet7n7YeAeYEnIgNz9X4DXQsZQzN13uvuG3L8PAluAUyq9J9VJgRgtMhroTGCBma0zs5+a2UWhA8q5MTf9sNLMTgodjJktAV5195+FjqWQmX3RzH4J/AHwF6HjKeGPgX8OHUSCnAL8suDxDqqc7Fqdmc0CLgDWVXpdEnoflRSnRQZwLQ0cJVSKieyxPBmYD1wE3GtmXV7n+bkqMX0buI3sle9twFfJnlzqqkpMnwMW1juGYtX+f3L3ZcAyM/sscCPw+STElXvNMuAocHdSYpJ0MbMJwH3AJ4tGxkMkNikksUVGpZjM7Abg/lwSeMrMMmQbY/WFiqkovruAH9UzlrxyMZnZecDpwM+yM3/MBDaY2Tx33xUiphLuBlbToKQQ4//z64HLgQ/V+wIjbkwJ8SpwasHjmbnnpIiZjSWbEO529/urvT7N00dJa5HxIHAJgJmdCYwjcKfEXJEp70og6KoId3/O3ae6+yx3n0V2yH9hvRNCNWY2u+DhEuCFULEUMrNFZGsvv+3uh0LHkzBPA7PN7HQzG0e2O8IPA8eUOLm663eBLe5+Z5z3pDkpjKRFRj2tBLpyy9HuAf6wUVd2FdxhZs+Z2bNkE9b/DBxPUt1uZptyx2khUHXZXoN8A5gI/CS3XPZvQgdkZlea2Q7gfcCPzezhEHHkCvA3Ag+TLZ7e6+6bQ8SSZ2bfB9YCZ5nZDjP7aMh4ct4PXAdcGndpeuqXpIqISO2keaQgIiI1pqQgIiIRJQUREYkoKYiISERJQUREIkoKIiISUVIQCcjM+kPHIFJISUGkBnJtV0RST0lBpIiZfcHMPlnw+IulNicxs18zszVm9kPgeTMbk9sY5+lcZ9qP5V43wcweM7MNuTvMg7Z4FqlEdzSLFMm1GL7f3S80szZgKzDP3fcVve7XgB8D57r7y2bWA0x19780s+OBfwOuJtvi+QR3P5Dbae5JYLa7u5n1u/uEhn05kSo05BUp4u7bzWyfmV0ATAOeKU4IBZ5y95dz/14IvMfMfjf3+F3AbLKN/76U25krQ7bv/zQgaCNAkVKUFERK+w5wPdl9BVZWeN2bBf824CZ3H9QkLtf+uoPs1qNHzGw70F7LYEVqRTUFkdIeABaR3TApbifQh4Ebcv3rMbMzzWw82RHDnlxCuAQ4rR4Bi9SCRgoiJbj7YTN7AnjD3d+J+bbvALPIbhxkZDdYuoLsxj3/z8yeA3pJyH4NIqWo0CxSQq7AvAG4OiF7gIs0hKaPRIqY2VzgReAxJQRpNRopiFSR21v6e0VPv+3uF4eIR6SelBRERCSi6SMREYkoKYiISERJQUREIkoKIiIS+f9nkyghw1m7pAAAAABJRU5ErkJggg==\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BQnbktyWU3r3"
      },
      "source": [
        "## Improving the model / More to play around with"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aT_7Sn88orPA"
      },
      "source": [
        "\n",
        "For example you can add:\n",
        "- Dropouts\n",
        "- Other (more intelligent) Pooling Layers (all layers here: https://pytorch-geometric.readthedocs.io/en/latest/modules/nn.html#)\n",
        "- Global Pooling Layers\n",
        "- Batch Normalization\n",
        "- More MP layers\n",
        "- Other hidden state sizes\n",
        "- Test metrics (test error) and Hyperparameter optimization\n",
        "- ...\n",
        "\n",
        "https://github.com/rusty1s/pytorch_geometric/tree/master/examples"
      ]
    }
  ]
}