notebooks/Reinforcement_Learning_Demo_DockStream.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **How to run this notebook (command-line)?**\n",
    "1. Install the `ReinventCommunity` environment:\n",
    "`conda env create -f environment.yml`\n",
    "2. Activate the environment:\n",
    "`conda activate ReinventCommunity`\n",
    "3. Execute `jupyter`:\n",
    "`jupyter notebook`\n",
    "4. Copy the link to a browser\n",
    "\n",
    "\n",
    "# `REINVENT 3.2`: reinforcement learning with DockStream (docking)\n",
    "\n",
    "\n",
    "This is a simple example of running `Reinvent` with only 1 score component (`DockStream`). To execute this notebook, make sure you have cloned the `DockStream` repository from GitHub and installed the conda environment.\n",
    "\n",
    "**NOTE: There is a detailed reasoning for each `REINVENT` code block provided in the `Reinforcement Learning Demo` notebook.**\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Set up the paths\n",
    "_Please update the following code block such that it reflects your system's installation and execute it._"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load dependencies\n",
    "import os\n",
    "import re\n",
    "import json\n",
    "import tempfile\n",
    "\n",
    "# --------- change these path variables as required\n",
    "reinvent_dir = os.path.expanduser(\"~/Desktop/Reinvent\")\n",
    "reinvent_env = os.path.expanduser(\"~/miniconda3/envs/reinvent.v3.2\")\n",
    "\n",
    "# DockStream variables\n",
    "dockstream_dir = os.path.expanduser(\"~/Desktop/ProjectData/DockStream\")\n",
    "dockstream_env = os.path.expanduser(\"~/miniconda3/envs/DockStream/bin/python\")\n",
    "# generate the path to the DockStream entry points\n",
    "docker_path = os.path.join(dockstream_dir, \"docker.py\")\n",
    "\n",
    "output_dir = os.path.expanduser(\"~/Desktop/REINVENT_RL_DockStream_demo\")\n",
    "\n",
    "# --------- do not change\n",
    "# get the notebook's root path\n",
    "try: ipynb_path\n",
    "except NameError: ipynb_path = os.getcwd()\n",
    "\n",
    "# if required, generate the folder to store the results\n",
    "try:\n",
    "    os.mkdir(output_dir)\n",
    "except FileExistsError:\n",
    "    pass\n",
    "\n",
    "# Glide docking variables\n",
    "grid_file_path = os.path.expanduser(\"~/Desktop/ReinventCommunity/notebooks/data/DockStream/1UYD_grid.zip\")\n",
    "output_ligands_docked_poses_path = os.path.expanduser(\"~/Desktop/REINVENT_RL_DockStream_demo/docked_poses\")\n",
    "output_ligands_docking_scores_path = os.path.expanduser(\"~/Desktop/REINVENT_RL_DockStream_demo/docking_scores\")\n",
    "\n",
    "try:\n",
    "    os.mkdir(output_ligands_docked_poses_path)\n",
    "except FileExistsError:\n",
    "    pass\n",
    "\n",
    "try:\n",
    "    os.mkdir(output_ligands_docking_scores_path)\n",
    "except FileExistsError:\n",
    "    pass\n",
    "\n",
    "docking_configuration_path = os.path.join(output_dir, \"Glide_DockStream_Conf.json\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Set up the `DockStream` Configuration\n",
    "_Please update the following code block such that it reflects your system's installation and execute it._\n",
    "\n",
    "In this notebook, we will demonstrate how to use `DockStream` with `REINVENT`. `Glide` with `LigPrep` will be used as the molecular docking component. For more details regarding using `Glide` in `DockStream`, see the `demo_Glide` notebook in the `DockStreamCommunity` repository. There, all details and supported functionalities are presented. The `Glide` with `LigPrep` configuration used in this notebook is the simplest case."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# specify the embedding and docking JSON file as a dictionary and write it out\n",
    "ed_dict = {\n",
    "  \"docking\": {\n",
    "    \"header\": {                                   # general settings\n",
    "      \"environment\": {\n",
    "      }\n",
    "    },\n",
    "    \"ligand_preparation\": {                       # the ligand preparation part, defines how to build the pool\n",
    "      \"embedding_pools\": [\n",
    "        {\n",
    "          \"pool_id\": \"Ligprep_pool\",\n",
    "          \"type\": \"Ligprep\",\n",
    "          \"parameters\": {\n",
    "            \"prefix_execution\": \"module load schrodinger/2019-4\",\n",
    "            \"parallelization\": {\n",
    "                \"number_cores\": 2\n",
    "            },\n",
    "            \"use_epik\": {\n",
    "              \"target_pH\": 7.0,\n",
    "              \"pH_tolerance\": 2.0\n",
    "            },\n",
    "            \"force_field\": \"OPLS3e\"\n",
    "          },\n",
    "          \"input\": {\n",
    "            \"standardize_smiles\": False,\n",
    "            \"type\": \"console\"                     # input type \"console\" when using DockStream with REINVENT\n",
    "          }\n",
    "        }\n",
    "      ]\n",
    "    },\n",
    "    \"docking_runs\": [\n",
    "        {\n",
    "          \"backend\": \"Glide\",\n",
    "          \"run_id\": \"Glide_run\",\n",
    "           \"input_pools\": [\"Ligprep_pool\"],\n",
    "          \"parameters\": {\n",
    "              \"prefix_execution\": \"module load schrodinger/2020-4\", # will be executed before a program call\n",
    "              \"parallelization\": {                                  # if present, the number of cores to be used\n",
    "                                                                    # can be specified\n",
    "            \"number_cores\": 2\n",
    "          },\n",
    "          \"glide_flags\": {                                  # all all command-line flags for Glide here \n",
    "            \"-HOST\": \"localhost\"\n",
    "          },\n",
    "          \"glide_keywords\": {                               # add all keywords for the \"input.in\" file here\n",
    "                                                            # this is the minimum keywords that needs to be \n",
    "                                                            # specified and represents a simple `Glide` \n",
    "                                                            # docking configuration\n",
    "                                                            \n",
    "            \"GRIDFILE\": grid_file_path,\n",
    "            \"POSE_OUTTYPE\": \"ligandlib_sd\",\n",
    "            \"PRECISION\": \"HTVS\"\n",
    "          }\n",
    "        },\n",
    "        \"output\": {\n",
    "          \"poses\": { \"poses_path\": os.path.join(output_ligands_docked_poses_path, \"docked_poses.sdf\")},\n",
    "          \"scores\": { \"scores_path\": os.path.join(output_ligands_docking_scores_path, \"docking_scores.csv\")}\n",
    "        }\n",
    "      }]}}\n",
    "\n",
    "with open(docking_configuration_path, 'w') as f:\n",
    "    json.dump(ed_dict, f, indent=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Set up the `REINVENT` configuration \n",
    "In the cells below we will build a nested dictionary object that will be eventually converted to JSON file which in turn will be consumed by `REINVENT`. \n",
    "You can find this file in your `output_dir` location."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A) Declare the run type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# initialize the dictionary\n",
    "configuration = {\n",
    "    \"version\": 3,                          # we are going to use REINVENT's newest release\n",
    "    \"run_type\": \"reinforcement_learning\",  # other run types: \"sampling\", \"validation\",\n",
    "                                           #                  \"transfer_learning\",\n",
    "                                           #                  \"scoring\" and \"create_model\"\n",
    "    \"model_type\": \"default\"\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### B) Sort out the logging details\n",
    "This includes `result_folder` path where the results will be produced.\n",
    "\n",
    "Also: `REINVENT` can send custom log messages to a remote location. We have retained this capability in the code. if the `recipient` value differs from `\"local\"` `REINVENT` will attempt to POST the data to the specified `recipient`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# add block to specify whether to run locally or not and\n",
    "# where to store the results and logging\n",
    "configuration[\"logging\"] = {\n",
    "    \"sender\": \"http://0.0.0.1\",            # only relevant if \"recipient\" is set to \"remote\"\n",
    "    \"recipient\": \"local\",                  # either to local logging or use a remote REST-interface\n",
    "    \"logging_frequency\": 1,                # log every x-th steps\n",
    "    \"logging_path\": os.path.join(output_dir, \"progress.log\"), # load this folder in tensorboard\n",
    "    \"result_folder\": os.path.join(output_dir, \"results\"),         # will hold the compounds (SMILES) and summaries\n",
    "    \"job_name\": \"Reinforcement learning DockStream demo\",         # set an arbitrary job name for identification\n",
    "    \"job_id\": \"demo\"                       # only relevant if \"recipient\" is set to a specific REST endpoint\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create `parameters` field:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# add the \"parameters\" block\n",
    "configuration[\"parameters\"] = {}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### C) Set Diversity Filter\n",
    "During each step of Reinforcement Learning the compounds scored above `minscore` threshold are kept in memory. Those scored smiles are written out to a file in the results folder `scaffold_memory.csv`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# add a \"diversity_filter\"\n",
    "configuration[\"parameters\"][\"diversity_filter\"] =  {\n",
    "    \"name\": \"IdenticalMurckoScaffold\",     # other options are: \"IdenticalTopologicalScaffold\", \n",
    "                                           #                    \"NoFilter\" and \"ScaffoldSimilarity\"\n",
    "                                           # -> use \"NoFilter\" to disable this feature\n",
    "    \"nbmax\": 25,                           # the bin size; penalization will start once this is exceeded\n",
    "    \"minscore\": 0.4,                       # the minimum total score to be considered for binning\n",
    "    \"minsimilarity\": 0.4                   # the minimum similarity to be placed into the same bin\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### D) Set Inception\n",
    "* `smiles` provide here a list of smiles to be incepted \n",
    "* `memory_size` the number of smiles allowed in the inception memory\n",
    "* `sample_size` the number of smiles that can be sampled at each reinforcement learning step from inception memory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# prepare the inception (we do not use it in this example, so \"smiles\" is an empty list)\n",
    "configuration[\"parameters\"][\"inception\"] = {\n",
    "    \"smiles\": [],                          # fill in a list of SMILES here that can be used (or leave empty)\n",
    "    \"memory_size\": 100,                    # sets how many molecules are to be remembered\n",
    "    \"sample_size\": 10                      # how many are to be sampled each epoch from the memory\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### E) Set the general Reinforcement Learning parameters\n",
    "* `n_steps` is the amount of Reinforcement Learning steps to perform. Best start with 1000 steps and see if thats enough.\n",
    "* `agent` is the generative model that undergoes transformation during the Reinforcement Learning run.\n",
    "\n",
    "We reccomend keeping the other parameters to their default values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# set all \"reinforcement learning\"-specific run parameters\n",
    "configuration[\"parameters\"][\"reinforcement_learning\"] = {\n",
    "    \"prior\": os.path.join(ipynb_path, \"models/random.prior.new\"), # path to the pre-trained model\n",
    "    \"agent\": os.path.join(ipynb_path, \"models/random.prior.new\"), # path to the pre-trained model\n",
    "    \"n_steps\": 2,                          # the number of epochs (steps) to be performed; often 1000\n",
    "                                           # (set to 2 in this notebook to decrease docking computation time -\n",
    "                                           # it is not expected that the agent will appreciably learn to\n",
    "                                           # generate compounds with good docking scores in only 2 epochs.\n",
    "                                           # The purpose of this notebook is to illustrate how DockStream \n",
    "                                           # can be specified as a component to the `Scoring Function`)\n",
    "    \n",
    "    \"sigma\": 128,                          # used to calculate the \"augmented likelihood\", see publication\n",
    "    \"learning_rate\": 0.0001,               # sets how strongly the agent is influenced by each epoch\n",
    "    \"batch_size\": 8,                      # specifies how many molecules are generated per epoch, often 128\n",
    "                                           # docking becomes more computationally demanding the greater the\n",
    "                                           # batch size, as each compound must be docked. Depending on the\n",
    "                                           # docking configuration, embedding ligands may generate different \n",
    "                                           # tautomers, ionization states, etc., which will increase the number\n",
    "                                           # of compounds that need to be docked. Batch size is set to 8 in \n",
    "                                           # this notebook to decrease docking computation time and just \n",
    "                                           # for illustration)\n",
    "    \"margin_threshold\": 50                 # specify the (positive) margin between agent and prior\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### F) Define the scoring function\n",
    "The scoring function will consist only of the `DockStream` component, in which `Glide` with `LigPrep` is used for molecular docking."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# prepare the scoring function definition and add at the end\n",
    "scoring_function = {\n",
    "    \"name\": \"custom_product\",                  # this is our default one (alternative: \"custom_sum\")\n",
    "    \"parallel\": False,                         # sets whether components are to be executed\n",
    "                                               # in parallel; note, that python uses \"False\" / \"True\"\n",
    "                                               # but the JSON \"false\" / \"true\"\n",
    "\n",
    "    # the \"parameters\" list holds the individual components\n",
    "    \"parameters\": [\n",
    "\n",
    "    # add component: use \n",
    "    {\n",
    "    \"component_type\": \"dockstream\",                           # use DockStream as a Scoring Function component      \n",
    "    \"name\": \"Glide LigPrep Docking\",                          # arbitrary name\n",
    "    \"weight\": 1,\n",
    "    \"specific_parameters\": {\n",
    "        \"transformation\": {\n",
    "            \"transformation_type\": \"reverse_sigmoid\",         # lower Glide scores are better - use reverse\n",
    "                                                              # sigmoid transformation\n",
    "            \"low\": -11,\n",
    "            \"high\": -5,\n",
    "            \"k\": 0.25\n",
    "            },\n",
    "        \"configuration_path\": docking_configuration_path,\n",
    "        \"docker_script_path\": docker_path,\n",
    "        \"environment_path\": dockstream_env\n",
    "        }\n",
    "    }]\n",
    "}\n",
    "configuration[\"parameters\"][\"scoring_function\"] = scoring_function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Write out the `REINVENT` configuration"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now have successfully filled the dictionary and will write it out as a `JSON` file in the output directory. Please have a look at the file before proceeding in order to see how the paths have been inserted where required and the `dict` -> `JSON` translations (e.g. `True` to `true`) have taken place."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# write the configuration file to the disc\n",
    "configuration_JSON_path = os.path.join(output_dir, \"RL_DockStream_config.json\")\n",
    "with open(configuration_JSON_path, 'w') as f:\n",
    "    json.dump(configuration, f, indent=4, sort_keys=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Run `REINVENT`\n",
    "Now it is time to execute `REINVENT` locally. Note, that depending on the number of epochs (steps) and the execution time of the scoring function components, this might take a while. As we have only specified a low number of epochs (125) and all components should be fairly quick, this should not take too long in our case though.\n",
    "\n",
    "The command-line execution looks like this:\n",
    "```\n",
    "# activate envionment\n",
    "conda activate reinvent.v3.2\n",
    "\n",
    "# execute REINVENT\n",
    "python <your_path>/input.py <config>.json\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%capture captured_err_stream --no-stderr\n",
    "\n",
    "# execute REINVENT from the command-line\n",
    "!{reinvent_env}/bin/python {reinvent_dir}/input.py {configuration_JSON_path}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# print the output to a file, just to have it for documentation\n",
    "with open(os.path.join(output_dir, \"run.err\"), 'w') as file:\n",
    "    file.write(captured_err_stream.stdout)\n",
    "\n",
    "# prepare the output to be parsed\n",
    "list_epochs = re.findall(r'INFO.*?local', captured_err_stream.stdout, re.DOTALL)\n",
    "data = [epoch for idx, epoch in enumerate(list_epochs)]\n",
    "data = [\"\\n\".join(element.splitlines()[:-1]) for element in data]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have calculated a total of 2 epochs, let us quickly investigate how the agent fared in the first epoch. Below you see the print-out of the first epoch. Running `REINVENT` with `DockStream` for more epochs will show that the agent gradually improves over time, i.e, generates compounds that satisfy the docking component, thus generating compounds that dock well. Note, that the fraction of valid `SMILES` is high right from the start (because we use a pre-trained prior). You can see the partial scores for each component for the first couple of compounds, but the most important information is the average score. If run for more epochs, the average score will increase over time.\n",
    "\n",
    "**Note: you may notice that some of the SMILES proposed by `REINVENT` receive a docking score of 0 (essentially do not dock). This is expected as in the beginning of the experiment, the `REINVENT` agent does not have any notion of what docks well and thus, initial generated SMILES are simply \"guesses\". Under more epochs, the `REINVENT` agent will gradually learn and eventually, most of the SMILES generated at a given epoch will dock and receive a favourable docking score.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO     starting an RL run\n",
      "INFO     \n",
      " Step 0   Fraction valid SMILES: 87.5   Score: 0.1077   Time elapsed: 88   Time left: 176.0\n",
      "  Agent     Prior     Target     Score     SMILES\n",
      "-27.50    -27.50    -10.64      0.13      C(C(Nc1ccccc1N)=O)c1cccc(NC(=O)c2cccc(OC)c2)c1\n",
      "-28.11    -28.11    -22.68      0.04      c1c(CC2C(=O)N(C)CN(CC(c3ccccc3)C(O)=O)S2)cccc1\n",
      "-38.69    -38.69     49.01      0.69      c1cc(C(F)(F)F)cc(COc2cc3c(cc2)N2C(C)(c4c(cccc4)CC2)N=C3N)c1\n",
      "-37.48    -37.48    -37.42      0.00      Cc1sc(NC(C(C)(C)C)=O)c(-c2ccc(C(C)(C)C)cc2)c1Cc1ccc(-c2ccccc2-c2nn[nH]n2)cc1\n",
      "-54.50    -54.50    -54.50      0.00      N(=C(C(C(NC(=O)C(NC(CC(c1scc(C(NC(c2ccc(F)cc2)c2ccccc2)=O)n1)=O)CCCCN)=O)CC1CCCCC1)O)=O)OC\n",
      "-33.65    -33.65    -33.59      0.00      N(C(=S)NCCOC)CC(Nc1ccc(OS(N)(=O)=O)cc1)=O\n",
      "-21.53    -21.53    -21.48      0.00      C(Oc1c(-c2n(-c3ccc(-c4onc(C)n4)cc3)c(O)c(O)c2C(=O)CC(C)C)cccc1)C\n",
      "-48.82    -48.82    -48.76      0.00      c1c(S(=O)(N2C(C3N4C(CC3)C(=O)N=C(C(N)Cc3ccccc3)C4=O)CCC2)=O)ccc(OC)c1\n",
      "Glide LigPrep Docking   raw_Glide LigPrep Docking\n",
      "0.13177260756492615   -6.034860134124756   \n",
      "0.04243171587586403   -4.751649856567383   \n",
      "0.6851630806922913   -8.810500144958496   \n",
      "0.0004639435501303524   0.0   \n",
      "0.0   0.0   \n",
      "0.0004639435501303524   0.0   \n",
      "0.0004639435501303524   0.0   \n",
      "0.0004639435501303524   0.0   \n",
      "\n"
     ]
    }
   ],
   "source": [
    "for element in data:\n",
    "    print(element)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. Analyse the Results\n",
    "In order to analyze the run in a more intuitive way, we can use `tensorboard`:\n",
    "\n",
    "```\n",
    "# go to the root folder of the output\n",
    "cd <your_path>/REINVENT_RL_demo\n",
    "\n",
    "# make sure, you have activated the proper environment\n",
    "conda activate reinvent.v3.2\n",
    "\n",
    "# start tensorboard\n",
    "tensorboard --logdir progress.log\n",
    "```\n",
    "\n",
    "Then copy the link provided to a browser window, e.g. \"http://workstation.url.com:6006/\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The results folder will hold four different files: the agent (pickled), the input JSON (just for reference purposes), the memory (highest scoring compounds in `CSV` format) and the scaffold memory (in `CSV` format)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ",smiles,score,likelihood\r\n",
      "2,c1cc(C(F)(F)F)cc(COc2cc3c(cc2)N2C(C)(c4c(cccc4)CC2)N=C3N)c1,0.6851631,-38.692852\r\n",
      "6,[nH]1[nH]c(O)cc1=Nc1ccccc1OC=CC#N,0.30170003,-32.48899\r\n",
      "1,Clc1cc(Cl)ccc1-c1nc2c3c(c1)ccnc3C(=O)C(=O)C2,0.27589664,-33.181587\r\n",
      "3,c1ccc(C#N)cc1NC(Nc1ccccc1)=O,0.1718968,-18.80789\r\n",
      "0,C(C(Nc1ccccc1N)=O)c1cccc(NC(=O)c2cccc(OC)c2)c1,0.13177261,-27.501987\r\n",
      "1,c1c(CC2C(=O)N(C)CN(CC(c3ccccc3)C(O)=O)S2)cccc1,0.042431716,-28.107481\r\n",
      "0,C1CCC(C)(C(C(OC2CC3[N+](C)(C)C(C2)C3)=O)(O)c2sccc2)C1,0.012870243,-34.28718\r\n",
      "3,Cc1sc(NC(C(C)(C)C)=O)c(-c2ccc(C(C)(C)C)cc2)c1Cc1ccc(-c2ccccc2-c2nn[nH]n2)cc1,0.00046394355,-37.47543\r\n",
      "5,N(C(=S)NCCOC)CC(Nc1ccc(OS(N)(=O)=O)cc1)=O,0.00046394355,-33.65011\r\n",
      "6,C(Oc1c(-c2n(-c3ccc(-c4onc(C)n4)cc3)c(O)c(O)c2C(=O)CC(C)C)cccc1)C,0.00046394355,-21.534409\r\n",
      "7,c1c(S(=O)(N2C(C3N4C(CC3)C(=O)N=C(C(N)Cc3ccccc3)C4=O)CCC2)=O)ccc(OC)c1,0.00046394355,-48.823143\r\n",
      "4,C(NC1C(=O)N2C(C(=O)NCC(O)CO)(C(O)=O)CSC2CN1S(=O)(Cc1ccccc1)=O)(=O)C(C(C)C)NC(=O)CCl,0.00046394355,-49.477028\r\n",
      "5,C1C2CC3CC1CC(COc1c(-c4ccnn4C4CCOC4)cc(C(NS(C4CC4)(=O)=O)=O)cc1)(C3)C2,0.00046394355,-35.95174\r\n",
      "7,C(CSc1n2c(c3c(cccc3)n1)nc(CCC(NCc1ccccc1OC)=O)c2O)(=O)NC1CCC(C)CC1,0.00046394355,-30.144173\r\n"
     ]
    }
   ],
   "source": [
    "!head -n 15 {output_dir}/results/memory.csv"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}