nb-3.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "name": "Work III .ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nJUPGgse2qTb"
      },
      "source": [
        "**INITIALIZATION:**\r\n",
        "- I use these three lines of code on top of my each notebooks because it will help to prevent the problems while reloading the Project. The third line of code helps to make visualization within the notebook."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eHTZcPc21Pbr"
      },
      "source": [
        "#@ INITIALIZATION:\r\n",
        "%reload_ext autoreload\r\n",
        "%autoreload 2\r\n",
        "%matplotlib inline"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PlpzA3vs2w4y"
      },
      "source": [
        "**DOWNLOADING THE DEPENDENCIES:**\r\n",
        "- I have downloaded all the libraries and dependencies required for the Project in one particular cell."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Y2l3vqYH2tw-"
      },
      "source": [
        "#@ DOWNLOADING THE DEPENDENCIES: UNCOMMENT BELOW:\r\n",
        "# !pip install kora -q                                        # Installing the Dependencies for RDKIT.\r\n",
        "import kora.install.rdkit                                     # Getting RDKIT. \r\n",
        "\r\n",
        "import numpy as np\r\n",
        "import pandas as pd\r\n",
        "import matplotlib.pyplot as plt\r\n",
        "\r\n",
        "from rdkit import Chem, DataStructs\r\n",
        "from rdkit.Chem import PandasTools, AllChem\r\n",
        "\r\n",
        "from sklearn.preprocessing import StandardScaler\r\n",
        "from sklearn.model_selection import train_test_split\r\n",
        "\r\n",
        "import torch\r\n",
        "import torch.nn as nn\r\n",
        "from torch.utils.data import Dataset\r\n",
        "from torch.optim.lr_scheduler import ReduceLROnPlateau\r\n",
        "\r\n",
        "from sklearn.metrics import r2_score"
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eOFgF6AiJfJE"
      },
      "source": [
        "#@ INSTALLING THE SMILES VECTORIZER: UNCOMMENT BELOW:\r\n",
        "# %cd /content/drive/MyDrive/Colab Notebooks\r\n",
        "# !git clone https://github.com/EBjerrum/molvecgen                  # Cloning the repository. \r\n",
        "# %cd /content/drive/MyDrive/Colab Notebooks/molvecgen\r\n",
        "# !python setup.py install                                          # Installing the Dependencies.  \r\n",
        "from molvecgen.vectorizers import SmilesVectorizer                  # Importing the Vectorizer. "
      ],
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oEcLddxH5gGN"
      },
      "source": [
        "**GETTING THE DATA:**\r\n",
        "- I have downloaded the dataset from [ExcapeDB](https://solr.ideaconsult.net/search/excape/). **ExcapeDB** is a project developed as a part of **BigChem**. I will read the data using pandas and manage the dataset."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 309
        },
        "id": "xvPjCYjB5mPU",
        "outputId": "5c5d03f5-0e9f-415c-b239-5b09a154bb3b"
      },
      "source": [
        "#@ GETTING THE DATA:\r\n",
        "PATH = \"/content/drive/MyDrive/WORK/Data.csv\"                  # Path to the Data.\r\n",
        "data = pd.read_csv(PATH)                                       # Reading the Data.\r\n",
        "data.head()                                                    # Inspecting the Data. "
      ],
      "execution_count": 6,
      "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>Ambit_InchiKey</th>\n",
              "      <th>Original_Entry_ID</th>\n",
              "      <th>Entrez_ID</th>\n",
              "      <th>Activity_Flag</th>\n",
              "      <th>pXC50</th>\n",
              "      <th>DB</th>\n",
              "      <th>Original_Assay_ID</th>\n",
              "      <th>Tax_ID</th>\n",
              "      <th>Gene_Symbol</th>\n",
              "      <th>Ortholog_Group</th>\n",
              "      <th>SMILES</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>AZMKBJHIXZCVNL-BXKDBHETNA-N</td>\n",
              "      <td>44590643</td>\n",
              "      <td>6532</td>\n",
              "      <td>A</td>\n",
              "      <td>5.68382</td>\n",
              "      <td>pubchem</td>\n",
              "      <td>393260</td>\n",
              "      <td>9606</td>\n",
              "      <td>SLC6A4</td>\n",
              "      <td>4061</td>\n",
              "      <td>FC1=CC([C@@H]2O[C@H](CC2)CN)=C(OC)C=C1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>AZMKBJHIXZCVNL-UHFFFAOYNA-N</td>\n",
              "      <td>11492305</td>\n",
              "      <td>6532</td>\n",
              "      <td>A</td>\n",
              "      <td>5.16210</td>\n",
              "      <td>pubchem</td>\n",
              "      <td>393258</td>\n",
              "      <td>9606</td>\n",
              "      <td>SLC6A4</td>\n",
              "      <td>4061</td>\n",
              "      <td>FC1=CC(C2OC(CC2)CN)=C(OC)C=C1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>AZOHUEDNMOIDOC-GETDIYNLNA-N</td>\n",
              "      <td>44419340</td>\n",
              "      <td>6532</td>\n",
              "      <td>A</td>\n",
              "      <td>6.66354</td>\n",
              "      <td>pubchem</td>\n",
              "      <td>276059</td>\n",
              "      <td>9606</td>\n",
              "      <td>SLC6A4</td>\n",
              "      <td>4061</td>\n",
              "      <td>FC1=CC=C(C[C@H]2C[C@@H](N(CC2)CC=C)CCCNC(=O)NC...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>AZSKJKSQZWHDOK-VJSLDGLSNA-N</td>\n",
              "      <td>CHEMBL1080745</td>\n",
              "      <td>6532</td>\n",
              "      <td>A</td>\n",
              "      <td>6.96000</td>\n",
              "      <td>chembl20</td>\n",
              "      <td>617082</td>\n",
              "      <td>9606</td>\n",
              "      <td>SLC6A4</td>\n",
              "      <td>4061</td>\n",
              "      <td>C=1C=C(C=CC1)C2=CC(=C(N2CC(C)C)C)C(NCCCN3CCN(C...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>AZTPZTRJVCAAMX-UHFFFAOYNA-N</td>\n",
              "      <td>CHEMBL578346</td>\n",
              "      <td>6532</td>\n",
              "      <td>A</td>\n",
              "      <td>8.00000</td>\n",
              "      <td>chembl20</td>\n",
              "      <td>596934</td>\n",
              "      <td>9606</td>\n",
              "      <td>SLC6A4</td>\n",
              "      <td>4061</td>\n",
              "      <td>C1=CC=C2C(=C1)C=C(C(N(C3CCNCC3)C4CCC4)=O)C=C2</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "                Ambit_InchiKey  ...                                             SMILES\n",
              "0  AZMKBJHIXZCVNL-BXKDBHETNA-N  ...             FC1=CC([C@@H]2O[C@H](CC2)CN)=C(OC)C=C1\n",
              "1  AZMKBJHIXZCVNL-UHFFFAOYNA-N  ...                      FC1=CC(C2OC(CC2)CN)=C(OC)C=C1\n",
              "2  AZOHUEDNMOIDOC-GETDIYNLNA-N  ...  FC1=CC=C(C[C@H]2C[C@@H](N(CC2)CC=C)CCCNC(=O)NC...\n",
              "3  AZSKJKSQZWHDOK-VJSLDGLSNA-N  ...  C=1C=C(C=CC1)C2=CC(=C(N2CC(C)C)C)C(NCCCN3CCN(C...\n",
              "4  AZTPZTRJVCAAMX-UHFFFAOYNA-N  ...      C1=CC=C2C(=C1)C=C(C(N(C3CCNCC3)C4CCC4)=O)C=C2\n",
              "\n",
              "[5 rows x 11 columns]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OLUkn91L5-Rn"
      },
      "source": [
        "### **PREPARING THE DATA:**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 703
        },
        "id": "UBFfuD7E5rqX",
        "outputId": "ed2803c8-708d-4d6d-f64c-a403ef03cc73"
      },
      "source": [
        "#@ DATA EXPLORATION:\r\n",
        "PandasTools.AddMoleculeColumnToFrame(data, \"SMILES\", \"Molecule\")\r\n",
        "data[[\"SMILES\", \"Molecule\"]].head(3)                                    # Inspecting the Data."
      ],
      "execution_count": 7,
      "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>SMILES</th>\n",
              "      <th>Molecule</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>FC1=CC([C@@H]2O[C@H](CC2)CN)=C(OC)C=C1</td>\n",
              "      <td><img data-content=\"rdkit/molecule\" src=\"data:image/png;base64,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\" alt=\"Mol\"/></td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>FC1=CC(C2OC(CC2)CN)=C(OC)C=C1</td>\n",
              "      <td><img data-content=\"rdkit/molecule\" src=\"data:image/png;base64,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\" alt=\"Mol\"/></td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>FC1=CC=C(C[C@H]2C[C@@H](N(CC2)CC=C)CCCNC(=O)NC...</td>\n",
              "      <td><img data-content=\"rdkit/molecule\" src=\"data:image/png;base64,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\" alt=\"Mol\"/></td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "                                              SMILES                                           Molecule\n",
              "0             FC1=CC([C@@H]2O[C@H](CC2)CN)=C(OC)C=C1  <img data-content=\"rdkit/molecule\" src=\"data:i...\n",
              "1                      FC1=CC(C2OC(CC2)CN)=C(OC)C=C1  <img data-content=\"rdkit/molecule\" src=\"data:i...\n",
              "2  FC1=CC=C(C[C@H]2C[C@@H](N(CC2)CC=C)CCCNC(=O)NC...  <img data-content=\"rdkit/molecule\" src=\"data:i..."
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EfG1hI8XtH-7"
      },
      "source": [
        "**VECTORIZING THE MOLECULES:**\r\n",
        "- I will be using **Molvecgen Package** to vectorize the smiles. The object is initialized with the generation parameters and subsequently fitted to the dataset which analyzes for what characters it contains the maximal length. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rV4n7RZK6HFK",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2be546c9-9ecd-49bb-9eb7-f5b37fe74b75"
      },
      "source": [
        "#@ VECTORIZING THE MOLECULES WITH DATA AUGMENTATION:\r\n",
        "smivec = SmilesVectorizer(pad=1, leftpad=True, canonical=False, augment=True) # Initializing the Smiles Vectorizer. \r\n",
        "smivec.fit(data.Molecule.values, )                                            # Implementation of the Vectorizer. \r\n",
        "print(smivec.charset)                                                         # Inspecting the Character set. \r\n",
        "print(smivec.dims)                                                            # Inspecting the Dimensions of Onehot Encoded Smiles. "
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3B#cn/7NO(]4\\o2rFHS6@1-)CIs85l[+=^$?\n",
            "(127, 36)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bRFzSenDjx1X"
      },
      "source": [
        "**PREPARING THE DATA:**\r\n",
        "- **PyTorch** needs to be trained on tensors. I will divide the dataset into train, validation and test dataset using **Scikit Learn**. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5K9P2d6WhHXz"
      },
      "source": [
        "#@ PREPARING THE DATA:\r\n",
        "y = data.pXC50.values.reshape((-1, 1))                                    # Reshaping the Dataset. \r\n",
        "X = data.Molecule.values                                                  # Preparing the Data. \r\n",
        "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.10, \r\n",
        "                                    random_state=11)                      # Splitting the Dataset into Training set and Test set. \r\n",
        "X_train, X_valid, y_train, y_valid = train_test_split(X_train, y_train, \r\n",
        "                                    test_size=0.05, random_state=11)      # Splitting the Training set into Train and Validation set. \r\n",
        "#@ NORMALIZATION:\r\n",
        "scaler = StandardScaler()                                                 # Initializing the Standard Scaler. \r\n",
        "y_train = scaler.fit_transform(y_train)                                   # Normalizing the Data.\r\n",
        "y_test = scaler.transform(y_test)                                         # Normalizing the Data.\r\n",
        "y_valid = scaler.transform(y_valid)                                       # Normalizing the Data.                                 "
      ],
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rD9G4T4wmYnn"
      },
      "source": [
        "**DATASET CLASS:**\r\n",
        "- **PyTorch** works with datasets. I will integrate the vectorizer using subclassing which allow us to load the dataset using **Rdkit** molecular objects and generate the tensors. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-Vo3Na5nmJY8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3dd13db5-60c2-4eb1-cb1c-bc709181bf2b"
      },
      "source": [
        "#@ INTEGRATING THE VECTORIZER IN DATASET CLASS:\r\n",
        "class SMILESDataset(Dataset):                                     # Dataset Class. \r\n",
        "  def __init__(self, molecules, y, vectorizer):\r\n",
        "    self.molecules = molecules\r\n",
        "    self.y = y\r\n",
        "    self.vectorizer = vectorizer\r\n",
        "  def __len__(self):                                              # Subclassing the method. \r\n",
        "    return len(self.molecules)\r\n",
        "  def __getitem__(self, idx):                                     # Subclassing the method. \r\n",
        "    if torch.is_tensor(idx):\r\n",
        "      idx = idx.tolist()\r\n",
        "    mols = self.molecules[idx]\r\n",
        "    sample = self.vectorizer.transform([mols])[0]\r\n",
        "    label = self.y[idx]\r\n",
        "    return sample, label\r\n",
        "#@ CREATING THE DATASET:\r\n",
        "train_dataset = SMILESDataset(X_train, y_train, smivec)           # Invoking the SMILESDataset Class. \r\n",
        "train_dataset[0]                                                  # Inspecting the Dataset. "
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(array([[0, 0, 0, ..., 0, 0, 0],\n",
              "        [0, 0, 0, ..., 0, 0, 0],\n",
              "        [0, 0, 0, ..., 0, 0, 0],\n",
              "        ...,\n",
              "        [0, 0, 0, ..., 0, 0, 0],\n",
              "        [0, 0, 0, ..., 0, 0, 0],\n",
              "        [0, 0, 0, ..., 0, 1, 0]], dtype=int8), array([-0.19724555]))"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IvJfWVAcPJVJ"
      },
      "source": [
        "**PREPARING THE DATA:**\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9MmhlkXEO3Wh",
        "outputId": "03b84fda-b083-4d02-fc4b-0ea357ec1ee6"
      },
      "source": [
        "#@ PREPARING THE DATA:\r\n",
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")      # Inspecting if CUDA is available. \r\n",
        "X_valid_t = smivec.transform(X_valid, canonical=False)                     # Vectorization. \r\n",
        "X_valid_t = torch.tensor(X_valid_t, device=device).float()                 # Converting into Float Tensors. \r\n",
        "y_valid_t = torch.tensor(y_valid, device=device).float()                   # Converting into Float Tensors. \r\n",
        "print(X_valid_t.shape, y_valid_t.shape)                                    # Inspecting the Data. "
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "torch.Size([326, 127, 36]) torch.Size([326, 1])\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UJT8PigeQjcC"
      },
      "source": [
        "### **BUILDING THE MODEL:**\r\n",
        "- I will define the **LSTM Neural Network** architecture. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "t0_stV-PQXHw",
        "outputId": "e65a88c4-27d0-4825-f636-baacfbed66e3"
      },
      "source": [
        "#@ LSTM MOLECULAR MODEL: \r\n",
        "class Net(nn.Module):                                                                      # LSTM Molecular Model. \r\n",
        "  def __init__(self, dimensions, lstm_size, hidden_size, dropout_size, output_size):\r\n",
        "    super(Net, self).__init__()\r\n",
        "    length = dims[0]\r\n",
        "    number_tokens = dims[1]\r\n",
        "    self.lstm = nn.LSTM(input_size=number_tokens, hidden_size=lstm_size, num_layers=1, \r\n",
        "                        batch_first=True, bidirectional=False)                             # LSTM Layer. \r\n",
        "    self.fc1 = nn.Linear(lstm_size, hidden_size)                                           # Simple Linear Layer. \r\n",
        "    self.activation = nn.ReLU()                                                            # Non Linear RELU Layer. \r\n",
        "    self.fc_out = nn.Linear(hidden_size, output_size)                                      # Output Layer.      \r\n",
        "    self.dropout = nn.Dropout(dropout_size)                                                # Dropout Layer. \r\n",
        "  def forward(self, x):                                                                    # Stacking each layer together. \r\n",
        "    out, (h_n, c_n) = self.lstm(x)                                                         # LSTM Network reads the onehot encoded SMILES. \r\n",
        "    out = self.dropout(h_n)                                                                # Defining the Dropout. \r\n",
        "    out = self.fc1(out)                                                                    # Passing into the Hidden Layer. \r\n",
        "    out = self.activation(out)                                                             # Using RELU Activation.\r\n",
        "    out = self.dropout(out)                                                                # Defining the Dropout. \r\n",
        "    out = self.fc_out(out)                                                                 # Using the Linear Layer for Output. \r\n",
        "    return out\r\n",
        "#@ DEFINING THE PARAMETERS:\r\n",
        "epochs = 750\r\n",
        "dims = smivec.dims\r\n",
        "lstm_size = 128                                                                            # Size of the LSTM Layer. \r\n",
        "hidden_size = 128                                                                          # Size of the Hidden Non Linear Layer. \r\n",
        "dropout_rate = 0.50                                                                        # The Dropout Rate. \r\n",
        "output_size = 1                                                                            # Single Task. \r\n",
        "batch_size = 128                                                                           # Minibatch size during Training. \r\n",
        "learning_rate = 0.003                                                                      # Initial Learning Rate for the Optimizer. \r\n",
        "#@ LSTM MOLECULAR MODEL:\r\n",
        "model = Net(smivec, lstm_size, hidden_size, dropout_rate, output_size)                     # Instantiating the Model. \r\n",
        "model.cuda()"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Net(\n",
              "  (lstm): LSTM(36, 128, batch_first=True)\n",
              "  (fc1): Linear(in_features=128, out_features=128, bias=True)\n",
              "  (activation): ReLU()\n",
              "  (fc_out): Linear(in_features=128, out_features=1, bias=True)\n",
              "  (dropout): Dropout(p=0.5, inplace=False)\n",
              ")"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Idm0HV7AXnZb",
        "outputId": "ad91dcb2-148f-47f6-fcf3-eccbb351da82"
      },
      "source": [
        "#@ INSPECTING THE MODEL:\r\n",
        "pred = model.forward(X_valid_t[10:11])                          # Implementing the Model. \r\n",
        "pred                                                            # Inspecting the result. "
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[[0.0567]]], device='cuda:0', grad_fn=<AddBackward0>)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RaeyFKXDYoHI"
      },
      "source": [
        "**PROCESSING THE MODEL:**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "J7d3jygXYQgP"
      },
      "source": [
        "#@ PROCESSING THE MODEL:\r\n",
        "criterion = nn.MSELoss()                                                                     # Initializing the Loss Function.\r\n",
        "optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)                           # Initializing the Optimizer. \r\n",
        "lr_scheduler = ReduceLROnPlateau(optimizer, mode=\"min\", factor=0.5, patience=50,\r\n",
        "                                 verbose=True, threshold=0.0001, threshold_mode=\"rel\", \r\n",
        "                                 cooldown=0, min_lr=1e-6, eps=1e-08)\r\n",
        "#@ PROCESSING THE DATA:\r\n",
        "train_loader = torch.utils.data.DataLoader(dataset=train_dataset,                            # Preparing the Dataset Loader. \r\n",
        "                                           batch_size=batch_size,\r\n",
        "                                           shuffle=True, num_workers=4)\r\n",
        "#@ INSPECTING THE TRAIN LOADER:\r\n",
        "for smiles, labels in train_loader:\r\n",
        "  break"
      ],
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QCfMwDTgbESP"
      },
      "source": [
        "**TRAINING THE MODEL:**\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IzgAGgOXa7vH",
        "outputId": "f1b456c6-767e-4044-d070-b083927c8132"
      },
      "source": [
        "#@ TRAINING THE MODEL:\r\n",
        "model.train()                                                                         # Ensuring the Network in Train Mode. \r\n",
        "train_losses = []                                                                     # Initializing the empty list.\r\n",
        "validation_losses = []                                                                # Initializing the empty list. \r\n",
        "for i in range(epochs):\r\n",
        "  running_loss = 0\r\n",
        "  for smiles, labels in train_loader:\r\n",
        "    smiles = torch.tensor(smiles, device=device).float()                              # Converting into GPU Tensors. \r\n",
        "    labels = torch.tensor(labels, device=device).float()                              # Converting into GPU Tensors. \r\n",
        "    optimizer.zero_grad()                                                             # Initializing the Gradients. \r\n",
        "    output = model(smiles)                                                            # Forward pass of the Minibatch. \r\n",
        "    loss = criterion(output, labels)                                                  # Computing the Loss. \r\n",
        "    loss.backward()                                                                   # Calculating the Backward Pass. \r\n",
        "    torch.nn.utils.clip_grad_norm_(model.parameters(), 1)\r\n",
        "    optimizer.step()                                                                  # Optimizing the Gradients. \r\n",
        "    running_loss += loss.item()\r\n",
        "  else:\r\n",
        "    model.eval()                                                                      # Ensuring the Network in Evaluation Mode. \r\n",
        "    validation_loss = torch.mean((y_valid_t - model(X_valid_t))**2, ).item()          # Calculating the Loss. \r\n",
        "    model.train()                                                                     # Network in Train Mode and Dropout in Active Mode. \r\n",
        "    lr_scheduler.step(validation_loss)                                                # Optimization. \r\n",
        "    train_loss = running_loss / len(train_loader)\r\n",
        "    train_losses.append(train_loss)                                                   # Appending the Training Loss. \r\n",
        "    validation_losses.append(validation_loss)                                         # Appending the Validation Loss. \r\n",
        "    if (i + 1) % 10 == 0:\r\n",
        "      print(\"Epoch %i, Training Loss: %0.2F Validation Loss: %0.2F\" %(i+1, train_loss, \r\n",
        "                                                                      validation_loss))"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:8: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
            "  \n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:9: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
            "  if __name__ == '__main__':\n",
            "/usr/local/lib/python3.6/dist-packages/torch/nn/modules/loss.py:446: UserWarning: Using a target size (torch.Size([128, 1])) that is different to the input size (torch.Size([1, 128, 1])). This will likely lead to incorrect results due to broadcasting. Please ensure they have the same size.\n",
            "  return F.mse_loss(input, target, reduction=self.reduction)\n",
            "/usr/local/lib/python3.6/dist-packages/torch/nn/modules/loss.py:446: UserWarning: Using a target size (torch.Size([35, 1])) that is different to the input size (torch.Size([1, 35, 1])). This will likely lead to incorrect results due to broadcasting. Please ensure they have the same size.\n",
            "  return F.mse_loss(input, target, reduction=self.reduction)\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Epoch 10, Training Loss: 0.85 Validation Loss: 0.89\n",
            "Epoch 20, Training Loss: 0.78 Validation Loss: 0.77\n",
            "Epoch 30, Training Loss: 0.70 Validation Loss: 0.76\n",
            "Epoch 40, Training Loss: 0.66 Validation Loss: 0.70\n",
            "Epoch 50, Training Loss: 0.61 Validation Loss: 0.66\n",
            "Epoch 60, Training Loss: 0.57 Validation Loss: 0.60\n",
            "Epoch 70, Training Loss: 0.55 Validation Loss: 0.60\n",
            "Epoch 80, Training Loss: 0.51 Validation Loss: 0.56\n",
            "Epoch 90, Training Loss: 0.48 Validation Loss: 0.53\n",
            "Epoch 100, Training Loss: 0.45 Validation Loss: 0.53\n",
            "Epoch 110, Training Loss: 0.43 Validation Loss: 0.49\n",
            "Epoch 120, Training Loss: 0.43 Validation Loss: 0.47\n",
            "Epoch 130, Training Loss: 0.41 Validation Loss: 0.49\n",
            "Epoch 140, Training Loss: 0.38 Validation Loss: 0.52\n",
            "Epoch 150, Training Loss: 0.37 Validation Loss: 0.49\n",
            "Epoch 160, Training Loss: 0.37 Validation Loss: 0.44\n",
            "Epoch 170, Training Loss: 0.36 Validation Loss: 0.44\n",
            "Epoch 180, Training Loss: 0.35 Validation Loss: 0.42\n",
            "Epoch 190, Training Loss: 0.35 Validation Loss: 0.42\n",
            "Epoch 200, Training Loss: 0.34 Validation Loss: 0.44\n",
            "Epoch 210, Training Loss: 0.32 Validation Loss: 0.43\n",
            "Epoch   218: reducing learning rate of group 0 to 1.5000e-03.\n",
            "Epoch 220, Training Loss: 0.30 Validation Loss: 0.41\n",
            "Epoch 230, Training Loss: 0.30 Validation Loss: 0.40\n",
            "Epoch 240, Training Loss: 0.29 Validation Loss: 0.39\n",
            "Epoch 250, Training Loss: 0.28 Validation Loss: 0.42\n",
            "Epoch 260, Training Loss: 0.27 Validation Loss: 0.40\n",
            "Epoch 270, Training Loss: 0.28 Validation Loss: 0.39\n",
            "Epoch 280, Training Loss: 0.27 Validation Loss: 0.41\n",
            "Epoch 290, Training Loss: 0.26 Validation Loss: 0.40\n",
            "Epoch 300, Training Loss: 0.25 Validation Loss: 0.41\n",
            "Epoch 310, Training Loss: 0.27 Validation Loss: 0.37\n",
            "Epoch 320, Training Loss: 0.26 Validation Loss: 0.40\n",
            "Epoch 330, Training Loss: 0.26 Validation Loss: 0.40\n",
            "Epoch 340, Training Loss: 0.26 Validation Loss: 0.40\n",
            "Epoch 350, Training Loss: 0.25 Validation Loss: 0.42\n",
            "Epoch 360, Training Loss: 0.24 Validation Loss: 0.38\n",
            "Epoch   361: reducing learning rate of group 0 to 7.5000e-04.\n",
            "Epoch 370, Training Loss: 0.24 Validation Loss: 0.39\n",
            "Epoch 380, Training Loss: 0.23 Validation Loss: 0.39\n",
            "Epoch 390, Training Loss: 0.23 Validation Loss: 0.40\n",
            "Epoch 400, Training Loss: 0.23 Validation Loss: 0.39\n",
            "Epoch 410, Training Loss: 0.23 Validation Loss: 0.39\n",
            "Epoch   412: reducing learning rate of group 0 to 3.7500e-04.\n",
            "Epoch 420, Training Loss: 0.23 Validation Loss: 0.39\n",
            "Epoch 430, Training Loss: 0.22 Validation Loss: 0.39\n",
            "Epoch 440, Training Loss: 0.22 Validation Loss: 0.40\n",
            "Epoch 450, Training Loss: 0.22 Validation Loss: 0.40\n",
            "Epoch 460, Training Loss: 0.22 Validation Loss: 0.39\n",
            "Epoch   463: reducing learning rate of group 0 to 1.8750e-04.\n",
            "Epoch 470, Training Loss: 0.21 Validation Loss: 0.39\n",
            "Epoch 480, Training Loss: 0.21 Validation Loss: 0.39\n",
            "Epoch 490, Training Loss: 0.22 Validation Loss: 0.39\n",
            "Epoch 500, Training Loss: 0.22 Validation Loss: 0.39\n",
            "Epoch 510, Training Loss: 0.22 Validation Loss: 0.39\n",
            "Epoch   514: reducing learning rate of group 0 to 9.3750e-05.\n",
            "Epoch 520, Training Loss: 0.21 Validation Loss: 0.39\n",
            "Epoch 530, Training Loss: 0.21 Validation Loss: 0.39\n",
            "Epoch 540, Training Loss: 0.21 Validation Loss: 0.39\n",
            "Epoch 550, Training Loss: 0.21 Validation Loss: 0.39\n",
            "Epoch 560, Training Loss: 0.21 Validation Loss: 0.39\n",
            "Epoch   565: reducing learning rate of group 0 to 4.6875e-05.\n",
            "Epoch 570, Training Loss: 0.21 Validation Loss: 0.38\n",
            "Epoch 580, Training Loss: 0.21 Validation Loss: 0.39\n",
            "Epoch 590, Training Loss: 0.21 Validation Loss: 0.39\n",
            "Epoch 600, Training Loss: 0.21 Validation Loss: 0.39\n",
            "Epoch 610, Training Loss: 0.21 Validation Loss: 0.39\n",
            "Epoch   616: reducing learning rate of group 0 to 2.3438e-05.\n",
            "Epoch 620, Training Loss: 0.21 Validation Loss: 0.39\n",
            "Epoch 630, Training Loss: 0.21 Validation Loss: 0.39\n",
            "Epoch 640, Training Loss: 0.21 Validation Loss: 0.39\n",
            "Epoch 650, Training Loss: 0.21 Validation Loss: 0.39\n",
            "Epoch 660, Training Loss: 0.21 Validation Loss: 0.39\n",
            "Epoch   667: reducing learning rate of group 0 to 1.1719e-05.\n",
            "Epoch 670, Training Loss: 0.21 Validation Loss: 0.38\n",
            "Epoch 680, Training Loss: 0.21 Validation Loss: 0.39\n",
            "Epoch 690, Training Loss: 0.21 Validation Loss: 0.39\n",
            "Epoch 700, Training Loss: 0.21 Validation Loss: 0.39\n",
            "Epoch 710, Training Loss: 0.21 Validation Loss: 0.38\n",
            "Epoch   718: reducing learning rate of group 0 to 5.8594e-06.\n",
            "Epoch 720, Training Loss: 0.20 Validation Loss: 0.38\n",
            "Epoch 730, Training Loss: 0.21 Validation Loss: 0.38\n",
            "Epoch 740, Training Loss: 0.21 Validation Loss: 0.38\n",
            "Epoch 750, Training Loss: 0.21 Validation Loss: 0.38\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BjJtJ5zEgoa_"
      },
      "source": [
        "**MODEL EVALUATION:**\r\n",
        "- I will plot the training now. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        },
        "id": "JF2Y2SkygMN_",
        "outputId": "c29cc592-3087-425a-fb73-0355a77a78a8"
      },
      "source": [
        "#@ PLOTTING THE TRAINING:\r\n",
        "plt.plot(train_losses, label=\"Train\")\r\n",
        "plt.plot(validation_losses, label=\"Validation\")\r\n",
        "plt.legend()\r\n",
        "plt.show()                                                  # Plotting the Training. "
      ],
      "execution_count": 16,
      "outputs": [
        {
          "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": "LzUz3lvficlO"
      },
      "source": [
        "**MODEL EVALUATION:**\r\n",
        "- Before using the model for prediction, it must be set to the evaluation mode, where the dropout layers are no longer active. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RBSWccqyili5",
        "outputId": "45239a22-121e-47f4-cad6-69043d107637"
      },
      "source": [
        "#@ EVALUATING THE PERFORMANCE:\r\n",
        "model.eval()                                            # Switching to evaluation mode. \r\n",
        "y_pred_valid = model(X_valid_t)                         # Predicting the Validation Data. \r\n",
        "print(torch.mean((y_valid_t - y_pred_valid)**2).item()) # Inspecting the result. "
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0.38341572880744934\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eUYalGkmkMGP"
      },
      "source": [
        "**MODEL EVALUATION:**\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZJjzqShpDvTE",
        "outputId": "79013584-ae33-4072-832b-9b1fcc790858"
      },
      "source": [
        "y_test_t = torch.tensor(y_test, device=device).float()        # Converting into GPU Tensors. \r\n",
        "y_pred_test = model(X_test_t)                                 # Predicting the Test Data. \r\n",
        "y_pred = np.array(y_pred_test.tolist()).flatten()\r\n",
        "y_test = np.array(y_test_t.tolist()).flatten()\r\n",
        "y_test.shape, y_pred.shape"
      ],
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "((723,), (723,))"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xRWYefpxkENZ",
        "outputId": "529c9070-5900-48c4-c5b3-7f187ba85a8c"
      },
      "source": [
        "#@ PROCESSING THE TRAIN AND TEST SET:\r\n",
        "X_train_t = smivec.transform(X_train, canonical=False)        # Vectorization. \r\n",
        "X_train_t = torch.tensor(X_train_t, device=device).float()    # Converting into GPU Tensors. \r\n",
        "y_train_t = torch.tensor(y_train, device=device).float()      # Converting into GPU Tensors. \r\n",
        "X_test_t = smivec.transform(X_test, canonical=False)          # Vectorization of Test Dataset. \r\n",
        "X_test_t = torch.tensor(X_test_t, device=device).float()      # Converting into GPU Tensors. \r\n",
        "y_test_t = torch.tensor(y_test, device=device).float()        # Converting into GPU Tensors. \r\n",
        "#@ EVALUATING THE PERFORMANCE:\r\n",
        "y_pred_train = model(X_train_t)                               # Predicting the Training Data. \r\n",
        "y_pred_test = model(X_test_t)                                 # Predicting the Test Data. \r\n",
        "train_rmse = torch.mean((y_train_t - y_pred_train)**2).item() # Calculating the RMSE. \r\n",
        "test_rmse = torch.mean((y_test_t - y_pred_test)**2).item()    # Calculating the RMSE.\r\n",
        "print(\"Train RMSE: %0.3F \\nTest RMSE: %0.3F\" % (train_rmse,\r\n",
        "                                                test_rmse))   # Inspecting the RMSE. \r\n",
        "#@ EVALUATING THE PERFORMANCE:\r\n",
        "y_test_t= np.array(y_test_t.tolist()).flatten()\r\n",
        "y_pred_test= np.array(y_pred_test.tolist()).flatten()\r\n",
        "r_square = r2_score(y_test_t, y_pred_test)                    # Calculating the R2. \r\n",
        "print(f\"R^2: {r_square}\")"
      ],
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Train RMSE: 0.182 \n",
            "Test RMSE: 1.707\n",
            "R^2: 0.6529237210980361\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 266
        },
        "id": "UUh0OiWxm0z_",
        "outputId": "f7e6e642-a1a7-4b39-e1c4-64cc00791f0f"
      },
      "source": [
        "#@ ESTIMATING USING SCATTERPLOT:\r\n",
        "plt.scatter(np.array(y_pred_train.tolist()).flatten(), np.array(y_train_t.tolist()).flatten(), alpha=0.1)\r\n",
        "plt.scatter(np.array(y_pred_valid.tolist()).flatten(), np.array(y_valid_t.tolist()).flatten(), alpha=0.5)\r\n",
        "plt.plot([-1.5, 1.5], [-1.5, 1.5], c=\"b\")\r\n",
        "plt.show()"
      ],
      "execution_count": 23,
      "outputs": [
        {
          "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"
          }
        }
      ]
    }
  ]
}