SMILES_Autoencoder.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "90a860f7-e171-4802-bc58-610d7a062c45",
   "metadata": {},
   "source": [
    "# SMILES string Autoencoder\n",
    "\n",
    "This Block\n",
    "- Tokenizes SMILES string input using a tokenizer from Deepchem (which inherits from Huggingface/Transformers)\n",
    "- Pads tokenized strings to max_length of the longest string\n",
    "- vocab list has been pre-trimmed to what is contained in the 6731 dataset; for a new dataset use a full vocab list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "3a76e239-bd0e-4783-9c3e-7eb5ca48caa4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\envs\\rdkitenv\\lib\\site-packages\\keras\\src\\losses.py:2976: The name tf.losses.sparse_softmax_cross_entropy is deprecated. Please use tf.compat.v1.losses.sparse_softmax_cross_entropy instead.\n",
      "\n",
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\envs\\rdkitenv\\lib\\site-packages\\tensorflow\\python\\util\\deprecation.py:588: calling function (from tensorflow.python.eager.polymorphic_function.polymorphic_function) with experimental_relax_shapes is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "experimental_relax_shapes is deprecated, use reduce_retracing instead\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Skipped loading modules with pytorch-geometric dependency, missing a dependency. No module named 'torch_geometric'\n",
      "Skipped loading modules with pytorch-geometric dependency, missing a dependency. cannot import name 'DMPNN' from 'deepchem.models.torch_models' (C:\\ProgramData\\Anaconda3\\envs\\rdkitenv\\lib\\site-packages\\deepchem\\models\\torch_models\\__init__.py)\n",
      "Skipped loading some Jax models, missing a dependency. No module named 'jax'\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "105\n",
      "Number of features and datapoints:  (6731, 105)\n",
      "featurization done with:  SMILES Tokenizer\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "import pandas as pd \n",
    "import deepchem as dc\n",
    "import time\n",
    "import mordred\n",
    "import transformers\n",
    "from rdkit import Chem\n",
    "import matplotlib.pyplot as plt\n",
    "from rdkit.Chem import AllChem, Draw\n",
    "from sklearn.model_selection import train_test_split\n",
    "from deepchem.feat.smiles_tokenizer import SmilesTokenizer\n",
    "\n",
    "#df = pd.read_csv(\"392-azo.csv\")\n",
    "#df = pd.read_csv(\"212-azo.csv\")\n",
    "#df = pd.read_csv(\"604-azo.csv\")\n",
    "#df = pd.read_csv(\"621-azo.csv\")\n",
    "df = pd.read_csv(\"6731-azo.csv\")\n",
    "\n",
    "Xa = [\"\"]*len(df)\n",
    "w = [\"\"]*len(df)\n",
    "i=0\n",
    "for name in df[\"SMILES\"]:\n",
    "    Xa[i]=name\n",
    "    w[i]=1.0\n",
    "    i += 1\n",
    "Xa = list(Xa)\n",
    "w=list(w)\n",
    "\n",
    "#===========================================================================================\n",
    "#featurize, padding to max_length\n",
    "\n",
    "tokenizer=dc.feat.SmilesTokenizer(vocab_file=\"vocab_new.txt\")\n",
    "featname=\"SMILES Tokenizer\"\n",
    "\n",
    "fl = list(map(lambda x: tokenizer.encode(x),Xa))\n",
    "biggest = 1\n",
    "for i in range(len(fl)):\n",
    "    temp = len(fl[i])\n",
    "    if temp > biggest:\n",
    "        biggest = temp\n",
    "\n",
    "print(biggest)\n",
    "max_length = biggest\n",
    "fl2 = list(map(lambda x: tokenizer.add_padding_tokens(x,max_length),fl))\n",
    "#print(fl2[:5])\n",
    "vocab_size=74\n",
    "\n",
    "f = np.array(fl2)\n",
    "print(\"Number of features and datapoints: \",f.shape)\n",
    "\n",
    "#===========================================================================================\n",
    "print(\"featurization done with: \",featname)\n",
    "\n",
    "# set npp for how many points in the dataset, len(df) for whole dataset\n",
    "nnp=len(df)\n",
    "\n",
    "#set y to X\n",
    "y = f\n",
    "\n",
    "#set dataset\n",
    "\n",
    "dataset = dc.data.NumpyDataset(X=f[:nnp,:], y=y[:nnp,:], ids=Xa[:nnp], w=w[:nnp])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "02bba94b-f090-4616-a5bd-dd843685511a",
   "metadata": {},
   "source": [
    "## Autoencoder Model\n",
    "- Encoder is one GRU layer with 128 NTLUs\n",
    "- Decoder is one GRU layer with 128 NTLUs, followed by a dense/softmax output layer "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "53776a66-81b7-47de-a716-739b647e456b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\envs\\rdkitenv\\lib\\site-packages\\keras\\src\\backend.py:873: The name tf.get_default_graph is deprecated. Please use tf.compat.v1.get_default_graph instead.\n",
      "\n",
      "Epoch 1/10\n",
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\envs\\rdkitenv\\lib\\site-packages\\keras\\src\\utils\\tf_utils.py:492: The name tf.ragged.RaggedTensorValue is deprecated. Please use tf.compat.v1.ragged.RaggedTensorValue instead.\n",
      "\n",
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\envs\\rdkitenv\\lib\\site-packages\\keras\\src\\engine\\base_layer_utils.py:384: The name tf.executing_eagerly_outside_functions is deprecated. Please use tf.compat.v1.executing_eagerly_outside_functions instead.\n",
      "\n",
      "INFO:tensorflow:Assets written to: SMILES_ED\\assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: SMILES_ED\\assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "190/190 - 46s - loss: 1.1893 - accuracy: 0.7049 - val_loss: 1.1194 - val_accuracy: 0.7114 - 46s/epoch - 240ms/step\n",
      "Epoch 2/10\n",
      "INFO:tensorflow:Assets written to: SMILES_ED\\assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: SMILES_ED\\assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "190/190 - 32s - loss: 0.2191 - accuracy: 0.9454 - val_loss: 0.4443 - val_accuracy: 0.9412 - 32s/epoch - 166ms/step\n",
      "Epoch 3/10\n",
      "INFO:tensorflow:Assets written to: SMILES_ED\\assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: SMILES_ED\\assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "190/190 - 32s - loss: 0.0430 - accuracy: 0.9919 - val_loss: 0.3780 - val_accuracy: 0.9654 - 32s/epoch - 170ms/step\n",
      "Epoch 4/10\n",
      "INFO:tensorflow:Assets written to: SMILES_ED\\assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: SMILES_ED\\assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "190/190 - 33s - loss: 0.0173 - accuracy: 0.9979 - val_loss: 0.3606 - val_accuracy: 0.9694 - 33s/epoch - 174ms/step\n",
      "Epoch 5/10\n",
      "INFO:tensorflow:Assets written to: SMILES_ED\\assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: SMILES_ED\\assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "190/190 - 34s - loss: 0.0095 - accuracy: 0.9990 - val_loss: 0.3629 - val_accuracy: 0.9700 - 34s/epoch - 178ms/step\n",
      "Epoch 6/10\n",
      "INFO:tensorflow:Assets written to: SMILES_ED\\assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: SMILES_ED\\assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "190/190 - 29s - loss: 0.0061 - accuracy: 0.9993 - val_loss: 0.3567 - val_accuracy: 0.9706 - 29s/epoch - 152ms/step\n",
      "Epoch 7/10\n",
      "INFO:tensorflow:Assets written to: SMILES_ED\\assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: SMILES_ED\\assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "190/190 - 31s - loss: 0.0042 - accuracy: 0.9994 - val_loss: 0.3573 - val_accuracy: 0.9724 - 31s/epoch - 165ms/step\n",
      "Epoch 8/10\n",
      "INFO:tensorflow:Assets written to: SMILES_ED\\assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: SMILES_ED\\assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "190/190 - 36s - loss: 0.0031 - accuracy: 0.9996 - val_loss: 0.3608 - val_accuracy: 0.9736 - 36s/epoch - 189ms/step\n",
      "Epoch 9/10\n",
      "INFO:tensorflow:Assets written to: SMILES_ED\\assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: SMILES_ED\\assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "190/190 - 31s - loss: 0.0023 - accuracy: 0.9997 - val_loss: 0.3593 - val_accuracy: 0.9743 - 31s/epoch - 162ms/step\n",
      "Epoch 10/10\n",
      "INFO:tensorflow:Assets written to: SMILES_ED\\assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: SMILES_ED\\assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "190/190 - 35s - loss: 0.0018 - accuracy: 0.9998 - val_loss: 0.3577 - val_accuracy: 0.9750 - 35s/epoch - 183ms/step\n"
     ]
    }
   ],
   "source": [
    "encoder = tf.keras.Sequential([\n",
    "    tf.keras.layers.Embedding(input_dim=vocab_size,output_dim=12),\n",
    "    tf.keras.layers.GRU(128,return_sequences=True)])\n",
    "\n",
    "decoder = tf.keras.Sequential([\n",
    "    tf.keras.layers.GRU(128,return_sequences=True),\n",
    "    tf.keras.layers.Dense(vocab_size,activation=\"softmax\")])\n",
    "\n",
    "encode_decode=tf.keras.Sequential([encoder,decoder])\n",
    "\n",
    "optimizer = tf.keras.optimizers.Nadam()\n",
    "encode_decode.compile(loss=\"sparse_categorical_crossentropy\",optimizer=optimizer, metrics=[\"accuracy\"])\n",
    "model_chkpt = tf.keras.callbacks.ModelCheckpoint(\"SMILES_ED\",monitor=\"val_accuracy\",save_best_only=True)\n",
    "\n",
    "history = encode_decode.fit(dataset.X,dataset.y,epochs=10,verbose=2,validation_split=0.1,callbacks=[model_chkpt])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "94b05b1a-154c-4ca8-bb29-46253cdbc890",
   "metadata": {},
   "source": [
    "## Saves a model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "1196b5c8-1d72-4986-9e33-d0739ab4cce6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: 28Feb_newvocab_embed12\\assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: 28Feb_newvocab_embed12\\assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model saved.\n"
     ]
    }
   ],
   "source": [
    "encode_decode.save(\"28Feb_newvocab_embed12\",save_format=\"tf\")\n",
    "print(\"model saved.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f814d99d-813a-4d92-872a-3e02186917d3",
   "metadata": {},
   "source": [
    "## Test model\n",
    "- Takes 2 strings that are not in the dataset and runs them through the model\n",
    "- Then takes the most probable token for each position\n",
    "- de-tokenizes this, converts it to a SMILES string, and then creates and displays a graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "9c7efe7f-b2a8-4643-a8c1-5216b69b6360",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/1 [==============================] - 1s 828ms/step\n",
      "Input Molecule:         Oc1cc(cc(c1O)[N+]([O-])=O)C#N\n",
      "\n",
      "Reconstructed Molecule: Oc1cc(cc(c1O)[N+]([O-])=O)C#N\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "encode_decode = tf.keras.models.load_model(\"28Feb_newvocab_embed12\")\n",
    "\n",
    "test_string=[\"\"]*2\n",
    "test_array = np.empty((2,1))\n",
    "test_xlist=[0]*2\n",
    "firstmol_list = [0]\n",
    "\n",
    "Xs=[\"\"]*2\n",
    "Xs[0] = \"Oc1cc(cc(c1O)[N+]([O-])=O)C#N\"\n",
    "Xs[1] = \"C(=O)C(C)=Cc1cc(O)c(O)c(c1)[N+]([O-])=O\"\n",
    "\n",
    "tl = list(map(lambda x: tokenizer.encode(x),Xs))\n",
    "tl2 = list(map(lambda x: tokenizer.add_padding_tokens(x,max_length),tl))\n",
    "testf = np.array(tl2)\n",
    "\n",
    "test_xlist[0] = testf[0]\n",
    "test_xlist[1] = testf[1]\n",
    "\n",
    "test_array = np.array(test_xlist)\n",
    "\n",
    "firstmol_list[0] = 1\n",
    "results = encode_decode.predict(test_array)\n",
    "\n",
    "for i in range(105):\n",
    "    proba = results[0,i,:]\n",
    "    first_pred = tf.argmax(proba)\n",
    "    firstmol_list.append(int(first_pred))\n",
    "\n",
    "firstmol_list.pop(0)\n",
    "firstmol_array = np.array(firstmol_list)\n",
    "\n",
    "new_molecule = tokenizer.decode(firstmol_list)\n",
    "\n",
    "nm1 = tokenizer.convert_tokens_to_string(new_molecule).replace(\" \",\"\")\n",
    "nm2 = nm1.replace(\"[CLS]\",\"\").replace(\"[SEP]\",\"\").replace(\"[PAD]\",\"\")\n",
    "\n",
    "print(f\"Input Molecule:         {Xs[0]}\") \n",
    "print(\"\")\n",
    "print(f\"Reconstructed Molecule: {nm2}\")\n",
    "print(\"\")\n",
    "mol1 = Chem.MolFromSmiles(Xs[0])\n",
    "mol2 = Chem.MolFromSmiles(nm2)\n",
    "\n",
    "mols = [mol1,mol2]\n",
    "legends = [\"Input Molecule\",\"Reconstructed Molecule\"]\n",
    "\n",
    "Draw.MolsToGridImage(mols=mols, legends=legends,molsPerRow=2,maxMols=500)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7a3c5045-1668-4501-8bc0-88d1886c2063",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}