Generating_Molecules_using_NLP_Models.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/samirapakravan/ML4Molecules/blob/main/Generating_Molecules_using_NLP_Models.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8dhxxFwJTw3M",
        "outputId": "2c34b0ca-5834-4120-d4ed-35561c7b8025"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Collecting rdkit\n",
            "  Downloading rdkit-2022.9.4-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (29.3 MB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m29.3/29.3 MB\u001b[0m \u001b[31m19.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hRequirement already satisfied: Pillow in /usr/local/lib/python3.8/dist-packages (from rdkit) (7.1.2)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.8/dist-packages (from rdkit) (1.21.6)\n",
            "Installing collected packages: rdkit\n",
            "Successfully installed rdkit-2022.9.4\n"
          ]
        }
      ],
      "source": [
        "pip install rdkit"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "PLXuP4qqTxWt"
      },
      "outputs": [],
      "source": [
        "from rdkit import Chem\n",
        "from rdkit.Chem import Descriptors\n",
        "from rdkit.Chem import AllChem\n",
        "from rdkit.Chem.Draw import IPythonConsole \n",
        "\n",
        "import numpy as np\n",
        "from sklearn.model_selection import train_test_split\n",
        "\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import pandas as pd\n",
        "from torch.utils.data import TensorDataset, DataLoader\n",
        "from torch.optim.lr_scheduler import StepLR\n",
        "from torch.optim.lr_scheduler import ReduceLROnPlateau\n",
        "from tqdm.notebook import trange\n",
        "\n",
        "# CUDA for PyTorch\n",
        "use_cuda = torch.cuda.is_available()\n",
        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
        "torch.backends.cudnn.benchmark = True"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8U6CAUUk6qnx"
      },
      "source": [
        "Reading file contents and filtering the SMILES to those with at most 50 characters:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "gTP85ecklboc"
      },
      "outputs": [],
      "source": [
        "zinc_df = pd.read_csv('SMILES_Keyboard.csv')\n",
        "zinc_df = zinc_df.loc[zinc_df['SMILES'].str.len()<50][['SMILES', 'NAME']].reset_index(drop=True)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3nlCMvfJ9M6S",
        "outputId": "883e31a8-d48e-497b-c3bb-380c8ec1db57"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'pandas.core.frame.DataFrame'>\n",
            "RangeIndex: 11808 entries, 0 to 11807\n",
            "Data columns (total 2 columns):\n",
            " #   Column  Non-Null Count  Dtype \n",
            "---  ------  --------------  ----- \n",
            " 0   SMILES  11808 non-null  object\n",
            " 1   NAME    11808 non-null  object\n",
            "dtypes: object(2)\n",
            "memory usage: 184.6+ KB\n"
          ]
        }
      ],
      "source": [
        "zinc_df.info()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fDeZqHv1Zffc"
      },
      "source": [
        "##**Method 1:** Natural Language Processing technique; i.e., neighborhood in latent space.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-37rRGw_73k5"
      },
      "source": [
        "###**Tokenization and Encoding** \n",
        "\n",
        "Tokenizer function to separate SMILES strings into separate tokens:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "EHpnI0iEU4vG"
      },
      "outputs": [],
      "source": [
        "def smi_tokenizer(smi):\n",
        "    \"\"\"\n",
        "    Tokenize a SMILES molecule or reaction\n",
        "    \"\"\"\n",
        "    import re\n",
        "    pattern =  \"(\\[[^\\]]+]|Br?|Cl?|N|O|S|P|F|I|b|c|n|o|s|p|\\(|\\)|\\.|=|#|-|\\+|\\\\\\\\|\\/|:|~|@|\\?|>|\\*|\\$|\\%[0-9]{2}|[0-9])\"\n",
        "    regex = re.compile(pattern)\n",
        "    tokens = [token for token in regex.findall(smi)]\n",
        "    assert smi == ''.join(tokens)\n",
        "    return ' '.join(tokens)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        },
        "id": "jGTGVZgfU56u",
        "outputId": "09d544c8-f4a8-4375-9f5f-6311c2e5de70"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'C c 1 c c ( - n 2 n c c ( = O ) [nH] c 2 = O ) c c c 1 C ( = O ) c 1 c c c ( C # N ) c c 1'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 6
        }
      ],
      "source": [
        "smi_tokenizer(zinc_df['SMILES'][1])"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Approach 1 token based\n",
        "\n",
        "tokenized_data = \"\"\n",
        "for i, row in zinc_df.iterrows():\n",
        "  t = smi_tokenizer(row['SMILES'])\n",
        "  tokenized_data += ' ' + t                     \n",
        "\n",
        "tokenSet = set()\n",
        "txt = []\n",
        "for token in tokenized_data.split(\" \"):\n",
        "  txt.append(token)\n",
        "  tokenSet.add(token)\n",
        "\n",
        "int2token = dict(enumerate(tokenSet))\n",
        "token2int = {t: id for id, t in int2token.items()}\n",
        "encoded = np.array([token2int[t] for t in txt])       # Encoded version of the entire dataset"
      ],
      "metadata": {
        "id": "PVRMwvyNaMaO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "tokenSet"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HjrzWLI9aQyW",
        "outputId": "488196b4-8445-48be-9259-581f715fbae8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'',\n",
              " '#',\n",
              " '(',\n",
              " ')',\n",
              " '-',\n",
              " '.',\n",
              " '/',\n",
              " '1',\n",
              " '2',\n",
              " '3',\n",
              " '4',\n",
              " '5',\n",
              " '6',\n",
              " '=',\n",
              " 'B',\n",
              " 'Br',\n",
              " 'C',\n",
              " 'Cl',\n",
              " 'F',\n",
              " 'I',\n",
              " 'N',\n",
              " 'O',\n",
              " 'P',\n",
              " 'S',\n",
              " '[135I]',\n",
              " '[2H]',\n",
              " '[Br-]',\n",
              " '[C@@H]',\n",
              " '[C@@]',\n",
              " '[C@H]',\n",
              " '[C@]',\n",
              " '[Cl-]',\n",
              " '[I-]',\n",
              " '[Li+]',\n",
              " '[N+]',\n",
              " '[N-]',\n",
              " '[Na+]',\n",
              " '[O-]',\n",
              " '[OH-]',\n",
              " '[PH]',\n",
              " '[S+]',\n",
              " '[S-]',\n",
              " '[S@@+]',\n",
              " '[Se]',\n",
              " '[Si]',\n",
              " '[n+]',\n",
              " '[n-]',\n",
              " '[nH]',\n",
              " '[o+]',\n",
              " '[s+]',\n",
              " '\\\\',\n",
              " 'c',\n",
              " 'n',\n",
              " 'o',\n",
              " 's'}"
            ]
          },
          "metadata": {},
          "execution_count": 28
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m8KiWzmYe6ZN"
      },
      "source": [
        "Finding all the unique tokens and encoding the entire dataset using 2 dictionaries that convert token to integer and integer to token"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xzUtuV8U7r7R"
      },
      "outputs": [],
      "source": [
        "# Approach 2 char based\n",
        "\n",
        "#tokenSet = set(\"\".join(list(zinc_df.SMILES))+\"!E\")\n",
        "#txt = \"\".join(list(zinc_df.SMILES))+\"!E\"\n",
        "\n",
        "tokenSet = set(\"\".join(list(zinc_df.SMILES)))\n",
        "txt = \"\".join(list(zinc_df.SMILES))\n",
        "\n",
        "int2token = dict(enumerate(tokenSet))\n",
        "token2int = {t: id for id, t in int2token.items()}\n",
        "encoded = np.array([token2int[t] for t in txt])"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tokenSet"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XWs10i77aYhm",
        "outputId": "748a0eab-a526-48c0-c398-1e37382c51bc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'#',\n",
              " '(',\n",
              " ')',\n",
              " '+',\n",
              " '-',\n",
              " '.',\n",
              " '/',\n",
              " '1',\n",
              " '2',\n",
              " '3',\n",
              " '4',\n",
              " '5',\n",
              " '6',\n",
              " '=',\n",
              " '@',\n",
              " 'B',\n",
              " 'C',\n",
              " 'F',\n",
              " 'H',\n",
              " 'I',\n",
              " 'L',\n",
              " 'N',\n",
              " 'O',\n",
              " 'P',\n",
              " 'S',\n",
              " '[',\n",
              " '\\\\',\n",
              " ']',\n",
              " 'a',\n",
              " 'c',\n",
              " 'e',\n",
              " 'i',\n",
              " 'l',\n",
              " 'n',\n",
              " 'o',\n",
              " 'r',\n",
              " 's'}"
            ]
          },
          "metadata": {},
          "execution_count": 30
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EfAeRaCjlEe1"
      },
      "source": [
        "Creating one hot encoding: creating column vector based on the integer values of tokens"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "y72KFkXoz3-B"
      },
      "outputs": [],
      "source": [
        "def one_hot_encode(encoded, n_uni_tokens):\n",
        "    one_hot = np.zeros((encoded.size, n_uni_tokens), dtype=np.float32)  # starting with zeros\n",
        "    one_hot[np.arange(one_hot.shape[0]), encoded.flatten()] = 1.0       # wherever index position meets set it 1\n",
        "    one_hot = one_hot.reshape((*encoded.shape, n_uni_tokens))           # reshape to get the original batch shape   \n",
        "    return one_hot"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Gv15ISCQ2bzg"
      },
      "source": [
        "###**Generating Training Batches** "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mBpnwnSp2w8J"
      },
      "source": [
        "Each training sample is a sequence of tokens along with a label which is the same sequence shifted by 1 time step"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "-aAGIf3qI80g"
      },
      "outputs": [],
      "source": [
        "def generate_batches(encoded, batch_size, seq_len):\n",
        "    token_per_batch = batch_size * seq_len            # total number of tokens per batch\n",
        "    n_batches = len(encoded)//token_per_batch         # total number of batches we can make out of all data\n",
        "    \n",
        "    encoded = encoded[:n_batches * token_per_batch]   # cut of the end of encoded\n",
        "    encoded = encoded.reshape((batch_size, -1))       # reshape encoded data into rows of size batch\n",
        "    \n",
        "    for n in range(0, encoded.shape[1], seq_len):     # encoded is reshaped now so we go along dimension 1\n",
        "        x = encoded[:, n:n+seq_len]\n",
        "        y = np.zeros_like(x)                          # creating array of zeros with same shape as x\n",
        "        \n",
        "        try:\n",
        "            y[:,:-1] = x[:,1:]\n",
        "            y[:,-1] = encoded[:,n+seq_len]       \n",
        "        except:                             # at the end there is a possibility to go out of range\n",
        "            y[:,:-1] = x[:,1:]\n",
        "            y[:,-1] = encoded[:,0]\n",
        "        yield x, y"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6BFHuPaD-Fr_"
      },
      "source": [
        "###**Creating NN Model** "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "QZUg3rzk-5w6"
      },
      "outputs": [],
      "source": [
        "class Model(nn.Module):\n",
        "    \n",
        "    def __init__(self, tokens, n_hidden=10, n_layers=2):\n",
        "        super().__init__()\n",
        "\n",
        "        self.n_layers = n_layers\n",
        "        self.n_hidden = n_hidden\n",
        "\n",
        "        # our built-in dictionaries\n",
        "        self.tokens = tokens\n",
        "        self.int2token = dict(enumerate(self.tokens))\n",
        "        self.token2int = {t: id for id, t in int2token.items()}\n",
        "        \n",
        "        self.lstm = nn.LSTM(len(self.tokens), n_hidden, n_layers, dropout=0.2, batch_first=True)   # batch_first=True --> (batch, seq, feature)\n",
        "        self.dropout = nn.Dropout(0.2)                                                             # Dropout layer to avoid overfitting\n",
        "        self.fc = nn.Linear(n_hidden, len(self.tokens)) \n",
        "\n",
        "    def forward(self, x, hidden):\n",
        "        lstm_out, hidden = self.lstm(x, hidden)      \n",
        "        out = self.dropout(lstm_out)  \n",
        "        out = out.contiguous().view(-1, self.n_hidden)       # Correct the view so we can pass it to the fc layer    \n",
        "        out = self.fc(out)   \n",
        "        return out, hidden   \n",
        "\n",
        "    def hidden_state(self, batch_size):\n",
        "        hidden = (torch.zeros(self.n_layers, batch_size, self.n_hidden).to(device), torch.zeros(self.n_layers, batch_size, self.n_hidden).to(device))        \n",
        "        return hidden"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ewD9UFMI-5zM",
        "outputId": "10e94f38-62c0-42d9-ebcc-ba037f4ac837"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model(\n",
            "  (lstm): LSTM(37, 50, num_layers=5, batch_first=True, dropout=0.2)\n",
            "  (dropout): Dropout(p=0.2, inplace=False)\n",
            "  (fc): Linear(in_features=50, out_features=37, bias=True)\n",
            ")\n"
          ]
        }
      ],
      "source": [
        "n_hidden=50\n",
        "n_layers=5\n",
        "model = Model(tokenSet, n_hidden, n_layers).to(device)\n",
        "print(model)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "-ZgQshvM-51W"
      },
      "outputs": [],
      "source": [
        "indx = int(len(encoded)*(1-0.1))\n",
        "train, test = encoded[:indx], encoded[indx:]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "MeQXcBdy-53h"
      },
      "outputs": [],
      "source": [
        "lr = 0.001\n",
        "optimizer = torch.optim.Adam(model.parameters(), lr=lr)\n",
        "loss_fn = nn.CrossEntropyLoss()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "qj3N-rsh-55p"
      },
      "outputs": [],
      "source": [
        "epochs = 50\n",
        "b = 0\n",
        "batch_size = 32\n",
        "seq_length = 40\n",
        "n_uni_tokens = len(model.tokens)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Nf9CSRVN-58t",
        "outputId": "255e59b8-2abe-4250-9231-08fe3933dfa2"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch:0   Loss:2.4478812217712402    Val_Loss: 2.4367823528520987\n",
            "Epoch:0   Loss:2.397529125213623    Val_Loss: 2.4335754423430473\n",
            "Epoch:1   Loss:2.4727389812469482    Val_Loss: 2.433168823068792\n",
            "Epoch:1   Loss:2.3781213760375977    Val_Loss: 2.433563644235784\n",
            "Epoch:1   Loss:2.3731837272644043    Val_Loss: 2.432621796925863\n",
            "Epoch:2   Loss:2.419724941253662    Val_Loss: 2.4332144260406494\n",
            "Epoch:2   Loss:2.38234281539917    Val_Loss: 2.4320300058885054\n",
            "Epoch:2   Loss:2.3845646381378174    Val_Loss: 2.432343345699888\n",
            "Epoch:3   Loss:2.413770914077759    Val_Loss: 2.432167371114095\n",
            "Epoch:3   Loss:2.3881001472473145    Val_Loss: 2.4314578663219106\n",
            "Epoch:3   Loss:2.395935297012329    Val_Loss: 2.431012168075099\n",
            "Epoch:4   Loss:2.066490650177002    Val_Loss: 2.122770916331898\n",
            "Epoch:4   Loss:1.9927459955215454    Val_Loss: 2.0292302695187656\n",
            "Epoch:4   Loss:1.909767746925354    Val_Loss: 1.9095187295566907\n",
            "Epoch:5   Loss:1.8683990240097046    Val_Loss: 1.8307336099220044\n",
            "Epoch:5   Loss:1.8253246545791626    Val_Loss: 1.768250129439614\n",
            "Epoch:5   Loss:1.7554601430892944    Val_Loss: 1.7071912216417717\n",
            "Epoch:6   Loss:1.665838599205017    Val_Loss: 1.6671366799961438\n",
            "Epoch:6   Loss:1.6894538402557373    Val_Loss: 1.611424901268699\n",
            "Epoch:6   Loss:1.5791950225830078    Val_Loss: 1.5737038200551814\n",
            "Epoch:7   Loss:1.5907959938049316    Val_Loss: 1.5554153232863455\n",
            "Epoch:7   Loss:1.6300824880599976    Val_Loss: 1.5269431959499011\n",
            "Epoch:7   Loss:1.5770856142044067    Val_Loss: 1.5049495913765647\n",
            "Epoch:8   Loss:1.5720138549804688    Val_Loss: 1.4854579441475146\n",
            "Epoch:8   Loss:1.5569610595703125    Val_Loss: 1.4724476445804944\n",
            "Epoch:8   Loss:1.554785966873169    Val_Loss: 1.4663172671289155\n",
            "Epoch:9   Loss:1.5133987665176392    Val_Loss: 1.4491464513720889\n",
            "Epoch:9   Loss:1.4305986166000366    Val_Loss: 1.4426292542255286\n",
            "Epoch:9   Loss:1.4684257507324219    Val_Loss: 1.4300569079139016\n",
            "Epoch:10   Loss:1.4188390970230103    Val_Loss: 1.4157339731852214\n",
            "Epoch:10   Loss:1.4419710636138916    Val_Loss: 1.40946199315967\n",
            "Epoch:10   Loss:1.384721040725708    Val_Loss: 1.397580255161632\n",
            "Epoch:11   Loss:1.41654634475708    Val_Loss: 1.3883007837064338\n",
            "Epoch:11   Loss:1.3904333114624023    Val_Loss: 1.3820509043606846\n",
            "Epoch:11   Loss:1.4586275815963745    Val_Loss: 1.3728780421343716\n",
            "Epoch:12   Loss:1.375343680381775    Val_Loss: 1.3639384363636826\n",
            "Epoch:12   Loss:1.3742454051971436    Val_Loss: 1.3669002670230288\n",
            "Epoch:12   Loss:1.397073745727539    Val_Loss: 1.352802251324509\n",
            "Epoch:13   Loss:1.3934072256088257    Val_Loss: 1.3453066999262029\n",
            "Epoch:13   Loss:1.4325308799743652    Val_Loss: 1.3402593027461658\n",
            "Epoch:13   Loss:1.3681142330169678    Val_Loss: 1.3335928049954502\n",
            "Epoch:14   Loss:1.391532301902771    Val_Loss: 1.325712460460085\n",
            "Epoch:14   Loss:1.3938188552856445    Val_Loss: 1.3243522933035186\n",
            "Epoch:14   Loss:1.3976542949676514    Val_Loss: 1.320815061077927\n",
            "Epoch:15   Loss:1.3122408390045166    Val_Loss: 1.3083531459172566\n",
            "Epoch:15   Loss:1.3766437768936157    Val_Loss: 1.3059051217454853\n",
            "Epoch:15   Loss:1.3821752071380615    Val_Loss: 1.3007517511194402\n",
            "Epoch:16   Loss:1.3749456405639648    Val_Loss: 1.303342985384392\n",
            "Epoch:16   Loss:1.3398717641830444    Val_Loss: 1.2890544443419485\n",
            "Epoch:16   Loss:1.371803879737854    Val_Loss: 1.286931366631479\n",
            "Epoch:17   Loss:1.3139231204986572    Val_Loss: 1.2808006207148235\n",
            "Epoch:17   Loss:1.2993075847625732    Val_Loss: 1.2796008948123816\n",
            "Epoch:17   Loss:1.3224818706512451    Val_Loss: 1.2747445034258293\n",
            "Epoch:18   Loss:1.3377876281738281    Val_Loss: 1.2621594342318447\n",
            "Epoch:18   Loss:1.308790922164917    Val_Loss: 1.2631520357998935\n",
            "Epoch:18   Loss:1.282043695449829    Val_Loss: 1.2571104837186409\n",
            "Epoch:19   Loss:1.287675380706787    Val_Loss: 1.2491646029732444\n",
            "Epoch:19   Loss:1.2612504959106445    Val_Loss: 1.2494058825752952\n",
            "Epoch:19   Loss:1.3208832740783691    Val_Loss: 1.246808749256712\n",
            "Epoch:20   Loss:1.321563720703125    Val_Loss: 1.2357449820547393\n",
            "Epoch:20   Loss:1.3177303075790405    Val_Loss: 1.2343095649372449\n",
            "Epoch:20   Loss:1.3225202560424805    Val_Loss: 1.2335013187292851\n",
            "Epoch:21   Loss:1.2139697074890137    Val_Loss: 1.2270549680247451\n",
            "Epoch:21   Loss:1.2930030822753906    Val_Loss: 1.2210990912986524\n",
            "Epoch:21   Loss:1.2349921464920044    Val_Loss: 1.2222727139790852\n",
            "Epoch:22   Loss:1.2727819681167603    Val_Loss: 1.2204428333224673\n",
            "Epoch:22   Loss:1.251737117767334    Val_Loss: 1.2120209354342837\n",
            "Epoch:22   Loss:1.1756250858306885    Val_Loss: 1.217354416847229\n",
            "Epoch:23   Loss:1.1615020036697388    Val_Loss: 1.210577509619973\n",
            "Epoch:23   Loss:1.1260591745376587    Val_Loss: 1.2007903438625913\n",
            "Epoch:23   Loss:1.2569440603256226    Val_Loss: 1.2016532276615952\n",
            "Epoch:24   Loss:1.1790010929107666    Val_Loss: 1.198254476894032\n",
            "Epoch:24   Loss:1.259543776512146    Val_Loss: 1.1913010568329783\n",
            "Epoch:24   Loss:1.1956613063812256    Val_Loss: 1.1909490570877537\n",
            "Epoch:25   Loss:1.225383996963501    Val_Loss: 1.1900091315760757\n",
            "Epoch:25   Loss:1.224839448928833    Val_Loss: 1.1833527557777637\n",
            "Epoch:25   Loss:1.246315360069275    Val_Loss: 1.1807034413019817\n",
            "Epoch:26   Loss:1.1159368753433228    Val_Loss: 1.1863908298087842\n",
            "Epoch:26   Loss:1.2507624626159668    Val_Loss: 1.1764589367490825\n",
            "Epoch:26   Loss:1.2100756168365479    Val_Loss: 1.1741059910167346\n",
            "Epoch:27   Loss:1.2295200824737549    Val_Loss: 1.180896672335538\n",
            "Epoch:27   Loss:1.1483367681503296    Val_Loss: 1.1684238693930886\n",
            "Epoch:27   Loss:1.1281635761260986    Val_Loss: 1.1669793634703665\n",
            "Epoch:28   Loss:1.2491518259048462    Val_Loss: 1.1695147716637813\n",
            "Epoch:28   Loss:1.1422770023345947    Val_Loss: 1.1689867395343203\n",
            "Epoch:28   Loss:1.1616076231002808    Val_Loss: 1.1636759981964573\n",
            "Epoch:29   Loss:1.1399993896484375    Val_Loss: 1.1654675982215188\n",
            "Epoch:29   Loss:1.1799471378326416    Val_Loss: 1.1512071869590066\n",
            "Epoch:29   Loss:1.1835120916366577    Val_Loss: 1.1488630229776555\n",
            "Epoch:30   Loss:1.1695852279663086    Val_Loss: 1.152283950285478\n",
            "Epoch:30   Loss:1.1846301555633545    Val_Loss: 1.1481275522347651\n",
            "Epoch:30   Loss:1.1656341552734375    Val_Loss: 1.1436985911745015\n",
            "Epoch:31   Loss:1.1814380884170532    Val_Loss: 1.1468719171755242\n",
            "Epoch:31   Loss:1.1826202869415283    Val_Loss: 1.1351815353740344\n",
            "Epoch:31   Loss:1.1461697816848755    Val_Loss: 1.1366309758388635\n",
            "Epoch:32   Loss:1.2029037475585938    Val_Loss: 1.1425342306946262\n",
            "Epoch:32   Loss:1.2175017595291138    Val_Loss: 1.135463985529813\n",
            "Epoch:32   Loss:1.1503111124038696    Val_Loss: 1.131368510650866\n",
            "Epoch:33   Loss:1.1082955598831177    Val_Loss: 1.134251142993118\n",
            "Epoch:33   Loss:1.1990070343017578    Val_Loss: 1.1332601308822632\n",
            "Epoch:34   Loss:1.1623079776763916    Val_Loss: 1.124818220283046\n",
            "Epoch:34   Loss:1.1502162218093872    Val_Loss: 1.1250599658850469\n",
            "Epoch:34   Loss:1.1908470392227173    Val_Loss: 1.1239967454563489\n",
            "Epoch:35   Loss:1.0370800495147705    Val_Loss: 1.117277412703543\n",
            "Epoch:35   Loss:1.1568022966384888    Val_Loss: 1.1184394431836677\n",
            "Epoch:35   Loss:1.133652925491333    Val_Loss: 1.1115469426819773\n",
            "Epoch:36   Loss:1.0962756872177124    Val_Loss: 1.113872022339792\n",
            "Epoch:36   Loss:1.1192667484283447    Val_Loss: 1.1197236198367495\n",
            "Epoch:36   Loss:1.098792314529419    Val_Loss: 1.117287440733476\n",
            "Epoch:37   Loss:1.075732707977295    Val_Loss: 1.1155074076219038\n",
            "Epoch:37   Loss:1.178707480430603    Val_Loss: 1.1225214329632847\n",
            "Epoch:37   Loss:1.1608102321624756    Val_Loss: 1.111224595344428\n",
            "Epoch:38   Loss:1.150028944015503    Val_Loss: 1.110920129400311\n",
            "Epoch:38   Loss:1.1663343906402588    Val_Loss: 1.1121529431054087\n",
            "Epoch:38   Loss:1.0933843851089478    Val_Loss: 1.1084286985975322\n",
            "Epoch:39   Loss:1.0480339527130127    Val_Loss: 1.1017359386790881\n",
            "Epoch:39   Loss:1.0767395496368408    Val_Loss: 1.1034384911710566\n",
            "Epoch:39   Loss:1.1086097955703735    Val_Loss: 1.1033324545080012\n",
            "Epoch:40   Loss:1.1005908250808716    Val_Loss: 1.1023282661582485\n",
            "Epoch:40   Loss:1.116679310798645    Val_Loss: 1.0993998538364063\n",
            "Epoch:40   Loss:1.1143015623092651    Val_Loss: 1.0940838853518169\n",
            "Epoch:41   Loss:1.0465247631072998    Val_Loss: 1.096439697525718\n",
            "Epoch:41   Loss:1.106850504875183    Val_Loss: 1.0913913105473374\n",
            "Epoch:41   Loss:1.1101346015930176    Val_Loss: 1.0869437510317022\n",
            "Epoch:42   Loss:1.1319453716278076    Val_Loss: 1.0896308096972378\n",
            "Epoch:42   Loss:1.0764477252960205    Val_Loss: 1.0934146624622922\n",
            "Epoch:42   Loss:1.1156558990478516    Val_Loss: 1.0883412325020991\n",
            "Epoch:43   Loss:1.123680830001831    Val_Loss: 1.0819405804980884\n",
            "Epoch:43   Loss:1.0796513557434082    Val_Loss: 1.0827225320266955\n",
            "Epoch:43   Loss:1.0819518566131592    Val_Loss: 1.0788446141011787\n",
            "Epoch:44   Loss:1.052112340927124    Val_Loss: 1.0804312752954888\n",
            "Epoch:44   Loss:1.0543402433395386    Val_Loss: 1.0803984367486201\n",
            "Epoch:44   Loss:1.0859259366989136    Val_Loss: 1.1018740336100261\n",
            "Epoch:45   Loss:1.062699794769287    Val_Loss: 1.0773638089497883\n",
            "Epoch:45   Loss:1.075348138809204    Val_Loss: 1.0809574976111904\n",
            "Epoch:45   Loss:1.0387556552886963    Val_Loss: 1.0792086846900708\n",
            "Epoch:46   Loss:1.0968056917190552    Val_Loss: 1.078494420557311\n",
            "Epoch:46   Loss:1.0415802001953125    Val_Loss: 1.081660422411832\n",
            "Epoch:46   Loss:1.0778882503509521    Val_Loss: 1.073304938547539\n",
            "Epoch:47   Loss:1.0188124179840088    Val_Loss: 1.0749411528760737\n",
            "Epoch:47   Loss:1.0996196269989014    Val_Loss: 1.0719504157702129\n",
            "Epoch:47   Loss:1.0240836143493652    Val_Loss: 1.0681560491070603\n",
            "Epoch:48   Loss:1.026750087738037    Val_Loss: 1.073982388684244\n",
            "Epoch:48   Loss:1.066455602645874    Val_Loss: 1.068391016035369\n",
            "Epoch:48   Loss:1.1607698202133179    Val_Loss: 1.0654359965613394\n",
            "Epoch:49   Loss:1.0857927799224854    Val_Loss: 1.0703898054180723\n",
            "Epoch:49   Loss:1.0751036405563354    Val_Loss: 1.0608520977424853\n",
            "Epoch:49   Loss:1.0846667289733887    Val_Loss: 1.0649585109768491\n"
          ]
        }
      ],
      "source": [
        "model.train()\n",
        "\n",
        "for i in range(epochs):\n",
        "    h = model.hidden_state(batch_size)\n",
        "    \n",
        "    for x, y in generate_batches(train, batch_size, seq_length):    # Creating input and target batches\n",
        "        b += 1\n",
        "\n",
        "        x = one_hot_encode(x, n_uni_tokens)                         # Creating one_hot_encoding of input\n",
        "        inputs, targets = torch.from_numpy(x), torch.from_numpy(y)  # Creating a Tensor from a numpy.ndarray\n",
        "        inputs, targets = inputs.to(device), targets.to(device)     # Using available device\n",
        "\n",
        "        h = tuple([each.data for each in h]) # Resetting the hidden state, if we don't reset it, it will backprop into all training\n",
        "\n",
        "        optimizer.zero_grad()\n",
        "        \n",
        "        output, h = model(inputs, h)     \n",
        "        loss = loss_fn(output, targets.view(batch_size*seq_length).long())  # Calculating the loss with correct shape of target\n",
        "        loss.backward()                                                     # Performs backpropagation\n",
        "        optimizer.step()     # Updates the value of parameters according to the optimization strategy\n",
        "        \n",
        "        if b % 100 == 0:\n",
        "            val_h = model.hidden_state(batch_size)\n",
        "            val_losses = []\n",
        "            model.eval()      # Changing to evaluation mode and doing the same process on test data\n",
        "\n",
        "            for x, y in generate_batches(test, batch_size, seq_length):\n",
        "                x = one_hot_encode(x, n_uni_tokens)\n",
        "                x, y = torch.from_numpy(x), torch.from_numpy(y)\n",
        "\n",
        "                val_h = tuple([each.data for each in val_h])\n",
        "                \n",
        "                inputs, targets = x, y\n",
        "                inputs, targets = inputs.to(device), targets.to(device)\n",
        "\n",
        "                output, val_h = model(inputs, val_h)\n",
        "                val_loss = loss_fn(output, targets.view(batch_size*seq_length).long())\n",
        "            \n",
        "                val_losses.append(val_loss.item())\n",
        "            \n",
        "            model.train()      # Changing back to evaluation mode\n",
        "            print(f\"Epoch:{i}   Loss:{loss.item()}    Val_Loss: {np.mean(val_losses)}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Nk3qv3J__ECz"
      },
      "outputs": [],
      "source": [
        "def predict(model, token, hidden=None, top_k=1):\n",
        "\n",
        "  encoded_text = model.token2int[token]                           # Encode the token                  \n",
        "  encoded_text = np.array([[encoded_text]])\n",
        "  encoded_text = one_hot_encode(encoded_text, len(model.tokens))  # one-hot-encode the token\n",
        "  encoded_text = torch.from_numpy(encoded_text)\n",
        "  encoded_text = encoded_text.to(device)\n",
        "\n",
        "  hidden = tuple([state.data for state in hidden])\n",
        "  out, hidden = model(encoded_text, hidden)                       # Run the model\n",
        "\n",
        "  probs = F.softmax(out, dim=1).data                              # Convert out to probabilities\n",
        "  probs = probs.cpu()\n",
        "\n",
        "  probs, index = probs.topk(top_k)                            # Returns the top ks\n",
        "  \n",
        "  index = index.numpy().squeeze()\n",
        "  probs = probs.numpy().squeeze()\n",
        "\n",
        "  token = np.random.choice(index, p=probs/probs.sum())   # Convert probabilities per index and chose token based on that\n",
        "  \n",
        "  return model.int2token[token], hidden"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "rBwtQxHcBNwh"
      },
      "outputs": [],
      "source": [
        "\n",
        "  def sample(model, size, prime='The', top_k=None):\n",
        "\n",
        "    \n",
        "    model.eval() # eval mode\n",
        "    \n",
        "    # First off, run through the prime characters\n",
        "    chars = [ch for ch in prime]\n",
        "    # if used approach 1 instead of reading chars we need to tokenize\n",
        "    # tokenized_prefix = smi_tokenizer(prefix)          # Converting prefix to a tokenized version\n",
        "    # output_tokens = [c for c in tokenized_prefix.split(\" \")]\n",
        "\n",
        "    h = model.hidden_state(1)\n",
        "    for ch in prime:\n",
        "        char, h = predict(model, ch, h, top_k=top_k)\n",
        "    chars.append(char)\n",
        "    \n",
        "    # Now pass in the previous character and get a new one\n",
        "    for ii in range(size):\n",
        "        char, h = predict(model, chars[-1], h, top_k=top_k)\n",
        "        chars.append(char)\n",
        "    return ''.join(chars)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "2czU4-dG_flS"
      },
      "outputs": [],
      "source": [
        "def result(prefix):\n",
        " \n",
        "  while len(s)<6:\n",
        "    result = sample(model, 2, prime=prefix, top_k=5)\n",
        "    mol = Chem.MolFromSmiles(result)\n",
        "    if result not in s and mol:\n",
        "      print(f'SMI:  {result}')\n",
        "      s.add(str(result))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kA956Y5o_fnZ",
        "outputId": "391fad11-a7b0-4b9a-80df-19653859fe41"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Please enter your prefix: CCc1ccc\n",
            "SMI:  CCc1cccnc1\n",
            "SMI:  CCc1ccccc1\n",
            "SMI:  CCc1ccccn1\n",
            "SMI:  CCc1cccnn1\n",
            "SMI:  CCc1cccn1C\n",
            "SMI:  CCc1cccn1O\n"
          ]
        }
      ],
      "source": [
        "prefix = input('Please enter your prefix: ')\n",
        "s = set()\n",
        "result(prefix)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "WTO56Rjy_fpt",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 167
        },
        "outputId": "6c4aebb4-9f0d-4091-f8ca-ef46bc901677"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<rdkit.Chem.rdchem.Mol at 0x7f7d13984120>"
            ],
            "image/png": "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\n"
          },
          "metadata": {},
          "execution_count": 21
        }
      ],
      "source": [
        "Chem.MolFromSmiles('CCc1cccnc1')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ET_swb6z_fsC",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 167
        },
        "outputId": "e11d5a96-94e0-4b70-eeed-f22a6c9c42a3"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<rdkit.Chem.rdchem.Mol at 0x7f7d139fb430>"
            ],
            "image/png": "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\n"
          },
          "metadata": {},
          "execution_count": 22
        }
      ],
      "source": [
        "Chem.MolFromSmiles('CCc1ccccc1')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "pupQuGMT_EFK",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 167
        },
        "outputId": "8e4f343a-08f8-41c5-ba8e-1f7c4d31cde2"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<rdkit.Chem.rdchem.Mol at 0x7f7d139fb580>"
            ],
            "image/png": "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\n"
          },
          "metadata": {},
          "execution_count": 23
        }
      ],
      "source": [
        "Chem.MolFromSmiles('CCc1ccccn1')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "GxGxrGyH_EHq",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 167
        },
        "outputId": "269a9067-481a-43a4-dae1-ce1e0fdb2e66"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<rdkit.Chem.rdchem.Mol at 0x7f7d139fb120>"
            ],
            "image/png": "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\n"
          },
          "metadata": {},
          "execution_count": 24
        }
      ],
      "source": [
        "Chem.MolFromSmiles('CCc1cccnn1')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "uZSfmgTz-5_i",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 167
        },
        "outputId": "35d14511-0d3f-4f85-a5c6-944698abe276"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<rdkit.Chem.rdchem.Mol at 0x7f7d139fb3c0>"
            ],
            "image/png": "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\n"
          },
          "metadata": {},
          "execution_count": 25
        }
      ],
      "source": [
        "Chem.MolFromSmiles('CCc1cccn1C')"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "Chem.MolFromSmiles('CCc1cccn1O')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 167
        },
        "id": "sEOdBghhRya3",
        "outputId": "d28b3f8e-4aa4-43bf-c348-523632eb1375"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<rdkit.Chem.rdchem.Mol at 0x7f7d139fb270>"
            ],
            "image/png": "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\n"
          },
          "metadata": {},
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "0Br1I3zyeBbb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "lkVUKT_CeaX8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##**Method 2:** Classic database query using Trie\n",
        "\n",
        "I was interested in exploring other methods on this dataset such as trie so used pygtrie"
      ],
      "metadata": {
        "id": "B2YORyOsIM6p"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "pip install pygtrie"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ovxdUxzOINdQ",
        "outputId": "c7b8fe18-ef37-4943-c632-2c99265046fe"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Collecting pygtrie\n",
            "  Downloading pygtrie-2.5.0-py3-none-any.whl (25 kB)\n",
            "Installing collected packages: pygtrie\n",
            "Successfully installed pygtrie-2.5.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "zinc_df = pd.read_csv('SMILES_Keyboard.csv')\n",
        "zinc_df = zinc_df.loc[zinc_df['SMILES'].str.len()<50][['SMILES', 'NAME']].reset_index(drop=True)"
      ],
      "metadata": {
        "id": "f24_x-cdI-tB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import pygtrie\n",
        "trie = pygtrie.CharTrie()\n",
        "for smile in zinc_df.SMILES:\n",
        "  trie[smile] = True\n",
        "trie['exit'] = False"
      ],
      "metadata": {
        "id": "xoe3Z3bpIp5i"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def find_topK(trie, text, k=5):\n",
        "  value = trie.get(text)\n",
        "  if value is not None:\n",
        "      print(repr(text), 'is a smile in database')\n",
        "  if trie.has_subtrie(text):\n",
        "      print(repr(text), 'is a prefix of a smile')\n",
        "  else:\n",
        "      print(repr(text), 'is not a prefix, going back to empty string')\n",
        "      return None\n",
        "  candidates = trie.keys(text)\n",
        "  # because with a few prefixes it is likely to predict smaller extensions\n",
        "  hits = sorted(candidates, key=len)[:k]\n",
        "  for hit in hits:\n",
        "    print(f\"\\t {hit}\")"
      ],
      "metadata": {
        "id": "jGM0gOWoIqCv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "text = 'CCc1ccc'\n",
        "find_topK(trie, text, k=5)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2TBN3FnIIunS",
        "outputId": "250ec31c-9d48-44d4-9cfa-7c747a975330"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "'CCc1ccc' is a prefix of a smile\n",
            "\t CCc1ccc(Cl)oc1=O\n",
            "\t CCc1ccc(=O)oc1Cl\n",
            "\t CCc1ccccc1N1CCNCC1\n",
            "\t CCc1ccccc1OCC1=NCCN1\n",
            "\t CCc1cccc(C2=NCCN2)c1\n"
          ]
        }
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "gpuClass": "standard",
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "nbformat": 4,
  "nbformat_minor": 0
}