Introduction_with_Molpro.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "e0786e9c",
   "metadata": {},
   "source": [
    "## <font color='red'>*********************** Molpro *****************</font>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13c2d249",
   "metadata": {},
   "source": [
    "#### MolPro is a comprehensive python package for small molecule generation using protein active site or/and similar molecules using 3D information of molecules with in-silico validation of molecules by docking , pharmacophore hypothesis. Also off target prediction based on the binding site similarities."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ba9ebd53",
   "metadata": {},
   "source": [
    "#### In Molpro we have diffrent diffrent features : "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b291677",
   "metadata": {},
   "source": [
    "### <font color='green'>1. Affinity Prediction </font>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "662991b6",
   "metadata": {},
   "source": [
    "The worldwide increase and proliferation of drug resistant microbes, coupled with the lag in new drug development, represents a major threat to human health. In order to reduce the time and cost for exploring the chemical search space, drug discovery increasingly relies on computational biology approaches. One key step in these approaches is the need for the rapid and accurate prediction of the binding affinity for potential leads. Here, we present an ensemble of three-dimensional (3D) Convolutional Neural Networks (CNNs), which combines voxelized molecular descriptors for predicting the absolute binding affinity of protein–ligand complexes. Reference : https://doi.org/10.1021/acs.jcim.0c00075"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "417c8156",
   "metadata": {},
   "source": [
    "######   Preparing dataset:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "501724b6",
   "metadata": {},
   "source": [
    "We will be using a subset of PDBBind dataset given in the sample data folder for training.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8eed46d",
   "metadata": {},
   "source": [
    "Sample Data Link : https://drive.google.com/drive/folders/15x-gLYOGfXYpGjVafmNLIv33e1pm7dUY?usp=sharing"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa822c0a",
   "metadata": {},
   "source": [
    "you can prepare the data for training from the raw data by running this command :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0bd0f781",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "\n",
    "python data.py --data_path {path where pdb and mol2 files are stored} --hdf_path {path where processed dataset is set to be stored}\n",
    "       --df_path {path to csv file containing pkd values and pdb ids} \n",
    "       \n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a3efaab",
   "metadata": {},
   "source": [
    "###### Training model:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a23027b",
   "metadata": {},
   "source": [
    "Once you have the dataset you can start training the model. For that can execute model.py file with the following command :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "70aa14ff",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "python model.py --hdf_path {path where dataset is stored} --train_ids_path {path where list of train ids is stored} --val_ids_path {path where list of validation ids is stored} \n",
    "                  --test_ids_path {path where list of test ids is stored}\n",
    "                  --batch_size {batch size for model training} --max_epochs {epochs to train for}\n",
    "                  --num_workers {number of workers for dataloader} \n",
    "                  --gpus {num_of_gpus_for_training: None for 'cpu'}\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5cd668ce",
   "metadata": {},
   "source": [
    "after executing you will get a new folder called \"lightning_logs\"."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0b12042",
   "metadata": {},
   "source": [
    "###### Pkd value prediction: "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "acc4c943",
   "metadata": {},
   "source": [
    "After training the model the checkpoint file saved in lightning_logs can be used for predicting the affinity of protein ligand complex. Make sure that the ligand is docked before giving to the model as input. The protein file should be protonated and not contain heteroatoms (water or ligand)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "08a98620",
   "metadata": {},
   "outputs": [],
   "source": [
    "from molpro.affinity_pred.predict import predict_affinity\n",
    "pkd = predict_affinity(protein_file_path, protein_file_type, ligand_file_path, ligand_file_type, model_checkpoint_path)\n",
    "\n",
    "# Input parameters :\n",
    "\"\"\"\n",
    "protein_file_path : str\n",
    "               Path to protein file\n",
    "protein_file_type : str\n",
    "               File format of protein (mol2,pdb,pdbqt)\n",
    "ligand_file_path : str\n",
    "               Path to ligand file\n",
    "ligand_file_type : str\n",
    "               File format of ligand (mol2,pdb,pdbqt)\n",
    "model_checkpoint_path : str \n",
    "               Path to the checkpoint of saved model\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e7ecc304",
   "metadata": {},
   "outputs": [],
   "source": [
    "# returns \n",
    "\"\"\"\n",
    "\n",
    "pkd value of the protein ligand complex : float \n",
    "\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7cc802a8",
   "metadata": {},
   "source": [
    "### <font color='green'>2. Docking </font>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8051407f",
   "metadata": {},
   "source": [
    "AutoDock Vina is one of the fastest and most widely used open-source docking engines. It is a turnkey computational docking program that is based on a simple scoring function and rapid gradient-optimization conformational search. It was originally designed and implemented by Dr. Oleg Trott in the Molecular Graphics Lab, and it is now being maintained and develop by the Forli Lab at The Scripps Research Institute.\n",
    "\n",
    "In this, we have created an End-to-End docking pipline, starting from docking, Protein-ligands complex generation and prediction of their interaction , then rescoring or Pkd prediction.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d65fe890",
   "metadata": {},
   "source": [
    "#### How to use?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4eef1090",
   "metadata": {},
   "source": [
    "##### <font color='blue'>1. Perform Docking </font>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8f328a32",
   "metadata": {},
   "outputs": [],
   "source": [
    "from molpro.docking import dock_score\n",
    "\n",
    "binding_score=dock_score(docking_engine = None,protein = None,smile = None,out_path = None,split_out_file = None,grid_size=[40,40,40],center = [0,0,0],exhaustiveness = 32,n_poses = 10)\n",
    "\n",
    "\n",
    "# Input Parameters \n",
    "\n",
    "\"\"\"\n",
    "docking_engine: Str\n",
    "            Docking Engine to be used** vina or vinardo**\n",
    "protein: Str\n",
    "        pdbqt protein file which need to be docked\n",
    "smile: Str\n",
    "        Smile which need to be docked\n",
    "out_path: Str\n",
    "        folder where the docked PDQT files to be saved\n",
    "split_out_file: boolean\n",
    "        if yes, splits the pdbqt file conatining given number poses into multiple files with one pose each. examples: out_pose_1.pdbqt,out_pose_2.pdbqt,out_pose_3.pdbqt,\n",
    "        out_pose_4.pdbqt, ...., out_pose_n.pdbqt\n",
    "        if no, no splitting happens\n",
    "grid_size: list\n",
    "        Box Size to be consider for rigid docking\n",
    "center: list\n",
    "        Box center to be consider for rigid docking\n",
    "exhaustiveness: int\n",
    "        flexibility of atoms to be given\n",
    "n_poses: int\n",
    "        number of poses to be consider for docking\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e2d28b32",
   "metadata": {},
   "outputs": [],
   "source": [
    "# returns \n",
    "\n",
    "\"\"\"Top_energies: list\n",
    "            Binding affinity scores of n_poses \n",
    "Generates PDBQT file [out.pdbqt, having the all poses informarion], if split_out_file=True, files will be geneated as mention above.\"\"\"\n",
    "\n",
    "Output: Binding affinity scores of n_poses like:..\n",
    "[-6.206, -6.143, -6.136, -6.054, -6.027, -5.999, -5.923, -5.802, -5.75, -5.593]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9f0424c7",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "e39980ac",
   "metadata": {},
   "source": [
    "###### <font color='blue'>2. Preparing the complex files for protein-Ligand interaction calculation </font>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6d25f8bd",
   "metadata": {},
   "outputs": [],
   "source": [
    "from molpro.docking import complex_prep\n",
    "complex_prep(protein = None,ligand= None ,ligand_file_type = None)\n",
    "\n",
    "# INput parameters\n",
    "\"\"\"\n",
    "protein: str\n",
    "        Path to protein ,file format PDB\n",
    "ligand: str\n",
    "        Path to ligand file\n",
    "ligand_file_type: str\n",
    "        File format of ligand (mol2,pdb,pdbqt)\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2d82f09",
   "metadata": {},
   "source": [
    "###### <font color='blue'>3. Protein ligand Interaction calculation </font>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a802e6f2",
   "metadata": {},
   "outputs": [],
   "source": [
    "from molpro.docking.dock import Pro_lig_int\n",
    "interaction = Pro_lig_int(complex=None)\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "complex: str\n",
    "        path for the complex file, file format PDB\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3abf33c8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Returns \n",
    "interaction: PLI like:..\n",
    "\n",
    "{'hydrophobic': [{'RESNR': 212, 'RESTYPE': 'LEU', 'RESCHAIN': 'A', 'RESNR_LIG': 1, 'RESTYPE_LIG': 'UNL', 'RESCHAIN_LIG': 'Z', 'DIST': '3.96', 'LIGCARBONIDX': 1460, 'PROTCARBONIDX': 518, 'LIGCOO': (26.163, 31.117, 21.82), 'PROTCOO': (23.244, 29.905, 24.2)},\n",
    "{'RESNR': 261, 'RESTYPE': 'TYR', 'RESCHAIN': 'A', 'RESNR_LIG': 1, 'RESTYPE_LIG': 'UNL', 'RESCHAIN_LIG': 'Z', 'DIST': '3.49', 'LIGCARBONIDX': 1463, 'PROTCARBONIDX': 800, 'LIGCOO': (27.579, 28.735, 20.895), 'PROTCOO': (27.125, 25.332, 21.507)}], \n",
    "'hbond': [{'RESNR': 241, 'RESTYPE': 'SER', 'RESCHAIN': 'A', 'RESNR_LIG': 1, 'RESTYPE_LIG': 'UNL', 'RESCHAIN_LIG': 'Z', 'SIDECHAIN': True, 'DIST_H-A': '3.59', 'DIST_D-A': '4.04', 'DON_ANGLE': '110.52', 'PROTISDON': True, 'DONORIDX': 649, 'DONORTYPE': 'O3', \n",
    "'ACCEPTORIDX': 1485, 'ACCEPTORTYPE': 'Nar', 'LIGCOO': (29.472, 32.75, 21.679), 'PROTCOO': (31.738, 35.553, 23.5)}, {'RESNR': 243, 'RESTYPE': 'SER', 'RESCHAIN': 'A', 'RESNR_LIG': 1, 'RESTYPE_LIG': 'UNL', \n",
    "'RESCHAIN_LIG': 'Z', 'SIDECHAIN': True, 'DIST_H-A': '3.14', 'DIST_D-A': '3.47', 'DON_ANGLE': '101.77', 'PROTISDON': True, 'DONORIDX': 663, 'DONORTYPE': 'O3', 'ACCEPTORIDX': 1486, 'ACCEPTORTYPE': 'Nar', 'LIGCOO': (29.412, 32.754, 23.0), \n",
    "'PROTCOO': (27.882, 35.066, 25.094)}, {'RESNR': 260, 'RESTYPE': 'GLU', 'RESCHAIN': 'A', 'RESNR_LIG': 1, 'RESTYPE_LIG': 'UNL', 'RESCHAIN_LIG': 'Z', 'SIDECHAIN': True, 'DIST_H-A': '3.12', 'DIST_D-A': '3.54', 'DON_ANGLE': '109.13', 'PROTISDON': True, 'DONORIDX': 794, \n",
    "'DONORTYPE': 'O3', 'ACCEPTORIDX': 1487, 'ACCEPTORTYPE': 'Nar', 'LIGCOO': (30.318, 31.87, 23.532), 'PROTCOO': (31.314, 30.247, 26.514)}]}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4384ba98",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "cc47555a",
   "metadata": {},
   "source": [
    "### <font color='green'>3. Geomol </font>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4af7c3de",
   "metadata": {},
   "source": [
    "Prediction of a molecule’s 3D conformer ensemble from the molecular graph holds a key role in areas of cheminformatics and drug discovery. We are using a machine learning approach to generate distributions of low-energy molecular 3D conformers. Leveraging the power of message passing neural networks (MPNNs) to capture local and global graph information, we predict local atomic 3D structures and torsion angles, and using these we are assembling the whole conformer for that molecule. The original work is done by Department of Chemical Engineering, MIT, Cambridge. For more details visit :  https://arxiv.org/pdf/2106.07802.pdf\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b558fa68",
   "metadata": {},
   "source": [
    "######  For training the model ->"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a20d8718",
   "metadata": {},
   "source": [
    "###### Data for training:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "937c3623",
   "metadata": {},
   "source": [
    "GEOM is a dataset with over 37 million molecular conformations annotated by energy and statistical weight for over 450,000 molecules. Here we will use a subset of it. you can download the dataset by clicking the link bellow"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d02dc3cf",
   "metadata": {},
   "source": [
    "https://dataverse.harvard.edu/api/access/datafile/4327252\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d312871",
   "metadata": {},
   "source": [
    "After downloading and unzipping the file you will get a folder name rdkit_folder under that 2 diffrent dataset will be there.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3766a118",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "\n",
    "rdkit_folder/\n",
    "             drugs/\n",
    "                    smile_seq1.pickle\n",
    "                    smile_seq2.pickle\n",
    "                    .\n",
    "                    .\n",
    "                    304340 pickle files\n",
    "             qm9/\n",
    "                    smile_name1.pickle\n",
    "                    smile_name2.pickle\n",
    "                    .\n",
    "                    .\n",
    "                    133232 pickle files\n",
    "\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b9de873",
   "metadata": {},
   "source": [
    "or if you just want to try on sample datset then we have created a sample dataset by randomly selecting datapoints from original dataset. You can download the sample dataset through the link :"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db5d3e62",
   "metadata": {},
   "source": [
    "https://drive.google.com/drive/folders/1Y7gktdSyq3iu6OmHXVdUfgANvtOq9GU_?usp=sharing"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "922d5ef3",
   "metadata": {},
   "source": [
    "###### Training of model:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f87fc39",
   "metadata": {},
   "source": [
    "Once you have the dataset you can start training the model. For that can execute model.py file with the following command :\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b77e6719",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "\n",
    "python model.py --data_dir {pat_of_the_dataset_directory(drugs or qm9)}  --n_epochs {max_number_of_epoch} --\n",
    "dataset {which_dataset_will_be_used_for_training_('drugs' or 'qm9')\n",
    "\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7c5f18d",
   "metadata": {},
   "source": [
    "after executing you will get a new folder called \"lightning_logs\".\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed755455",
   "metadata": {},
   "source": [
    "###### Generating similiar molecules with trained model ->"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89269437",
   "metadata": {},
   "source": [
    "After training of model you can start generating 3d representation of molecules. For this you can use generate_conformers function from predict.py script. This function takes a list of smiles and returns a dictionary containing smile as the key and values as a list of generated conformers.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "07e9b2d5",
   "metadata": {},
   "outputs": [],
   "source": [
    "from molpro.geomol.predict import generate_conformers\n",
    "generated_conformers =  generate_conformers(input_smiles:List[str],hparams_path:str=None,checkpoint_path :str=None,\n",
    "                            n_conformers:int=10,dataset :str =\"drugs\",mmff: bool =False) \n",
    "\n",
    "\"\"\"\n",
    "    input_smiles : List[str]\n",
    "                   those simles for which you want to generated 3d-conformer. input should be in ['smile_1,smiles_2,.....,smile_n] format\n",
    "    hparams_path : str\n",
    "                   path for the hparams.yaml file. which is under lightning_logs folder\n",
    "    ckpt_path    : str \n",
    "                   path of the ckpt file. which is under lightning_logs/checkpoints directory\n",
    "    n_conformers : int\n",
    "                   how many number of conformers you want to generate per smile\n",
    "    dataset : str\n",
    "                   By which model you want to generate the conformers ('drugs' or 'qm9')\n",
    "    mmff : bool \n",
    "                   want to optimize the generated conformers by adding 'MMff94s' energy.?\n",
    "                   \"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eab2ab38",
   "metadata": {},
   "outputs": [],
   "source": [
    "# returns\n",
    "\"\"\"generated_conformers = {\"smile_1\":[gen_conf_1,gen_conf_2......,gen_conf_n],\n",
    "                        \"smile_2\":[gen_conf_1,gen_conf_2......,gen_conf_n],\n",
    "                        .\n",
    "                        .\n",
    "                        .\n",
    "                        \"smile_+str(len(input_smiles))\": [gen_conf_1,gen_conf_2.......,gen_conf_n] }\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c5fe82f5",
   "metadata": {},
   "outputs": [],
   "source": [
    "from rdkit import Chem\n",
    "from ipywidgets import interact, fixed, IntSlider\n",
    "import ipywidgets\n",
    "import py3Dmol"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "30188c09",
   "metadata": {},
   "outputs": [],
   "source": [
    "def show_mol(mol, view, grid):\n",
    "    mb = Chem.MolToMolBlock(mol)\n",
    "    view.removeAllModels(viewer=grid)\n",
    "    view.addModel(mb,'sdf', viewer=grid)\n",
    "    view.setStyle({'model':0},{'stick': {}}, viewer=grid)\n",
    "    view.zoomTo(viewer=grid)\n",
    "    return view\n",
    "\n",
    "def view_single(mol):\n",
    "    view = py3Dmol.view(width=600, height=600, linked=False, viewergrid=(1,1))\n",
    "    show_mol(mol, view, grid=(0, 0))\n",
    "    return view\n",
    "\n",
    "def MolTo3DView(mol, size=(600, 600), style=\"stick\", surface=False, opacity=0.5, confId=0):\n",
    "    \"\"\"Draw molecule in 3D\n",
    "    \n",
    "    Args:\n",
    "    ----\n",
    "        mol: rdMol, molecule to show\n",
    "        size: tuple(int, int), canvas size\n",
    "        style: str, type of drawing molecule\n",
    "               style can be 'line', 'stick', 'sphere', 'carton'\n",
    "        surface, bool, display SAS\n",
    "        opacity, float, opacity of surface, range 0.0-1.0\n",
    "    Return:\n",
    "    ----\n",
    "        viewer: py3Dmol.view, a class for constructing embedded 3Dmol.js views in ipython notebooks.\n",
    "    \"\"\"\n",
    "    assert style in ('line', 'stick', 'sphere', 'carton')\n",
    "    mblock = Chem.MolToMolBlock(mol[confId])\n",
    "    viewer = py3Dmol.view(width=size[0], height=size[1])\n",
    "    viewer.addModel(mblock, 'mol')\n",
    "    viewer.setStyle({style:{}})\n",
    "    if surface:\n",
    "        viewer.addSurface(py3Dmol.SAS, {'opacity': opacity})\n",
    "    viewer.zoomTo()\n",
    "    return viewer\n",
    "\n",
    "def conf_viewer(idx, mol):\n",
    "    return MolTo3DView(mol, confId=idx).show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "62afa841",
   "metadata": {},
   "outputs": [],
   "source": [
    "index_of_smile = 0 # index of the smile in input_smile list for which you want to visualise generated conformers\n",
    "\n",
    "smile = input_smiles[index_of_smile]\n",
    "print(\"Smile is :\",smile)\n",
    "\n",
    "mol_graph = Chem.MolFromSmiles(smi)\n",
    "print(\"Graph of smile is :\\n\")\n",
    "display(mol_graph)\n",
    "\n",
    "mols = generated_conformers.get(smile)\n",
    "interact(conf_viewer, idx=ipywidgets.IntSlider(min=0, max=len(mols)-1, step=1), mol=fixed(mols));"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "65a4b241",
   "metadata": {},
   "source": [
    "### <font color='green'>4. Shape Alignment </font>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b43fe783",
   "metadata": {},
   "source": [
    "###### <font color='green'>To align small molecules and calculate their 3D similarity between them. </font>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "19d75c0b",
   "metadata": {},
   "source": [
    "In drug discovery, common atomic level information of the small molecules / drugs aren't avaiable. In such cases, 3D arrangement (or superposition) of putative ligands have been utilized to conclude underlying necessities for organic movement. Various techniques are proposed for little atomic superposition or primary arrangement. These techniques can be ordered generally into two kinds, in particular point-based and property-based strategies. In point-based strategies, sets of molecules or pharmacophoric focuses are superposed by the least-squares fitting. Notwithstanding, in property-based techniques, different sub-atomic properties are used for superposition, including electron thickness, sub-atomic volume or shape, charge conveyance or sub-atomic electrostatic potential (MEP), hydrophobicity, hydrogen holding capacity, etc."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9d66361",
   "metadata": {},
   "source": [
    "#### There are two function under this feature: "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af5d1e2c",
   "metadata": {},
   "source": [
    "###### <font color='blue'> 1. To find similarities of one smile with user's small size custom library </font>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e40e4bac",
   "metadata": {},
   "source": [
    "###### How to use it?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "32b610f0",
   "metadata": {},
   "outputs": [],
   "source": [
    "from molpro.shape_alignment import UPA\n",
    "\n",
    "input_smiles=[smile1,smile2,smile3,....,smileN]\n",
    "\n",
    "data_out=UPA(query_smile,input_smiles)\n",
    "\n",
    "# Input Parametrs\n",
    "\"\"\"\n",
    "input_smiles : List[str]\n",
    "          Simles for which you want to Find similarity with query smile. input should be in ['smile_1,smiles_2,.....,smile_n] format\n",
    "query_smile: str\n",
    "    Smile for which you wnat to find the similarities. \n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cf7214b3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Returns :\n",
    "\"\"\"\n",
    " data_out: pandas DataFrame\n",
    "          DataFrame with smiles,taget_id(Library ID),fp_score(fingerprint score),Shape_similarity\n",
    "          (3D shape similarity score),query_path(user smile's aligned SDF file path),hit_path(aligned SDF file path\n",
    "          Smile from library which is similary to query smiles ) \n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "63534a82",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "7765ba90",
   "metadata": {},
   "source": [
    "###### <font color='blue'> 2. To screen a huge library which meets the similarity thresholds with given query smile. </font>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca78a1a9",
   "metadata": {},
   "source": [
    "###### How to use it?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fa8d9dda",
   "metadata": {},
   "outputs": [],
   "source": [
    "from molpro.shape_alignment import library_screening\n",
    "\n",
    "library_path=\"chembl/surechembl path\"\n",
    "\n",
    "data_out=UPA(library_path,smile)\n",
    "\n",
    "# Input Parameters\n",
    "\"\"\"\n",
    "library_path : Str,\n",
    "        Chembl / Surechembl or any huge libraries.Pickle File contains the ID,SMILES, and Fingerprint(\n",
    "            morgan figerprint radius 2 and bits 1024) \n",
    "smile: Str,\n",
    "        Query smile whose similar smiles need to be screened\n",
    "thres: float\n",
    "        Minimum 3D similarity score that smiles need to meet. Default: 0.6\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8851b32a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Returns \n",
    "\n",
    "\"\"\"data_out: pandas DataFrame\n",
    "        DataFrame with smiles,taget_id(Library ID),fp_score(fingerprint score),Shape_similarity\n",
    "        (3D shape similarity score),query_path(user smile's aligned SDF file path),hit_path(aligned SDF file path\n",
    "        Smile from library which is similary to query smiles )\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "806ed33b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "cfc33f30",
   "metadata": {},
   "source": [
    "### <font color='green'>5. Shape Based Generator: </font>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3980dc01",
   "metadata": {},
   "source": [
    "The generative design of novel scaffolds and functional groups can cover unexplored regions of chemical space that still possess lead-like properties. Here we are using an AI approach to generate novel molecules starting from a seed compound, its three-dimensional (3D) shape. A variational autoencoder is used to generate the 3D representation of a compound, followed by a system of convolutional for encoding and recurrent neural networks that generate a sequence of SMILES tokens. The generative design of novel scaffolds and functional groups can cover unexplored regions of chemical space that still possess lead-like properties.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d276e13",
   "metadata": {},
   "source": [
    "###### For training the model ->"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df3d201c",
   "metadata": {},
   "source": [
    "###### Data for training:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6045f8de",
   "metadata": {},
   "source": [
    " We will be using a subset of Zinc15 dataset for our model training. That will only have drug like smiles. you can download the dataset by clicking the link given bellow:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da229a5b",
   "metadata": {},
   "source": [
    "http://pub.htmd.org/zinc15_druglike_clean_canonical_max60.zip"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4132c70",
   "metadata": {},
   "source": [
    "After downloading unzipping the file you will get a .smi file as name \"zinc15_druglike_clean_canonical_max60.smi\". which will have smiles.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "465ce4c1",
   "metadata": {},
   "source": [
    "or if you just want to try on sample datset then we have created a sample dataset by randomly selecting datapoints from original dataset. You can download the sample dataset through the link :"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4a2be7d3",
   "metadata": {},
   "source": [
    "https://drive.google.com/drive/folders/1CBakMNrUu-mJdH6oJJzNT1dcDVj6ECJV?usp=sharing"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8fe5c76",
   "metadata": {},
   "source": [
    "###### Training of model:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56272e95",
   "metadata": {},
   "source": [
    "Once you have the dataset you can start training the model. For that can execute model.py file with the following command through your terminal:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c26262c9",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "python model.py --input_path {path_for_.smi_file} --batch_size {your_batch_size} \n",
    "                       --max_epochs {max_numnber_of_epochs}\n",
    "                       --num_workers {num_of_workers}\n",
    "                       --device {'cpu'_or_'gpu'} --gpus {num_of_gpus_for_training}\n",
    "\"\"\"\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aff3146e",
   "metadata": {},
   "source": [
    "after executing you will get a new folder called \"lightning_logs\" in the working directory.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae8dbaa0",
   "metadata": {},
   "source": [
    "###### Generating similiar molecules with trained model ->"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "380fca32",
   "metadata": {},
   "source": [
    "After training of model you can start generating 3d representation of molecules. For this you can use generate_conformers function from predict.py script. This function takes a list of smiles and returns a dictionary containing smile as the key and values as a list of generated conformers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3eb21d2c",
   "metadata": {},
   "outputs": [],
   "source": [
    "from molpro.geomol.predict import generate_conformers\n",
    "generated_conformers =  generate_conformers(input_smiles:List[str],hparams_path:str=None,checkpoint_path :str=None,\n",
    "                            n_conformers:int=10,dataset :str =\"drugs\",mmff: bool =False) \n",
    "\n",
    "\"\"\"\n",
    "    input_smiles : List[str]\n",
    "                   those simles for which you want to generated 3d-conformer. input should be in ['smile_1,smiles_2,.....,smile_n] format\n",
    "    hparams_path : str\n",
    "                   path for the hparams.yaml file. which is under lightning_logs folder\n",
    "    ckpt_path    : str \n",
    "                   path of the ckpt file. which is under lightning_logs/checkpoints directory\n",
    "    n_conformers : int\n",
    "                   how many number of conformers you want to generate per smile\n",
    "    dataset : str\n",
    "                   By which model you want to generate the conformers ('drugs' or 'qm9')\n",
    "    mmff : bool \n",
    "                   want to optimize the generated conformers by adding 'MMff94s' energy.?\n",
    "                   \"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9cc68dce",
   "metadata": {},
   "outputs": [],
   "source": [
    "# returns \n",
    "\n",
    "\"\"\"\n",
    "generated_smiles = {\"smile_1\":[gen_smi_1,gen_smi_2......,gen_smi_n],\n",
    "                    \"smile_2\":[gen_smi_1,gen_smi_2......,gen_smi_n],\n",
    "                    .\n",
    "                    .\n",
    "                    .\n",
    "                    \"smile_+str(len(input_smiles))\": [gen_smi_1,gen_smi_2.......,gen_smi_n] }\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "48ce90f2",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "e4c42179",
   "metadata": {},
   "source": [
    "### <font color='green'>6. Site Based Gen </font>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d83525d7",
   "metadata": {},
   "source": [
    "###### <font color='green'>Generating novel molecules accoding to a given protein binding site\n",
    "</font>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5512c540",
   "metadata": {},
   "source": [
    "A novel method was developed to generate focused virtual libraries of small molecules based on the protein structure using deep learning-based generative models. Structures of protein–ligand complexes obtained from ligand docking are used to train a generative adversarial model to generate compound structures that are complementary to protein but also maintain diversity among themselves. Reference: https://doi.org/10.1021/acs.molpharmaceut.9b00634"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9dc44b92",
   "metadata": {},
   "source": [
    "######  Preparing dataset:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9281e0e6",
   "metadata": {},
   "source": [
    "We will be using a subset of PDBBind dataset given in the sample data folder for training. you can download the sample data from given link :"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f58e539a",
   "metadata": {},
   "source": [
    "https://drive.google.com/drive/folders/1pmoC4uBAiCkZHwYYaCAJg0OS3qlR-cgs?usp=sharing"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb743a77",
   "metadata": {},
   "source": [
    "you can prepare the data for training from the raw data by running this command :\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "42dc5b57",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "\n",
    "python data.py --data_path {path where pdb and mol2 files are stored} \n",
    "                   --hdf_path {path where processed dataset is set to be stored}\n",
    "                   --df_path {path to csv file containing pdb ids and associated smiles} \n",
    "\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "87e0476d",
   "metadata": {},
   "source": [
    "##### Training model: "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b88048d0",
   "metadata": {},
   "source": [
    "Once you have the dataset you can start training the model. For that can execute model.py file with the following command :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "73a0f281",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "\n",
    "python model.py --hdf_path {path where dataset is stored} --train_ids_path {path where list of train ids is stored} \n",
    "            --val_ids_path {path where list of validation ids is stored} \n",
    "            --test_ids_path {path where list of test ids is stored} \n",
    "            --batch_size {batch size for model training} --max_epochs {epochs to train for} \n",
    "            --num_workers {number of workers for dataloader} --gpus {num_of_gpus_for_training: None for 'cpu'}\n",
    "\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c1a8971",
   "metadata": {},
   "source": [
    "after executing you will get a new folder called \"lightning_logs\".\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1490b03f",
   "metadata": {},
   "source": [
    "###### Generate novel molecules: "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14efd0dd",
   "metadata": {},
   "source": [
    "After training the model the checkpoint file saved in lightning_logs can be used for generating novel molecules. The protein file should be protonated and not contain heteroatoms (water or ligand)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d9fb1f8d",
   "metadata": {},
   "outputs": [],
   "source": [
    "from molpro.site_based_gen.predict import generate_smiles\n",
    "smiles = generate_smiles(protein_file_path, protein_file_type, generator_checkpoint_path, \n",
    "                         captioning_checkpoint_path, generator_steps, decoding_steps)\n",
    "\n",
    "# Input Parameters\n",
    "\"\"\"\n",
    "protein_file_path : str\n",
    "               Path to protein file\n",
    "protein_file_type : str\n",
    "               File format of protein (mol2,pdb,pdbqt)\n",
    "generator_checkpoint_path : str\n",
    "               Path to the checkpoint of saved generated model\n",
    "captioning_checkpoint_path : str\n",
    "               Path to the checkpoint of saved shape captioning model\n",
    "generator_steps : str \n",
    "               The number of times a unique ligand shape is produced\n",
    "decoding_steps : str \n",
    "               The number of times a unique ligand shape is decoded into SMILES\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d875d30c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Returns :\n",
    "\"\"\"\n",
    "\n",
    "A list of SMILES containing less than or equal to generator_steps x decoding_steps entries : List[str]\n",
    "\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3e710e8b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "249fa7c2",
   "metadata": {},
   "source": [
    "### <font color='green'>7. Site Prediction </font>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "faf6c640",
   "metadata": {},
   "source": [
    "###### <font color='green'>Predicting the binding site of a protein ligand complex (Binding site prediction)</font>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc3c1f2b",
   "metadata": {},
   "source": [
    "The aim of rational drug design is to discover new drugs faster and cheaper. Much of the effort is put into improving docking and scoring methodologies. However, most techniques assume that the exact location of binding sites – also referred to as pockets or binding cavities – is known. Such pockets can be located both on a surface of a single protein (and be used to modulate its activity) or at protein-protein interaction (PPI) interfaces (and be used to disrupt the interaction). This task is very challenging and we lack a method that would predict binding sites with high accuracy – most methods are able to detect only 30%–40% of pockets. In our case, the input is a 3D structure of a protein represented with a grid that can be analyzed in the same manner as 3D images, whereas the desired object is the binding pocket. Our model is based on U-Net – a state of the art model for image segmentation. The model takes protein structure as input, automatically converts it to a 3D grid with features, and outputs probability density – each point in the 3D space has assigned probability of being a part of a pocket. Reference : https://doi.org/10.1038/s41598-020-61860-z"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42eea026",
   "metadata": {},
   "source": [
    "###### Preparing dataset:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1fd9276",
   "metadata": {},
   "source": [
    "We will be using a subset of scPDB dataset given in the sample data folder for training. You can download the sample data from given link :\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96bfebe5",
   "metadata": {},
   "source": [
    "https://drive.google.com/drive/folders/1Z6WV3Pk6EQgUtWMEHn7xx1zhh2_dhFlh?usp=sharing"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "985ceb1f",
   "metadata": {},
   "source": [
    "you can prepare the data for training from the raw data by running this command :\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a2542f3a",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "\n",
    "python data.py --data_path {path where pdb and mol2 files are stored} \n",
    "             --hdf_path {path where processed dataset is set to be stored}\n",
    "\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b0444f0e",
   "metadata": {},
   "source": [
    "###### Training model:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8e6337a",
   "metadata": {},
   "source": [
    "Once you have the dataset you can start training the model. For that can execute model.py file with the following command :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "352fbb67",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "\n",
    "python model.py --hdf_path {path where dataset is stored} --train_ids_path {path where list of train ids is stored} \n",
    "               --val_ids_path {path where list of validation ids is stored} \n",
    "               --test_ids_path {path where list of test ids is stored} \n",
    "               --batch_size {batch size for model training} --max_epochs {epochs to train for} \n",
    "               --num_workers {number of workers for dataloader} --gpus {num_of_gpus_for_training: None for 'cpu'}\n",
    "\n",
    "\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "587c4a65",
   "metadata": {},
   "source": [
    "after executing you will get a new folder called \"lightning_logs\" in the same directory."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2fdabacc",
   "metadata": {},
   "source": [
    "###### Binding site prediction:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5e0a6b9a",
   "metadata": {},
   "outputs": [],
   "source": [
    "from molpro.site_pred.predict import predict_pocket_atoms, write_to_file\n",
    "\n",
    "mols = predict_pocket_atoms(protein_file_path, protein_file_type, model_checkpoint_path) # Returns openbabel mol objects\n",
    "write_to_file(mols, file_path, file_type)\n",
    "\n",
    "# Input Parameters\n",
    "\"\"\"\n",
    "protein_file_path : str\n",
    "               Path to protein file\n",
    "protein_file_type : str\n",
    "               File format of protein (mol2,pdb,pdbqt)\n",
    "file_path : str\n",
    "               Path to output file\n",
    "file_type : str\n",
    "               File format of output file (mol2,pdb,pdbqt)\n",
    "model_checkpoint_path : str \n",
    "               Path to the checkpoint of saved model\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eb3fd34f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Returns :\n",
    "\n",
    "\"\"\"\n",
    "Output files are stored according to output format and file name\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a8d3d209",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:molpro]",
   "language": "python",
   "name": "conda-env-molpro-py"
  },
  "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.7.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}