GCN_comparative.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Acgrl3TSb7w0",
        "outputId": "15de0e1c-28f3-4834-8fc0-70c7e8731b8a"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: torch in /usr/local/lib/python3.7/dist-packages (1.10.0+cu111)\n",
            "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.7/dist-packages (from torch) (3.10.0.2)\n",
            "1.10.0+cu111\n",
            "Looking in links: https://pytorch-geometric.com/whl/torch-1.10.0+cu111.html\n",
            "Collecting torch-geometric\n",
            "  Downloading torch_geometric-2.0.3.tar.gz (370 kB)\n",
            "\u001b[K     |████████████████████████████████| 370 kB 5.4 MB/s \n",
            "\u001b[?25hCollecting torch-sparse\n",
            "  Downloading https://data.pyg.org/whl/torch-1.10.0%2Bcu113/torch_sparse-0.6.12-cp37-cp37m-linux_x86_64.whl (3.5 MB)\n",
            "\u001b[K     |████████████████████████████████| 3.5 MB 5.3 MB/s \n",
            "\u001b[?25hCollecting torch-scatter\n",
            "  Downloading https://data.pyg.org/whl/torch-1.10.0%2Bcu113/torch_scatter-2.0.9-cp37-cp37m-linux_x86_64.whl (7.9 MB)\n",
            "\u001b[K     |████████████████████████████████| 7.9 MB 25.5 MB/s \n",
            "\u001b[?25hCollecting torch-cluster\n",
            "  Downloading https://data.pyg.org/whl/torch-1.10.0%2Bcu113/torch_cluster-1.5.9-cp37-cp37m-linux_x86_64.whl (2.3 MB)\n",
            "\u001b[K     |████████████████████████████████| 2.3 MB 35.0 MB/s \n",
            "\u001b[?25hRequirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from torch-geometric) (1.21.5)\n",
            "Requirement already satisfied: tqdm in /usr/local/lib/python3.7/dist-packages (from torch-geometric) (4.63.0)\n",
            "Requirement already satisfied: scipy in /usr/local/lib/python3.7/dist-packages (from torch-geometric) (1.4.1)\n",
            "Requirement already satisfied: networkx in /usr/local/lib/python3.7/dist-packages (from torch-geometric) (2.6.3)\n",
            "Requirement already satisfied: scikit-learn in /usr/local/lib/python3.7/dist-packages (from torch-geometric) (1.0.2)\n",
            "Requirement already satisfied: requests in /usr/local/lib/python3.7/dist-packages (from torch-geometric) (2.23.0)\n",
            "Requirement already satisfied: pandas in /usr/local/lib/python3.7/dist-packages (from torch-geometric) (1.3.5)\n",
            "Collecting rdflib\n",
            "  Downloading rdflib-6.1.1-py3-none-any.whl (482 kB)\n",
            "\u001b[K     |████████████████████████████████| 482 kB 45.1 MB/s \n",
            "\u001b[?25hRequirement already satisfied: googledrivedownloader in /usr/local/lib/python3.7/dist-packages (from torch-geometric) (0.4)\n",
            "Requirement already satisfied: jinja2 in /usr/local/lib/python3.7/dist-packages (from torch-geometric) (2.11.3)\n",
            "Requirement already satisfied: pyparsing in /usr/local/lib/python3.7/dist-packages (from torch-geometric) (3.0.7)\n",
            "Collecting yacs\n",
            "  Downloading yacs-0.1.8-py3-none-any.whl (14 kB)\n",
            "Requirement already satisfied: PyYAML in /usr/local/lib/python3.7/dist-packages (from torch-geometric) (3.13)\n",
            "Requirement already satisfied: MarkupSafe>=0.23 in /usr/local/lib/python3.7/dist-packages (from jinja2->torch-geometric) (2.0.1)\n",
            "Requirement already satisfied: python-dateutil>=2.7.3 in /usr/local/lib/python3.7/dist-packages (from pandas->torch-geometric) (2.8.2)\n",
            "Requirement already satisfied: pytz>=2017.3 in /usr/local/lib/python3.7/dist-packages (from pandas->torch-geometric) (2018.9)\n",
            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.7/dist-packages (from python-dateutil>=2.7.3->pandas->torch-geometric) (1.15.0)\n",
            "Requirement already satisfied: importlib-metadata in /usr/local/lib/python3.7/dist-packages (from rdflib->torch-geometric) (4.11.2)\n",
            "Collecting isodate\n",
            "  Downloading isodate-0.6.1-py2.py3-none-any.whl (41 kB)\n",
            "\u001b[K     |████████████████████████████████| 41 kB 600 kB/s \n",
            "\u001b[?25hRequirement already satisfied: setuptools in /usr/local/lib/python3.7/dist-packages (from rdflib->torch-geometric) (57.4.0)\n",
            "Requirement already satisfied: typing-extensions>=3.6.4 in /usr/local/lib/python3.7/dist-packages (from importlib-metadata->rdflib->torch-geometric) (3.10.0.2)\n",
            "Requirement already satisfied: zipp>=0.5 in /usr/local/lib/python3.7/dist-packages (from importlib-metadata->rdflib->torch-geometric) (3.7.0)\n",
            "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests->torch-geometric) (3.0.4)\n",
            "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests->torch-geometric) (2.10)\n",
            "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.7/dist-packages (from requests->torch-geometric) (1.24.3)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests->torch-geometric) (2021.10.8)\n",
            "Requirement already satisfied: threadpoolctl>=2.0.0 in /usr/local/lib/python3.7/dist-packages (from scikit-learn->torch-geometric) (3.1.0)\n",
            "Requirement already satisfied: joblib>=0.11 in /usr/local/lib/python3.7/dist-packages (from scikit-learn->torch-geometric) (1.1.0)\n",
            "Building wheels for collected packages: torch-geometric\n",
            "  Building wheel for torch-geometric (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for torch-geometric: filename=torch_geometric-2.0.3-py3-none-any.whl size=581968 sha256=6a5e0f5cbe907c5be28041bffe137234cf486f1022e4c7439f32b3856d26d3bb\n",
            "  Stored in directory: /root/.cache/pip/wheels/c3/2a/58/87ce0508964d4def1aafb92750c4f3ac77038efd1b9a89dcf5\n",
            "Successfully built torch-geometric\n",
            "Installing collected packages: isodate, yacs, rdflib, torch-sparse, torch-scatter, torch-geometric, torch-cluster\n",
            "Successfully installed isodate-0.6.1 rdflib-6.1.1 torch-cluster-1.5.9 torch-geometric-2.0.3 torch-scatter-2.0.9 torch-sparse-0.6.12 yacs-0.1.8\n",
            "Collecting rdkit-pypi\n",
            "  Downloading rdkit_pypi-2021.9.5-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (20.4 MB)\n",
            "\u001b[K     |████████████████████████████████| 20.4 MB 47.0 MB/s \n",
            "\u001b[?25hRequirement already satisfied: numpy>=1.19 in /usr/local/lib/python3.7/dist-packages (from rdkit-pypi) (1.21.5)\n",
            "Requirement already satisfied: Pillow in /usr/local/lib/python3.7/dist-packages (from rdkit-pypi) (7.1.2)\n",
            "Installing collected packages: rdkit-pypi\n",
            "Successfully installed rdkit-pypi-2021.9.5\n"
          ]
        }
      ],
      "source": [
        "# installing pytorch\n",
        "!pip install torch\n",
        "!python -c \"import torch; print(torch.__version__)\"\n",
        "\n",
        "\n",
        "#installing pytorch geometric\n",
        "!pip install torch-geometric \\\n",
        "  torch-sparse \\\n",
        "  torch-scatter \\\n",
        "  torch-cluster \\\n",
        "  -f https://pytorch-geometric.com/whl/torch-1.10.0+cu111.html\n",
        "\n",
        "#installing rdkit\n",
        "!pip install rdkit-pypi"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8u1EKvH6jcGp"
      },
      "source": [
        "## Importing data and analyzing it"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "CaV47vxKdwwv",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "feed8c58-a7d0-4e37-b3da-082599910b72"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Downloading https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/delaney-processed.csv\n",
            "Processing...\n",
            "Done!\n"
          ]
        }
      ],
      "source": [
        "from torch_geometric.datasets import MoleculeNet\n",
        "data = MoleculeNet(root=\".\", name=\"ESOL\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "89UK4-MBjO40",
        "outputId": "a80e352b-26ca-4e9e-bce2-a271690cfb10"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "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(x=[32, 9], edge_index=[2, 68], edge_attr=[68, 3], y=[1, 1], smiles='OCC3OC(OCC2OC(OC(C#N)c1ccccc1)C(O)C(O)C2O)C(O)C(O)C3O ')\n",
            "Sample  nodes:  32\n",
            "Sample  edges:  68\n"
          ]
        }
      ],
      "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)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mSAbYyoAkNzw"
      },
      "source": [
        "## Pytorch-Geometric model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fDvvSnznkEVH",
        "outputId": "5ed93d6e-4150-4d88-8550-3c858265b481"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "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=1, bias=True)\n",
            ")\n",
            "Number of parameters:  13249\n"
          ]
        }
      ],
      "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, 1)\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()))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zCCd9QVQk1QZ"
      },
      "source": [
        "## Training"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3xbXqNXXk021",
        "outputId": "f7a370a4-0f4e-452d-e457-f0cb3453df4b"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Starting training...\n",
            "Epoch 0 | Train Loss 3.377596378326416\n",
            "Epoch 100 | Train Loss 0.9627334475517273\n",
            "Epoch 200 | Train Loss 1.072218656539917\n",
            "Epoch 300 | Train Loss 0.638767659664154\n",
            "Epoch 400 | Train Loss 0.38274532556533813\n",
            "Epoch 500 | Train Loss 0.4588406980037689\n",
            "Epoch 600 | Train Loss 0.4875830411911011\n",
            "Epoch 700 | Train Loss 0.3256550431251526\n",
            "Epoch 800 | Train Loss 0.35816076397895813\n",
            "Epoch 900 | Train Loss 0.31040292978286743\n",
            "Epoch 1000 | Train Loss 0.2475055456161499\n",
            "Epoch 1100 | Train Loss 0.1682727336883545\n",
            "Epoch 1200 | Train Loss 0.21468645334243774\n",
            "Epoch 1300 | Train Loss 0.2138790786266327\n",
            "Epoch 1400 | Train Loss 0.19109489023685455\n",
            "Epoch 1500 | Train Loss 0.1968095600605011\n",
            "Epoch 1600 | Train Loss 0.21863166987895966\n",
            "Epoch 1700 | Train Loss 0.23082487285137177\n",
            "Epoch 1800 | Train Loss 0.3015650808811188\n",
            "Epoch 1900 | Train Loss 0.19388283789157867\n"
          ]
        }
      ],
      "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() # use torch.nn.L1Loss()\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}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 267
        },
        "id": "GMKAZBRakuO7",
        "outputId": "ebfe8f6a-7add-4f0d-ccef-3f6763d998e5"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "import matplotlib.pyplot as plt\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",
        "sns.lineplot(loss_indices, losses_float)\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TIPVpIPptkGe"
      },
      "source": [
        "## ZINC dataset"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "07na4IuOryX2",
        "outputId": "1e47ef85-b2ff-4908-a548-93c8bdaa8407"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Downloading https://www.dropbox.com/s/feo9qle74kg48gy/molecules.zip?dl=1\n",
            "Extracting ./molecules.zip\n",
            "Downloading https://raw.githubusercontent.com/graphdeeplearning/benchmarking-gnns/master/data/molecules/train.index\n",
            "Downloading https://raw.githubusercontent.com/graphdeeplearning/benchmarking-gnns/master/data/molecules/val.index\n",
            "Downloading https://raw.githubusercontent.com/graphdeeplearning/benchmarking-gnns/master/data/molecules/test.index\n",
            "Processing...\n",
            "Processing train dataset: 100%|██████████| 220011/220011 [00:20<00:00, 10889.94it/s]\n",
            "Processing val dataset: 100%|██████████| 24445/24445 [00:03<00:00, 7037.41it/s]\n",
            "Processing test dataset: 100%|██████████| 5000/5000 [00:00<00:00, 8772.96it/s] \n",
            "Done!\n"
          ]
        }
      ],
      "source": [
        "from torch_geometric.datasets import ZINC\n",
        "data = ZINC(root = '.')\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "viN7ZxXnsmIO",
        "outputId": "6fbf4e9e-1930-427b-8a1d-c5627ed1074c"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Dataset type:  <class 'torch_geometric.datasets.zinc.ZINC'>\n",
            "Dataset features:  1\n",
            "Dataset target:  218362\n",
            "Dataset length:  <bound method InMemoryDataset.len of ZINC(220011)>\n",
            "Dataset sample:  Data(x=[33, 1], edge_index=[2, 72], edge_attr=[72], y=[1])\n",
            "Sample  nodes:  33\n",
            "Sample  edges:  72\n"
          ]
        }
      ],
      "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)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yGbsaOCuuQDk",
        "outputId": "33c4a6dc-c6d5-43b4-cee1-6a13b72e16dc"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "GCN(\n",
            "  (initial_conv): GCNConv(1, 64)\n",
            "  (conv1): GCNConv(64, 64)\n",
            "  (conv2): GCNConv(64, 64)\n",
            "  (conv3): GCNConv(64, 64)\n",
            "  (out): Linear(in_features=128, out_features=1, bias=True)\n",
            ")\n",
            "Number of parameters:  12737\n"
          ]
        }
      ],
      "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, 1)\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()))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vsdn165lubN3",
        "outputId": "f1ae11bc-a1a6-4475-ce46-f7d6c54cf8da"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Starting training...\n",
            "Epoch 0 | Train Loss 2.834458112716675\n",
            "Epoch 2 | Train Loss 2.479088544845581\n",
            "Epoch 4 | Train Loss 2.4101486206054688\n",
            "Epoch 6 | Train Loss 1.3092743158340454\n",
            "Epoch 8 | Train Loss 1.8261083364486694\n",
            "Epoch 10 | Train Loss 1.0654610395431519\n",
            "Epoch 12 | Train Loss 1.4480472803115845\n",
            "Epoch 14 | Train Loss 5.456602573394775\n",
            "Epoch 16 | Train Loss 1.861289143562317\n",
            "Epoch 18 | Train Loss 2.3593173027038574\n"
          ]
        }
      ],
      "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(20):\n",
        "    loss, h = train(data)\n",
        "    losses.append(loss)\n",
        "    if epoch % 2 == 0:\n",
        "      print(f\"Epoch {epoch} | Train Loss {loss}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "id": "5xXka65saqR1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4725ee92-bc2c-4537-d92c-f10b108a3420"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Starting training...\n",
            "Epoch 0 | Train Loss 3.2991349697113037\n",
            "Epoch 2 | Train Loss 1.7229862213134766\n",
            "Epoch 4 | Train Loss 1.228234052658081\n",
            "Epoch 6 | Train Loss 1.7237424850463867\n",
            "Epoch 8 | Train Loss 2.6074130535125732\n",
            "Epoch 10 | Train Loss 1.3801002502441406\n",
            "Epoch 12 | Train Loss 1.598260521888733\n",
            "Epoch 14 | Train Loss 1.727259635925293\n",
            "Epoch 16 | Train Loss 1.5225437879562378\n",
            "Epoch 18 | Train Loss 0.8487586379051208\n"
          ]
        }
      ],
      "source": [
        "print(\"Starting training...\")\n",
        "for epoch in range(20):\n",
        "    loss, h = train(data)\n",
        "    losses.append(loss)\n",
        "    if epoch % 2 == 0:\n",
        "      print(f\"Epoch {epoch} | Train Loss {loss}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "id": "LsLnNBp-aq9O",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "438e1a8c-70e3-4946-8896-7323ebf0b698"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Starting training...\n",
            "Epoch 0 | Train Loss 1.5556533336639404\n",
            "Epoch 2 | Train Loss 1.3677154779434204\n",
            "Epoch 4 | Train Loss 1.1134958267211914\n",
            "Epoch 6 | Train Loss 1.1324230432510376\n",
            "Epoch 8 | Train Loss 2.368504047393799\n",
            "Epoch 10 | Train Loss 2.1689822673797607\n",
            "Epoch 12 | Train Loss 1.5967885255813599\n",
            "Epoch 14 | Train Loss 1.3123024702072144\n",
            "Epoch 16 | Train Loss 2.7762234210968018\n",
            "Epoch 18 | Train Loss 1.855214238166809\n"
          ]
        }
      ],
      "source": [
        "print(\"Starting training...\")\n",
        "for epoch in range(20):\n",
        "    loss, h = train(data)\n",
        "    losses.append(loss)\n",
        "    if epoch % 2 == 0:\n",
        "      print(f\"Epoch {epoch} | Train Loss {loss}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "id": "EvHBZXaSZnOO",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        },
        "outputId": "70b33c2f-3326-4062-b46b-ed1b1028e094"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "import matplotlib.pyplot as plt\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",
        "sns.lineplot(loss_indices, losses_float)\n",
        "plt.show()"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "collapsed_sections": [],
      "name": "GCNs-Solvability.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}