03_gen_SMILES_LSTM/SMILES_LSTM_Walkthrough.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "id": "2e3bc9ac",
      "metadata": {
        "id": "2e3bc9ac"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/schwallergroup/ai4chem_course/blob/smiles_lstm/notebooks/06%20-%20Generative%20Models%202/SMILES-LSTM-Walkthrough.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "id": "35ef2541",
      "metadata": {
        "id": "35ef2541",
        "outputId": "3df87e3f-61d9-4ab3-b46b-30fc12fdad58",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "--2024-06-02 09:29:15--  https://raw.githubusercontent.com/schwallergroup/ai4chem_course/smiles_lstm/notebooks/06%20-%20Generative%20Models%202/utils.py\n",
            "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.108.133, 185.199.109.133, 185.199.110.133, ...\n",
            "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.108.133|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 582 [text/plain]\n",
            "Saving to: ‘utils.py’\n",
            "\n",
            "\rutils.py              0%[                    ]       0  --.-KB/s               \rutils.py            100%[===================>]     582  --.-KB/s    in 0s      \n",
            "\n",
            "2024-06-02 09:29:15 (33.0 MB/s) - ‘utils.py’ saved [582/582]\n",
            "\n",
            "--2024-06-02 09:29:15--  https://raw.githubusercontent.com/schwallergroup/ai4chem_course/smiles_lstm/notebooks/06%20-%20Generative%20Models%202/pretrained.zinc.rnn.pth\n",
            "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.111.133, 185.199.108.133, 185.199.109.133, ...\n",
            "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.111.133|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 25454495 (24M) [application/octet-stream]\n",
            "Saving to: ‘pretrained.rnn.pth’\n",
            "\n",
            "pretrained.rnn.pth  100%[===================>]  24.27M   159MB/s    in 0.2s    \n",
            "\n",
            "2024-06-02 09:29:15 (159 MB/s) - ‘pretrained.rnn.pth’ saved [25454495/25454495]\n",
            "\n",
            "fatal: destination path 'dl-chem-101' already exists and is not an empty directory.\n"
          ]
        }
      ],
      "source": [
        "# download a utils.py file containing some utility functions we will need\n",
        "!wget https://raw.githubusercontent.com/schwallergroup/ai4chem_course/smiles_lstm/notebooks/06%20-%20Generative%20Models%202/utils.py -O utils.py\n",
        "# download the pre-trained RNN model\n",
        "!wget https://raw.githubusercontent.com/schwallergroup/ai4chem_course/smiles_lstm/notebooks/06%20-%20Generative%20Models%202/pretrained.zinc.rnn.pth -O pretrained.rnn.pth\n",
        "# clone RNN generative model repository\n",
        "!git clone https://github.com/rociomer/dl-chem-101.git"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "id": "1969b1b2",
      "metadata": {
        "id": "1969b1b2"
      },
      "outputs": [],
      "source": [
        "# -------------------------------------------------------------------------------------\n",
        "# -------------------------------------------------------------------------------------\n",
        "# -------------------------------------------------------------------------------------\n",
        "# WARNING: stop here for a moment - let us know when the above cell is finished running\n",
        "# -------------------------------------------------------------------------------------\n",
        "# -------------------------------------------------------------------------------------\n",
        "# -------------------------------------------------------------------------------------"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "id": "d759b152",
      "metadata": {
        "id": "d759b152",
        "outputId": "95a4a12c-feb8-4eea-a488-701b0e1a88ab",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "/content/dl-chem-101\n",
            "/content/dl-chem-101/03_gen_SMILES_LSTM\n",
            "Obtaining file:///content/dl-chem-101/03_gen_SMILES_LSTM\n",
            "  Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "Installing collected packages: smiles-lstm\n",
            "  Attempting uninstall: smiles-lstm\n",
            "    Found existing installation: smiles-lstm 1.0.0\n",
            "    Uninstalling smiles-lstm-1.0.0:\n",
            "      Successfully uninstalled smiles-lstm-1.0.0\n",
            "  Running setup.py develop for smiles-lstm\n",
            "Successfully installed smiles-lstm-1.0.0\n"
          ]
        }
      ],
      "source": [
        "# need to install the RNN repository as a package\n",
        "%cd dl-chem-101\n",
        "%cd 03_gen_SMILES_LSTM\n",
        "!pip install -e ."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "id": "07e26381",
      "metadata": {
        "id": "07e26381",
        "outputId": "8a232685-40c0-455d-a156-13abf4d65ca2",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "/content\n"
          ]
        }
      ],
      "source": [
        "%cd ../.."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "id": "43b296f4",
      "metadata": {
        "id": "43b296f4",
        "outputId": "b71917d8-b2e6-43ab-99f2-63bf10aaa6c6",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: torch in /usr/local/lib/python3.10/dist-packages (2.3.0+cu121)\n",
            "Requirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from torch) (3.14.0)\n",
            "Requirement already satisfied: typing-extensions>=4.8.0 in /usr/local/lib/python3.10/dist-packages (from torch) (4.11.0)\n",
            "Requirement already satisfied: sympy in /usr/local/lib/python3.10/dist-packages (from torch) (1.12)\n",
            "Requirement already satisfied: networkx in /usr/local/lib/python3.10/dist-packages (from torch) (3.3)\n",
            "Requirement already satisfied: jinja2 in /usr/local/lib/python3.10/dist-packages (from torch) (3.1.4)\n",
            "Requirement already satisfied: fsspec in /usr/local/lib/python3.10/dist-packages (from torch) (2023.6.0)\n",
            "Requirement already satisfied: nvidia-cuda-nvrtc-cu12==12.1.105 in /usr/local/lib/python3.10/dist-packages (from torch) (12.1.105)\n",
            "Requirement already satisfied: nvidia-cuda-runtime-cu12==12.1.105 in /usr/local/lib/python3.10/dist-packages (from torch) (12.1.105)\n",
            "Requirement already satisfied: nvidia-cuda-cupti-cu12==12.1.105 in /usr/local/lib/python3.10/dist-packages (from torch) (12.1.105)\n",
            "Requirement already satisfied: nvidia-cudnn-cu12==8.9.2.26 in /usr/local/lib/python3.10/dist-packages (from torch) (8.9.2.26)\n",
            "Requirement already satisfied: nvidia-cublas-cu12==12.1.3.1 in /usr/local/lib/python3.10/dist-packages (from torch) (12.1.3.1)\n",
            "Requirement already satisfied: nvidia-cufft-cu12==11.0.2.54 in /usr/local/lib/python3.10/dist-packages (from torch) (11.0.2.54)\n",
            "Requirement already satisfied: nvidia-curand-cu12==10.3.2.106 in /usr/local/lib/python3.10/dist-packages (from torch) (10.3.2.106)\n",
            "Requirement already satisfied: nvidia-cusolver-cu12==11.4.5.107 in /usr/local/lib/python3.10/dist-packages (from torch) (11.4.5.107)\n",
            "Requirement already satisfied: nvidia-cusparse-cu12==12.1.0.106 in /usr/local/lib/python3.10/dist-packages (from torch) (12.1.0.106)\n",
            "Requirement already satisfied: nvidia-nccl-cu12==2.20.5 in /usr/local/lib/python3.10/dist-packages (from torch) (2.20.5)\n",
            "Requirement already satisfied: nvidia-nvtx-cu12==12.1.105 in /usr/local/lib/python3.10/dist-packages (from torch) (12.1.105)\n",
            "Requirement already satisfied: triton==2.3.0 in /usr/local/lib/python3.10/dist-packages (from torch) (2.3.0)\n",
            "Requirement already satisfied: nvidia-nvjitlink-cu12 in /usr/local/lib/python3.10/dist-packages (from nvidia-cusolver-cu12==11.4.5.107->torch) (12.5.40)\n",
            "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.10/dist-packages (from jinja2->torch) (2.1.5)\n",
            "Requirement already satisfied: mpmath>=0.19 in /usr/local/lib/python3.10/dist-packages (from sympy->torch) (1.3.0)\n",
            "Requirement already satisfied: rdkit in /usr/local/lib/python3.10/dist-packages (2023.9.6)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (from rdkit) (1.25.2)\n",
            "Requirement already satisfied: Pillow in /usr/local/lib/python3.10/dist-packages (from rdkit) (9.4.0)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (1.25.2)\n"
          ]
        }
      ],
      "source": [
        "!pip install torch\n",
        "!pip install rdkit\n",
        "!pip install numpy"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "id": "9872fef6",
      "metadata": {
        "id": "9872fef6"
      },
      "outputs": [],
      "source": [
        "# restart run-time"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "05c12dab",
      "metadata": {
        "id": "05c12dab"
      },
      "source": [
        "# Generative SMILES Model: Details\n",
        "\n",
        "This Jupyter notebook accompanies the generative SMILES model codebase adapted from `REINVENT`. See the following publications for details on `REINVENT`:\n",
        "\n",
        "* https://jcheminf.biomedcentral.com/articles/10.1186/s13321-017-0235-x\n",
        "\n",
        "* https://pubs.acs.org/doi/full/10.1021/acscentsci.7b00512\n",
        "\n",
        "* https://pubs.acs.org/doi/10.1021/acs.jcim.0c00915\n",
        "\n",
        "The content here is an attempt to breakdown how each component of the generative SMILES model comes together."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "id": "05d9d669",
      "metadata": {
        "id": "05d9d669"
      },
      "outputs": [],
      "source": [
        "import re\n",
        "import numpy as np\n",
        "\n",
        "import torch\n",
        "from torch import nn\n",
        "import torch.nn.functional as F\n",
        "\n",
        "import warnings\n",
        "# ignore some deprecation warnings\n",
        "warnings.filterwarnings('ignore')"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "2117c4a8",
      "metadata": {
        "id": "2117c4a8"
      },
      "source": [
        "## SMILES Vocabulary: How is it generated?\n",
        "\n",
        "The model's `Vocabulary` handles the transformation of SMILES strings into a sequence of tokens. Tokens are the pre-defined lowest and indivisible unit of string text. In `Natural Language Processing (NLP)`, tokens are typically defined on the word or character level. The level of tokenization dictates ***what*** the model can output, e.g., if tokenization on the character level is used, then the model outputs individual characters.\n",
        "\n",
        "For generative SMILES models, tokenization is performed on the character level where each token ***loosely*** maps to a unique atom type (brackets, \"(\" for example indicate branching and thus, do not map to an atom but rather gives connectivity information)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "id": "16029ad8",
      "metadata": {
        "id": "16029ad8"
      },
      "outputs": [],
      "source": [
        "from smiles_lstm.model.smiles_vocabulary import Vocabulary, SMILESTokenizer"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "8d06b8b4",
      "metadata": {
        "id": "8d06b8b4"
      },
      "source": [
        "Let's first explore how SMILES strings are tokenized which constitutes **Data Preparation** and is thus the first step in training our generative SMILES model. The most important part of the code are the ***rules*** denoting ***how*** to tokenize the SMILES. It is based on **regular expressions (regexp)** which perform pattern matching. The code below is from the `SMILESTokenizer` class."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "id": "114172da",
      "metadata": {
        "id": "114172da"
      },
      "outputs": [],
      "source": [
        "REGEXPS = {\n",
        "        \"brackets\": re.compile(r\"(\\[[^\\]]*\\])\"),\n",
        "        \"2_ring_nums\": re.compile(r\"(%\\d{2})\"),\n",
        "        \"brcl\": re.compile(r\"(Br|Cl)\")\n",
        "    }\n",
        "REGEXP_ORDER = [\"brackets\", \"2_ring_nums\", \"brcl\"]\n",
        "\n",
        "def tokenize(data, with_begin_and_end=True):\n",
        "    \"\"\"Tokenizes a SMILES string.\"\"\"\n",
        "    def split_by(data, regexps):\n",
        "        if not regexps:\n",
        "            return list(data)\n",
        "        regexp = REGEXPS[regexps[0]]\n",
        "        splitted = regexp.split(data)\n",
        "        tokens = []\n",
        "        for i, split in enumerate(splitted):\n",
        "            if i % 2 == 0:\n",
        "                tokens += split_by(split, regexps[1:])\n",
        "            else:\n",
        "                tokens.append(split)\n",
        "        return tokens\n",
        "\n",
        "    tokens = split_by(data, REGEXP_ORDER)\n",
        "\n",
        "    # if true, the token set is enriched by \"^\" and \"$\" denoting the start and end of the embedding, respectively\n",
        "    if with_begin_and_end:\n",
        "        tokens = [\"^\"] + tokens + [\"$\"]\n",
        "    return tokens"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "4dcdc6eb",
      "metadata": {
        "id": "4dcdc6eb"
      },
      "source": [
        "The **REGEXPS** variable holds the patterns in which the SMILES are to be tokenized. Let's illustrate each pattern and the chemistry rationale. Below is a visual of the **\"brackets\"** pattern (*generated using debuggex*):\n",
        "\n",
        "<div>\n",
        "<img src=\"data:image/png;base64,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\" width=\"500\">\n",
        "</div>\n",
        "\n",
        "This regexp pattern groups characters within square brackets together which can represent charged atoms in the SMILES syntax. This is relevant in chemistry for example with positively charged nitrogen atoms:\n",
        "\n",
        "<div>\n",
        "<img src=\"data:image/png;base64,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\" width=150>\n",
        "</div>\n",
        "\n",
        "Let's now tokenize the SMILES."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "id": "9dfbcb6b",
      "metadata": {
        "id": "9dfbcb6b",
        "outputId": "b6fe0948-136a-41c1-8ba2-67b269eb90d8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['C', '[NH+]', 'C']\n"
          ]
        }
      ],
      "source": [
        "charged_nitrogen_smiles = 'C[NH+]C'\n",
        "# [NH+] is its own token which means it is part of the generative model's vocabulary\n",
        "# therefore, the generative model will learn to output positively charged nitrogen atoms\n",
        "# the \"with_begin_and_end\" boolean denotes whether to add a \"start\" and \"end\" token to the tokenized SMILES.\n",
        "# it is set to false here to strictly illustrate tokenization of only the SMILES itself\n",
        "print(tokenize(charged_nitrogen_smiles, with_begin_and_end=False))"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "90a73e22",
      "metadata": {
        "id": "90a73e22"
      },
      "source": [
        "Let's perform the same illustration for the other 2 regexp patterns. Below is a visual of the \"2_ring_nums\" pattern:\n",
        "\n",
        "<div>\n",
        "<img src=\"data:image/png;base64,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\" width=500>\n",
        "</div>\n",
        "\n",
        "\"Numbers\" in SMILES strings can indicate either explicit hydrogens or ring closing. This is relevant in chemistry for example with explicit hydrogens such as \"CH3\" which would indicate there are 3 hydrogens attached to the carbon. Typically, however, hydrogens are implicitly expressed. This regex pattern is related to ring numbering and closing. Rings are distinguished by numbering. For molecules with over 10 rings, the percent (\"%\") symbol is used, e.g. \"%10\" means the tenth ring in the molecule. **This regex pattern matches \"numbers\" up to 2 digits**, for example, a molecule with 10 rings. As an extreme example (and as an excuse to use one of my favourite molecules), below is the structure of buckminsterfullerene or \"bucky ball\":\n",
        "\n",
        "<div>\n",
        "<img src=\"data:image/png;base64,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\" width=200>\n",
        "</div>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "id": "aa367732",
      "metadata": {
        "id": "aa367732",
        "outputId": "209b1117-a06e-40d5-d015-5e341b615265",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['C', '1', '2', '=', 'C', '3', 'C', '4', '=', 'C', '5', 'C', '6', '=', 'C', '1', 'C', '7', '=', 'C', '8', 'C', '9', '=', 'C', '1', 'C', '%10', '=', 'C', '%11', 'C', '(', '=', 'C', '2', '9', ')', 'C', '3', '=', 'C', '2', 'C', '3', '=', 'C', '4', 'C', '4', '=', 'C', '5', 'C', '5', '=', 'C', '9', 'C', '6', '=', 'C', '7', 'C', '6', '=', 'C', '7', 'C', '8', '=', 'C', '1', 'C', '1', '=', 'C', '8', 'C', '%10', '=', 'C', '%10', 'C', '%11', '=', 'C', '2', 'C', '2', '=', 'C', '3', 'C', '3', '=', 'C', '4', 'C', '4', '=', 'C', '5', 'C', '5', '=', 'C', '%11', 'C', '%12', '=', 'C', '(', 'C', '6', '=', 'C', '9', '5', ')', 'C', '7', '=', 'C', '1', 'C', '1', '=', 'C', '%12', 'C', '5', '=', 'C', '%11', 'C', '4', '=', 'C', '3', 'C', '3', '=', 'C', '5', 'C', '(', '=', 'C', '8', '1', ')', 'C', '%10', '=', 'C', '2', '3']\n"
          ]
        }
      ],
      "source": [
        "# notice the numbers in the smiles\n",
        "bucky_ball_smiles = 'C12=C3C4=C5C6=C1C7=C8C9=C1C%10=C%11C(=C29)C3=C2C3=C4C4=C5C5=C9C6=C7C6=C7C8=C1C1=C8C%10=C%10C%11=C2C2=C3C3=C4C4=C5C5=C%11C%12=C(C6=C95)C7=C1C1=C%12C5=C%11C4=C3C3=C5C(=C81)C%10=C23'\n",
        "\n",
        "# the tokenized form has many \"double digit\" numbers which are their own individual tokens\n",
        "print(tokenize(bucky_ball_smiles, with_begin_and_end=False))"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "183b0c02",
      "metadata": {
        "id": "183b0c02"
      },
      "source": [
        "A quick note is that such large molecules are typically removed from the training data as they are far too large to be reasonable drug molecules (there are of course exceptions).\n",
        "\n",
        "The last regex pattern is \"brcl\":\n",
        "\n",
        "<div>\n",
        "<img src=\"data:image/png;base64,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\" width=500>\n",
        "</div>\n",
        "\n",
        "This regexp pattern simply matches bromine and chlorine (\"Br\" and \"Cl\") and ensures they are their own unique token. These halogen atoms are quintessential in drug molecules. Below is an example of a molecule containing bromine (bromoethane):\n",
        "\n",
        "<div>\n",
        "<img src=\"data:image/png;base64,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\" width=150>\n",
        "</div>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "id": "3952c4d4",
      "metadata": {
        "id": "3952c4d4",
        "outputId": "b78d5fbf-7436-41d7-8cf6-61fdea022c7b",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['C', 'C', 'Br']\n"
          ]
        }
      ],
      "source": [
        "bromoethane_smiles = 'CCBr'\n",
        "# as expected \"Br\" is its own token\n",
        "print(tokenize(bromoethane_smiles, with_begin_and_end=False))"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "51f1696f",
      "metadata": {
        "id": "51f1696f"
      },
      "source": [
        "## Constructing the Generative Model's SMILES Vocabulary"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "50ab6c57",
      "metadata": {
        "id": "50ab6c57"
      },
      "source": [
        "The previous section focused on how a SMILES string is tokenized. In order to use these tokenized SMILES, we must create the `Vocabulary`. Much like in a natural language like english where one's vocabulary controls what sentences can be formulated, a molecular generative model's vocabulary controls what kind of atoms can be proposed - sentences in this context are molecules.\n",
        "\n",
        "The below method is in `vocabulary.py`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "id": "5fee113d",
      "metadata": {
        "id": "5fee113d"
      },
      "outputs": [],
      "source": [
        "def create_vocabulary(smiles_list, tokenizer):\n",
        "    \"\"\"Creates a vocabulary for the SMILES syntax.\"\"\"\n",
        "    tokens = set()\n",
        "    for smi in smiles_list:\n",
        "        tokens.update(tokenize(data=smi, with_begin_and_end=False))\n",
        "\n",
        "    vocabulary = Vocabulary()\n",
        "    vocabulary.update([\"$\", \"^\"] + sorted(tokens))  # end token is 0 (also counts as padding)\n",
        "    return vocabulary"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "id": "f6cae87a",
      "metadata": {
        "id": "f6cae87a"
      },
      "outputs": [],
      "source": [
        "# example dataset containing the 3 molecules from the previous section\n",
        "# notice the \"bucky ball\" was included. It is not a reasonable drug molecule but it is included\n",
        "# here to illustrate a consequence of having exceptionally large molecules in your dataset\n",
        "smiles_dataset = ['C[NH+](C)C',\n",
        "                  'C12=C3C4=C5C6=C1C7=C8C9=C1C%10=C%11C(=C29)C3=C2C3=C4C4=C5C5=C9C6=C7C6=C7C8=C1C1=C8C%10=C%10C%11=C2C2=C3C3=C4C4=C5C5=C%11C%12=C(C6=C95)C7=C1C1=C%12C5=C%11C4=C3C3=C5C(=C81)C%10=C23',\n",
        "                  'CCBr'\n",
        "                 ]\n",
        "\n",
        "vocabulary = create_vocabulary(smiles_list=smiles_dataset, tokenizer=SMILESTokenizer)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "b45df826",
      "metadata": {
        "id": "b45df826"
      },
      "source": [
        "We've now created a `Vocabulary` object using the example SMILES dataset. Let's take a closer look:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "id": "c675b70f",
      "metadata": {
        "id": "c675b70f",
        "outputId": "511f3560-e72b-4f7e-8036-dbc659904478",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "There are 20 unique tokens in the vocabulary.\n",
            "\n",
            "The unique tokens are: \n",
            "['$', '^', '%10', '%11', '%12', '(', ')', '1', '2', '3', '4', '5', '6', '7', '8', '9', '=', 'Br', 'C', '[NH+]']\n"
          ]
        }
      ],
      "source": [
        "print(f'There are {len(vocabulary)} unique tokens in the vocabulary.\\n')\n",
        "print(f'The unique tokens are: \\n{vocabulary.tokens()}')"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "dfef5b22",
      "metadata": {
        "id": "dfef5b22"
      },
      "source": [
        "A `Vocabulary` containing 20 tokens means the generative model will be able to output 20 tokens. The specific tokens are shown above. The \"bucky ball\" was included in the example dataset to show that exceptionally large molecules may contain **\"rare\" tokens which make the vocabulary larger**. In addition to the \"bucky ball\" not being a type of molecule we would typically want to generate (it is not very \"drug-like\"), the **\"rare\" tokens** such as \"%10\" are rare because typical drug molecules would not contain these tokens.\n",
        "\n",
        "\n",
        "**The important consequence is that a larger vocabulary makes the generative model slower. This could be acceptable if we indeed want to generate exceptionally large molecules. However, for drug discovery, such molecules are often removed from the dataset for 2 reasons:**\n",
        "\n",
        "1) Ensures all SMILES in the dataset are reasonable (\"drug-likeness\"). This affects the \"type\" of molecules the generative model outputs as ***the goal when training the generative model is to learn the underlying probability distribution of the dataset.*** This will be elaborated in the model details section.\n",
        "\n",
        "2) Eliminate \"rare\" tokens that slow the model down. \"Rare\" tokens are tokens with very few occurrences in the training set. The details into why this slows the model will be elaborated in the model details section."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "b5935ae6",
      "metadata": {
        "id": "b5935ae6"
      },
      "source": [
        "Finally, in order for the token representations of SMILES sequences to be passed into a machine learning model, they must be transformed into a numerical representation. This is done in the `Vocabulary` class where each unique token is mapped to a numerical index. This is shown below:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "id": "709b7766",
      "metadata": {
        "id": "709b7766",
        "outputId": "d7925eb2-1f3d-434c-94ea-09de1fb6894d",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['C', 'C', 'Br']"
            ]
          },
          "metadata": {},
          "execution_count": 16
        }
      ],
      "source": [
        "# bromoethane has the SMILES sequence \"CCBr\"\n",
        "bromoethane_smiles = 'CCBr'\n",
        "# recall its tokenized form\n",
        "tokenized_bromoethane = tokenize(bromoethane_smiles, with_begin_and_end=False)\n",
        "tokenized_bromoethane"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "febbe3d9",
      "metadata": {
        "id": "febbe3d9"
      },
      "source": [
        "Cross-referencing the unique tokens list above, we can see that \"Br\" and \"C\" are located at indices 17 and 18, respectively. Let's show this:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "id": "a7635006",
      "metadata": {
        "id": "a7635006",
        "outputId": "53c5710a-c9c3-4418-8ad3-c009ece2d5be",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([18., 18., 17.], dtype=float32)"
            ]
          },
          "metadata": {},
          "execution_count": 17
        }
      ],
      "source": [
        "# the \"encode\" method in the Vocabulary class takes a list of tokens and returns its numerical indices\n",
        "# the indices are what we expect\n",
        "vocabulary.encode(tokenized_bromoethane)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "d907dd67",
      "metadata": {
        "id": "d907dd67"
      },
      "source": [
        "Exactly ***how*** this numerical representation is used in the generative model will be elaborated in the `RNN Sampling: Step-by-Step` section. Let's first discuss what a Recurrent Neural Network using SMILES means."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "c928662b",
      "metadata": {
        "id": "c928662b"
      },
      "source": [
        "## What is a Recurrent Neural Network (RNN) using SMILES?"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "e1b475ab",
      "metadata": {
        "id": "e1b475ab"
      },
      "source": [
        "The molecular generative model uses a Recurrent Neural Network (RNN) ***which is tasked to learn the underlying probability distribution of the SMILES sequences in the dataset.*** The following section attempts to deconvolute what this exactly means.\n",
        "\n",
        "### High Level Idea\n",
        "* We want our model to be able to generate **valid** SMILES. Valid SMILES are those that can be parsed successfully and transformed into a 2D molecular representation (for example, through RDKit which is a Python cheminformatics library)\n",
        "\n",
        "\n",
        "* **Goal**: Teach the RNN the SMILES syntax via the following steps:\n",
        "\n",
        "1) Create a SMILES dataset (training data). Open-source databases like ChEMBL (https://www.ebi.ac.uk/chembl/) and ZINC (https://zinc.docking.org/) curate large collections of \"drug-like\" molecules\n",
        "\n",
        "2) The SMILES dataset will be passed to the RNN and the task is for the RNN to **reproduce** these SMILES\n",
        "\n",
        "**Note:** This is what learning the underlying probability distribution of the SMILES sequences in the training set means. The RNN outputs 1 token at a time and successfully reproducing the training set SMILES teaches the model the SMILES syntax. By contrast, an untrained RNN would just output random sequences of tokens with no chemical meaning.\n",
        "\n",
        "As a concrete example (also the example given by Marwin Segler in the following publication: https://pubs.acs.org/doi/full/10.1021/acscentsci.7b00512), consider the model has produced the following sequence thus far:\n",
        "\n",
        "**c1ccccc**\n",
        "\n",
        "The next token the model outputs has high probability of being **\"1\"**, yielding the sequence:\n",
        "\n",
        "**c1ccccc1**\n",
        "\n",
        "This SMILES string corresponds to benzene:\n",
        "\n",
        "<div>\n",
        "<img src=\"data:image/png;base64,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\" width=100>\n",
        "</div>\n",
        "\n",
        "Benzene is ubiquitous in bioactive molecules and predicting the next token to be **\"1\"** closes the benzene ring and gives some notion that the model has learned ***conditional-dependence***. Specifically, the model's prediction of the next token ***should*** take into account the sequence of tokens observed ***thus far***. After all, the sequence observed thus far could perhaps give *hints* into what the \"correct\" (in the context of what SMILES is to be reproduced) next token is. This will be formalized in the next section."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "325d37cf",
      "metadata": {
        "id": "325d37cf"
      },
      "source": [
        "### Formal Problem Set-up\n",
        "\n",
        "The probability of generating a particular SMILES sequence is given by:\n",
        "\n",
        "$$P_\\theta(S) = P_\\theta(s_1) * \\prod_{t = 2}^{T} P_\\theta(s_t|s_{t-1}, s_{t-2},...,s_1)$$\n",
        "\n",
        "where $S$ is a SMILES sequence, $s_t$ are the tokens, and $\\theta$ are the traininable parameters of the model. The expression above states that generating a particular SMILES sequence is the product sum of the ***conditional probabilities*** of generating the 1st token, then generating the 2nd token ***given*** the 1st token, then generating the 3rd token ***given*** the 1st and 2nd token, etc.\n",
        "\n",
        "A RNN is used because they use ***hidden state matrices*** to keep track of the tokens generated thus far. This allows the RNN to model ***conditional-dependence***. A detailed description of RNNs is omitted here but a few key equations are shown below to further highlight how ***conditional-dependence*** is modelled.\n",
        "\n",
        "Normal feed-foward neural networks (FFNNs) perform the following operations:\n",
        "\n",
        "$$H = \\phi(XW_1 + b_1)$$\n",
        "\n",
        "$$Output = HW_2 + b_2$$\n",
        "\n",
        "where $\\phi$ is the activation function, $X$ is the input matrix, $W_1$ is the weight matrix, and $b_1$ is the bias. The first equation details the hidden layer computation where the result is then used to compute the final output.\n",
        "\n",
        "By contrast, RNNs perform the following operations:\n",
        "\n",
        "$$H_t = \\phi(X_tW_{input} + H_{t-1}W_{hidden} + b_1)$$\n",
        "\n",
        "$$Output = H_tW_{output} + b_2$$\n",
        "\n",
        "In contrast to FFNNs, RNNs contain an extra term, $H_{t-1}$. Each time the RNN generates a token is defined as a time-step. The first equation states that the computation of the hidden layer of the current time-step, $H_t$ depends on the **hidden state** from the previous time-step, $H_{t-1}$. In this way, RNNs model ***conditional-dependence***.\n",
        "\n",
        "**Note**: The specific type of recurrent cells used is called `Long Short-Term Memory (LSTM)` which perform a different computation than shown above (more complex but still involving the **hidden state** from the previous time-step). The key information I wanted to convey is that explicit treatment of $H_{t-1}$ keeps track of the token sequence observed thus far. For more information including the equations involved in LSTM cells, see the original publication: https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.676.4320&rep=rep1&type=pdf\n",
        "\n",
        "Finally, the output of the RNN (which token to sample next) is a ***multinomial probability distribution*** over the entire `Vocabulary`, i.e., the conditional probabilities of all the possible tokens. This will be shown in the next section.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "7bcfe158",
      "metadata": {
        "id": "7bcfe158"
      },
      "source": [
        "## RNN Sampling: Step-by-Step"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "3fcb33d6",
      "metadata": {
        "id": "3fcb33d6"
      },
      "source": [
        "The RNN sampling proceeds via the following steps:\n",
        "\n",
        "1) Obtain the token embedding vector\n",
        "\n",
        "2) Pass the embedding vector into the RNN\n",
        "\n",
        "3) Output the softmax conditional probability\n",
        "\n",
        "Let's go through each step."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "8c146855",
      "metadata": {
        "id": "8c146855"
      },
      "source": [
        "### Embedding\n",
        "\n",
        "This section describes ***how*** the numerical representation of tokens are transformed into an input vector known as the embedding that will act as the input to the RNN."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 33,
      "id": "3567dbcd",
      "metadata": {
        "id": "3567dbcd",
        "outputId": "f1bcee4d-75ec-4489-a84f-5d02fc791054",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['C', 'C', 'Br']"
            ]
          },
          "metadata": {},
          "execution_count": 33
        }
      ],
      "source": [
        "# bromoethane has the SMILES sequence \"CCBr\"\n",
        "bromoethane_smiles = 'CCBr'\n",
        "# recall its tokenized form\n",
        "tokenized_bromoethane = tokenize(bromoethane_smiles, with_begin_and_end=False)\n",
        "tokenized_bromoethane"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 34,
      "id": "2e68b4dd",
      "metadata": {
        "id": "2e68b4dd",
        "outputId": "0c66c04f-a8ae-4872-8432-127c6a93f4eb",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Parameter containing:\n",
            "tensor([[ 1.8001, -0.0732,  0.2166, -0.3086,  0.7973],\n",
            "        [ 1.1639, -1.5838, -0.4858,  0.2225,  0.6333],\n",
            "        [ 0.2929, -0.6077, -1.1071, -1.0590, -0.3361],\n",
            "        [ 0.8809, -0.3849,  1.8577, -0.1750, -1.0803],\n",
            "        [-0.6631,  1.4213, -0.1709, -0.5737, -0.1763],\n",
            "        [ 0.1067,  1.6357, -3.0426, -0.8589,  0.4065],\n",
            "        [-2.4978, -0.0403,  0.9841, -0.8503, -1.5185],\n",
            "        [ 1.8389,  1.0928,  0.6933,  0.8675, -0.8122],\n",
            "        [ 1.7398,  0.4412,  0.5456, -0.6644,  0.7221],\n",
            "        [-0.7238, -0.1377, -0.4668, -0.4398,  1.6462],\n",
            "        [-0.1673,  0.2392, -0.5324,  1.0256, -0.2488],\n",
            "        [-0.3220,  0.4515, -2.2329, -1.1261,  0.6172],\n",
            "        [ 1.1898,  0.4855,  0.0739, -1.2175,  1.1985],\n",
            "        [ 0.1620, -1.1384, -2.0720, -0.3215, -0.7182],\n",
            "        [ 0.8252, -1.4342, -0.7217, -0.6769, -1.3779],\n",
            "        [-0.0569,  1.9769, -0.8712, -0.7362,  0.0563],\n",
            "        [-0.9470,  1.3394,  0.3083, -1.7112,  0.4569],\n",
            "        [-0.6984,  0.2843,  0.2308,  0.3988,  1.7561],\n",
            "        [ 0.6507,  0.4783, -1.0150, -0.2699, -0.7583],\n",
            "        [ 1.0449,  0.6834, -0.6246,  0.8608, -0.6895]], requires_grad=True)\n"
          ]
        }
      ],
      "source": [
        "# construct an \"Embedding layer\"\n",
        "embedding_layer = nn.Embedding(num_embeddings=20,\n",
        "                               embedding_dim=5)\n",
        "\n",
        "# show the embedding vectors\n",
        "# note the vectors at indices 17 and 18 (3rd last and 2nd last): they will be cross-referenced 3 cells down\n",
        "print(embedding_layer.weight)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "6ed094ae",
      "metadata": {
        "id": "6ed094ae"
      },
      "source": [
        "An `Embedding Layer` is essentially a look-up table. In the constructor above, `\"num_embeddings\"` refers to the `Vocabulary` size. In our case, the example `Vocabulary` has a size of 20:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "id": "cccbc119",
      "metadata": {
        "id": "cccbc119",
        "outputId": "4fc90bd6-71b5-45be-e2f6-8c3d17980423",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "There are 20 unique tokens in the vocabulary.\n",
            "\n",
            "The unique tokens are: \n",
            "['$', '^', '%10', '%11', '%12', '(', ')', '1', '2', '3', '4', '5', '6', '7', '8', '9', '=', 'Br', 'C', '[NH+]']\n"
          ]
        }
      ],
      "source": [
        "# recall the example Vocabulary\n",
        "print(f'There are {len(vocabulary)} unique tokens in the vocabulary.\\n')\n",
        "print(f'The unique tokens are: \\n{vocabulary.tokens()}')"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "605024a2",
      "metadata": {
        "id": "605024a2"
      },
      "source": [
        "`\"num_embeddings\"` denotes how many vectors to initialize. Since we have 20 unique tokens, we need 20 different vectors: 1 for each unique token. This is why `\"num_embeddings\"` is 20 in this example. `\"embedding_dim\"` denotes the dimension of the embedding vector. 5 is arbitrarily chosen here just for easy visualization."
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Print the tokenized form of bromoethane\n",
        "print(\"Tokenized bromoethane:\", tokenized_bromoethane)\n"
      ],
      "metadata": {
        "id": "Vaa1BVwPjRZj",
        "outputId": "24008da0-6852-4fd1-f62b-e673b61f8f46",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "id": "Vaa1BVwPjRZj",
      "execution_count": 55,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Tokenized bromoethane: ['C', 'C', 'Br']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# bromoethane has the SMILES sequence \"CCBr\"\n",
        "bromoethane_smiles = 'CCBr'\n",
        "# recall its tokenized form\n",
        "tokenized_bromoethane = tokenize(bromoethane_smiles, with_begin_and_end=False)\n",
        "tokenized_bromoethane"
      ],
      "metadata": {
        "id": "STkqsJZzjZRa",
        "outputId": "70d29c8c-0597-4c02-f58c-d14943f5257a",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "id": "STkqsJZzjZRa",
      "execution_count": 53,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['C', 'C', 'Br']"
            ]
          },
          "metadata": {},
          "execution_count": 53
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "\n",
        "# Assuming vocabulary is defined somewhere\n",
        "# vocabulary = YourVocabularyClass()\n",
        "\n",
        "# Get the numerical indices of bromoethane\n",
        "numerical_indices_bromoethane = torch.LongTensor([vocabulary.encode(tokenized_bromoethane).astype(int)])\n",
        "print(f\"Numerical indices of bromoethane:\\n{numerical_indices_bromoethane}\\n\")\n",
        "\n",
        "# Pass the numerical indices through the embedding layer\n",
        "embedding = embedding_layer(numerical_indices_bromoethane)\n",
        "print(f\"Embedding:\\n{embedding}\")\n"
      ],
      "metadata": {
        "id": "qvN3jgjZjjxi",
        "outputId": "37c8d35c-3eda-4cf0-dcc6-70f137c90a80",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "id": "qvN3jgjZjjxi",
      "execution_count": 56,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Numerical indices of bromoethane:\n",
            "tensor([[18, 18, 17]])\n",
            "\n",
            "Embedding:\n",
            "tensor([[[ 0.6507,  0.4783, -1.0150, -0.2699, -0.7583],\n",
            "         [ 0.6507,  0.4783, -1.0150, -0.2699, -0.7583],\n",
            "         [-0.6984,  0.2843,  0.2308,  0.3988,  1.7561]]],\n",
            "       grad_fn=<EmbeddingBackward0>)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "id": "b43180f6",
      "metadata": {
        "id": "b43180f6"
      },
      "source": [
        "### Recurrent Layers"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "75b32fcc",
      "metadata": {
        "id": "75b32fcc"
      },
      "source": [
        "The `Embedding Layer` generates the input vector to be passed to the `Recurrent Layers` which perform the \"recurrent\" computation as shown in the `Formal Problem Set-up` section.\n",
        "\n",
        "Below is code that initializes a `Recurrent Layer` using `Long Short-Term Memory (LSTM)` cells which has demonstrated extensive success in `Natural Language Processing (NLP)` tasks. See the original publication for details on `LSTM`: https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.676.4320&rep=rep1&type=pdf"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 57,
      "id": "8aa1af6b",
      "metadata": {
        "id": "8aa1af6b",
        "outputId": "6d75dfdb-3d6f-4676-d1a5-bc43df4fde52",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "torch.Size([1, 3, 5])"
            ]
          },
          "metadata": {},
          "execution_count": 57
        }
      ],
      "source": [
        "# only 1 layer of LSTM cells is initialized here for the sake of illustration\n",
        "# input_size = 5 because we previously defined the \"embedding_dim\" of the Embedding layer to be 5\n",
        "# hidden_size = 5 is arbitrarily chosen for easy visualization\n",
        "recurrent_layer = nn.LSTM(input_size=5,\n",
        "                          hidden_size=5,\n",
        "                          num_layers=1,\n",
        "                          dropout=0,\n",
        "                          batch_first=True)\n",
        "\n",
        "# recall the shape of our embedded SMILES sequence (this is our input to the recurrent layer)\n",
        "# the shape is: (batch size) x (sequence length) x (embedding dimension)\n",
        "# batch size is 1 since we only pass in 1 SMILES sequence for the sake of illustration\n",
        "embedding.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 61,
      "id": "6673d3df",
      "metadata": {
        "id": "6673d3df"
      },
      "outputs": [],
      "source": [
        "# let's run the embedding through the recurrent layer\n",
        "rnn_output, (hidden_state, cell_state) = recurrent_layer(embedding)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "01002783",
      "metadata": {
        "id": "01002783"
      },
      "source": [
        "The RNN output is what will be passed further through our model. The hidden state and cell state both keep track of previous information, i.e., the observed token sequence so far. The details of each are related to the LSTM cell and are omitted here.\n",
        "\n",
        "Let's double check the dimensions of output to make sure it is correct."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 62,
      "id": "a466beab",
      "metadata": {
        "id": "a466beab",
        "outputId": "0c7e78d2-4c0a-4742-d0d9-7f1d81fcd991",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([1, 3, 5])\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 62
        }
      ],
      "source": [
        "# the shape should be (batch size) x (sequence length) x (embedding dimension) just like the embedding\n",
        "print(rnn_output.shape)\n",
        "\n",
        "rnn_output.shape == embedding.shape"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "b9ca5d8e",
      "metadata": {
        "id": "b9ca5d8e"
      },
      "source": [
        "After the input has passed through the `Recurrent Layer` (in the actual model, there are 3 recurrent layers), it is passed through the final `Linear Layer`. The purpose of the `Linear Layer` is to transform the output from the `Recurrent Layer` which has dimensions:\n",
        "\n",
        "(batch size) x (sequence length) x **(hidden size)**\n",
        "\n",
        "to\n",
        "\n",
        "(batch size) x (sequence length) x **(vocabulary size)**\n",
        "\n",
        "An output over the `Vocabulary` size means there will be 1 numerical quantity corresponding to each possible token in the `Vocabulary`. The purpose of this is for the final step where these numerical quantities are transformed into a \"probability\". ***There will be 1 probability associated with each token, representing how likely the model will propose each token in the next time step.***\n",
        "\n",
        "Before discussing how the multinomial probability distribution (multinomial since the `Vocabulary` size is greater than 1), let's first show the output from the `Linear Layer`:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 63,
      "id": "54448716",
      "metadata": {
        "id": "54448716",
        "outputId": "6d1eab94-e505-4a3e-c8a2-6dbfca0747b4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "torch.Size([1, 3, 20])"
            ]
          },
          "metadata": {},
          "execution_count": 63
        }
      ],
      "source": [
        "# initialize the linear layer\n",
        "# in_features = 5 as that is the hidden_size defined in the recurrent layer above\n",
        "# out_features = 20 as that is the size of the Vocabulary\n",
        "linear_layer = nn.Linear(in_features=5,\n",
        "                         out_features=20)\n",
        "\n",
        "linear_output = linear_layer(rnn_output)\n",
        "\n",
        "# verify the shape of the linear output is what we expect:\n",
        "# (batch size) x (sequence length) x (vocabulary size)\n",
        "linear_output.shape"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "805a3446",
      "metadata": {
        "id": "805a3446"
      },
      "source": [
        "### Softmax: Obtaining a Multinomial Conditional Probability Distribution"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "7c79fb4f",
      "metadata": {
        "id": "7c79fb4f"
      },
      "source": [
        "At this point, we have a tensor that has dimensions **(batch size) x (sequence length) x (vocabulary size)**. The last step is to apply the `Softmax Function` to obtain a multinomial probability distribution which can be interpreted as the probability of generating each specific token at the next time step. To breakdown this step, let's first introduce the `Softmax Function`:\n",
        "\n",
        "$$Softmax(token_i) = \\frac{e^{token_i}}{\\sum\\limits_{j=1}^N e^{token_j}}$$\n",
        "\n",
        "where $i$, $j = 1, 2, 3 ... N$ is the token index and $N$ corresponds to the last vocabulary token. The `Softmax Function` assigns each token probability a value between 0 and 1 (as all probabilities should be). Moreover, the sum of all token probabilities is 1, i.e., the probability of sampling *any* token must be 1.\n",
        "\n",
        "**Problem: The `Softmax Function` can be numerically unstable whereby token probabilities can be assigned extremely small probabilities to the point of 0 or extremely large probabilities to the point of overflow (since we are taking $e$ to the exponent).**\n",
        "\n",
        "Instead of using the `Softmax Function`, the `Log-Softmax Function` is used which outputs values $[-\\infty, 0)$. This circumvents the numerical instabilities described above and importantly, retains the ***order*** of probability magnitudes, i.e., a lower probability outputted by The `Softmax Function` is also a lower probability from the `Log-Softmax Function` and vice versa.\n",
        "\n",
        "\n",
        "$$Log-Softmax(token_i) = \\log(\\frac{e^{token_i}}{\\sum\\limits_{j=1}^N e^{token_j}})$$\n",
        "\n",
        "\n",
        "Let's take the output from the `Linear Layer` above and apply the `Log-Softmax Function`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 64,
      "id": "3a87c941",
      "metadata": {
        "id": "3a87c941",
        "outputId": "799c49b4-3136-41c3-9be3-9cea1f33c969",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([[[0.0661, 0.0491, 0.0667, 0.0424, 0.0585, 0.0488, 0.0375, 0.0670,\n",
            "          0.0540, 0.0419, 0.0436, 0.0322, 0.0800, 0.0423, 0.0318, 0.0412,\n",
            "          0.0428, 0.0364, 0.0459, 0.0719],\n",
            "         [0.0688, 0.0461, 0.0650, 0.0419, 0.0561, 0.0499, 0.0370, 0.0683,\n",
            "          0.0571, 0.0403, 0.0442, 0.0318, 0.0846, 0.0390, 0.0309, 0.0418,\n",
            "          0.0449, 0.0340, 0.0468, 0.0714],\n",
            "         [0.0652, 0.0481, 0.0703, 0.0435, 0.0588, 0.0512, 0.0410, 0.0760,\n",
            "          0.0516, 0.0426, 0.0401, 0.0294, 0.0798, 0.0403, 0.0295, 0.0424,\n",
            "          0.0430, 0.0338, 0.0481, 0.0650]]], grad_fn=<SoftmaxBackward0>)\n",
            "tensor([[1.0000, 1.0000, 1.0000]], grad_fn=<SumBackward1>)\n"
          ]
        }
      ],
      "source": [
        "# let's first show the normal softmax output\n",
        "# recall the output from the linear layer has dimensions: (batch size) x (sequence length) x (vocabulary size)\n",
        "# therefore, dim=2 because we want to compute the softmax over the vocabulary to obtain a probability for each token\n",
        "softmax = linear_output.softmax(dim=2)\n",
        "print(softmax)\n",
        "\n",
        "# the nice thing about softmax is that the sum of all probabilities equates to 1\n",
        "print(softmax.sum(dim=2))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 65,
      "id": "fbca5293",
      "metadata": {
        "id": "fbca5293",
        "outputId": "d523a86a-0c6b-4c43-f82b-abd032134408",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([[[-2.7162, -3.0141, -2.7070, -3.1615, -2.8394, -3.0196, -3.2847,\n",
            "          -2.7029, -2.9179, -3.1724, -3.1328, -3.4365, -2.5262, -3.1636,\n",
            "          -3.4496, -3.1890, -3.1506, -3.3135, -3.0819, -2.6322],\n",
            "         [-2.6766, -3.0763, -2.7338, -3.1719, -2.8811, -2.9974, -3.2975,\n",
            "          -2.6832, -2.8636, -3.2124, -3.1198, -3.4469, -2.4693, -3.2432,\n",
            "          -3.4768, -3.1739, -3.1033, -3.3821, -3.0617, -2.6391],\n",
            "         [-2.7298, -3.0341, -2.6547, -3.1344, -2.8338, -2.9729, -3.1936,\n",
            "          -2.5767, -2.9636, -3.1549, -3.2153, -3.5267, -2.5287, -3.2103,\n",
            "          -3.5233, -3.1605, -3.1460, -3.3865, -3.0344, -2.7331]]],\n",
            "       grad_fn=<LogSoftmaxBackward0>)\n",
            "tensor([[-60.6115, -60.7100, -60.7132]], grad_fn=<SumBackward1>)\n"
          ]
        }
      ],
      "source": [
        "# let's now show the log-softmax output\n",
        "log_softmax = linear_output.log_softmax(dim=2)\n",
        "print(log_softmax)\n",
        "\n",
        "# by contrast, the sum of the log-softmax output does not equate to 1\n",
        "# since the log-softmax outputs values [-inf, 0)\n",
        "print(log_softmax.sum(dim=2))"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "09c68eda",
      "metadata": {
        "id": "09c68eda"
      },
      "source": [
        "**Finally, how is the `Log-Softmax Function` output interpreted as token probabilities?**\n",
        "\n",
        "Each tensor contains the probability of generating each token in the vocabulary at the next time step. Concretely:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 66,
      "id": "9cc3fcc7",
      "metadata": {
        "id": "9cc3fcc7",
        "outputId": "41227f5f-3068-48bd-c938-698cae12bc19",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Original SMILES string: CCBr\n",
            "\n",
            "The unique tokens are: \n",
            "['$', '^', '%10', '%11', '%12', '(', ')', '1', '2', '3', '4', '5', '6', '7', '8', '9', '=', 'Br', 'C', '[NH+]']\n",
            "\n",
            "At time step 1, the generative model proposes 6 as the most probable token and the correct token is C\n",
            "At time step 2, the generative model proposes 6 as the most probable token and the correct token is C\n",
            "At time step 3, the generative model proposes 6 as the most probable token and the correct token is B\n"
          ]
        }
      ],
      "source": [
        "# recall our original SMILES\n",
        "print(f\"Original SMILES string: {bromoethane_smiles}\\n\")\n",
        "\n",
        "# recall our vocabulary\n",
        "print(f\"The unique tokens are: \\n{vocabulary.tokens()}\\n\")\n",
        "\n",
        "# we now extract the max value in each tensor of the log-softmax output above and the corresponding token\n",
        "most_probable_tokens = log_softmax.argmax(dim=2).flatten().tolist()\n",
        "for idx, (correct_token, most_probable_token) in enumerate(zip(bromoethane_smiles, most_probable_tokens)):\n",
        "    print(f\"At time step {idx+1}, the generative model proposes {vocabulary.tokens()[most_probable_token]} as the most probable token and the correct token is {correct_token}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "0bc94bd0",
      "metadata": {
        "id": "0bc94bd0"
      },
      "source": [
        "**Cross-referencing the log-softmax output 2 cells above, notice the probability of each token is quite similar, i.e., the model thinks it is (roughly) equally likely to generate each token. This is because the model is untrained. Correspondingly, we see above that the model is quite poor at predicting the correct token.**\n",
        "\n",
        "In summary, the steps of sampling the generative model are:\n",
        "\n",
        "1. Tokenize the raw SMILES\n",
        "\n",
        "\n",
        "2. Encode the vector (get the numerical vocabulary indices)\n",
        "\n",
        "\n",
        "\n",
        "3. Collate the vector (pad the vector so that regardless of the length of SMILES strings passed into the model, the embedding vector has the same dimensions)\n",
        "\n",
        "\n",
        "4. Generate the embedding (input vector)\n",
        "\n",
        "\n",
        "5. Pass the embedding to the RNN\n",
        "\n",
        "\n",
        "6. Apply a linear transformation on the RNN output so that the dimensions is equal to the vocabulary length\n",
        "\n",
        "\n",
        "7. Apply log-softmax to obtain the multinomial token probability distribution"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "3dd28d80",
      "metadata": {
        "id": "3dd28d80"
      },
      "source": [
        "## How Does The Model Learn?\n",
        "\n",
        "The previous section went through step-by-step how a raw SMILES string is passed through the entire model. The resulting multinomial probability distribution was not very useful as all tokens seemed to be equally likely of being proposed at the next time step. This section introduces the loss function, `Negative Log-Likelihood (NLL)` which we want to minimize.\n",
        "\n",
        "$$NLL = \\log(probability_{token})$$\n",
        "\n",
        "Since the `Log-Softmax Function` already takes the $log$, the `Negative Log-Likelihood` simply takes the negative of the `Log-Softmax Function` output.\n",
        "\n",
        "Let's first see how this looks like through the corresponding tensors:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 67,
      "id": "2512c7a9",
      "metadata": {
        "id": "2512c7a9",
        "outputId": "bf8d718e-9039-42e3-b2fb-9eb88c55d400",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "These are the token indices we would want our model to predict:\n",
            "tensor([[18, 18, 17]])\n",
            "\n",
            "Recall the log-softmax output:\n",
            "tensor([[[-2.7162, -3.0141, -2.7070, -3.1615, -2.8394, -3.0196, -3.2847,\n",
            "          -2.7029, -2.9179, -3.1724, -3.1328, -3.4365, -2.5262, -3.1636,\n",
            "          -3.4496, -3.1890, -3.1506, -3.3135, -3.0819, -2.6322],\n",
            "         [-2.6766, -3.0763, -2.7338, -3.1719, -2.8811, -2.9974, -3.2975,\n",
            "          -2.6832, -2.8636, -3.2124, -3.1198, -3.4469, -2.4693, -3.2432,\n",
            "          -3.4768, -3.1739, -3.1033, -3.3821, -3.0617, -2.6391],\n",
            "         [-2.7298, -3.0341, -2.6547, -3.1344, -2.8338, -2.9729, -3.1936,\n",
            "          -2.5767, -2.9636, -3.1549, -3.2153, -3.5267, -2.5287, -3.2103,\n",
            "          -3.5233, -3.1605, -3.1460, -3.3865, -3.0344, -2.7331]]],\n",
            "       grad_fn=<LogSoftmaxBackward0>)\n",
            "\n",
            "We will transpose the log-softmax tensor to have shape (batch size) x (vocabulary) x (sequence length):\n",
            "tensor([[[-2.7162, -2.6766, -2.7298],\n",
            "         [-3.0141, -3.0763, -3.0341],\n",
            "         [-2.7070, -2.7338, -2.6547],\n",
            "         [-3.1615, -3.1719, -3.1344],\n",
            "         [-2.8394, -2.8811, -2.8338],\n",
            "         [-3.0196, -2.9974, -2.9729],\n",
            "         [-3.2847, -3.2975, -3.1936],\n",
            "         [-2.7029, -2.6832, -2.5767],\n",
            "         [-2.9179, -2.8636, -2.9636],\n",
            "         [-3.1724, -3.2124, -3.1549],\n",
            "         [-3.1328, -3.1198, -3.2153],\n",
            "         [-3.4365, -3.4469, -3.5267],\n",
            "         [-2.5262, -2.4693, -2.5287],\n",
            "         [-3.1636, -3.2432, -3.2103],\n",
            "         [-3.4496, -3.4768, -3.5233],\n",
            "         [-3.1890, -3.1739, -3.1605],\n",
            "         [-3.1506, -3.1033, -3.1460],\n",
            "         [-3.3135, -3.3821, -3.3865],\n",
            "         [-3.0819, -3.0617, -3.0344],\n",
            "         [-2.6322, -2.6391, -2.7331]]], grad_fn=<TransposeBackward0>)\n",
            "\n",
            "The output tensor from negative log-likelihood is:\n",
            "tensor([[3.0819, 3.0617, 3.3865]], grad_fn=<ViewBackward0>)\n",
            "\n"
          ]
        }
      ],
      "source": [
        "# define the loss\n",
        "loss = torch.nn.NLLLoss(reduction='none')\n",
        "# recall the correct token indices of \"CCBr\" which was our original SMILES\n",
        "print(f\"These are the token indices we would want our model to predict:\\n{numerical_indices_bromoethane}\\n\")\n",
        "print(f\"Recall the log-softmax output:\\n{log_softmax}\\n\")\n",
        "print(f\"We will transpose the log-softmax tensor to have shape (batch size) x (vocabulary) x (sequence length):\\n{log_softmax.transpose(1,2)}\\n\")\n",
        "\n",
        "print(f\"The output tensor from negative log-likelihood is:\\n{loss(log_softmax.transpose(1, 2), numerical_indices_bromoethane)}\\n\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "1b9e3eae",
      "metadata": {
        "id": "1b9e3eae"
      },
      "source": [
        "The token index we wanted to predict at time step 1 was **18**. Cross-referencing the first column of the transposed log-softmax tensor at the 18th index (2nd last row), we see that the `Negative Log-Likelihood` simply takes the negative of the value. Similarly, at the last time step, we wanted to predict token index **17**. Cross-referencing the third column of the transposed log-softmax tensor at the 17th index (3rd last row), we see that the value is again the negative, as expected.\n",
        "\n",
        "The `Negative Log-Likelihood` compares the token probabilities assigned by the model to the correct token indices. Recall that the `Log-Softmax Function` takes on values $[\\infty$, 0). We would want our model to assign a high probability to the correct token. Therefore, training the model involves minimizing the `Negative Log-Likehood`.\n",
        "\n",
        "Lastly, during backpropagation, we take the sum of the `Negative Log-Likehood` tensor to \"summarize\" the total loss associated with a given SMILES sequence:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 68,
      "id": "0e149c52",
      "metadata": {
        "id": "0e149c52",
        "outputId": "bf8d2667-9ce4-43bf-8425-464b8b7d17f4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([9.5301], grad_fn=<SumBackward1>)"
            ]
          },
          "metadata": {},
          "execution_count": 68
        }
      ],
      "source": [
        "loss(log_softmax.transpose(1, 2), numerical_indices_bromoethane).sum(dim=1)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "fb37daa8",
      "metadata": {
        "id": "fb37daa8"
      },
      "source": [
        "## What Does a Trained Model Look Like?\n",
        "\n",
        "The previous section ended with showing how the loss function is calculated. Together with the observation that the untrained model assigns (rougly) equal probability of generating each token, this section quantitatively shows how a trained model may be expected to perform.\n",
        "\n",
        "Recall that the **objective is to learn the underlying probability distribution of a SMILES dataset**. Here, we use the scripts available in the repository to download SMILES data from `ZINC` and to train a molecular generative model. The specific scripts used are: `01_download_data.py` and `02_train_model_locally.py`. The model was trained for 50 epochs using 50,000 SMILES strings. **Note that you should monitor the loss when training the molecular generative model such that it doesn't increase on the validation set (a sign of overfitting on the training set).** As the purpose of this section is to show ***how*** a trained model may be expected to perform, the model was somewhat arbitrarily trained for 50 epochs. The trained model is provided in the repository: `model.49.pth`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 69,
      "id": "740e12d7",
      "metadata": {
        "id": "740e12d7",
        "outputId": "9b485926-6d98-43e1-dcce-c6fe6a4ce071",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "There are 57 unique tokens:\n",
            "['$', '^', '#', '(', ')', '-', '/', '1', '2', '3', '4', '5', '6', '7', '=', 'Br', 'C', 'Cl', 'F', 'I', 'N', 'O', 'P', 'S', '[C@@H]', '[C@@]', '[C@H]', '[C@]', '[CH-]', '[CH2-]', '[N+]', '[N-]', '[NH+]', '[NH-]', '[NH2+]', '[NH3+]', '[O-]', '[OH+]', '[P@@H]', '[P@@]', '[P@]', '[PH]', '[S+]', '[S-]', '[S@@]', '[S@]', '[SH+]', '[n+]', '[n-]', '[nH+]', '[nH]', '[o+]', '\\\\', 'c', 'n', 'o', 's']\n"
          ]
        }
      ],
      "source": [
        "# let's load the trained model\n",
        "from smiles_lstm.model.smiles_lstm import SmilesLSTM\n",
        "from utils import load_from_file\n",
        "\n",
        "trained_model = load_from_file(\"pretrained.rnn.pth\")\n",
        "\n",
        "# let's take a look at the vocabulary\n",
        "print(f\"There are {len(trained_model.vocabulary)} unique tokens:\\n{trained_model.vocabulary.tokens()}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "c19c5285",
      "metadata": {
        "id": "c19c5285"
      },
      "source": [
        "The vocabulary is much bigger! There are quite a number of tokens that encode **Stereochemistry** and are present because the raw `ZINC` training data contains **Stereisomers**. In practice, this can add quite some complexity to the model and one may wish to remove instances of **Stereoisomers** before training a molecular generative model. Here, we omit any dataset filtering as the goal is just to show how this trained model performs.\n",
        "\n",
        "Let's now use the same example proposed earlier about generating benzene with SMILES sequence:\n",
        "\n",
        "**c1ccccc1**\n",
        "\n",
        "Given a SMILES sequence of:\n",
        "\n",
        "**c1ccccc**\n",
        "\n",
        "a trained model should assign high probability to the **\"1\"** token to close out the benzene ring.\n",
        "\n",
        "Let's show this:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 70,
      "id": "0c685849",
      "metadata": {
        "id": "0c685849"
      },
      "outputs": [],
      "source": [
        "# import Dataset to use its collate_fn method\n",
        "from smiles_lstm.model.smiles_dataset import Dataset\n",
        "\n",
        "benzene = 'c1ccccc'\n",
        "# tokenize\n",
        "benzene_tokenized = tokenize(benzene)\n",
        "# encode (obtain numerical token indices)\n",
        "benzene_encoded = trained_model.vocabulary.encode(benzene_tokenized)\n",
        "# transform it into a tensor for collating\n",
        "benzene_encoded = torch.tensor([benzene_encoded])\n",
        "# collate\n",
        "benzene_collated = Dataset.collate_fn(benzene_encoded)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 71,
      "id": "b2be7241",
      "metadata": {
        "id": "b2be7241",
        "outputId": "c8bc57a4-bd08-413d-a619-0ef30b7455fb",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([-14.2435, -13.5502, -13.2694,  -2.2387, -16.8499, -12.3029, -11.7999,\n",
              "         -0.1184,  -5.4217,  -9.4808, -11.5950, -11.6601, -13.1247, -13.4469,\n",
              "        -13.0427, -15.8290, -11.8195, -15.7927, -17.0695, -13.9670, -10.1932,\n",
              "        -14.0092, -12.4640, -12.1874, -12.5263, -13.0197, -12.2085, -12.7578,\n",
              "        -13.4579, -14.7750, -14.9601, -13.7766, -13.5120, -13.4319, -12.9227,\n",
              "        -15.2083, -16.5822, -13.4793, -13.9786, -14.1714, -14.1127, -14.9476,\n",
              "        -13.7649, -14.6333, -13.5755, -13.8157, -14.3851, -12.2122, -13.7716,\n",
              "        -12.1530, -13.1898, -13.7298, -14.4979,  -7.7511, -10.8087, -13.5854,\n",
              "        -13.7679], grad_fn=<SelectBackward0>)"
            ]
          },
          "metadata": {},
          "execution_count": 71
        }
      ],
      "source": [
        "# pass the collated tensor to the trained model\n",
        "logits, _ = trained_model.network(benzene_collated[:, :-1])\n",
        "log_probs = logits.log_softmax(dim=2)\n",
        "# let's isolate the probability distribution of the last token in the incomplete benzene sequence\n",
        "log_probs[0][7]"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "2d3dd948",
      "metadata": {
        "id": "2d3dd948"
      },
      "source": [
        "The interpretation of the tensor above is: **The token probabilities given observing the sequence c1ccccc thus far**\n",
        "\n",
        "A stark contrast from the previously untrained model is that there are different values assigned to tokens now. We are interested in finding the most probable token (based on having the highest probability):"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 72,
      "id": "4f941819",
      "metadata": {
        "id": "4f941819",
        "outputId": "7e17a15b-b615-45ae-cd00-a1827195aeb1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The token with the highest probability is: -0.11842899769544601 at index: 7\n",
            "The token is: 1\n"
          ]
        }
      ],
      "source": [
        "# extract the index of the highest probability\n",
        "highest_probability_index = (torch.argmax(log_probs[0][7]))\n",
        "# print that probability\n",
        "print(f\"The token with the highest probability is: {log_probs[0][7][highest_probability_index]} at index: {highest_probability_index}\")\n",
        "# print the token\n",
        "print(f\"The token is: {trained_model.vocabulary.tokens()[highest_probability_index]}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "7a77100a",
      "metadata": {
        "id": "7a77100a"
      },
      "source": [
        "The token with the highest probability is **\"1\"** which is the correct token! Adding this token to the sequence would recover benzene:\n",
        "\n",
        "**c1ccccc1**\n",
        "\n",
        "It seems the model has learned something! As a final note in this section, the training data has important implications on what the model produces.\n",
        "\n",
        "**Training Data Implication:** Since the RNN learns the underlying probability distribution, one should expect that the ***type*** of molecules in the training data affects the ***type*** of molecules that the RNN will output. More concretely, ChEMBL and ZINC are typically used to train the RNN as they contain \"drug-like\" molecules. Consequently, the trained RNN will generally propose \"drug-like\" molecules as well. \"Drug-like\" molecule may be defined as being **Lipinski Compliant**. These molecules possess properties (such as solubility) within a certain range but I emphasize here that **Lipinski Compliance is only a guideline rather than hard-set rules.** See the original publication for further details (https://www.sciencedirect.com/science/article/abs/pii/S0169409X96004231)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "1cd66d32",
      "metadata": {
        "id": "1cd66d32"
      },
      "source": [
        "## Trained Model: Sampling SMILES"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "ecff2fc9",
      "metadata": {
        "id": "ecff2fc9"
      },
      "source": [
        "In this final section, we show how SMILES are sampled from a trained model and a provide a practical interpretation to `Likelihood`.\n",
        "\n",
        "The code below is from `smiles_lstm.py`:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 73,
      "id": "2ce3cb44",
      "metadata": {
        "id": "2ce3cb44"
      },
      "outputs": [],
      "source": [
        "# batch size hard-coded as 3 here just for illustration --> this method samples 3 SMILES\n",
        "def sample(batch_size=3):\n",
        "    start_token = torch.zeros(batch_size,\n",
        "                              dtype=torch.long,\n",
        "                              device='cpu')\n",
        "    start_token[:] = trained_model.vocabulary[\"^\"]\n",
        "    input_vector = start_token\n",
        "    sequences = [\n",
        "        trained_model.vocabulary[\"^\"] * torch.ones([batch_size, 1],\n",
        "                                                   dtype=torch.long,\n",
        "                                                   device='cpu')\n",
        "    ]\n",
        "    # NOTE: The first token never gets added in the loop so\n",
        "    # the sequences are initialized with a start token\n",
        "    hidden_state = None\n",
        "    nlls = torch.zeros(batch_size)\n",
        "    for _ in range(256 - 1):\n",
        "        logits, hidden_state = trained_model.network(input_vector.unsqueeze(1),\n",
        "                                                     hidden_state)\n",
        "        logits        = logits.squeeze(1)\n",
        "        probabilities = logits.softmax(dim=1)\n",
        "        log_probs     = logits.log_softmax(dim=1)\n",
        "        input_vector  = torch.multinomial(probabilities, 1).view(-1)\n",
        "        sequences.append(input_vector.view(-1, 1))\n",
        "        nlls += loss(log_probs, input_vector)\n",
        "        if input_vector.sum() == 0:\n",
        "            break\n",
        "\n",
        "    sequences = torch.cat(sequences, 1)\n",
        "    return sequences.data, nlls"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "2fb3136f",
      "metadata": {
        "id": "2fb3136f"
      },
      "source": [
        "Let's breakdown a few key steps:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 74,
      "id": "d2f9a5ad",
      "metadata": {
        "id": "d2f9a5ad",
        "outputId": "a0a1d414-d638-4aac-c8b7-88220410cc54",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([1, 1, 1])"
            ]
          },
          "metadata": {},
          "execution_count": 74
        }
      ],
      "source": [
        "# initialize batch size (in this case, 3) number of tensors and place the \"^\" token at the first position\n",
        "# this token is the \"START\" token indicating that the token sequence is starting\n",
        "start_token = torch.zeros(3,\n",
        "                          dtype=torch.long,\n",
        "                          device='cpu')\n",
        "start_token[:] = trained_model.vocabulary[\"^\"]\n",
        "start_token"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 75,
      "id": "199795b7",
      "metadata": {
        "id": "199795b7"
      },
      "outputs": [],
      "source": [
        "# initialize the input vectors to contain the start token, \"^\"\n",
        "input_vector = start_token\n",
        "# pass the input vector through the network --> embedding --> RNN --> linear\n",
        "logits, hidden_state = trained_model.network(input_vector.unsqueeze(1))\n",
        "logits = logits.squeeze(1)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "f7ba5194",
      "metadata": {
        "id": "f7ba5194"
      },
      "source": [
        "The operations performed so far are the same as introduced in the previous sections. The next step is the key difference when sampling SMILES and we now **explicitly** treat the token probabilities as a multinomial distribution."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 76,
      "id": "87a69f9e",
      "metadata": {
        "id": "87a69f9e"
      },
      "outputs": [],
      "source": [
        "# here we apply normal softmax\n",
        "probabilities = logits.softmax(dim=1)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "6a484005",
      "metadata": {
        "id": "6a484005"
      },
      "source": [
        "After introducing the `Log-Softmax Function` as a more numerically stable computation, why are we using the normal `Softmax Function` here? The numerical stability of the `Log-Softmax Function` is used to minimize the `Negative Log-Likelihood` during model training. However, recall that the `Softmax Function` has the nice property that the sum of all token probabilities equals 1. This allows us to interpret the output tensor as a multinomial probability distribution. Using this distribution, we can **sample** from it."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 77,
      "id": "ba5cac13",
      "metadata": {
        "id": "ba5cac13"
      },
      "outputs": [],
      "source": [
        "# torch.multinomial treats the softmax output as a multinomial probability distribution\n",
        "# and we sample 1 token from this distribution\n",
        "input_vector  = torch.multinomial(probabilities, 1).view(-1)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "f8f2cb24",
      "metadata": {
        "id": "f8f2cb24"
      },
      "source": [
        "Let's take a look at the probabilities and the sampled token of 1 sequence:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 78,
      "id": "7dd49840",
      "metadata": {
        "id": "7dd49840",
        "outputId": "d997654c-6071-44b8-867f-7e51c3ed9320",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "All token probabilities:\n",
            "tensor([9.3530e-06, 1.0911e-05, 1.7479e-05, 3.3557e-05, 6.5491e-06, 8.0344e-04,\n",
            "        1.2395e-04, 1.2275e-04, 4.1210e-06, 1.7474e-06, 5.6200e-06, 6.2380e-06,\n",
            "        7.8821e-05, 3.2696e-05, 4.2444e-04, 1.2401e-03, 6.2757e-01, 3.3356e-03,\n",
            "        6.9900e-03, 1.8766e-04, 5.8840e-02, 6.3043e-02, 2.5694e-05, 8.1178e-03,\n",
            "        6.1889e-04, 6.1946e-05, 5.6118e-04, 4.6440e-05, 1.0089e-05, 1.1012e-05,\n",
            "        1.7799e-03, 2.2088e-04, 2.8766e-03, 8.6382e-06, 1.7434e-03, 1.0465e-03,\n",
            "        2.3079e-03, 9.3288e-06, 1.4756e-05, 1.7027e-05, 1.5310e-05, 1.7746e-05,\n",
            "        2.4646e-05, 8.3773e-05, 1.3043e-05, 3.2634e-05, 8.6809e-06, 6.3762e-05,\n",
            "        3.7606e-05, 2.4779e-04, 1.3794e-03, 1.3457e-05, 2.0363e-05, 1.9373e-01,\n",
            "        1.7046e-02, 2.0350e-03, 2.8622e-03], grad_fn=<SelectBackward0>)\n",
            "\n",
            "The token with the highest probability:\n",
            "16\n",
            "\n",
            "The sampled token:\n",
            "21\n"
          ]
        }
      ],
      "source": [
        "# show all the token probabilities\n",
        "print(f\"All token probabilities:\\n{probabilities[0]}\\n\")\n",
        "# which token has the highest probability?\n",
        "print(f\"The token with the highest probability:\\n{torch.argmax(probabilities[0])}\\n\")\n",
        "# which token was sampled?\n",
        "print(f\"The sampled token:\\n{input_vector[0]}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "6d1b21a9",
      "metadata": {
        "id": "6d1b21a9"
      },
      "source": [
        "We see that it's not guaranteed that the highest probability token is sampled. The last step is to save the sequences generated so far and to compute the `Negative Log-Likelihood`. The details are identical as introduced in the `How Does The Model Learn?` section.\n",
        "\n",
        "Let's now run the `sample` method and see the SMILES generated:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 86,
      "id": "eceb086f",
      "metadata": {
        "id": "eceb086f",
        "outputId": "1e0136f1-e0e6-4746-e834-d2c5957ec32e",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['N1(Cc2ccccc2OCC1)CCCCCN1CC(C#N)=C1',\n",
              " 'n1cscc1C1Cc2n[nH]cc212',\n",
              " 'c1c(F)cccc1CCSCCC[C@H]2CCC[NH+]2C']"
            ]
          },
          "metadata": {},
          "execution_count": 86
        }
      ],
      "source": [
        "sequences, nlls = sample()\n",
        "# extract the SMILES\n",
        "smiles = [trained_model.tokenizer.untokenize(trained_model.vocabulary.decode(seq)) for seq in sequences.numpy()]\n",
        "# show the SMILES\n",
        "smiles"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 87,
      "id": "c7e4b1f6",
      "metadata": {
        "id": "c7e4b1f6",
        "outputId": "ea2334ff-0658-40a6-a620-06935f8e950f",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 217
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<IPython.core.display.Image object>"
            ]
          },
          "metadata": {},
          "execution_count": 87
        }
      ],
      "source": [
        "from rdkit import Chem\n",
        "from rdkit.Chem import Draw\n",
        "\n",
        "# convert the SMILES to RDKit Mol objects\n",
        "molecules = [Chem.MolFromSmiles(s) for s in smiles]\n",
        "# show the molecules\n",
        "# Note: if less than 3 molecules show up, it's because they were invalid SMILES - try running the cell above again\n",
        "Draw.MolsToGridImage(molecules)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "af84f5ef",
      "metadata": {
        "id": "af84f5ef"
      },
      "source": [
        "We see that the trained generative model is able to produce valid SMILES! Whether those particular SMILES are desirable or not is out of the scope of this notebook but it shows that training a generative model to **learn the underlying probability distribution of a SMILES dataset can yield a model that has learned the SMILES syntax and generate valid SMILES strings.**\n",
        "\n",
        "The last topic to touch on is the `Negative Log-Likelihood` which is sometimes simply referred to as the `Likelihood`:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 81,
      "id": "cfdb3841",
      "metadata": {
        "id": "cfdb3841",
        "outputId": "08bf031f-8422-43d2-e7e5-b8da57849f88",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([20.8829, 27.3180, 59.2792], grad_fn=<AddBackward0>)"
            ]
          },
          "metadata": {},
          "execution_count": 81
        }
      ],
      "source": [
        "# print the negative log-likelihoods of the above 3 molecules\n",
        "nlls"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "3817e90f",
      "metadata": {
        "id": "3817e90f"
      },
      "source": [
        "### What Does The `Negative Log-Likelihood` Mean?\n",
        "\n",
        "Recall 3 things:\n",
        "\n",
        "1. The `Negative Log-Likelihood` sums up all the probabilities of generating each token in the entire sequence\n",
        "\n",
        "\n",
        "2. The `Log-Softmax Function` output was passed to the `Negative Log-Likelihood`\n",
        "\n",
        "\n",
        "3. The `Log-Softmax Function` output is $[\\infty, 0)$\n",
        "\n",
        "This means a higher log probability of generating a token is closer to \"0\". **Thus, the smaller the `Negative Log-Likelihood` is, the greater probability the model has of generating that particular sequence**. In the above example, one can say that the model is more likely to generate molecules 2 and 3 compared to 1. **The `Negative Log-Likelihood` is sometimes expressed as the \"`Likelihood` of generating a SMILES sequence\".**"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "c97311a0",
      "metadata": {
        "id": "c97311a0"
      },
      "source": [
        "## Negative Log-Likelihood in Practical Applications"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "a1d33e26",
      "metadata": {
        "id": "a1d33e26"
      },
      "source": [
        "When using a molecular generative model, one would want proposed SMILES to be ***desirable***, i.e., satisfy a multitude of properties. This is done in `REINVENT` via `Reinforcement Learning (RL)` which is out of the scope of this notebook for the time being. However, another popular method is `Fine-Tuning` or `Transfer Learning` whereby one takes a trained model which has learned the SMILES syntax and **further trains it to bias the `Negative Log-Likelihoods` toward a smaller dataset of SMILES (fine-tuning dataset). This smaller dataset typically contains SMILES that are known to be desirable, e.g., possesses known potency, and the objective may be to propose new SMILES that are similar to these.** One can show using the `Negative Log-Likelihood` that `Fine-Tuning` or `Transfer Learning` does indeed lower the `Negative Log-Likelihood` of generating SMILES/similar SMILES to the fine-tuning dataset. For a concrete literature example of this, see **Fig. 1** in the following paper: https://link.springer.com/article/10.1007/s10822-021-00392-8"
      ]
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3 (ipykernel)",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.10.6"
    },
    "colab": {
      "provenance": []
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
}