GNN_for_handling_moelcular_data_pytorch.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "GNN for handling moelcular data pytorch.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyPR6Nx3XHuR1lo8ix8HIpRq",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/galib96/gnn-handling-molecular-data-esol/blob/main/GNN_for_handling_moelcular_data_pytorch.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rHx-cueaDQ1s"
      },
      "source": [
        "Installing dependencies. Code Taken from: <p> https://colab.research.google.com/drive/16GBgwYR2ECiXVxA1BoLxYshKczNMeEAQ?usp=sharing#scrollTo=YnRp-W6y5K1f </p>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "0kumOuVIAQjb",
        "outputId": "02a136d8-810e-429c-fa36-6277b084a91a"
      },
      "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\n",
        "  !pip install torchvision\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": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Found existing installation: torch 1.11.0+cu113\n",
            "Uninstalling torch-1.11.0+cu113:\n",
            "  Successfully uninstalled torch-1.11.0+cu113\n",
            "Found existing installation: torchvision 0.12.0+cu113\n",
            "Uninstalling torchvision-0.12.0+cu113:\n",
            "  Successfully uninstalled torchvision-0.12.0+cu113\n",
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Collecting torch\n",
            "  Downloading torch-1.12.0-cp37-cp37m-manylinux1_x86_64.whl (776.3 MB)\n",
            "\u001b[K     |████████████████████████████████| 776.3 MB 19 kB/s \n",
            "\u001b[?25hRequirement already satisfied: typing-extensions in /usr/local/lib/python3.7/dist-packages (from torch) (4.1.1)\n",
            "Installing collected packages: torch\n",
            "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n",
            "fastai 2.6.3 requires torchvision>=0.8.2, which is not installed.\n",
            "torchtext 0.12.0 requires torch==1.11.0, but you have torch 1.12.0 which is incompatible.\n",
            "torchaudio 0.11.0+cu113 requires torch==1.11.0, but you have torch 1.12.0 which is incompatible.\n",
            "fastai 2.6.3 requires torch<1.12,>=1.7.0, but you have torch 1.12.0 which is incompatible.\u001b[0m\n",
            "Successfully installed torch-1.12.0\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "application/vnd.colab-display-data+json": {
              "pip_warning": {
                "packages": [
                  "torch"
                ]
              }
            }
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Collecting torchvision\n",
            "  Downloading torchvision-0.13.0-cp37-cp37m-manylinux1_x86_64.whl (19.1 MB)\n",
            "\u001b[K     |████████████████████████████████| 19.1 MB 1.2 MB/s \n",
            "\u001b[?25hRequirement already satisfied: pillow!=8.3.*,>=5.3.0 in /usr/local/lib/python3.7/dist-packages (from torchvision) (7.1.2)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from torchvision) (1.21.6)\n",
            "Requirement already satisfied: requests in /usr/local/lib/python3.7/dist-packages (from torchvision) (2.23.0)\n",
            "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.7/dist-packages (from torchvision) (4.1.1)\n",
            "Requirement already satisfied: torch==1.12.0 in /usr/local/lib/python3.7/dist-packages (from torchvision) (1.12.0)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests->torchvision) (2022.6.15)\n",
            "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests->torchvision) (2.10)\n",
            "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests->torchvision) (3.0.4)\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->torchvision) (1.24.3)\n",
            "Installing collected packages: torchvision\n",
            "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n",
            "fastai 2.6.3 requires torch<1.12,>=1.7.0, but you have torch 1.12.0 which is incompatible.\u001b[0m\n",
            "Successfully installed torchvision-0.13.0\n",
            "1.12.0+cu102\n",
            "10.2\n",
            "Python 3.7.13\n",
            "Fri Jul  1 01:40:28 2022       \n",
            "+-----------------------------------------------------------------------------+\n",
            "| NVIDIA-SMI 460.32.03    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   43C    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"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#@title\n",
        "# Install rdkit\n",
        "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()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "s4asTNGDsRoV",
        "outputId": "f282eadb-aee6-4e36-b21d-f2080ed1b0fa"
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "add /root/miniconda/lib/python3.7/site-packages to PYTHONPATH\n",
            "python version: 3.7.13\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"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5QF53_UPC4Du",
        "outputId": "e1d3fe92-ae3f-4988-f892-55eda9bf9b1f"
      },
      "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__}.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": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking in links: https://pytorch-geometric.com/whl/torch-1.12.0+cu102.html\n",
            "Collecting torch-scatter\n",
            "  Downloading https://data.pyg.org/whl/torch-1.12.0%2Bcu102/torch_scatter-2.0.9-cp37-cp37m-linux_x86_64.whl (8.0 MB)\n",
            "\u001b[K     |████████████████████████████████| 8.0 MB 1.3 MB/s \n",
            "\u001b[?25hInstalling collected packages: torch-scatter\n",
            "Successfully installed torch-scatter-2.0.9\n",
            "Looking in links: https://pytorch-geometric.com/whl/torch-1.12.0+cu102.html\n",
            "Collecting torch-sparse\n",
            "  Downloading https://data.pyg.org/whl/torch-1.12.0%2Bcu102/torch_sparse-0.6.14-cp37-cp37m-linux_x86_64.whl (2.9 MB)\n",
            "\u001b[K     |████████████████████████████████| 2.9 MB 1.3 MB/s \n",
            "\u001b[?25hRequirement already satisfied: scipy in /usr/local/lib/python3.7/dist-packages (from torch-sparse) (1.4.1)\n",
            "Requirement already satisfied: numpy>=1.13.3 in /usr/local/lib/python3.7/dist-packages (from scipy->torch-sparse) (1.21.6)\n",
            "Installing collected packages: torch-sparse\n",
            "Successfully installed torch-sparse-0.6.14\n",
            "Looking in links: https://pytorch-geometric.com/whl/torch-1.12.0+cu102.html\n",
            "Collecting torch-cluster\n",
            "  Downloading https://data.pyg.org/whl/torch-1.12.0%2Bcu102/torch_cluster-1.6.0-cp37-cp37m-linux_x86_64.whl (1.4 MB)\n",
            "\u001b[K     |████████████████████████████████| 1.4 MB 739 kB/s \n",
            "\u001b[?25hInstalling collected packages: torch-cluster\n",
            "Successfully installed torch-cluster-1.6.0\n",
            "Looking in links: https://pytorch-geometric.com/whl/torch-1.12.0+cu102.html\n",
            "Collecting torch-spline-conv\n",
            "  Downloading https://data.pyg.org/whl/torch-1.12.0%2Bcu102/torch_spline_conv-1.2.1-cp37-cp37m-linux_x86_64.whl (633 kB)\n",
            "\u001b[K     |████████████████████████████████| 633 kB 564 kB/s \n",
            "\u001b[?25hInstalling collected packages: torch-spline-conv\n",
            "Successfully installed torch-spline-conv-1.2.1\n",
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Collecting torch-geometric\n",
            "  Downloading torch_geometric-2.0.4.tar.gz (407 kB)\n",
            "\u001b[K     |████████████████████████████████| 407 kB 5.1 MB/s \n",
            "\u001b[?25hRequirement already satisfied: tqdm in /usr/local/lib/python3.7/dist-packages (from torch-geometric) (4.64.0)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from torch-geometric) (1.21.6)\n",
            "Requirement already satisfied: scipy in /usr/local/lib/python3.7/dist-packages (from torch-geometric) (1.4.1)\n",
            "Requirement already satisfied: pandas in /usr/local/lib/python3.7/dist-packages (from torch-geometric) (1.3.5)\n",
            "Requirement already satisfied: jinja2 in /usr/local/lib/python3.7/dist-packages (from torch-geometric) (2.11.3)\n",
            "Requirement already satisfied: requests in /usr/local/lib/python3.7/dist-packages (from torch-geometric) (2.23.0)\n",
            "Requirement already satisfied: pyparsing in /usr/local/lib/python3.7/dist-packages (from torch-geometric) (3.0.9)\n",
            "Requirement already satisfied: scikit-learn in /usr/local/lib/python3.7/dist-packages (from torch-geometric) (1.0.2)\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) (2022.1)\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: 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: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests->torch-geometric) (2.10)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests->torch-geometric) (2022.6.15)\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: 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.4-py3-none-any.whl size=616603 sha256=733c5f676d9dcd165cc327917f89d1283dc22cd7a1394d9b41a4289dd955913d\n",
            "  Stored in directory: /root/.cache/pip/wheels/18/a6/a4/ca18c3051fcead866fe7b85700ee2240d883562a1bc70ce421\n",
            "Successfully built torch-geometric\n",
            "Installing collected packages: torch-geometric\n",
            "Successfully installed torch-geometric-2.0.4\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "M8MbnMp2DJ_P",
        "outputId": "c0db0d33-de82-4fb8-e339-698c4369d2f5"
      },
      "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": 3,
      "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"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "ESOL(1128)"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Tc-9wsVYFWQx",
        "outputId": "e3542c18-62e0-450c-94f3-bf13031145d8"
      },
      "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)"
      ],
      "execution_count": null,
      "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"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from rdkit import Chem\n",
        "from rdkit.Chem.Draw import IPythonConsole\n",
        "molecule = Chem.MolFromSmiles(data[0][\"smiles\"])\n",
        "molecule"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 167
        },
        "id": "nJtudO03c-kC",
        "outputId": "16f5a81e-be2c-43ae-d00d-acad1743fb8a"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<rdkit.Chem.rdchem.Mol at 0x7f1b24f060d0>"
            ],
            "image/png": "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\n"
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Udrj7bStFb0D",
        "outputId": "d15a3dba-0a88-4489-ca7c-1a93db0882c8"
      },
      "source": [
        "# Investigating the features\n",
        "# Shape: [num_nodes, num_node_features]\n",
        "data[0].x"
      ],
      "execution_count": 6,
      "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": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pJAybptWFgOb",
        "outputId": "740b703d-3adf-47d9-d82c-98141e6f02f0"
      },
      "source": [
        "# Investigating the edges in sparse COO format\n",
        "# Shape [2, num_edges]\n",
        "data[0].edge_index.t()"
      ],
      "execution_count": 7,
      "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": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_c2eVyCLFnTO",
        "outputId": "699d785d-f728-47be-8ecb-8af264a3f9d4"
      },
      "source": [
        "data[0].y"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[-0.7700]])"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tyiHDkPtFtGH",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f1de616e-587d-4991-8e56-5d3eed5d4e57"
      },
      "source": [
        "import torch\n",
        "from torch.nn import Linear, Dropout\n",
        "import torch.nn.functional as ftl\n",
        "from torch_geometric.nn import BatchNorm\n",
        "from torch_geometric.nn import GCNConv, TopKPooling\n",
        "from torch_geometric.nn import global_mean_pool as gap, global_max_pool as gmp\n",
        "embed_size = 256\n",
        "\n",
        "class GCN(torch.nn.Module):\n",
        "    def __init__(self):\n",
        "        # parent\n",
        "        super(GCN, self).__init__()\n",
        "        torch.manual_seed(42)\n",
        "\n",
        "        # GCN layers\n",
        "        self.initial_conv = GCNConv(data.num_features, embed_size)\n",
        "        self.conv1 = GCNConv(embed_size, embed_size)\n",
        "        self.conv2 = GCNConv(embed_size, embed_size)\n",
        "        self.conv3 = GCNConv(embed_size, embed_size)\n",
        "        self.conv4 = GCNConv(embed_size, embed_size)\n",
        "        self.conv5 = GCNConv(embed_size, embed_size)\n",
        "\n",
        "        # output layer\n",
        "        self.output = Linear(embed_size*2, data.num_classes)\n",
        "\n",
        "    def forward(self, x, edge_index, batch_index):\n",
        "        # first convolution layer\n",
        "        hidden = self.initial_conv(x, edge_index)\n",
        "        hidden = ftl.tanh(hidden)\n",
        "\n",
        "        # Other convolutional layers\n",
        "        hidden = self.conv1(hidden, edge_index)\n",
        "        hidden = ftl.tanh(hidden)\n",
        "        hidden = BatchNorm(hidden)\n",
        "        hidden = ftl.dropout(hidden, p=0.2)\n",
        "        hidden = self.conv2(hidden, edge_index)\n",
        "        hidden = ftl.tanh(hidden)\n",
        "        hidden = BatchNorm(hidden)\n",
        "        hidden = ftl.dropout(hidden, p=0.15)\n",
        "        hidden = self.conv3(hidden, edge_index)\n",
        "        hidden = ftl.tanh(hidden)\n",
        "        hidden = BatchNorm(hidden)\n",
        "        hidden = ftl.dropout(hidden, p=0.1)\n",
        "        hidden = self.conv4(hidden, edge_index)\n",
        "        hidden = ftl.tanh(hidden)\n",
        "        hidden = BatchNorm(hidden)\n",
        "        hidden = ftl.dropout(hidden, p=0.05)\n",
        "        hidden = self.conv5(hidden, edge_index)\n",
        "        hidden = ftl.tanh(hidden)\n",
        "\n",
        "        # Global pooling\n",
        "        hidden = torch.cat([gmp(hidden, batch_index), gap(hidden, batch_index)], dim=1)\n",
        "\n",
        "        # final classifier\n",
        "        output = self.output(hidden)\n",
        "\n",
        "        return output, hidden\n",
        "\n",
        "model = GCN()\n",
        "print(model)\n",
        "print(\"Number of parameters: \", sum(p.numel() for p in model.parameters()))"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "GCN(\n",
            "  (initial_conv): GCNConv(9, 256)\n",
            "  (conv1): GCNConv(256, 256)\n",
            "  (conv2): GCNConv(256, 256)\n",
            "  (conv3): GCNConv(256, 256)\n",
            "  (conv4): GCNConv(256, 256)\n",
            "  (conv5): GCNConv(256, 256)\n",
            "  (output): Linear(in_features=512, out_features=734, bias=True)\n",
            ")\n",
            "Number of parameters:  708062\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from torch_geometric.data import DataLoader\n",
        "import warnings\n",
        "warnings.filterwarnings(\"ignore\")\n",
        "\n",
        "# RMSE\n",
        "loss_fun = torch.nn.MSELoss()\n",
        "optimizer = torch.optim.Adam(model.parameters(), lr=0.001)\n",
        "\n",
        "# Utilize GPU for training\n",
        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
        "model = model.to(device)\n",
        "\n",
        "# put data in data loader\n",
        "data_size = len(data)\n",
        "graphs_per_batch = 128\n",
        "loader = DataLoader(data[:int(data_size * 0.8)], \n",
        "                    batch_size=graphs_per_batch, shuffle=True)\n",
        "test_loader = DataLoader(data[int(data_size * 0.8):], \n",
        "                         batch_size=graphs_per_batch, shuffle=True)\n",
        "\n",
        "def train(data):\n",
        "    # Enumerate over data\n",
        "    for batch in loader:\n",
        "\n",
        "        batch.to(device)\n",
        "        optimizer.zero_grad()\n",
        "\n",
        "        # Pass the node features info\n",
        "        pred, embedding = model(batch.x.float(), batch.edge_index, batch.batch) \n",
        "\n",
        "        # Calculating the loss and gradients\n",
        "        loss = torch.sqrt(loss_fun(pred, batch.y))       \n",
        "        loss.backward()  \n",
        "\n",
        "        optimizer.step()\n",
        "\n",
        "    return loss, embedding\n",
        "\n",
        "print(\"Training will start...\")\n",
        "losses = []\n",
        "ep = 5000\n",
        "for epoch in range(ep+1):\n",
        "    loss, h = train(data)\n",
        "    losses.append(loss)\n",
        "    if epoch % 100 == 0:\n",
        "        print(f\"Epoch {epoch} | Train Loss {loss}\")\n",
        "    elif epoch == ep:\n",
        "        print(f\"Epoch {epoch} | Train Loss {loss}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "e_RO4cUghKj7",
        "outputId": "e12b8617-42e6-4829-8ec0-598c5a7d3e35"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Training will start...\n",
            "Epoch 0 | Train Loss 1.655456304550171\n",
            "Epoch 100 | Train Loss 0.7378121614456177\n",
            "Epoch 200 | Train Loss 0.6628007888793945\n",
            "Epoch 300 | Train Loss 0.6157793402671814\n",
            "Epoch 400 | Train Loss 0.4790579378604889\n",
            "Epoch 500 | Train Loss 0.6734787821769714\n",
            "Epoch 600 | Train Loss 0.5623463988304138\n",
            "Epoch 700 | Train Loss 0.4885372817516327\n",
            "Epoch 800 | Train Loss 1.4096837043762207\n",
            "Epoch 900 | Train Loss 0.7257806062698364\n",
            "Epoch 1000 | Train Loss 0.29615306854248047\n",
            "Epoch 1100 | Train Loss 0.2579258978366852\n",
            "Epoch 1200 | Train Loss 0.2821653187274933\n",
            "Epoch 1300 | Train Loss 0.2691676914691925\n",
            "Epoch 1400 | Train Loss 0.4005942940711975\n",
            "Epoch 1500 | Train Loss 0.30648288130760193\n",
            "Epoch 1600 | Train Loss 0.18040357530117035\n",
            "Epoch 1700 | Train Loss 0.2893927991390228\n",
            "Epoch 1800 | Train Loss 0.2847399413585663\n",
            "Epoch 1900 | Train Loss 0.2241537719964981\n",
            "Epoch 2000 | Train Loss 0.3233843743801117\n",
            "Epoch 2100 | Train Loss 0.3448353111743927\n",
            "Epoch 2200 | Train Loss 0.24414671957492828\n",
            "Epoch 2300 | Train Loss 0.430730402469635\n",
            "Epoch 2400 | Train Loss 0.2558881342411041\n",
            "Epoch 2500 | Train Loss 0.21544329822063446\n",
            "Epoch 2600 | Train Loss 0.2121286243200302\n",
            "Epoch 2700 | Train Loss 0.33021730184555054\n",
            "Epoch 2800 | Train Loss 0.19570541381835938\n",
            "Epoch 2900 | Train Loss 0.2310224324464798\n",
            "Epoch 3000 | Train Loss 0.09636545181274414\n",
            "Epoch 3100 | Train Loss 0.19804419577121735\n",
            "Epoch 3200 | Train Loss 0.28404566645622253\n",
            "Epoch 3300 | Train Loss 0.28374606370925903\n",
            "Epoch 3400 | Train Loss 0.1422453224658966\n",
            "Epoch 3500 | Train Loss 0.28689244389533997\n",
            "Epoch 3600 | Train Loss 0.28127536177635193\n",
            "Epoch 3700 | Train Loss 0.20151102542877197\n",
            "Epoch 3800 | Train Loss 0.2515157163143158\n",
            "Epoch 3900 | Train Loss 0.45590323209762573\n",
            "Epoch 4000 | Train Loss 0.13214042782783508\n",
            "Epoch 4100 | Train Loss 0.20864906907081604\n",
            "Epoch 4200 | Train Loss 0.24780908226966858\n",
            "Epoch 4300 | Train Loss 0.07751047611236572\n",
            "Epoch 4400 | Train Loss 0.2155972719192505\n",
            "Epoch 4500 | Train Loss 0.13793230056762695\n",
            "Epoch 4600 | Train Loss 0.2851857841014862\n",
            "Epoch 4700 | Train Loss 0.1422072947025299\n",
            "Epoch 4800 | Train Loss 0.17684383690357208\n",
            "Epoch 4900 | Train Loss 0.20194771885871887\n",
            "Epoch 5000 | Train Loss 0.24351400136947632\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "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"
      ],
      "metadata": {
        "id": "ROYWU9kGdU0t",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 284
        },
        "outputId": "968b87ac-b409-46ac-a514-4cb694ecff27"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.axes._subplots.AxesSubplot at 0x7f1ad5aaf5d0>"
            ]
          },
          "metadata": {},
          "execution_count": 14
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "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"
      ],
      "metadata": {
        "id": "C8FdkPOJdV5h",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 424
        },
        "outputId": "4a57610e-7233-41c7-e512-3e992356beea"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "     y_real    y_pred\n",
              "0    -6.637 -6.995487\n",
              "1    -2.982 -3.237353\n",
              "2    -2.060 -2.251452\n",
              "3    -0.490 -0.571177\n",
              "4    -0.972 -0.774131\n",
              "..      ...       ...\n",
              "123  -3.380 -3.198223\n",
              "124  -4.286 -3.178186\n",
              "125  -3.120 -2.272325\n",
              "126   1.100  1.050579\n",
              "127  -2.160 -1.419184\n",
              "\n",
              "[128 rows x 2 columns]"
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-ac459314-c145-4409-9cb7-19c4034c4f14\">\n",
              "    <div class=\"colab-df-container\">\n",
              "      <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>-6.637</td>\n",
              "      <td>-6.995487</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>-2.982</td>\n",
              "      <td>-3.237353</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>-2.060</td>\n",
              "      <td>-2.251452</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>-0.490</td>\n",
              "      <td>-0.571177</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>-0.972</td>\n",
              "      <td>-0.774131</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>...</th>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>123</th>\n",
              "      <td>-3.380</td>\n",
              "      <td>-3.198223</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>124</th>\n",
              "      <td>-4.286</td>\n",
              "      <td>-3.178186</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>125</th>\n",
              "      <td>-3.120</td>\n",
              "      <td>-2.272325</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>126</th>\n",
              "      <td>1.100</td>\n",
              "      <td>1.050579</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>127</th>\n",
              "      <td>-2.160</td>\n",
              "      <td>-1.419184</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "<p>128 rows × 2 columns</p>\n",
              "</div>\n",
              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-ac459314-c145-4409-9cb7-19c4034c4f14')\"\n",
              "              title=\"Convert this dataframe to an interactive table.\"\n",
              "              style=\"display:none;\">\n",
              "        \n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "       width=\"24px\">\n",
              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
              "  </svg>\n",
              "      </button>\n",
              "      \n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      flex-wrap:wrap;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "      <script>\n",
              "        const buttonEl =\n",
              "          document.querySelector('#df-ac459314-c145-4409-9cb7-19c4034c4f14 button.colab-df-convert');\n",
              "        buttonEl.style.display =\n",
              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "        async function convertToInteractive(key) {\n",
              "          const element = document.querySelector('#df-ac459314-c145-4409-9cb7-19c4034c4f14');\n",
              "          const dataTable =\n",
              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                     [key], {});\n",
              "          if (!dataTable) return;\n",
              "\n",
              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "            + ' to learn more about interactive tables.';\n",
              "          element.innerHTML = '';\n",
              "          dataTable['output_type'] = 'display_data';\n",
              "          await google.colab.output.renderOutput(dataTable, element);\n",
              "          const docLink = document.createElement('div');\n",
              "          docLink.innerHTML = docLinkHtml;\n",
              "          element.appendChild(docLink);\n",
              "        }\n",
              "      </script>\n",
              "    </div>\n",
              "  </div>\n",
              "  "
            ]
          },
          "metadata": {},
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "%matplotlib inline\n",
        "\n",
        "plt.scatter(df['y_real'], df['y_pred'])\n",
        "plt.ylim(-9,2)\n",
        "plt.xlim(-9,2)\n",
        "plt.xlabel('real value')\n",
        "plt.ylabel('predicted value')\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "qYEIfD6FdaWT",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 283
        },
        "outputId": "29c0bb0a-1c28-48f6-b960-204aaae79529"
      },
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.metrics import mean_absolute_percentage_error, mean_squared_error, r2_score\n",
        "\n",
        "prct_error = mean_absolute_percentage_error(df[\"y_real\"], df[\"y_pred\"])\n",
        "print(\"Absolute error percent of the model is: \", prct_error)\n",
        "\n",
        "MSE = mean_squared_error(df[\"y_real\"], df[\"y_pred\"])\n",
        "print(\"Mean squared error: \", MSE)\n",
        "\n",
        "R_square = r2_score(df[\"y_real\"], df[\"y_pred\"])\n",
        "print(\"R Squared Value: \", R_square)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lUjWGyBnXI-3",
        "outputId": "6cf6ac73-c9a9-4db0-b51d-3b20e40362b2"
      },
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Absolute error percent of the model is:  0.5045338401545941\n",
            "Mean squared error:  0.4817582163437138\n",
            "R Squared Value:  0.8768661969801965\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "JZQFNEb4da5k"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}