main.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "main.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "mount_file_id": "1-Ua33q8uRe6SLZMJ84U_odrp1oMsc5if",
      "authorship_tag": "ABX9TyOwfIsntav2tbZ2YvAQai1T",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/gist/SK124/ba3c3cca86f5d6cb788d72b57892f9db/drugagentrl-mat.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "orNnmpaoUuYA",
        "outputId": "c4a45021-9479-4373-ea8e-351cd7cd893d",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        }
      },
      "source": [
        "\"\"\" Imports neccesary for installing RDkit \"\"\"\n",
        " \n",
        "!wget -c https://repo.continuum.io/miniconda/Miniconda3-latest-Linux-x86_64.sh\n",
        "!#cp '/content/drive/My Drive/Miniconda3-latest-Linux-x86_64.sh' /content/\n",
        "!chmod +x Miniconda3-latest-Linux-x86_64.sh\n",
        "!time bash ./Miniconda3-latest-Linux-x86_64.sh -b -f -p /usr/local\n",
        "!time conda install -q -y -c conda-forge rdkit\n",
        "%matplotlib inline\n",
        "import matplotlib.pyplot as plt\n",
        "import sys\n",
        "import os\n",
        "sys.path.append('/usr/local/lib/python3.7/site-packages/rdkit')\n",
        "%cd /usr/local/lib/python3.7/site-packages/"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "PREFIX=/usr/local\n",
            "Unpacking payload ...\n",
            "Collecting package metadata (current_repodata.json): - \b\b\\ \b\bdone\n",
            "Solving environment: / \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\bdone\n",
            "\n",
            "## Package Plan ##\n",
            "\n",
            "  environment location: /usr/local\n",
            "\n",
            "  added / updated specs:\n",
            "    - _libgcc_mutex==0.1=main\n",
            "    - ca-certificates==2020.1.1=0\n",
            "    - certifi==2020.4.5.1=py37_0\n",
            "    - cffi==1.14.0=py37he30daa8_1\n",
            "    - chardet==3.0.4=py37_1003\n",
            "    - conda-package-handling==1.6.1=py37h7b6447c_0\n",
            "    - conda==4.8.3=py37_0\n",
            "    - cryptography==2.9.2=py37h1ba5d50_0\n",
            "    - idna==2.9=py_1\n",
            "    - ld_impl_linux-64==2.33.1=h53a641e_7\n",
            "    - libedit==3.1.20181209=hc058e9b_0\n",
            "    - libffi==3.3=he6710b0_1\n",
            "    - libgcc-ng==9.1.0=hdf63c60_0\n",
            "    - libstdcxx-ng==9.1.0=hdf63c60_0\n",
            "    - ncurses==6.2=he6710b0_1\n",
            "    - openssl==1.1.1g=h7b6447c_0\n",
            "    - pip==20.0.2=py37_3\n",
            "    - pycosat==0.6.3=py37h7b6447c_0\n",
            "    - pycparser==2.20=py_0\n",
            "    - pyopenssl==19.1.0=py37_0\n",
            "    - pysocks==1.7.1=py37_0\n",
            "    - python==3.7.7=hcff3b4d_5\n",
            "    - readline==8.0=h7b6447c_0\n",
            "    - requests==2.23.0=py37_0\n",
            "    - ruamel_yaml==0.15.87=py37h7b6447c_0\n",
            "    - setuptools==46.4.0=py37_0\n",
            "    - six==1.14.0=py37_0\n",
            "    - sqlite==3.31.1=h62c20be_1\n",
            "    - tk==8.6.8=hbc83047_0\n",
            "    - tqdm==4.46.0=py_0\n",
            "    - urllib3==1.25.8=py37_0\n",
            "    - wheel==0.34.2=py37_0\n",
            "    - xz==5.2.5=h7b6447c_0\n",
            "    - yaml==0.1.7=had09818_2\n",
            "    - zlib==1.2.11=h7b6447c_3\n",
            "\n",
            "\n",
            "The following packages will be SUPERSEDED by a higher-priority channel:\n",
            "\n",
            "  ca-certificates    conda-forge::ca-certificates-2020.6.2~ --> pkgs/main::ca-certificates-2020.1.1-0\n",
            "  certifi            conda-forge::certifi-2020.6.20-py37he~ --> pkgs/main::certifi-2020.4.5.1-py37_0\n",
            "  conda              conda-forge::conda-4.9.0-py37he5f6b98~ --> pkgs/main::conda-4.8.3-py37_0\n",
            "  openssl            conda-forge::openssl-1.1.1h-h516909a_0 --> pkgs/main::openssl-1.1.1g-h7b6447c_0\n",
            "\n",
            "\n",
            "Preparing transaction: | \b\bdone\n",
            "Executing transaction: - \b\b\\ \b\bdone\n",
            "installation finished.\n",
            "WARNING:\n",
            "    You currently have a PYTHONPATH environment variable set. This may cause\n",
            "    unexpected behavior when running the Python interpreter in Miniconda3.\n",
            "    For best results, please verify that your PYTHONPATH only points to\n",
            "    directories of packages that are compatible with the Python interpreter\n",
            "    in Miniconda3: /usr/local\n",
            "\n",
            "real\t0m37.185s\n",
            "user\t0m41.547s\n",
            "sys\t0m7.030s\n",
            "Collecting package metadata (current_repodata.json): ...working... done\n",
            "Solving environment: ...working... done\n",
            "\n",
            "## Package Plan ##\n",
            "\n",
            "  environment location: /usr/local\n",
            "\n",
            "  added / updated specs:\n",
            "    - rdkit\n",
            "\n",
            "\n",
            "The following packages will be UPDATED:\n",
            "\n",
            "  ca-certificates     pkgs/main::ca-certificates-2020.1.1-0 --> conda-forge::ca-certificates-2020.6.20-hecda079_0\n",
            "  certifi              pkgs/main::certifi-2020.4.5.1-py37_0 --> conda-forge::certifi-2020.6.20-py37he5f6b98_2\n",
            "  conda                       pkgs/main::conda-4.8.3-py37_0 --> conda-forge::conda-4.9.0-py37he5f6b98_0\n",
            "  openssl              pkgs/main::openssl-1.1.1g-h7b6447c_0 --> conda-forge::openssl-1.1.1h-h516909a_0\n",
            "\n",
            "\n",
            "Preparing transaction: ...working... done\n",
            "Verifying transaction: ...working... done\n",
            "Executing transaction: ...working... done\n",
            "\n",
            "real\t0m8.454s\n",
            "user\t0m7.514s\n",
            "sys\t0m1.128s\n",
            "/usr/local/lib/python3.7/site-packages\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oRKiRKa9ITwi"
      },
      "source": [
        "\"\"\" Imports for preprocessing,loss calculaitons and other utilities \"\"\"\n",
        "\n",
        "import re\n",
        "import os\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "import random\n",
        "import pickle\n",
        "import sys\n",
        "import time\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "from torch.nn import CosineSimilarity\n",
        "from torch.utils.data import Dataset\n",
        "from torch.utils.data import DataLoader\n",
        "from rdkit import Chem\n",
        "from rdkit.Chem import AllChem\n",
        "from rdkit.Chem import MolFromSmiles\n",
        "from rdkit.Chem import DataStructs\n",
        "from rdkit.Chem import AllChem\n",
        "from rdkit.Chem import RDConfig\n",
        "from tqdm import tqdm"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8GzcD4k7RpKe",
        "outputId": "c793f96b-75be-49de-8f5a-4ba57a4a1812",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "%cd /content"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/content\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yUeeOJSqMHHU",
        "outputId": "c080946b-c0a5-4852-c01b-cfd77807b9fd",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 202
        }
      },
      "source": [
        "\"\"\" Loading corpus into the memory ; It is a CSV File \"\"\"\n",
        "path='/content/drive/My Drive/De NovoDrug/full_data_final.csv'\n",
        "df=pd.read_csv(path)\n",
        "df.head()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>col</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>CC(C)(C)c1ccc2occ(CC(=O)Nc3ccccc3F)c2c1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>C[C@@H]1CC(Nc2cncc(-c3nncn3C)c2)C[C@@H](C)C1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>N#Cc1ccc(-c2ccc(O[C@@H](C(=O)N3CCCC3)c3ccccc3)...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>CCOC(=O)[C@@H]1CCCN(C(=O)c2nc(-c3ccc(C)cc3)n3c...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>N#CC1=C(SCC(=O)Nc2cccc(Cl)c2)N=C([O-])[C@H](C#...</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "                                                 col\n",
              "0            CC(C)(C)c1ccc2occ(CC(=O)Nc3ccccc3F)c2c1\n",
              "1       C[C@@H]1CC(Nc2cncc(-c3nncn3C)c2)C[C@@H](C)C1\n",
              "2  N#Cc1ccc(-c2ccc(O[C@@H](C(=O)N3CCCC3)c3ccccc3)...\n",
              "3  CCOC(=O)[C@@H]1CCCN(C(=O)c2nc(-c3ccc(C)cc3)n3c...\n",
              "4  N#CC1=C(SCC(=O)Nc2cccc(Cl)c2)N=C([O-])[C@H](C#..."
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 30
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mOpkjEPOMKEZ"
      },
      "source": [
        "def csv2txt(dataframe):\n",
        " \"\"\" CSV needs to be converted to a text file with each SMILES string in a new line \"\"\"\n",
        " with open('drug.txt','w') as f:\n",
        "       for i in range(len(dataframe)):\n",
        "           text=dataframe['col'][i]\n",
        "           f.write(text+'\\n')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-Yl3N2ZKRjvP"
      },
      "source": [
        "csv2txt(df)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CknbU843MMbG"
      },
      "source": [
        "def txt2list(fname):\n",
        "# \" Takes the molecules in text file to and store it in list \"\n",
        "  smiles = []\n",
        "  with open(fname, 'r') as f:\n",
        "     for line in f:\n",
        "         smiles.append(line.split()[0])\n",
        "  return smiles"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UMAmxHtNR0TO"
      },
      "source": [
        "smiles=txt2list('drug.txt')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-HVM4PZIMOdF"
      },
      "source": [
        "def replace_halogen(string):\n",
        "    \"\"\"Regex to replace Br and Cl with single letters\"\"\"\n",
        "    br = re.compile('Br')\n",
        "    cl = re.compile('Cl')\n",
        "    string = br.sub('R', string)\n",
        "    string = cl.sub('L', string)\n",
        "\n",
        "    return string\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6EXycsDfMQJ6"
      },
      "source": [
        "def construct_vocabulary(smiles_list,fname):\n",
        "    #\"\"\"Returns all the characters present in a SMILES file.\n",
        "    #   Uses regex to find characters/tokens of the format '[x]'.\"\"\"\n",
        "    add_chars = set()\n",
        "    for i, smiles in enumerate(smiles_list):\n",
        "        regex = '(\\[[^\\[\\]]{1,10}\\])'\n",
        "\n",
        "       # \"\"\"\n",
        "        #Regex Explaination : \\ signifies a special sequence inside a specific set [] of characters for eg.([...CC[NH+]COCN...]) so \\[...] , which can contain [NH+] like molecules inside it which is taken care by  the ... as explained in the following  \n",
        "        #To capture such [NH+],[C@@H],[...] molecules, ^ (start with operator) is used, which is to say such a token is going to start, inside which we give the \\[\\] to denote a specific sequence which will start with a '[' and end with ']' ie.[NH+] or [C@@H], here \\ is used to say escape the inbetween enitities(C@@H,NH+) ie dont split them\n",
        "        #There can be numbers 1,2....10 to denote begining of rings within the sequence like CCCcc1n.... to capture these numbers {1,10} ie all numbers between 1 to 10, is used\n",
        "        #INPUT SMILE ----> 'CCC[C@@H][NH3+][O+][O-][OH+][P+]COCCCcc1nnn' \n",
        "        #char_list = ['CCC','[C@@H]','[NH3+]','[O+]','[O-]','[OH+]','[P+]','COCCCcc1nnn']\n",
        "         \n",
        "        #\"\"\"\n",
        "\n",
        "        smiles = replace_halogen(smiles)\n",
        "        char_list = re.split(regex, smiles)\n",
        "        for char in char_list:\n",
        "        #\"There are characters like [NH+] which need to considered as single token rather than '[', 'N','H','+',']'\"\n",
        "            if char.startswith('['):\n",
        "                add_chars.add(char)\n",
        "\n",
        "            else:\n",
        "            #\"chars inside charlist need to be split as well i.e. COCCCcc1nnn need to split into tokens like 'C','O','1','c','n' \"\n",
        "                chars = [unit for unit in char]\n",
        "                [add_chars.add(unit) for unit in chars]\n",
        "\n",
        "    print(\"Number of characters: {}\".format(len(add_chars)))\n",
        "    with open(fname, 'w') as f:\n",
        "        for char in add_chars:\n",
        "            f.write(char + \"\\n\")\n",
        "    return add_chars\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "x7XtjJG6R3lJ",
        "outputId": "2562db50-2a34-44be-f301-e2dd6ed83ca1",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        }
      },
      "source": [
        "construct_vocabulary(smiles,'vocab.txt')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Number of characters: 58\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'#',\n",
              " '(',\n",
              " ')',\n",
              " '-',\n",
              " '/',\n",
              " '1',\n",
              " '2',\n",
              " '3',\n",
              " '4',\n",
              " '5',\n",
              " '6',\n",
              " '7',\n",
              " '=',\n",
              " 'C',\n",
              " 'F',\n",
              " 'I',\n",
              " 'L',\n",
              " 'N',\n",
              " 'O',\n",
              " 'P',\n",
              " 'R',\n",
              " 'S',\n",
              " '[C@@H]',\n",
              " '[C@@]',\n",
              " '[C@H]',\n",
              " '[C@]',\n",
              " '[CH-]',\n",
              " '[CH2-]',\n",
              " '[N+]',\n",
              " '[N-]',\n",
              " '[NH+]',\n",
              " '[NH-]',\n",
              " '[NH2+]',\n",
              " '[NH3+]',\n",
              " '[O+]',\n",
              " '[O-]',\n",
              " '[OH+]',\n",
              " '[P+]',\n",
              " '[P@@H]',\n",
              " '[P@@]',\n",
              " '[P@]',\n",
              " '[PH2]',\n",
              " '[S+]',\n",
              " '[S-]',\n",
              " '[S@@]',\n",
              " '[S@]',\n",
              " '[SH+]',\n",
              " '[n+]',\n",
              " '[n-]',\n",
              " '[nH+]',\n",
              " '[nH]',\n",
              " '[o+]',\n",
              " '[s+]',\n",
              " '\\\\',\n",
              " 'c',\n",
              " 'n',\n",
              " 'o',\n",
              " 's'}"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 37
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "67cfdD6lL5eG"
      },
      "source": [
        "class Vocabulary(object):\n",
        "   # \"\"\"A class for handling encoding/decoding from SMILES to an array of indices\"\"\"\n",
        "    def __init__(self, init_from_file=None, max_length=140):\n",
        "    #    \"E and G are used to signify ending and begining of seqeunce\"\n",
        "        self.special_tokens = ['E', 'G']\n",
        "      #   \"Other tokens from SMILES grammer needs to be added\"\n",
        "        self.additional_chars = set()\n",
        "        self.chars = self.special_tokens\n",
        "        self.vocab_size = len(self.chars)\n",
        "        self.vocab = dict(zip(self.chars, range(len(self.chars))))\n",
        "        self.reversed_vocab = {v: k for k, v in self.vocab.items()}\n",
        "        self.max_length = max_length\n",
        "        if init_from_file: \n",
        "       #     \" vocab.txt file which contains all the tokens is given as a input which initiates the vocabulary for the language model\" \n",
        "          self.init_from_file(init_from_file)\n",
        "\n",
        "    def encode(self, char_list):\n",
        "      #  \"\"\"Takes a list of characters (eg '[NH]') and encodes to array of indices\"\"\"\n",
        "        smiles_matrix = np.zeros(len(char_list), dtype=np.float32)\n",
        "        for i, char in enumerate(char_list):\n",
        "       #    \"2D Matrix : All the tokens are converted from SMILES to integers\"\n",
        "            smiles_matrix[i] = self.vocab[char]\n",
        "        return smiles_matrix\n",
        "\n",
        "    def decode(self, matrix):\n",
        "      #  \"\"\"Takes an array of indices and returns the corresponding SMILES\"\"\"\n",
        "        chars = []\n",
        "        for i in matrix:\n",
        "            if i == self.vocab['E']: break\n",
        "          #   \"If E token which is the End token is reached, the process terminates\"\n",
        "            chars.append(self.reversed_vocab[i])\n",
        "        smiles = \"\".join(chars)\n",
        "        smiles = smiles.replace(\"L\", \"Cl\").replace(\"R\", \"Br\")\n",
        "        return smiles\n",
        "\n",
        "    def tokenize(self, smiles):\n",
        "       # \"\"\"Takes a SMILES and return a list of characters/tokens\"\"\"\n",
        "        regex = '(\\[[^\\[\\]]{1,6}\\])'\n",
        "        smiles = replace_halogen(smiles)\n",
        "        char_list = re.split(regex, smiles)\n",
        "        tokenized = []\n",
        "       # \"SMILES Sequence needs to be converted to tokens for preprocessing, this is the same code we had in Vocabulary class with few modifns.\"\n",
        "        for char in char_list:\n",
        "            if char.startswith('['):\n",
        "                tokenized.append(char)\n",
        "            else:\n",
        "                chars = [unit for unit in char]\n",
        "                [tokenized.append(unit) for unit in chars]\n",
        "        # \"E token is added to signify the ending of a token\"\n",
        "        tokenized.append('E')\n",
        "        return tokenized\n",
        "\n",
        "    def add_characters(self, chars):\n",
        "     #   \"\"\"Adds characters to the vocabulary\"\"\"\n",
        "        for char in chars:\n",
        "            self.additional_chars.add(char)\n",
        "        char_list = list(self.additional_chars)\n",
        "        char_list.sort()\n",
        "        self.chars = char_list + self.special_tokens\n",
        "        self.vocab_size = len(self.chars)\n",
        "        self.vocab = dict(zip(self.chars, range(len(self.chars))))\n",
        "        self.reversed_vocab = {v: k for k, v in self.vocab.items()}\n",
        "\n",
        "    def init_from_file(self, file):\n",
        "       # \"\"\"Takes a file containing \\n separated characters to initialize the vocabulary\"\"\"\n",
        "        with open(file, 'r') as f:\n",
        "      #     \"All characters from vocab.txt file which has all the unique tokens is taken and added to the Vocabukary of the model\"\n",
        "            chars = f.read().split()\n",
        "        self.add_characters(chars)\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.chars)\n",
        "\n",
        "    def __str__(self):\n",
        "        return \"Vocabulary containing {} tokens: {}\".format(len(self), self.chars)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BdyrLR1Ym7oN"
      },
      "source": [
        "class MolData(Dataset):\n",
        "    \"\"\"Custom PyTorch Dataset that takes a file containing SMILES.\n",
        "        Args:\n",
        "                fname : path to a file containing \\n separated SMILES.\n",
        "                voc   : a Vocabulary instance\n",
        "        Returns:\n",
        "                A custom PyTorch dataset for training the Prior.\n",
        "    \"\"\"\n",
        "    def __init__(self, fname, voc):\n",
        "        self.voc = voc\n",
        "        self.smiles = []\n",
        "        with open(fname, 'r') as f:\n",
        "            for line in f:\n",
        "                self.smiles.append(line.split()[0])\n",
        "\n",
        "    def __getitem__(self, i): \n",
        "        mol = self.smiles[i]\n",
        "        tokenized = self.voc.tokenize(mol)\n",
        "        encoded = self.voc.encode(tokenized)\n",
        "        return Variable(encoded)\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.smiles)\n",
        "\n",
        "    def __str__(self):\n",
        "        return \"Dataset containing {} structures.\".format(len(self))\n",
        "\n",
        "    @classmethod\n",
        "    def collate_fn(cls, arr):\n",
        "        \"\"\"Function to take a list of encoded sequences and turn them into a batch\"\"\"\n",
        "        max_length = max([seq.size(0) for seq in arr])\n",
        "        \"\"\" For every batch lets say 64, 64 sequences will be taken an the maximum length of the sequence from that batch woul be max_length \n",
        "        and the shorter seqeunces will be padded till the max_length before passing it to the GRU \"\"\"\n",
        "        collated_arr = Variable(torch.zeros(len(arr), max_length))\n",
        "        for i, seq in enumerate(arr):\n",
        "            collated_arr[i, :seq.size(0)] = seq\n",
        "        return collated_arr\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VEbQMlk0R9Cj"
      },
      "source": [
        "def Variable(tensor):\n",
        "    \"\"\"Wrapper for torch.autograd.Variable that also accepts\n",
        "       numpy arrays directly and automatically assigns it to\n",
        "       the GPU if availale else CPU.\"\"\"\n",
        "    if isinstance(tensor, np.ndarray):\n",
        "        tensor = torch.from_numpy(tensor)\n",
        "    if torch.cuda.is_available():\n",
        "        return torch.autograd.Variable(tensor).cuda()\n",
        "    return torch.autograd.Variable(tensor)\n",
        "\n",
        "def decrease_learning_rate(optimizer, decrease_by=0.01):\n",
        "    \"\"\"Multiplies the learning rate of the optimizer by 1 - decrease_by\"\"\"\n",
        "    for param_group in optimizer.param_groups:\n",
        "        param_group['lr'] *= (1 - decrease_by)\n",
        "\n",
        "def seq_to_smiles(seqs, voc):\n",
        "    \"\"\"Takes an output sequence from the RNN and returns the\n",
        "       corresponding SMILES.\"\"\"\n",
        "    smiles = []\n",
        "    for seq in seqs.cpu().numpy():\n",
        "        smiles.append(voc.decode(seq))\n",
        "    return smiles\n",
        "\n",
        "def fraction_valid_smiles(smiles):\n",
        "    \"\"\"Takes a list of SMILES and returns fraction valid.\"\"\"\n",
        "    i = 0\n",
        "    for smile in smiles:\n",
        "        if Chem.MolFromSmiles(smile):\n",
        "            i += 1\n",
        "    return i / len(smiles)\n",
        "\n",
        "def unique(arr):\n",
        "    \"\"\"Finds unique rows in arr and return their indices\"\"\"\n",
        "    arr = arr.cpu().numpy()\n",
        "    arr_ = np.ascontiguousarray(arr).view(np.dtype((np.void, arr.dtype.itemsize * arr.shape[1])))\n",
        "    _, idxs = np.unique(arr_, return_index=True)\n",
        "    if torch.cuda.is_available():\n",
        "        return torch.LongTensor(np.sort(idxs)).cuda()\n",
        "    return torch.LongTensor(np.sort(idxs))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ot6ABOaiI66d"
      },
      "source": [
        "class Experience(object):\n",
        "    \"\"\"Class for prioritized experience replay that remembers the highest scored sequences\n",
        "       seen and samples from them with probabilities relative to their scores.\n",
        "       To perform experience replay we store the agent's experiences \"\"\"\n",
        "    def __init__(self, voc, max_size=100):\n",
        "        self.memory = []\n",
        "        \" Memory stores SMILE decoded seq,respective score,NLL_likelihood \"\n",
        "        self.max_size = max_size\n",
        "        self.voc = voc\n",
        "\n",
        "    def add_experience(self, experience):\n",
        "        \"\"\"Experience should be a list of (smiles, score, prior likelihood) tuples\"\"\"\n",
        "        self.memory.extend(experience)\n",
        "        if len(self.memory)>self.max_size:\n",
        "            # Remove duplicates as sampling might prouce same moelcule occasionally\n",
        "            idxs, smiles = [], []\n",
        "            for i, exp in enumerate(self.memory):\n",
        "                if exp[0] not in smiles:\n",
        "                    idxs.append(i)\n",
        "                    smiles.append(exp[0])\n",
        "            self.memory = [self.memory[idx] for idx in idxs]\n",
        "            # Retain only the highest scores\n",
        "            self.memory.sort(key = lambda x: x[1], reverse=True)\n",
        "            self.memory = self.memory[:self.max_size]\n",
        "            print(\"\\nBest score in memory: {:.2f}\".format(self.memory[0][1]))\n",
        "\n",
        "    def sample(self, n):\n",
        "        \"\"\"Sample a batch size n of experience\"\"\"\n",
        "        if len(self.memory)<n:\n",
        "            raise IndexError('Size of memory ({}) is less than requested sample ({})'.format(len(self), n))\n",
        "        else:\n",
        "            scores = [x[1] for x in self.memory]\n",
        "            sample = np.random.choice(len(self), size=n, replace=False, p=scores/np.sum(scores))\n",
        "            sample = [self.memory[i] for i in sample]\n",
        "            smiles = [x[0] for x in sample]\n",
        "            scores = [x[1] for x in sample]\n",
        "            prior_likelihood = [x[2] for x in sample]\n",
        "        tokenized = [self.voc.tokenize(smile) for smile in smiles]\n",
        "        encoded = [Variable(self.voc.encode(tokenized_i)) for tokenized_i in tokenized]\n",
        "        encoded = MolData.collate_fn(encoded)\n",
        "        return encoded, np.array(scores), np.array(prior_likelihood)\n",
        "\n",
        "    def initiate_from_file(self, fname, scoring_function, Prior):\n",
        "        \"\"\"Adds experience from a file with SMILES\n",
        "           Needs a scoring function and an RNN to score the sequences.\n",
        "           Using this feature means that the learning can be very biased\n",
        "           and is typically advised against.\"\"\"\n",
        "        with open(fname, 'r') as f:\n",
        "            smiles = []\n",
        "            for line in f:\n",
        "                smile = line.split()[0]\n",
        "                if Chem.MolFromSmiles(smile):\n",
        "                    smiles.append(smile)\n",
        "        scores = scoring_function(smiles)\n",
        "        tokenized = [self.voc.tokenize(smile) for smile in smiles]\n",
        "        encoded = [Variable(self.voc.encode(tokenized_i)) for tokenized_i in tokenized]\n",
        "        encoded = MolData.collate_fn(encoded)\n",
        "        prior_likelihood, _ = Prior.likelihood(encoded.long())\n",
        "        prior_likelihood = prior_likelihood.data.cpu().numpy()\n",
        "        new_experience = zip(smiles, scores, prior_likelihood)\n",
        "        self.add_experience(new_experience)\n",
        "\n",
        "    def print_memory(self, path):\n",
        "        \"\"\"Prints the memory.\"\"\"\n",
        "        print(\"\\n\" + \"*\" * 80 + \"\\n\")\n",
        "        print(\"         Best recorded SMILES: \\n\")\n",
        "        print(\"Score     Prior log P     SMILES\\n\")\n",
        "        with open(path, 'w') as f:\n",
        "            f.write(\"SMILES Score PriorLogP\\n\")\n",
        "            for i, exp in enumerate(self.memory[:100]):\n",
        "                if i < 50:\n",
        "                    print(\"{:4.2f}   {:6.2f}        {}\".format(exp[1], exp[2], exp[0]))\n",
        "                    f.write(\"{} {:4.2f} {:6.2f}\\n\".format(*exp))\n",
        "        print(\"\\n\" + \"*\" * 80 + \"\\n\")\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.memory)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3QU3CRRSL4kk"
      },
      "source": [
        "class MultiGRU(nn.Module):\n",
        "    \"\"\" Implements a three layer GRU cell including an embedding layer\n",
        "       and an output linear layer back to the size of the vocabulary\"\"\"\n",
        "    def __init__(self, voc_size):\n",
        "        super(MultiGRU, self).__init__()\n",
        "        self.embedding = nn.Embedding(voc_size, 128)\n",
        "        self.gru_1 = nn.GRUCell(128, 512)\n",
        "        self.gru_2 = nn.GRUCell(512, 512)\n",
        "        self.gru_3 = nn.GRUCell(512, 512)\n",
        "        self.linear = nn.Linear(512, voc_size)\n",
        "\n",
        "    def forward(self, x, h):\n",
        "        x = self.embedding(x)\n",
        "        h_out = Variable(torch.zeros(h.size()))\n",
        "        x = h_out[0] = self.gru_1(x, h[0])\n",
        "        x = h_out[1] = self.gru_2(x, h[1])\n",
        "        x = h_out[2] = self.gru_3(x, h[2])\n",
        "        x = self.linear(x)\n",
        "        return x, h_out\n",
        "\n",
        "    def init_h(self, batch_size):\n",
        "        # Initial cell state is zero\n",
        "        return Variable(torch.zeros(3, batch_size, 512))\n",
        "\n",
        "class RNN():\n",
        "    \"\"\"Implements the Prior and Agent RNN. Needs a Vocabulary instance in\n",
        "    order to determine size of the vocabulary and index of the End (E) token\"\"\"\n",
        "    def __init__(self, voc):\n",
        "        self.rnn = MultiGRU(voc.vocab_size)\n",
        "        if torch.cuda.is_available():\n",
        "            self.rnn.cuda()\n",
        "        self.voc = voc\n",
        "\n",
        "    def likelihood(self, target):\n",
        "        \"\"\"\n",
        "            Retrieves the likelihood of a given sequence\n",
        "            Args:\n",
        "                target: (batch_size * sequence_length) A batch of sequences\n",
        "            Outputs:\n",
        "                log_probs : (batch_size) Log likelihood for each example*\n",
        "                entropy: (batch_size) The entropies for the sequences. Not\n",
        "                                      currently used.\n",
        "        \"\"\"\n",
        "        batch_size, seq_length = target.size()\n",
        "        start_token = Variable(torch.zeros(batch_size, 1).long())\n",
        "        start_token[:] = self.voc.vocab['G']\n",
        "        x = torch.cat((start_token, target[:, :-1]), 1)\n",
        "        h = self.rnn.init_h(batch_size)\n",
        "\n",
        "        log_probs = Variable(torch.zeros(batch_size))\n",
        "        entropy = Variable(torch.zeros(batch_size))\n",
        "        for step in range(seq_length):\n",
        "        #   \"\"\" For every step from 0 to sequnce length, we pass the GRU seqeunce based on the timestep and hidden state and get logits and \n",
        "         # hidden state after taking that step\n",
        "         # logits is a vector of 'D' dimension where D = voc_size with scores on what should be the next token, which is converted to \n",
        "        #  log_probs using log_softmax and sent to the NLL Loss function which compares the next predicted word by RNN and Ground Truth and calculates \n",
        "        #  the loss per sequence per timestep which is accumulated under log_probs and returns total loss after end time step \"\"\"\n",
        "            logits, h = self.rnn(x[:, step], h)\n",
        "            log_prob = F.log_softmax(logits)\n",
        "            prob = F.softmax(logits)\n",
        "            log_probs += NLLLoss(log_prob, target[:, step])\n",
        "            entropy += -torch.sum((log_prob * prob), 1)\n",
        "        return log_probs, entropy\n",
        "\n",
        "    def sample(self, batch_size, max_length=140):\n",
        "        \"\"\"\n",
        "            Sample a batch of sequences\n",
        "            Args:\n",
        "                batch_size : Number of sequences to sample \n",
        "                max_length:  Maximum length of the sequences\n",
        "            Outputs:\n",
        "            seqs: (batch_size, seq_length) The sampled sequences.\n",
        "            log_probs : (batch_size) Log likelihood for each sequence.\n",
        "            entropy: (batch_size) The entropies for the sequences. Not\n",
        "                                    currently used.\n",
        "        \"\"\"\n",
        "        start_token = Variable(torch.zeros(batch_size).long())\n",
        "        start_token[:] = self.voc.vocab['G']\n",
        "        h = self.rnn.init_h(batch_size)\n",
        "        x = start_token\n",
        "\n",
        "        sequences = []\n",
        "        log_probs = Variable(torch.zeros(batch_size))\n",
        "        finished = torch.zeros(batch_size).byte()\n",
        "        entropy = Variable(torch.zeros(batch_size))\n",
        "        if torch.cuda.is_available():\n",
        "            finished = finished.cuda()\n",
        "\n",
        "        for step in range(max_length):\n",
        "        #   \"\"\" After language model learns the semantic syntax, we need to check its perfomance which is why we sample from it.\n",
        "        #  The code here is exactly similar to the code in likeilhood function \"\"\" \n",
        "            logits, h = self.rnn(x, h)\n",
        "            prob = F.softmax(logits)\n",
        "            log_prob = F.log_softmax(logits)\n",
        "        #    \"\"\" torch.multinomial returns a tensor where each row contains 1 index sampled from the multinomial probability distribution \n",
        "         ##   located in the corresponding row of tensor input.\n",
        "        #    \"\"\"\n",
        "            x = torch.multinomial(prob,1).view(-1)\n",
        "            sequences.append(x.view(-1, 1))\n",
        "            log_probs +=  NLLLoss(log_prob, x)\n",
        "            entropy += -torch.sum((log_prob * prob), 1)\n",
        "\n",
        "            x = Variable(x.data)\n",
        "       #      \"\"\" Sampling terminates when E token is spit out of GRU \"\"\"\n",
        "            EOS_sampled = (x == self.voc.vocab['E']).data\n",
        "            finished = torch.ge(finished + EOS_sampled, 1)\n",
        "            if torch.prod(finished) == 1: break\n",
        "\n",
        "        sequences = torch.cat(sequences, 1)\n",
        "        return sequences.data, log_probs, entropy\n",
        "\n",
        "def NLLLoss(inputs, targets):\n",
        "    \"\"\"\n",
        "        Custom Negative Log Likelihood loss that returns loss per example,\n",
        "        rather than for the entire batch.\n",
        "        Args:\n",
        "            inputs : (batch_size, num_classes) *Log probabilities of each class*\n",
        "            targets: (batch_size) *Target class index*\n",
        "        Outputs:\n",
        "            loss : (batch_size) *Loss for each example*\n",
        "    \"\"\"\n",
        "\n",
        "    if torch.cuda.is_available():\n",
        "        target_expanded = torch.zeros(inputs.size()).cuda()\n",
        "    else:\n",
        "        target_expanded = torch.zeros(inputs.size())\n",
        "\n",
        "    target_expanded.scatter_(1, targets.contiguous().view(-1, 1).data, 1.0)\n",
        "    loss = Variable(target_expanded) * inputs\n",
        "    loss = torch.sum(loss, 1)\n",
        "    return loss"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "L6i3r5HdDhFB"
      },
      "source": [
        "def get_scoring_function(scoring_function, num_processes=None, **kwargs):\n",
        "    \"\"\"Function that initializes and returns a scoring function by name\"\"\"\n",
        "    scoring_function_classes = [MAT,tanimoto]\n",
        "    scoring_functions = [f.__name__ for f in scoring_function_classes]\n",
        "    scoring_function_class = [f for f in scoring_function_classes if f.__name__ == scoring_function][0]\n",
        "\n",
        "    if scoring_function not in scoring_functions:\n",
        "        raise ValueError(\"Scoring function must be one of {}\".format([f for f in scoring_functions]))\n",
        "\n",
        "    for k, v in kwargs.items():\n",
        "        if k in scoring_function_class.kwargs:\n",
        "            setattr(scoring_function_class, k, v)\n",
        "\n",
        "    if num_processes == 0:\n",
        "        return Singleprocessing(scoring_function=scoring_function_class)\n",
        "    return Multiprocessing(scoring_function=scoring_function, num_processes=num_processes)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "h5KZbw5_EJYy"
      },
      "source": [
        "%cd /content\n",
        "!git clone https://github.com/ardigen/MAT.git\n",
        "import pandas as pd\n",
        "import torch\n",
        "%cd /content/MAT\n",
        "os.chdir('src')\n",
        "from featurization.data_utils import load_data_from_smiles, construct_loader\n",
        "batch_size = 1\n",
        "\n",
        "# Formal charges are one-hot encoded to keep compatibility with the pre-trained weights.\n",
        "# If you do not plan to use the pre-trained weights, we recommend to set one_hot_formal_charge to False.\n",
        "client='C1=CC=CC=C1'\n",
        "batch_size = 1\n",
        "client_list=[client]\n",
        "label=list([float(1)])\n",
        "\n",
        "!cp /content/drive/'/My Drive'/transform.py  /content/MAT/src\n",
        "from transform import make_models\n",
        "\n",
        "#d_atom = X[0][0].shape[1]  # It depends on the used featurization.\n",
        "\n",
        "model_params = {\n",
        "    'd_atom': 28,\n",
        "    'd_model': 1024,\n",
        "    'N': 8,\n",
        "    'h': 16,\n",
        "    'N_dense': 1,\n",
        "    'lambda_attention': 0.33, \n",
        "    'lambda_distance': 0.33,\n",
        "    'leaky_relu_slope': 0.1, \n",
        "    'dense_output_nonlinearity': 'relu', \n",
        "    'distance_matrix_kernel': 'exp', \n",
        "    'dropout': 0.0,\n",
        "    \n",
        "}\n",
        "\n",
        "model = make_models(**model_params)\n",
        "model\n",
        "!cp '/content/drive/My Drive/De NovoDrug/pretrained_weights.pt' /content/MAT/src\n",
        "pretrained_name = 'pretrained_weights.pt'  # This file should be downloaded first (See README.md).\n",
        "pretrained_state_dict = torch.load(pretrained_name)\n",
        "model_state_dict = model.state_dict()\n",
        "for name, param in pretrained_state_dict.items():\n",
        "    if 'generator' in name:\n",
        "         continue\n",
        "    if isinstance(param, torch.nn.Parameter):\n",
        "        param = param.data\n",
        "    model_state_dict[name].copy_(param)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KP6lCDs13XUK"
      },
      "source": [
        "def MATSCORE(smiles):\n",
        "      specimen=smiles\n",
        "      batch_size = 1\n",
        "      client_list=[specimen]\n",
        "      label=list([float(1)])\n",
        "      X, Y = load_data_from_smiles(client_list,label, one_hot_formal_charge=True)\n",
        "      data_loader = construct_loader(X, Y, batch_size)\n",
        "\n",
        "      for batch in data_loader:\n",
        "          adjacency_matrix, node_features, distance_matrix, y = batch\n",
        "          batch_mask = torch.sum(torch.abs(node_features), dim=-1) != 0\n",
        "          output = model(node_features, batch_mask, adjacency_matrix, distance_matrix,None)   \n",
        "          \n",
        "      x=output\n",
        "      mask=batch_mask\n",
        "      mask = mask.unsqueeze(-1).float()\n",
        "      out_masked = x * mask\n",
        "      out_sum = x.sum(dim=1)\n",
        "      mask_sum = mask.sum(dim=(1))\n",
        "      out_avg_pooling = out_sum / mask_sum\n",
        "      return out_avg_pooling"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lVZjOS-m1Jb1"
      },
      "source": [
        "class MAT():\n",
        "\n",
        "  kwargs=[\"k\",\"client_struct\"]\n",
        "  k=0.95\n",
        "  cos = nn.CosineSimilarity(dim=1, eps=1e-6)\n",
        "  client_struct='C(=O)(OC(C)(C)C)CCCc1ccc(cc1)N(CCCl)CCCl'\n",
        "  def __init__(self):\n",
        "    self.client=MATSCORE(self.client_struct)\n",
        "  def __call__(self, smile):\n",
        "        mol = Chem.MolFromSmiles(smile)\n",
        "        if mol:\n",
        "            fp = MATSCORE(smile)\n",
        "            score = self.cos(self.client, fp)\n",
        "            score = min(score, self.k) / self.k\n",
        "            return float(score)\n",
        "        return 0.0\n",
        "\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gtq_w5S6PjMQ"
      },
      "source": [
        "class tanimoto():\n",
        "    \"\"\" Scores structures based on Tanimoto similarity to a query structure.\n",
        "        Scores are only scaled up to k=(0,1), after which no more reward is given.\"\"\"\n",
        "\n",
        "    kwargs = [\"k\", \"query_structure\"]\n",
        "    k = 0.7\n",
        "    #query_structure = \"Cc1ccc(cc1)c2cc(nn2c3ccc(cc3)S(=O)(=O)N)C(F)(F)F\"\n",
        "    #query_structure =\"C1=CC=C(C=C1)Cl\"\n",
        "    query_structure=\"C1=CC=C(C=C1)Cl\"\n",
        "\n",
        "    def __init__(self):\n",
        "        query_mol = Chem.MolFromSmiles(self.query_structure)\n",
        "        self.query_fp = AllChem.GetMorganFingerprint(query_mol, 2, useCounts=True, useFeatures=True)\n",
        "\n",
        "    def __call__(self, smile):\n",
        "        mol = Chem.MolFromSmiles(smile)\n",
        "        if mol:\n",
        "            fp = AllChem.GetMorganFingerprint(mol, 2, useCounts=True, useFeatures=True)\n",
        "            score = DataStructs.TanimotoSimilarity(self.query_fp, fp)\n",
        "            score = min(score, self.k) / self.k\n",
        "            return float(score)\n",
        "        return 0.0"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7_ecRfIWDun1"
      },
      "source": [
        "class Singleprocessing():\n",
        "    \"\"\"Adds an option to not spawn new processes for the scoring functions, but rather\n",
        "       run them in the main process.\"\"\"\n",
        "    def __init__(self, scoring_function=None):\n",
        "        self.scoring_function = scoring_function()\n",
        "    def __call__(self, smiles):\n",
        "        scores = [self.scoring_function(smile) for smile in smiles]\n",
        "        return np.array(scores, dtype=np.float32)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZAxEOYZcgXib"
      },
      "source": [
        "import os\n",
        "from shutil import copyfile\n",
        "import sys\n",
        "import pexpect\n",
        "import threading\n",
        "from rdkit import rdBase\n",
        "from rdkit.Chem import AllChem\n",
        "rdBase.DisableLog('rdApp.error')\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rm_X-N6boxAJ",
        "outputId": "775d12a4-7879-4c98-ad92-232493f97e09",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 69
        }
      },
      "source": [
        "if __name__ == \"__main__\":\n",
        "\n",
        "    smiles_file = '/content/drug.txt'\n",
        "    print(\"Reading smiles...\")\n",
        "    smiles_list = smiles\n",
        "    print(\"Constructing vocabulary...\")\n",
        "    voc_chars = construct_vocabulary(smiles_list, \"vocab.txt\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Reading smiles...\n",
            "Constructing vocabulary...\n",
            "Number of characters: 58\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3c8gymzAOVGH",
        "outputId": "8d2f96d7-a2ce-4380-f420-b7e6df45ee67",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        }
      },
      "source": [
        "def train_agent(restore_prior_from='/content/drive/My Drive/De NovoDrug/50_epoch.ckpt',\n",
        "                restore_agent_from='/content/drive/My Drive/De NovoDrug/50_epoch.ckpt',\n",
        "                scoring_function='MAT',\n",
        "                scoring_function_kwargs=None,\n",
        "                save_dir=None, learning_rate=0.0005,\n",
        "                batch_size=64, n_steps=3000,\n",
        "                num_processes=0, sigma=60,\n",
        "                experience_replay=0):\n",
        "  \n",
        "\n",
        "    #\"\"\" Loads the vocabulary, initalizes Prior and Agent Language Models, Calculates scores,loss, experience score ,loss (RL) and writes the \n",
        "   # valid and similarly scored molecules wrt the molecule given into a text file during training \"\"\"\n",
        "    \n",
        "\n",
        "    voc = Vocabulary(init_from_file=\"/content/vocab.txt\")\n",
        "\n",
        "    start_time = time.time()\n",
        "\n",
        "    Prior = RNN(voc)\n",
        "    Agent = RNN(voc)\n",
        "\n",
        "\n",
        "    \"\"\" By default restore Agent to same model as Prior, but can restore from already trained Agent too.\n",
        "     Saved models are partially on the GPU, but if we dont have cuda enabled we can remap these\n",
        "     to the CPU.\"\"\"\n",
        "    if torch.cuda.is_available():\n",
        "        Prior.rnn.load_state_dict(torch.load('/content/drive/My Drive/De NovoDrug/50_epoch.ckpt'))\n",
        "        Agent.rnn.load_state_dict(torch.load(restore_prior_from))\n",
        "    else:\n",
        "        Prior.rnn.load_state_dict(torch.load('/content/drive/My Drive/De NovoDrug/50_epoch.ckpt', map_location=lambda storage, loc: storage))\n",
        "        Agent.rnn.load_state_dict(torch.load(restore_agent_from, map_location=lambda storage, loc: storage))\n",
        "\n",
        "    # We dont need gradients with respect to Prior\n",
        "    for param in Prior.rnn.parameters():\n",
        "        param.requires_grad = False\n",
        "\n",
        "    optimizer = torch.optim.Adam(Agent.rnn.parameters(), lr=0.0005)\n",
        "\n",
        "    # Scoring_function\n",
        "    scoring_function = get_scoring_function(scoring_function=scoring_function, num_processes=num_processes,k=0.99,query_structure=MAT)\n",
        "  \n",
        "\n",
        "\n",
        "   # \"\"\"\" For policy based RL, we normally train on-policy and correct for the fact that more likely actions\n",
        "   # occur more often (which means the agent can get biased towards them).\n",
        "   # Using experience replay is therefor not as theoretically sound as it is for value based RL, but it seems to work well.\"\"\"\n",
        "    experience = Experience(voc)\n",
        "\n",
        "    print(\"Model initialized, starting training...\")\n",
        "\n",
        "    for step in range(n_steps):\n",
        "\n",
        "        # Sample from Agent\n",
        "        seqs, agent_likelihood, entropy = Agent.sample(batch_size)\n",
        "\n",
        "        # Remove duplicates, ie only consider unique seqs\n",
        "        unique_idxs = unique(seqs)\n",
        "        seqs = seqs[unique_idxs]\n",
        "        agent_likelihood = agent_likelihood[unique_idxs]\n",
        "        entropy = entropy[unique_idxs]\n",
        "\n",
        "        # Get prior likelihood and score\n",
        "        prior_likelihood, _ = Prior.likelihood(Variable(seqs))\n",
        "        smiles = seq_to_smiles(seqs, voc)\n",
        "        score = scoring_function(smiles)\n",
        "\n",
        "        # Calculate augmented likelihood\n",
        "        augmented_likelihood = prior_likelihood + sigma * Variable(score)\n",
        "        loss = torch.pow((augmented_likelihood - agent_likelihood), 2)\n",
        "\n",
        "        # Experience Replay\n",
        "        # First sample\n",
        "        if experience_replay and len(experience)>4:\n",
        "        #\"\"\" After adding experience from first n_step, we sample from them and take the 4 samples (using np.random.choice) and their scores,losses and add it with agent's loss,likelihood.\"\"\"\n",
        "        #        \"\"\"Reason : Experience replay enables reinforcement learning agents to memorize and reuse past experiences, just as humans replay memories for the situation at hand.\"\"\"\n",
        "         #       \"\"\"Contemporary off-policy algorithms either replay past experiences uniformly or utilize a rule- based replay strategy, which may be sub-optimal.\"\"\"\n",
        "            exp_seqs, exp_score, exp_prior_likelihood = experience.sample(4)\n",
        "            exp_agent_likelihood, exp_entropy = Agent.likelihood(exp_seqs.long())\n",
        "            exp_augmented_likelihood = exp_prior_likelihood + sigma * exp_score\n",
        "            exp_loss = torch.pow((Variable(exp_augmented_likelihood) - exp_agent_likelihood), 2)\n",
        "            loss = torch.cat((loss, exp_loss), 0)\n",
        "            agent_likelihood = torch.cat((agent_likelihood, exp_agent_likelihood), 0)\n",
        "\n",
        "        # Then add new experience\n",
        "        prior_likelihood = prior_likelihood.data.cpu().numpy()\n",
        "        new_experience = zip(smiles, score, prior_likelihood)\n",
        "        experience.add_experience(new_experience)\n",
        "\n",
        "        # Calculate loss\n",
        "        loss = loss.mean()\n",
        "\n",
        "        # Add regularizer that penalizes high likelihood for the entire sequence\n",
        "        loss_p = - (1 / agent_likelihood).mean()\n",
        "        loss += 5 * 1e3 * loss_p\n",
        "\n",
        "        # Calculate gradients and make an update to the network weights\n",
        "        optimizer.zero_grad()\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "\n",
        "        # Convert to numpy arrays so that we can print them\n",
        "        augmented_likelihood = augmented_likelihood.data.cpu().numpy()\n",
        "        agent_likelihood = agent_likelihood.data.cpu().numpy()\n",
        "\n",
        "        # Print some information for this step\n",
        "        time_elapsed = (time.time() - start_time) / 3600\n",
        "        time_left = (time_elapsed * ((n_steps - step) / (step + 1)))\n",
        "        print(\"\\n       Step {}   Fraction valid SMILES: {:4.1f}  Time elapsed: {:.2f}h Time left: {:.2f}h\".format(\n",
        "              step, fraction_valid_smiles(smiles) * 100, time_elapsed, time_left))\n",
        "        print(\"  Agent    Prior   Target   Score             SMILES\")\n",
        "        for i in range(10):\n",
        "            print(\" {:6.2f}   {:6.2f}  {:6.2f}  {:6.2f}     {}\".format(agent_likelihood[i],\n",
        "                                                                       prior_likelihood[i],\n",
        "                                                                       augmented_likelihood[i],\n",
        "                                                                       score[i],\n",
        "                                                                       smiles[i]))\n",
        "    if not save_dir:\n",
        "        save_dir = '/content/drive/My Drive/De NovoDrug/results/run_' + time.strftime(\"%Y-%m-%d-%H_%M_%S\", time.localtime())\n",
        "    os.makedirs(save_dir)\n",
        "\n",
        "    experience.print_memory(os.path.join(save_dir, \"memory\"))\n",
        "    #Save Agent's trained weights \n",
        "    torch.save(Agent.rnn.state_dict(), os.path.join(save_dir, 'Agent.ckpt'))\n",
        "    #After training sample from agent model \n",
        "    seqs, agent_likelihood, entropy = Agent.sample(256)\n",
        "    prior_likelihood, _ = Prior.likelihood(Variable(seqs))\n",
        "    prior_likelihood = prior_likelihood.data.cpu().numpy()\n",
        "    smiles = seq_to_smiles(seqs, voc)\n",
        "    score = scoring_function(smiles)\n",
        "    with open(os.path.join(save_dir, \"sampled\"), 'w') as f:\n",
        "        f.write(\"SMILES Score PriorLogP\\n\")\n",
        "        for smiles, score, prior_likelihood in zip(smiles, score, prior_likelihood):\n",
        "            f.write(\"{} {:5.2f} {:6.2f}\\n\".format(smiles, score, prior_likelihood))\n",
        "\n",
        "if __name__ == \"__main__\":\n",
        "    train_agent()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Model initialized, starting training...\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "       Step 0   Fraction valid SMILES: 90.6  Time elapsed: 0.00h Time left: 12.00h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -17.56   -17.56   41.99    0.99     CC(=O)N1CCN(C(=O)CCOc2ccc(C#N)cc2)CC1\n",
            " -18.10   -18.10   41.23    0.99     N#Cc1cccc(CNC(=O)N2CCC3(CCCCC3)C2)c1\n",
            " -20.56   -20.56   37.82    0.97     C[C@@H](C(=O)N1CCC(C(=O)c2ccc3ccccc3c2)CC1)c1ccsc1\n",
            " -22.27   -22.27   35.57    0.96     CCc1ccc([C@H]2Nc3ccccc3C(=O)N2NC(=O)c2ccc(Cl)cc2)cc1\n",
            " -18.43   -18.43   40.95    0.99     C[C@@H](CNC(=O)COc1ccc(Cl)cc1Cl)c1ccncc1\n",
            " -17.25   -17.25   41.77    0.98     CNC(=O)C1CC[NH+](CC(=O)Nc2cc(F)ccc2F)CC1\n",
            " -25.19   -25.19   32.93    0.97     C1CCCC[C@H]1Nc1ccc(F)cc1\n",
            " -19.91   -19.91   38.32    0.97     [NH3+]Cc1ccc(S(=O)(=O)c2cc(Br)ccc2F)cc1\n",
            " -22.00   -22.00   37.36    0.99     COc1ccc(CCNS(=O)(=O)N2CCN(C(=O)C(C)C)CC2)cc1OC\n",
            " -19.39   -19.39   39.20    0.98     Cc1ccc(N2C[C@@H](C(=O)N3CCCCc4ccccc43)CC2=O)cc1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 1   Fraction valid SMILES: 82.8  Time elapsed: 0.01h Time left: 11.97h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -19.99   -19.82   38.57    0.97     CN1C(=O)c2ccccc2[C@H](C(=O)N2Cc3ccccc3C[C@H]2C)C1=O\n",
            " -31.03   -31.05   26.38    0.96     Br/C(/C=C\\c1ccccc1)=C1/C(=N)NC(=O)N(c2cccc(Cl)c2)C1=O\n",
            " -22.04   -21.56   37.11    0.98     CCOC[C@H]1CCCN(c2nc(-c3ccccc3Br)no2)C1\n",
            " -22.66   -22.61   35.19    0.96     COc1ccc(-c2cccc(C=O)c2)cc1C=O\n",
            " -31.10   -30.55  -30.55    0.00     CC(=O)O[C@@H]1C[C@@H]2[C@H](CC(=O)[C@H]3C(=O)N(CCOC)C(=O)[C@@H]3[C@@H](O)[C@]21C\n",
            " -22.87   -23.43  -23.43    0.00     Cc1nc(COc2ccc(C(=O)NNC(=O)CCOCC(C)C)cc2)s1\n",
            " -20.65   -21.17   38.06    0.99     Cn1cc(C(=O)Nc2ccc(C(F)(F)F)cc2)c(C(=O)N2CCCCC2)n1\n",
            " -18.55   -17.95   41.45    0.99     Cc1n[nH]c(C)c1CNC(=O)Cc1cccc(OCC#N)c1\n",
            " -31.98   -34.20  -34.20    0.00     Cc1cc(C(C)(C)C)cc(C)cc1S(=O)(=O)N1CCC([C@@]2(O)CCCN(C(=O)c3ccc4c(c3)OCCO4)CC2)CC1\n",
            " -18.34   -18.16   41.23    0.99     CCC[C@@H]1C[C@@]1(O)Cc1cccc(Br)c1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 2   Fraction valid SMILES: 89.1  Time elapsed: 0.01h Time left: 11.89h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -23.20   -23.61   35.64    0.99     C[C@@H]([NH2+]CCO)c1ccc(OCC[NH+](C)C)cc1\n",
            " -26.35   -27.28   32.05    0.99     CCn1c(=O)/c(=C/c2cc(OC)c(OC)c(OCC)c2)sc2c(OC)cccc21\n",
            " -26.39   -26.13  -26.13    0.00     CSCC[C@](C)(O)CNC(=O)NCc1sc(-c2cccc(F)c2)n1\n",
            " -30.86   -30.49  -30.49    0.00     N#Cc1ccc2ncc(CN3C[C@@H]4CCC[NH+](Cc5cccs5)C4)c3c2)c1\n",
            " -17.76   -17.85   40.18    0.97     O=C(NCCc1cc(F)cc(F)c1)c1n[nH]c2ccccc12\n",
            " -23.93   -24.26   33.68    0.97     O=C(CCCN1C(=O)/C(=C/c2ccc(Cl)cc2)n2cccc21)\\c1cccc(Cl)c1\n",
            " -21.99   -21.82   37.14    0.98     CC(=O)N1CC[C@@H](C(=O)Nc2ccc(CC[NH+]3CCCC3)cc2)C1\n",
            " -17.06   -16.93   41.87    0.98     CC[C@]1(c2ccc(F)cc2)NC(=O)N(CC(=O)Nc2ccc(F)cc2)C1=O\n",
            " -26.42   -27.11   31.50    0.98     CC[C@H](C)N1C(=O)C(=Cc2c(CC)nn(-c3ccccc3)c2-n2cccc2)CC1=O\n",
            " -26.69   -26.66   32.43    0.98     C[C@@H]1CC(CNc2cc(C)cc(F)c2)CC(C)(C)C1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 3   Fraction valid SMILES: 89.1  Time elapsed: 0.02h Time left: 11.75h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -18.52   -17.77   38.52    0.94     Nc1ccc(SCCCn2cc[nH+]c2)nc1\n",
            " -19.96   -21.91   37.17    0.98     O=C(C[NH+](CCCO)CC(=O)NC1CC1)Nc1ccccc1\n",
            " -14.92   -14.69   43.79    0.97     O=C(NCc1ccccc1F)NCc1ccccn1\n",
            " -15.80   -15.95   43.53    0.99     C[NH2+][C@H](Cc1ccc(Cl)cc1Cl)[C@H]1CSCCO1\n",
            " -39.78   -43.09  -43.09    0.00     C=CCN1C(=O)[C@H]2CCCN(c3cn5ccc(C(F)(F)F)cn4)C[C@H]3C)c2cc1Cl\n",
            " -19.48   -22.08   36.54    0.98     COc1ccc(C(=O)N2CCC(c3cc(C)[nH]n3)CC2)c(O)c1\n",
            " -18.86   -19.54   39.87    0.99     CC(=O)CCc1ccc(OC(=O)[C@H]2CC(=O)N(c3ccc(Cl)cc3)C2)cc1\n",
            " -21.59   -25.02   33.71    0.98     Cc1cc(C(=O)N2CCCC[C@H]2CN2CCc3ccccc3C2)ccc1N\n",
            " -17.80   -18.24   39.18    0.96     CCCn1nc(C(=O)Nc2ccc(-c3nc4ccccc4s3)cc2)cc1C\n",
            " -30.80   -29.18   26.03    0.92     O=C(c1cccnc1)c1nnc2n1-c1ccccc1-c1c(Cl)cccc1C2\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 4   Fraction valid SMILES: 85.9  Time elapsed: 0.02h Time left: 11.64h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -16.77   -16.77   41.63    0.97     CCOc1ccc(C[NH+]2CCC(N3CCNC3=O)CC2)c(OC)c1\n",
            " -17.31   -17.88   40.26    0.97     NC(=O)c1ccc(N2CC[C@@H](Nc3ccccc3)C2=O)cc1\n",
            " -20.26   -21.63   37.21    0.98     CCN(C)C(=O)Cc1cn(Cc2ccc(F)cc2)c(=O)c2ccccc12\n",
            " -25.26   -26.40   32.70    0.99     COc1ccc(CN(C)C(=O)[C@]2(Cc3ccccc3Cl)CCCN(C(=O)c3ccccc3F)C2=O)cc1\n",
            " -20.90   -23.40   35.79    0.99     C=CCOc1ccc(C(=O)N2CCC(c3ccc(C#N)cc3)CC2)cc1\n",
            " -22.90   -25.01   33.98    0.98     CN(C(=O)C[C@H](c1ccc(F)cc1)c1cccnc1)C1CC1\n",
            " -18.02   -17.42   40.45    0.96     COC(=O)[C@H](C)[S@@](=O)Cc1nc(C)no1\n",
            " -25.90   -27.03   32.32    0.99     O=C(CCCOCc1c(F)cccc1Cl)Nc1ccc(N2CC[NH+](C)CC2)cc1\n",
            " -31.29   -32.53  -32.53    0.00     O=c1c(-c2cccnc2)c2sc(NC(=O)CSCc3cccc(Cl)c3)cc2s1\n",
            " -29.96   -31.85   27.45    0.99     CCN(C[C@H]1C(=O)O[C@@H]2CCCC[C@@H]2[C@@H]1O)c1ccc(OC(F)F)cc1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 5   Fraction valid SMILES: 90.6  Time elapsed: 0.02h Time left: 11.70h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -23.24   -24.83   33.59    0.97     O=C(CCl)Nc1nnc(C(=O)N2CCN(c3ccc(F)cc3)CC2)s1\n",
            " -44.15   -45.88  -45.88    0.00     CNC(=O)c1cccc2c1NC(=O)[C@]21[C@@H]2C(=O)N(c3cccc(Cl)c3)C(=O)N=C2O[C@@H]2N=C3CCN(CC=C)C[C@H]3N2\n",
            " -15.82   -16.06   43.69    1.00     C[C@@H](Oc1ccc(C#N)cc1)C(=O)NC1CCCCC1\n",
            " -21.71   -23.44   34.72    0.97     Cc1n[nH]c(-c2ccc(CNC(=O)N3CCCN(c4ccccc4F)CC3)cc2)n1\n",
            " -26.37   -28.95  -28.95    0.00     O=C(NCc1ccc(N2CCOCC2)[nH+]c1)C(F)(F)F)C(=O)NCc1ccccc1\n",
            " -21.76   -20.67   37.53    0.97     C[NH+]1CCN(C(=O)CO/N=C2\\CCOc3ccccc32)CC1\n",
            " -22.42   -21.21   36.80    0.97     O=C(Nc1ccnn1Cc1ccc(C(F)(F)F)cc1)[C@H]1Cc2ccccc2S1\n",
            " -19.57   -20.07   37.97    0.97     Cc1c(F)cccc1Nc1nc(Cl)ncc1C(F)(F)F\n",
            " -16.85   -16.31   41.65    0.97     Cc1ccc(S(=O)(=O)/N=C(\\[S-])Nc2ccccc2)cc1\n",
            " -18.26   -19.72   38.61    0.97     Fc1ccc(F)c(CNCc2c(F)cccc2Cl)c1F\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 6   Fraction valid SMILES: 93.8  Time elapsed: 0.07h Time left: 29.55h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -19.63   -20.09   38.68    0.98     C[C@H](CC(=O)[O-])N(C)C(=O)Nc1ccc(F)c(C#N)c1\n",
            " -17.68   -20.19   38.38    0.98     N#CC1(NC(=O)c2cc(Cl)cc(Cl)c2)Cc2ccccc2C1\n",
            " -25.40   -33.22   25.84    0.98     N#C/C(=C/C(=O)N[C@H](CO)Cc1c[nH]c2ccccc21)C(=O)NC1CC1\n",
            " -42.57   -46.42  -46.42    0.00     COc1cc(=O)n2c(c1C)N(C(=O)Cn1cc(C(F)(F)F)c3cc(C)nc31)CC(=O)N=2\n",
            " -19.38   -18.95   40.68    0.99     COCC[NH2+]CCCN1C(=O)c2ccccc2C1=O\n",
            " -32.39   -33.92   21.93    0.93     c1cnc(-c2n[nH]cc2C[NH+](Cc2cc3ccccc3[nH]2)CC2CC2)cc1\n",
            " -17.45   -17.44   42.28    1.00     CO[C@H](C)C(=O)NCc1ccc(C#N)cc1F\n",
            " -14.57   -15.87   43.66    0.99     C[C@H](C(=O)N(C)CC(=O)N(C)C)c1ccc(Cl)s1\n",
            " -25.90   -29.70   28.69    0.97     COC(=O)C1=NO[C@H](c2cc(OC)c(OC)cc2)CN1C\n",
            " -23.66   -21.25   38.53    1.00     CSCCCNC(=O)c1ccccc1NC(=O)[C@H]1CC=CCC1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 7   Fraction valid SMILES: 93.8  Time elapsed: 0.07h Time left: 27.35h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -29.57   -28.73   30.33    0.98     CC(C)(C(=O)N1CCC([C@@]2(Cc3ccccc3)CCC2)C(=O)CC1=O)c1ccccc1\n",
            " -14.12   -15.22   43.29    0.98     CNS(=O)(=O)CC(=O)Nc1cc(F)cc(F)c1\n",
            " -22.85   -23.50   34.10    0.96     O=C(CSCC(F)(F)F)N1C[C@H](CO)[C@H](C(=O)[O-])C1\n",
            " -21.46   -20.23   38.18    0.97     NC(=O)[C@@H]1COCC[NH+]1Cc1ccc(Br)cc1\n",
            " -21.83   -24.07   35.44    0.99     CCOC(=O)C1=C(C)N(CCOC)C(=O)CN1c1ccc(Cl)cc1F\n",
            " -13.97   -16.85   41.79    0.98     CC1(C)NC(=O)N(Cc2ccc(F)cc2F)C1=O\n",
            " -19.57   -23.97   35.44    0.99     C[C@H](c1ccccn1)N(C)C(=O)/C=C/c1ccc(C(=O)N2CCCC2)cc1\n",
            " -21.34   -23.18   33.88    0.95     N#Cc1ccc(NC(=O)Cn2ncc(=O)c(-c3ccccc3)n2)cc1\n",
            " -19.65   -20.45   37.58    0.97     Cc1cc(C(=O)Cn2ccc(C(=O)[O-])c2)nn1C\n",
            " -18.16   -19.96   38.50    0.97     Cc1ccc([C@H](C)[NH2+]Cc2cc[nH]n2)c(F)c1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 8   Fraction valid SMILES: 90.6  Time elapsed: 0.08h Time left: 25.59h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -20.36   -21.60   36.06    0.96     C[C@H](NC(=O)Cn1cc(C(=O)[O-])cn1)c1cnccn1\n",
            " -19.57   -20.78   36.69    0.96     O=C(Nc1ccc(F)c(C#N)c1)c1cnc(Cc2ccccc2)s1\n",
            " -18.62   -23.19   35.66    0.98     CCc1nc(C(=O)Nc2cc(C)c(F)cc2F)ccc1F\n",
            " -23.27   -20.78   38.13    0.98     CN(C)C(=O)Cc1ccc(NC(=O)N2CCN(c3ncccc3F)CC2)s1\n",
            " -23.50   -26.58   31.00    0.96     CN(C)c1nc(C[NH+](C)Cc2cncn2C)nc(-c2ccccc2)n1\n",
            " -15.34   -17.01   42.46    0.99     O[C@H](CNCc1ccc(F)cc1F)C1CC1\n",
            " -27.16   -30.12   28.71    0.98     O=C(C[NH+]1CCC[C@@H](C(=O)NCc2ccc(F)cc2)C1)Nc1ncc(F)cc1\n",
            " -21.56   -24.56   34.65    0.99     CNC(=O)CCCNC(=O)N[C@@H](c1ccc(F)cc1)c1noc(C)n1\n",
            " -23.26   -23.60   34.35    0.97     COc1ccc(NC(=O)[C@H](C)n2c(Cc3ccccc3)nc3ccccc3c2=O)cc1Cl\n",
            " -22.06   -27.15   32.04    0.99     COc1cc(F)cc(CNC(=O)Nc2cc(C#N)cc(C)c2)c1Br\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 9   Fraction valid SMILES: 96.9  Time elapsed: 0.08h Time left: 24.13h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -22.21   -22.46   36.91    0.99     CC(C)(C)OC(=O)N1CCC[C@@H](c2cccc(OCc3ccccc3)c2)C1\n",
            " -19.19   -21.38   38.10    0.99     CCC[C@@H](CO)NC(=O)C(=O)Nc1ccc(F)c(C#N)c1\n",
            " -19.62   -23.87   35.42    0.99     CO[C@H](CNC(=O)C(=O)Nc1cc(C)c(F)cc1F)c1ccncc1\n",
            " -15.28   -17.65   41.93    0.99     CC(C)N(C)C(=O)C[S@@](=O)Cc1cc(-c2ccc(F)cc2)on1\n",
            " -19.14   -20.89   37.97    0.98     O=C(/C=C/c1ccc(F)cc1)Nc1cccc(Cl)c1N1CCOCC1\n",
            " -21.32   -24.38   35.12    0.99     CCOc1cccc(C(=O)N(CCc2ccc(F)cc2F)C2CC2)c1\n",
            " -16.75   -18.80   41.00    1.00     N#C[C@]1(NC(=O)NCCc2ccc(F)cc2F)CCCCC1\n",
            " -23.96   -26.33   31.44    0.96     N#CCN(C(=O)C[C@H]1NC(=O)NC1=O)c1cc(Cl)c(Cl)cc1Cl\n",
            " -25.58   -27.40   31.56    0.98     CN(C[C@H]1CCCN(C(=O)CCc2cn[nH]c2)C1)C1CCCC1\n",
            " -19.38   -24.43   34.10    0.98     CNC(=O)Cc1cc(C(C)=O)cc(C(=O)[O-])c1F\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 10   Fraction valid SMILES: 93.8  Time elapsed: 0.08h Time left: 23.05h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -12.77   -16.26   42.35    0.98     O=C(NCc1ccccc1F)C(=O)Nc1ccc(F)c(F)c1F\n",
            " -16.89   -15.94   42.21    0.97     CO[C@H](C)c1noc(CN2CCC[C@H]([NH3+])C2)n1\n",
            " -17.42   -17.00   43.00    1.00     CC[C@H](C)NC(=O)[C@H](C)[S@@](=O)Cc1ccc(C(C)=O)cc1\n",
            " -26.10   -26.70   32.00    0.98     O=C([O-])Cc1cc(OC[C@H]2CCCO2)c[nH]1\n",
            " -16.73   -18.25   41.43    0.99     CCC[NH2+][C@H](CSC(C)C)C(C)(C)c1ccccc1\n",
            " -15.11   -18.03   41.10    0.99     Cc1c(NC(=O)C(=O)NCc2ccc(F)cc2)cccc1C(N)=O\n",
            " -26.99   -37.64   21.54    0.99     CC(C)(C)c1c(C(=O)NC[C@@H](c2ccco2)[NH+](C)C)cc(-c2ccccc2F)nc1C\n",
            " -26.17   -26.35   30.20    0.94     CC(=O)NC(=S)NNC(=O)/C=C\\c1ccncc1[N+](=O)[O-]\n",
            " -15.53   -15.21   43.36    0.98     CC[C@@H](C)C(=O)Nc1ccc([N+](=O)[O-])cc1\n",
            " -28.73   -30.26   29.35    0.99     COCCN(C(=O)N(C)[C@H](C)c1cccs1)[C@H](C)CO\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 11   Fraction valid SMILES: 92.2  Time elapsed: 0.09h Time left: 22.05h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -22.95   -22.44   36.73    0.99     C[C@H](O)[C@H](O)CNC(=O)c1cc(Cl)ccc1Cl\n",
            " -21.05   -22.02   35.55    0.96     FC(F)Cc1nc(-c2ccc(I)cc2)n[nH]1\n",
            " -24.99   -25.56   32.08    0.96     O=C(CSCc1cnc(-c2cccnc2)cc1)NCc1ccccc1\n",
            " -28.17   -26.35   33.16    0.99     CC[C@H](NC(=O)NCc1ccc(NC(=O)Nc2ccccc2)s1)C(=O)NC(C)(C)C\n",
            " -18.85   -19.53   39.61    0.99     O=C(c1ccnc(OCC(F)F)n1)N1CCC[C@@H](C(F)(F)F)C1\n",
            " -19.71   -23.78   34.95    0.98     O[C@H](CNCc1cc(F)c(F)c(F)c1F)c1ccc(Cl)cn1\n",
            " -23.15   -21.70   36.42    0.97     N#Cc1ccccc1-c1noc(C2CC[NH+](CC(=O)N3CCCC3)CC2)n1\n",
            " -19.78   -21.03   38.84    1.00     CC[C@H](C)N(C)c1ccc(F)cc1CN1C[C@H](C)OC1=O\n",
            " -21.10   -22.18   37.59    1.00     CCCOCC(=O)N[C@H](c1ccc(C)cc1C)c1c(C)noc1C\n",
            " -16.65   -17.40   41.83    0.99     O=C(NC1(C(=O)[O-])CCCC1)c1ccc(Br)cc1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 12   Fraction valid SMILES: 81.2  Time elapsed: 0.09h Time left: 21.16h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -16.58   -17.91   40.92    0.98     CCOC(=O)c1c(NC(=O)c2ccc(OCC(=O)[O-])cc2)sc(C)c1C\n",
            " -23.51   -24.32   35.19    0.99     CC(C)c1noc([C@H](C)[NH2+]CCC(=O)N2C[C@H](C)C[C@@H](C)C2)n1\n",
            " -24.79   -35.95   23.20    0.99     O=C(C[NH+](C/C=C/c1ccc(F)cc1F)C1CC1)Nc1ccc(F)c(F)c1F\n",
            " -21.74   -22.50   36.68    0.99     CCC[C@H](CNc1ncnc2cc(C)c(C)cc12)[NH+](C)C\n",
            " -23.71   -26.43   32.65    0.98     O=C(N[C@H](C(=O)N1CCN(c2ccccc2F)CC1)C(F)(F)F)Nc1ccccc1\n",
            " -22.28   -30.51   29.11    0.99     C[NH+](CC(=O)N[C@H](CO)c1ccc(F)c(F)c1)CC(C)(C)C[NH+](C)C\n",
            " -17.50   -18.62   40.02    0.98     C[NH2+][C@@H](CCc1ccc(F)cc1)c1ccc(F)cn1\n",
            " -14.75   -18.25   41.75    1.00     Cc1cc(F)cc(NC(=O)C[C@H](C)CCC#N)c1\n",
            " -15.39   -17.23   42.77    1.00     CCOC(=O)C[C@H](C)CNC(=O)N1CCc2c(F)ccc(F)c2C1\n",
            " -27.76   -25.73   33.14    0.98     CCC[C@@H]1C[C@@H]1NC(=O)c1ccc(CN2CCN(c3ccccc3)CC2)cc1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 13   Fraction valid SMILES: 90.6  Time elapsed: 0.10h Time left: 20.50h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -21.10   -27.64   31.75    0.99     COC(=O)CCC(=O)N1CCC(NC(=O)C(=O)Nc2ccc(Cl)c(Cl)c2)CC1\n",
            " -23.00   -25.13   33.42    0.98     CCc1nn(C)cc1CNCc1cc(=O)oc(C)n1\n",
            " -22.77   -25.35   34.35    0.99     Cc1cc(NC(=O)C(=O)NC[C@@H](O)C(C)(C)C)c(Cl)c(C(F)(F)F)c1\n",
            " -23.44   -26.01   33.66    0.99     CC(=O)N(C)Cc1ccc(NC(=O)[C@@H](C)OC(=O)c2cccc(Cl)c2)cc1\n",
            " -23.06   -24.91   34.20    0.99     CCCOC(=O)CN1CCN(c2cc(C)c([N+](=O)[O-])cc2C)CC1\n",
            " -18.47   -20.46   38.67    0.99     O=C(Nc1ccc(C(=O)N2CCCC2)cc1)N(Cc1ccc(F)cc1)C1CC1\n",
            " -20.56   -20.71   39.29    1.00     CCN(CC)C(=O)NCc1cccc(NC(=O)CC(F)(F)F)c1\n",
            " -17.30   -20.81   38.57    0.99     CS(=O)(=O)NC[C@H](c1ccc(F)cc1)N1CCN(CC(F)(F)F)CC1\n",
            " -20.52   -23.84   33.47    0.96     COC(=O)c1cc(-c2cc(=O)oc3ccc(C)cc23)cc([N+](=O)[O-])c1C\n",
            " -22.99   -25.25   34.40    0.99     CCOc1cc([C@H]2C(C(=O)C(C)C)=C[C@H](C)C2=O)ccc1OC(C)C\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 14   Fraction valid SMILES: 95.3  Time elapsed: 0.10h Time left: 19.98h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -22.05   -24.23   33.67    0.97     CC(C)CCNC(=O)CCNC(=O)N1CC[NH+](CC2CCCCC2)CC1\n",
            " -17.71   -19.79   37.82    0.96     Cc1nc([C@@H](NC(=O)c2cc(F)ccc2F)c2ccccc2)n[nH]1\n",
            " -16.32   -17.49   41.47    0.98     CCOC(=O)[C@H](C)OC(=O)c1ccc(Cl)o1\n",
            " -29.07   -29.56   30.31    1.00     CC[C@H](CO)NC(C)(C)CC(=O)NCc1cccc(N)c1\n",
            " -28.11   -29.64   29.99    0.99     CC[C@@](C)(N/C(N)=O)C(=O)Nc1c(OC)cccc1F\n",
            " -18.15   -19.80   39.62    0.99     CCc1cnc(C[NH+](CCO)Cc2cccc(Cl)c2Cl)o1\n",
            " -21.08   -26.48   33.51    1.00     CCC(CC)C(=O)N(C[C@@H]1CCCO1)C(=O)c1cc(C)c(C)[nH]1\n",
            " -19.52   -21.86   36.30    0.97     O=C(N[C@@H](C(=O)N1CCOCC1)c1nc2ccccc2s1)c1ccc(Cl)cn1\n",
            " -17.71   -19.57   40.27    1.00     CCOCCCNC(=O)N[C@H](CO)c1cccc(F)c1\n",
            " -20.78   -27.44  -27.44    0.00     Cn1c(=O)[nH]c(=O)c2c(C(=O)N3CCC(COc4ccc(F)cc4)CC3)ccc21\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 15   Fraction valid SMILES: 95.3  Time elapsed: 0.10h Time left: 19.48h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -23.07   -26.73   32.84    0.99     C[C@H](NC(=O)N[C@H]1CCN(C(=O)C=C2CCCC2)C1)c1ccc(F)c(F)c1\n",
            " -14.59   -22.08   35.56    0.96     O=C(Cc1ccc(F)c(F)c1F)c1ccc(F)cc1F\n",
            " -21.63   -25.97   33.95    1.00     CCc1ccc(CN(C(=O)C(=O)NCC(=O)NC(C)C)C(C)C)cc1\n",
            " -21.15   -21.76   37.62    0.99     CN(CC(C)(C)c1nc(C(C)(C)C)cs1)C1(C[NH3+])CCCCC1\n",
            " -28.09   -34.37   25.07    0.99     C/C(=N\\NC(=O)c1cnc(NCc2cccc(F)c2)nc1C1CC1)C(C)C\n",
            " -18.62   -18.92   40.67    0.99     CCNC(=O)CN(C)S(=O)(=O)Cc1cccc(F)c1\n",
            " -13.21   -16.90   42.77    0.99     CCOC(=O)CCC(=O)Nc1ccc(F)c(C#N)c1\n",
            " -21.83   -24.58   35.07    0.99     C[C@H](N)C(C)(C)[NH+](C)Cc1cc(F)ccc1F\n",
            " -19.72   -20.15   38.95    0.99     Cc1c(Cl)cccc1NC(=O)CN1CCO[C@H](c2cccc(F)c2)C1\n",
            " -32.47   -34.62   25.15    1.00     CCCn1cc(C(=O)N[C@H](C(=O)Nc2cccc(OC)c2)C(C)C)c(Cl)n1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 16   Fraction valid SMILES: 98.4  Time elapsed: 0.11h Time left: 19.05h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -24.47   -26.48   33.12    0.99     C[C@@H](C(=O)N[C@@H](C)c1ccc(C#N)cc1)[C@H]1CCCN(C(=O)C2CC2)C1\n",
            " -19.31   -21.03   38.52    0.99     CSCC[C@@H](NC(=O)C(=O)Nc1cc(F)ccc1F)c1cccc(Cl)c1\n",
            " -25.80   -28.86   30.16    0.98     C[C@H](C(=O)c1c(C)nc(N)nc1N)N(C)Cc1ccccc1\n",
            " -11.47   -13.72   46.28    1.00     CCCCC(=O)Nc1ccc(I)cc1\n",
            " -22.40   -22.76   35.85    0.98     O=C(NC[C@H](O)CN1CCOCC1)Nc1ccc(Oc2ccccc2)cc1\n",
            " -20.29   -19.70   38.25    0.97     Cc1nn(CN2CCN(C(=O)c3cccc(O)c3)CC2)c(=O)c2ccccc12\n",
            " -25.96   -29.98   29.96    1.00     CCN(C)C(=O)CNC(=O)NC[C@H](Oc1c(Cl)cccc1Cl)C(C)C\n",
            " -19.75   -25.55   34.02    0.99     C[C@H](C(=O)NCCC(=O)N1CCN(C(=O)c2ccccc2F)CC1)c1ccc(F)c(F)c1\n",
            " -20.44   -21.23   35.72    0.95     C[C@H]1CC(=O)C2=C(CC1)[C@@H](C(=O)[O-])OC(=O)C2\n",
            " -17.80   -19.77   37.91    0.96     COC(=O)C1CCN(/C(N)=[NH+]/C2CCCC2)CC1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 17   Fraction valid SMILES: 92.2  Time elapsed: 0.11h Time left: 18.67h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -20.13   -23.09   36.57    0.99     COCCOc1nc(C)nc(CC)c1C\n",
            " -25.46   -25.94   33.56    0.99     CO[C@@H](CNC(=O)[C@H](C)Sc1cccnc1)c1ccc(F)c(F)c1\n",
            " -29.66   -34.51   25.15    0.99     C[C@H](c1ccc(Cl)s1)N(C(=O)[C@@H](C)C(C)C)C(=O)c1cccc(F)c1\n",
            " -29.32   -39.05  -39.05    0.00     Fc1cc(Cl)cc(C(=O)NC[C@H]([C@@H]2CCOC2)N1CC[NH+](C)C\n",
            " -25.77   -28.56   31.23    1.00     Cc1cccc(CC(=O)C(=O)NNC(=O)COCC(C)C)c1\n",
            " -23.37   -23.70   35.29    0.98     CC(=O)Nc1cc(NC(=O)c2cn(CC(=O)NC3CCCC3)nn2)ccc1C\n",
            " -17.28   -21.08   37.29    0.97     C[C@H](CNC(=O)C1CCN(C(=O)C(C)(C)C)CC1)C[NH+]1CCCC1\n",
            " -29.66   -33.89   25.97    1.00     CCOC(=O)c1cc(CC)c(C(=O)NCc2ccnc(OCC(F)F)c2)cc1\n",
            " -24.17   -31.22   28.70    1.00     C=C(C)CN(CC(=O)NCc1ccc(F)cc1)C(=O)c1cc(C)cc(C)c1\n",
            " -21.52   -22.10   37.32    0.99     COc1cccc(NC(=O)[C@H](C)N[C@H](C)c2ccc(C(C)C)cc2)c1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 18   Fraction valid SMILES: 89.1  Time elapsed: 0.12h Time left: 18.31h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -15.44   -17.99   40.97    0.98     O=C(COc1ccc(I)cc1)C1CCN(c2ccc(F)cc2)CC1\n",
            " -18.47   -21.55   38.45    1.00     CC(C)CO[C@@H]1CCCN(C(=O)CCC(=O)c2ccc(F)c(F)c2)C1\n",
            " -20.81   -21.56   36.13    0.96     CC[C@H](CS)C[NH+](CCO)C1CCC1\n",
            " -21.26   -23.76   34.94    0.98     C[C@H](C(=O)N[C@H](CCCO)C(C)(C)C)N1C[C@H](C)O[C@H](C)C1\n",
            " -16.83   -20.26   39.72    1.00     COCCCC(=O)NCC(=O)N1CCc2cc(F)ccc2C1\n",
            " -19.83   -24.71   34.64    0.99     O=C(Cc1cccc(Cl)c1)NCC(=O)NC[C@H](O)c1ccc(Cl)cc1\n",
            " -25.79   -24.99   34.12    0.99     Cc1nn(C)cc1CCC(=O)N[C@@H]1CCC[C@@H](N2CCCC2=O)C1\n",
            " -18.27   -19.79   39.54    0.99     O=C(C[C@H](O)c1ccc(Cl)cc1)NNC(=O)C(C)(C)c1ccccc1\n",
            " -16.19   -21.65   37.21    0.98     O=C(C[C@H](c1ccc(F)cc1)c1cccc(F)c1)N1CCCCC1\n",
            " -38.38   -34.76  -34.76    0.00     O=C(c1ccc(F)cc1)N1CCC[C@H](C(=O)N2C[C@@H]3CC=CCC3)[C@@H](c3ccc(N4CCOCC4)cc3)C2)C1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 19   Fraction valid SMILES: 92.2  Time elapsed: 0.12h Time left: 18.01h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -20.70   -25.82   33.59    0.99     COC(=O)[C@]1(F)CCN(C(=O)CC(=O)c2ccc(C(F)(F)F)cc2)C1\n",
            " -20.58   -25.65   33.81    0.99     CCCCCC[C@H](C)NC(=O)NC[C@@H]1CCCN(c2cnn(C)c2)C1\n",
            " -25.43   -25.10   32.57    0.96     CN1CCC/C1=N\\CC(=O)N1CCC[C@H](C(=O)N2CCCC2)C1\n",
            " -18.06   -16.73   41.64    0.97     CCC1(CC)CC[NH2+]C[C@@H]1c1ccco1\n",
            " -18.85   -22.16   36.30    0.97     O=C(c1ccc(=O)[nH]c1)N1CCN(C(=O)CCC2=c3ccccc3=[NH+]C2)CC1\n",
            " -20.21   -29.06  -29.06    0.00     CCc1cc(=O)n(CC(=O)Nc2cc(F)c(OC)cc2F)ccc1F\n",
            " -32.89   -32.13   24.83    0.95     C(=C\\COC(=O)c1cnn(-c2cccc(F)c2)c1-c1ccccc1)c1ccc([N+](=O)[O-])cc1\n",
            " -18.11   -18.31   40.77    0.98     CCCc1cc(NC(=O)C(=O)NCC(C)(C)[NH+](C)C)n(C)n1\n",
            " -16.09   -22.08   37.21    0.99     COc1cc(/C=C(\\C#N)c2cccc(F)c2)c(OC)c(OC)c1OC\n",
            " -23.40   -23.65   35.45    0.98     CO/C([O-])=C(\\C#N)C(=O)[C@H]1CCCN(c2ccc(F)c(F)c2)C1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 20   Fraction valid SMILES: 89.1  Time elapsed: 0.12h Time left: 17.68h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -18.54   -18.76   40.68    0.99     Cc1ccc(CNC(=O)COC(=O)c2cc(C)ccc2F)cc1\n",
            " -23.85   -23.09   35.79    0.98     CC(C)c1nn(CC(=O)NCc2ccccc2C)c(=O)c2c(C)nn(C)c12\n",
            " -21.36   -25.78   31.58    0.96     CC[C@H](C)C(=O)NCC(=O)NNC(=O)C(=O)N1CCCC1\n",
            " -22.51   -26.97   32.86    1.00     CC(=O)N(CCC(=O)NC1CC1)[C@H](c1ccccc1F)C1CC1\n",
            " -22.20   -23.86   35.68    0.99     Cc1nc(C)c(C[C@@H](O)C2(C(=O)[O-])CCC(C)CC2)s1\n",
            " -18.47   -19.53   37.95    0.96     CC(C)n1nnnc1-c1cccc(C#N)c1\n",
            " -21.21   -26.73   32.54    0.99     CCCCOCC(=O)N[C@H](CC(C)=O)C1CCCCC1\n",
            " -20.62   -25.55   34.38    1.00     CCOC(=O)NCCCC(=O)Nc1c(C)cc(N)cc1C\n",
            " -19.58   -19.96   39.91    1.00     CCC[C@H]([NH2+]Cc1cc(Cl)ccc1O)C(C)(C)[NH+](C)C\n",
            " -13.41   -20.10   39.06    0.99     O=C(CCC(=O)c1ccc(F)c(F)c1)NCc1ccc(F)c(F)c1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 21   Fraction valid SMILES: 95.3  Time elapsed: 0.13h Time left: 17.41h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -15.02   -17.84   41.27    0.99     CCOC(=O)CC1CC[NH+](Cc2cc(C)on2)CC1\n",
            " -18.26   -22.05   35.51    0.96     CC[C@H](C)[C@@H](NS(=O)(=O)C(C)C)C(=O)NC(C)C\n",
            " -13.96   -15.93   41.77    0.96     CCC[NH2+][C@H](CCC(C)C)C(C)C\n",
            " -14.54   -21.71   35.87    0.96     CCN(C(C)=O)C(=O)NCC(C)(C)C[NH+](C)C\n",
            " -19.70   -20.36   38.32    0.98     O=C(COC(=O)c1cccc(F)c1)NNC(=O)c1ccc(Cl)cc1Cl\n",
            " -21.80   -25.46   34.42    1.00     CC[C@H](NC(=O)N(CCC(=O)[O-])CC(C)C)c1c(F)cccc1F\n",
            " -23.09   -23.99   34.86    0.98     C[C@H](Cn1cccn1)NC(=O)N[C@H](c1ccc(Cl)cc1)N1CCOCC1\n",
            " -14.61   -19.82   38.35    0.97     C[C@@H]([NH2+]C1CCC(C(=O)N(C)C)CC1)C(=O)[O-]\n",
            " -26.35   -33.19   26.02    0.99     O=C(NCCC(=O)N1C[C@@H](CN2CCCC2)[C@H]1c1cccc(F)c1)c1ccccc1\n",
            " -18.17   -21.57   35.19    0.95     CNC(=O)CCCC/C(C)=N/NC(N)=O\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 22   Fraction valid SMILES: 90.6  Time elapsed: 0.13h Time left: 17.16h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -21.69   -26.24   32.29    0.98     O=C(NCCc1nnc(-c2ccccc2F)o1)N[C@H](c1ccc(Cl)cc1)C1CC1\n",
            " -17.27   -22.17   37.54    1.00     CN(CC(C)(C)C)C(=O)C1CC[NH+](C[C@H](O)c2ccc(Cl)cc2)CC1\n",
            " -20.86   -21.79   35.87    0.96     CCc1nc(-c2ccc(N3CCN(C(=O)COc4ccccc4F)CC3)[nH+]c2)no1\n",
            " -18.67   -20.78   38.60    0.99     CCCc1noc(CN(C)C(=O)[C@@H](C)OCC(F)(F)F)n1\n",
            " -24.75   -26.52   32.22    0.98     Cc1nn(CC(C)C)cc1C(=O)OCc1cc(=O)c2ccccc2[nH]1\n",
            " -14.08   -17.99   41.94    1.00     CC(C)(C)C(=O)NC[C@H](O)c1cc(F)ccc1F\n",
            " -26.33   -29.49   27.91    0.96     CC(C)CC[NH+]1CCC(NCCC(=O)N2CCN(C3=NC(=O)CC3=O)CC2)CC1\n",
            " -29.06   -32.35   27.17    0.99     CCC[C@H]1CCc2nc(CN/C(N)=[NH+]\\C(C)(C)C)c(=O)n(C)c21\n",
            " -18.50   -21.61   37.16    0.98     Cc1ccc(C(=O)NC[C@@H](c2cccc(F)c2)N2CC[NH+](C)CC2)cc1\n",
            " -18.99   -22.68  -22.68    0.00     CCC(CC)[NH2+]CC/C=C/(=O)C(C)(C)C\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 23   Fraction valid SMILES: 89.1  Time elapsed: 0.14h Time left: 16.97h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -16.21   -18.73   40.38    0.99     CC(C)[C@H](CO)NC(=O)C(=O)Nc1cccc(N)c1\n",
            " -18.53   -24.87   32.26    0.95     C[C@H](NC(=O)NCCC(=O)[O-])C(=O)N(C)CC(=O)N1CCCC1\n",
            " -16.69   -19.48   39.68    0.99     CC(C)[C@H](CO)NC(=O)N[C@@H](c1ccc(F)cc1)[C@H]1CCS(=O)(=O)C1\n",
            " -30.97   -34.78   24.91    0.99     CCC1(CC)[C@H](NC(=O)C(=O)NCCc2ccc(C)c(N)c2)[C@H](C)[C@@H]1O\n",
            " -25.67   -23.40   35.41    0.98     COC[C@H](C)Nc1ncc(Cc2cccnc2)nc1C\n",
            " -19.79   -19.26   38.58    0.96     FC(F)C(F)(F)Oc1ccc2cnccc2c1\n",
            " -14.96   -18.60   39.77    0.97     COC(=O)CC[NH+](C)CC(=O)N1CCCC[C@H]1C\n",
            " -29.05   -30.81   28.86    0.99     CC(C)(C)OC(=O)NCCCNC(=O)c1ccnn1-c1cccc(OC(F)(F)F)c1\n",
            " -28.87   -33.21   25.89    0.98     C[C@H](SCc1ccc(C(=O)N(C)C)c(Cl)c1)C(=O)Nn1cncn1\n",
            " -20.54   -21.76   37.28    0.98     CCCOC[C@H]1CCCN(C(=O)C(=O)Nc2cc(Cl)ccc2[N+](=O)[O-])C1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 24   Fraction valid SMILES: 93.8  Time elapsed: 0.14h Time left: 16.74h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -21.05   -25.54   34.18    1.00     C[C@H](C(=O)NC(C)(C)C)C(=O)N[C@@H](C)c1ccccn1\n",
            " -19.16   -21.57   37.97    0.99     C[C@@H](c1cccc(F)c1)N(C)C(=O)CCOc1cccc(C#N)c1\n",
            " -20.39   -25.00   34.64    0.99     C[C@@H](CCc1c(F)cccc1F)C(=O)NC(=O)NCc1ccc(F)cc1\n",
            " -22.86   -23.57   34.12    0.96     COc1cc(C(=O)N2CCN3C(=N)CCC3=NC2=O)c(Br)cc1O\n",
            " -22.03   -25.60   33.56    0.99     CC(C)(C)CCNC(=O)[C@H](C)S(=O)(=O)Cc1ccc([N+](=O)[O-])cc1\n",
            " -17.19   -19.93   38.26    0.97     CCOC(=O)[C@@H](C)NC(=O)[C@H](C)CC(C)C\n",
            " -20.97   -23.29   36.58    1.00     CCNC(=O)NC(=O)CSCCCOc1ccc(F)cc1\n",
            " -13.66   -19.86   38.89    0.98     CCC(CC)C(=O)N1CCC(C(=O)N2CCCC2)CC1\n",
            " -22.00   -25.32   32.70    0.97     C=CCC[C@H](C)N[C@@H](C(=O)[O-])C(C)C\n",
            " -18.77   -22.05   37.94    1.00     CCCC(CC(=O)N[C@@H](CO)Cc1ccccc1)C(C)C\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 25   Fraction valid SMILES: 87.5  Time elapsed: 0.14h Time left: 16.57h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -20.91   -25.49   33.67    0.99     CN(C(=O)CSCC(=O)Nc1cc(C(C)(C)C)on1)c1nccs1\n",
            " -18.93   -20.19   38.42    0.98     C[C@H](CCCO)NC(=O)N[C@H]1CCN(C(=O)CCC(F)(F)F)C1\n",
            " -28.98   -33.44   22.67    0.94     COC(C)(C)SC/C(=C(\\C#N)C(N)=O)C(=O)[O-]\n",
            " -22.12   -24.47   35.15    0.99     CCCc1nn(C)c(Cl)c1C[NH2+][C@H](C)c1ccc(F)c(C)c1\n",
            " -21.84   -32.22   27.15    0.99     C/C(=N/NC(=O)[C@@H](C)Nc1ccc(F)c(Cl)c1)C(=O)NC(C)C\n",
            " -31.86   -28.09   29.20    0.95     Cc1cc(NC(=O)C(=O)c2cc(Br)cn2C)c2c(=O)n(-c3ccccc3)c(=O)[nH]c2c1\n",
            " -31.56   -36.53   23.24    1.00     Cc1c(Cl)cc(S(=O)(=O)N2CCCC[C@H]2C)cc1C(=O)N[C@H](CC(C)C)C(=O)N1CCCCC1\n",
            " -18.19   -20.89   39.11    1.00     COc1ccc(CCNC(=O)CCC(C)(C)C)cc1\n",
            " -20.93   -22.35   37.22    0.99     CC(C)CC(=O)N(CC(=O)Nc1ccccc1)Cc1ccccc1\n",
            " -16.42   -16.76   42.53    0.99     C[C@H]1CCCC[C@H]1NC(=O)CSc1nnc(C(C)(C)C)n1N\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 26   Fraction valid SMILES: 92.2  Time elapsed: 0.15h Time left: 16.36h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -20.64   -26.90   32.97    1.00     Cc1cc(C(=O)CN(C)C(=O)CCl)cc(C)c1F\n",
            " -17.54   -22.85   35.93    0.98     CCC(C)(C)NC(=O)CCC(=O)NC[C@@H](C)N1CCOCC1\n",
            " -20.68   -23.34   35.71    0.98     O=C(CO/C(=C\\c1ccc(Cl)cc1)c1ccccc1)N1CCOCC1\n",
            " -17.30   -20.21   39.79    1.00     CSCC[C@H](C)N(C)C(=O)C(=O)Nc1ccc(C(C)=O)c(C)c1\n",
            " -20.47   -25.09   34.91    1.00     CCC(=O)N[C@@H](Cc1ccc(F)cc1)C(=O)N(C)CCC#N\n",
            " -20.55   -25.32  -25.32    0.00     C[C@H]([NH2+]CCC(=O)N(CC(C)()C)C)c1ccc(F)cn1\n",
            " -18.02   -21.24   37.63    0.98     CC(C)NC(=O)CCCC(=O)OC[C@H]1CCCO1\n",
            " -21.23   -23.50   36.30    1.00     O=C(CC1CCCC1)N(Cc1ccc(OC(F)(F)F)cc1)C[C@H]1CCCO1\n",
            " -19.61   -24.52  -24.52    0.00     CCCCn1c(C)nn(C[NH+]2CCN(C(=O)c3ccc(F)cc3F)CC2)c1C\n",
            " -16.68   -19.91   40.09    1.00     C[C@@H](CC1CCCC1)C(=O)NCC(=O)Nc1c(F)cccc1F\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 27   Fraction valid SMILES: 89.1  Time elapsed: 0.15h Time left: 16.20h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -20.90   -22.94   36.26    0.99     Cc1nc(CNC(=O)[C@H](C)[NH+]2CCC[C@H](C(=O)NC(C)C)C2)sc1C\n",
            " -26.10   -27.76   31.13    0.98     COCCn1/c(=N/C(=O)Nc2ccc(N(C)C)cc2)sc2ccc(F)cc21\n",
            " -23.23   -28.52   31.48    1.00     CCCCN(CCC)C(=O)c1cc(OC)cc(F)c1F\n",
            " -16.98   -26.43   33.52    1.00     CC[C@H](C(=O)N(C(C)CC)Cc1ccc(F)cc1)C(=O)[O-]\n",
            " -22.96   -34.14   22.14    0.94     C[C@@H](CNC(=O)[C@H](C)[NH+](C)CC(=O)NC(=O)OC(C)(C)C)C(=O)[O-]\n",
            " -14.54   -20.97   38.61    0.99     C/C(=N\\NC(=O)COc1ccc(C(C)C)cc1)C(=O)Nc1cccc(Cl)c1\n",
            " -16.57   -19.51   38.53    0.97     O=C(NC[C@@H](O)C(=O)[O-])c1cc(F)cc(F)c1\n",
            " -17.01   -21.03   37.19    0.97     C[C@H](C(=O)N(C)CC(=O)NC1CCCCC1)[NH+](C)C1CC1\n",
            " -22.93   -30.87  -30.87    0.00     CC[C@@H](CC(=O)N[C@H](C(=O)N1CCCC1)C(N)=O)c1F\n",
            " -16.66   -15.29   41.37    0.94     C#CCNCC(=O)N[C@@H](C)CC(=O)[O-]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 28   Fraction valid SMILES: 93.8  Time elapsed: 0.16h Time left: 16.03h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -15.54   -17.72   41.32    0.98     O=C(CCOc1ccc(F)cc1F)NCc1ccco1\n",
            " -18.22   -18.46   40.34    0.98     Cc1cc(C(=O)[O-])ccc1NC(=O)[C@H](C)Cl\n",
            " -22.70   -27.57  -27.57    0.00     C[C@H](NC(=O)C(=O)N1CCCCC1)C(O)(C(=O)OC(C)(C)C\n",
            " -15.99   -19.67   40.33    1.00     CC(C)CC(=O)NCC(=O)N(C)Cc1cccc(C(F)(F)F)c1\n",
            " -16.76   -21.52   36.98    0.97     O=C(CCCO)NCCC(=O)NC1CCCCC1\n",
            " -28.19   -24.39   32.90    0.95     CCN[C@]1(C#N)CCC[C@H]([NH+]2CCCC[C@@H]2C)C1CCC\n",
            " -20.31   -24.11   34.89    0.98     COC(=O)CCCn1nnc(C(=O)Nc2cc(F)c(F)cc2F)c1C\n",
            " -24.60   -28.57   28.66    0.95     O=C(CCC(=O)N1CCCC1)N1CCC[C@H](C(=O)N2CC(=O)NC2)C1\n",
            " -15.54   -19.72   40.00    1.00     O=C(CCC(=O)c1ccc(F)c(Br)c1)NC(C1CC1)C1CC1\n",
            " -21.64   -31.13   25.90    0.95     CCCOC(=O)[C@@H](CC(=O)C(C)C)C(=O)[O-]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 29   Fraction valid SMILES: 95.3  Time elapsed: 0.16h Time left: 15.91h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -37.55   -47.62   10.59    0.97     O=C(CCc1ccccc1)OCCN1C(=O)N(CCO)C(=O)C(C2NC(=O)C2=O)[C@H](c2ccccc2)C1=O\n",
            " -21.97   -32.03   27.59    0.99     CC[C@H](C(=O)Nc1ccc(F)c(N(C)C)c1)C(=O)Nc1ccc(F)cc1\n",
            " -14.37   -18.53   41.31    1.00     CC(C)NC(=O)CCNC(=O)N[C@H](c1ccc(F)cc1)C1CC1\n",
            " -28.17   -24.76   30.77    0.93     CC(C)N1[C@H]2CC[C@@H]1C[NH+](C1COCCC1)C2\n",
            " -21.52   -29.99   28.70    0.98     CC(C)CC(=O)CCC(=O)NC1CC[NH+](CC2CCN(C(=O)C(C)(C)C)CC2)CC1\n",
            " -19.94   -23.37   36.44    1.00     CN(C[C@@H](O)C1CC1)C(=O)[C@H](C)Oc1cccc(I)c1\n",
            " -28.66   -28.07   31.60    0.99     CCCOCC(C)(C)C[NH+](Cc1ccnn1C)CC(C)C\n",
            " -27.00   -33.30   26.23    0.99     C[C@@H](c1ccoc1)N(CC(=O)N(C)CCC(=O)NC1CC1)C1CC1\n",
            " -21.93   -23.08   36.87    1.00     COC[C@H](C)COC(=O)[C@@H]1C[C@@H]1c1ccc(F)c(F)c1\n",
            " -21.28   -20.00   37.81    0.96     O=C(CSc1nc(-c2ccc(C(F)(F)F)cc2)n[nH]1)Nc1cccnc1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 30   Fraction valid SMILES: 93.8  Time elapsed: 0.17h Time left: 15.81h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -17.97   -18.19   41.81    1.00     COc1ccc(OC)c(C[NH2+][C@H](C)C(C)C)c1\n",
            " -24.85   -21.74   37.64    0.99     CCc1ccc(O[C@H](C)C(=O)Nc2cc(S(C)(=O)=O)ccc2Cl)o1\n",
            " -19.36   -20.30   38.98    0.99     O=C(Nc1cccc(C(=O)NC[C@H]2CCCO2)c1)c1ccc(C(F)(F)F)cc1\n",
            " -22.16   -24.37   35.56    1.00     C[C@@H](NC(=O)N[C@H](C)C(=O)NCC(C)(C)C)c1ccccc1Cl\n",
            " -27.32   -29.90   28.26    0.97     CCC[C@H](C(=O)Cc1nncn1-c1ccccc1Cl)c1ccccc1\n",
            " -21.76   -20.22   38.49    0.98     COC(=O)[C@@H]1CCN(C(=O)/C=C(/C)C2CC2)C1\n",
            " -18.16   -21.42   38.06    0.99     CCC[C@@H](CC(=O)OC)NC(=O)c1nn(C)c(=O)c2ccccc12\n",
            " -20.66   -27.70   32.08    1.00     CC(C)C(=O)N1CCC[C@H](C(=O)N(Cc2ccc(F)cc2F)C[C@H]2CCCO2)C1\n",
            " -15.43   -18.81   40.71    0.99     O=C(N[C@H](CC(F)(F)F)c1ccc(F)c(F)c1)N1CCCC1\n",
            " -27.62   -39.18   19.91    0.98     O=C(CCC(=O)c1ccc(F)cc1F)NC[C@H](c1ccccc1)N1CCN1C(=O)c1ccc(Cl)cc1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 31   Fraction valid SMILES: 90.6  Time elapsed: 0.17h Time left: 15.68h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -21.43   -29.42   29.66    0.98     CC[C@H](NC(=O)NCC1(CC(C)C)CCCCCC1)C(=O)NC(C)(C)C\n",
            " -20.08   -23.31   35.40    0.98     CN(Cc1ccc(F)cc1Cl)C(=O)Cn1cnc(C#N)n1\n",
            " -22.55   -26.24   33.50    1.00     C[C@H](CO)[C@H]([NH3+])CNC(=O)C(C)(C)Cc1ccccc1\n",
            " -19.01   -23.89   35.79    0.99     CCN(CC[C@H](C)CS)c1ccccc1N\n",
            " -14.91   -22.92   35.53    0.97     O=C(C[C@H](O)c1ccc(Cl)c(Cl)c1)N[C@H](CO)C(=O)[O-]\n",
            " -34.68   -43.94  -43.94    0.00     O=C(OC(=O)CNC(=O)[C@@]1(Cc2ccccc2F)CCCCC[C@@H](C(F)(F)F)C1=O\n",
            " -17.32   -22.60   37.40    1.00     CCOC[C@H](C)C(=O)N[C@@H](C)c1cc(F)cc(F)c1\n",
            " -29.41   -34.48   23.82    0.97     C=CCN(C(=O)[C@H]1CC(=O)N(CC(=O)N2CCC(C(=O)NC)CC2)C1)C1CCC(C)CC1\n",
            " -15.99   -21.99   37.02    0.98     C[C@@H](CC(=O)N(CC(=O)[O-])C(N)=O)c1ccccc1\n",
            " -20.82   -25.42   34.03    0.99     CCOC(=O)C(=O)/N=C(\\NCc1ccc(F)cc1C)c1ccccc1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 32   Fraction valid SMILES: 87.5  Time elapsed: 0.17h Time left: 15.59h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -20.98   -21.33   38.57    1.00     C=CCCOCCNC(=O)NCc1cccc(C#N)c1\n",
            " -20.72   -25.48   34.07    0.99     Cc1ccc(C(C)(C)C)cc1NC(=O)C[C@H](C)c1cc(F)ccc1F\n",
            " -21.92   -21.24   38.22    0.99     c1cc(CN(C[C@H]2CCCO2)C2CC2)ccc1OC(F)F\n",
            " -27.94   -36.87   20.62    0.96     C[C@H](NC(=O)CN(C)C(=O)C1=CC=CN2C[C@@H](C(F)(F)F)C(=O)O2)C1(C)C\n",
            " -21.26   -23.45   35.64    0.98     NC(=O)CN(CC(=O)Nc1ccc(C#N)c(Cl)c1)CC(F)(F)F\n",
            " -17.12   -21.80   37.59    0.99     O=C(CCn1nc(C(F)(F)F)ccc1=O)N[C@H](c1ccc(F)cc1)C1CCCC1\n",
            " -21.07   -22.25   37.00    0.99     C[C@H](CS(C)(=O)=O)NC(=O)NC(Cc1ccccc1)c1ccccc1\n",
            " -14.79   -22.98  -22.98    0.00     OC[C@H]([NH2+]C[C@H]1CC[C@H](C(=O)[O-])C1(C)C\n",
            " -21.88   -24.02   35.27    0.99     Cc1ccc(OC[C@H](O)Cn2cc([C@@H](C)[NH3+])cc2F)cc1\n",
            " -17.80   -24.55   35.22    1.00     C[S@@](=O)CCNC(=O)C1CCN(C(=O)/C=C/c2ccc(F)cc2F)CC1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 33   Fraction valid SMILES: 92.2  Time elapsed: 0.18h Time left: 15.50h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -23.42   -25.99   33.84    1.00     CC(C)(C)c1noc(C(=O)N[C@@H](CC(C)C)c2ccc(F)cc2)n1\n",
            " -18.88   -25.75   33.97    1.00     C[C@H](C(=O)N1CCC(C(=O)NCC(F)F)CC1)c1ccc(C(F)(F)F)cc1\n",
            " -25.60   -39.73   17.50    0.95     C[C@H](NC(=O)CN(C1=NCCCS1=O)C[C@H](C)O)N1CCOCC1\n",
            " -26.37   -34.87   24.40    0.99     C[C@@H](C(=O)N[C@H](C)c1ccc(NC(=O)C(=O)NC(CO)C)s1)c1ccccc1\n",
            " -19.34   -19.86   35.98    0.93     CN(C)C(=O)NCC/C(C)=N/O\n",
            " -13.93   -15.40   44.29    0.99     CCOC(=O)C[C@H]([NH3+])c1ccc(OC(F)F)cc1\n",
            " -21.55   -29.20   30.58    1.00     CCC(CC)(CO)NC(=O)[C@H](C)NC(=O)[C@H]1CC(=O)N(c2ccc(Cl)cc2)C1\n",
            " -22.67   -28.01   30.68    0.98     C[C@H](C(=O)NC(C)(C)C)[C@@H]1CCCN(C(=O)NC(C)C)C1\n",
            " -12.07   -18.31   40.38    0.98     O=C(Cc1ccc(F)c(F)c1F)NCc1ccc(F)cc1\n",
            " -15.07   -17.92   41.16    0.98     CC1(C(=O)NCCc2c[nH]c3ccccc23)CC1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 34   Fraction valid SMILES: 90.6  Time elapsed: 0.18h Time left: 15.42h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -12.41   -17.87   40.88    0.98     CC[C@H](C)C(=O)NCC(=O)N(C(C)C)C1CC1\n",
            " -24.23   -29.19   28.26    0.96     O=C(c1n[nH]c(=O)[nH]c1=O)N(CCO)c1ccc(F)cc1\n",
            " -14.18   -18.34   41.43    1.00     COC(=O)C[C@H](C)NC(=O)COc1cccc(I)c1\n",
            " -20.53   -21.68   35.97    0.96     O[C@@H](C[C@H](O)COc1ccccc1)c1ccccc1\n",
            " -18.72   -24.68   35.29    1.00     COC(=O)C[C@H](NC(=O)C(=O)NCc1cccc(Cl)c1)C(C)(C)C\n",
            " -37.73   -39.09   19.85    0.98     CN(Cc1ccccc1)C(=O)[C@H]1C[C@H](C)N(C(=O)[C@H]2CC(=O)N(Cc3c[nH]cn3)C2)C1\n",
            " -20.63   -22.62   34.77    0.96     CCCN(CCO)C(=O)N[C@H]1CCC(=O)N(C)C1=O\n",
            " -13.82   -19.10   40.64    1.00     CC(=O)NCCNC(=O)C(=O)NCC1(c2ccc(F)cc2F)CC1\n",
            " -15.50   -16.66   42.63    0.99     C[NH2+]C[C@@]1(c2ccc(F)cc2F)CCC[C@H]1C\n",
            " -18.91   -21.83   37.97    1.00     C[NH2+][C@]1(C(=O)[O-])CCC[C@H](N(C)Cc2ccc(OC)c(F)c2)C1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 35   Fraction valid SMILES: 93.8  Time elapsed: 0.19h Time left: 15.34h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -14.45   -18.35   40.09    0.97     CCC(CC)C(=O)N1C[C@H](OC)CC[C@@H]1C(=O)[O-]\n",
            " -24.14   -34.34  -34.34    0.00     CC(C)NC(=O)CN(CC(F)(F)(F)(O)CO)C(=O)CNC(=O)c1ccccc1\n",
            " -19.68   -22.86   36.00    0.98     CCOC(=O)[C@@H](CC(=O)OC(C)=O)C1CCCCC1\n",
            " -34.25   -33.51   25.49    0.98     CCN1C(=O)/C(=N/Cc2nc3ccccc3o2)C(=O)N(CC(C)C)[C@H]1c1ccc(F)cc1\n",
            " -17.70   -22.92   37.08    1.00     C[NH2+][C@H](CC(=O)N[C@H](C)c1cccc(F)c1)C(C)C\n",
            " -24.40   -26.34   32.97    0.99     Cc1ccc(OCCNC(=O)c2cc(=O)[nH]c(C(C)C)n2)cc1\n",
            " -19.61   -28.65   30.59    0.99     C[C@H](CNC(=O)N1CC[C@H](C(=O)N[C@@H](C)c2ccccc2)C1)c1ccccc1\n",
            " -24.35   -26.16   31.79    0.97     Cc1cc(NC(=O)c2ccc(Cn3nc(C)c([N+](=O)[O-])c3F)cc2)ccc1C(N)=O\n",
            " -27.35   -26.59   31.55    0.97     C[C@H]1CC[C@](CO)([C@@H](F)c2ccc3ccccc3c2)C1\n",
            " -20.33   -19.75   38.14    0.96     O=C(NCCc1nc2ccccc2[nH]1)[C@H]1CCC[NH+](C2CCCCC2)C1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 36   Fraction valid SMILES: 100.0  Time elapsed: 0.19h Time left: 15.29h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -25.09   -29.93   29.94    1.00     CN(C(=O)[C@H](C)Nc1cccc(F)c1F)C[C@@H]1CCOC1\n",
            " -12.52   -14.23   43.30    0.96     CC(C)[C@@H](CO)[NH2+]CC(C)(C)C(=O)[O-]\n",
            " -21.57   -27.26   31.94    0.99     NC(=O)CCC(=O)N1CCC[C@H](C(=O)Nc2cncc(-c3ccccc3)c2)C1\n",
            " -24.45   -23.23   35.63    0.98     Cc1nc(CCNC(=O)NCCc2cccnc2OCc2ccccc2)sc1C\n",
            " -29.66   -38.94   20.49    0.99     COC(=O)[C@H](C)NC(=O)[C@@H](C[C@@H](O)c1ccc(Cl)cc1)N1CC=CC1\n",
            " -17.28   -21.94   37.44    0.99     C[C@H]1C[C@H](C)CN(C(=O)C(=O)Nc2ccc(N(C)Cc3ccccc3)cc2)C1\n",
            " -20.51   -24.17   34.05    0.97     CCOC[C@H]([NH3+])[C@@H](OC)[C@H]1CCOC2(CCCC2)C1\n",
            " -18.81   -17.73   40.57    0.97     CCCCC1CCC(C(=O)N[C@@H]2CCCC[C@@H]2O)CC1\n",
            " -27.63   -32.63   25.78    0.97     CC[NH2+][C@H](CC1C[C@H](C)[C@@H](C)C1)[C@@H]1CCCc2cccnc21\n",
            " -18.25   -21.71   38.29    1.00     C/C(C)=C(/C)C(=O)NCc1ccc(Cl)cc1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 37   Fraction valid SMILES: 95.3  Time elapsed: 0.19h Time left: 15.20h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -28.29   -31.22   27.69    0.98     C[C@H](OCC[NH+](C)Cc1ccc(-n2cccn2)cc1)C(=O)N1CCc2c(F)cccc2C1\n",
            " -16.04   -19.97   39.75    1.00     C[C@H](CNC(=O)NCCC(=O)N(C)C)N(C)c1ccccc1\n",
            " -23.72   -30.39   29.37    1.00     CC[C@H]1CCCC[C@H]1OCC(=O)N1CCC[C@H](C(=O)Cc2ccc(F)cc2)C1\n",
            " -19.02   -24.36   34.79    0.99     Cc1c(C(=O)NCC(=O)NCC(F)(F)F)c(F)ccc1F\n",
            " -28.06   -34.45   24.69    0.99     NC(=O)CN1C(=O)CC[C@H](Cl)[C@H]2c3ccccc3CCCC[C@@H]21\n",
            " -18.65   -20.41   38.49    0.98     COC(C)(C)COC(=O)C1(C(=O)OC)CCCC1\n",
            " -24.51   -23.97   35.27    0.99     Cc1nc(N(C)C(C)C)cc([C@H]2CNC(=O)C2(C)C)n1\n",
            " -19.70   -19.53  -19.53    0.00     COc1cccc(C(=O)NC[C@@H](c2ccccc2)[NH+](C)C)cc1OC\n",
            " -22.99   -27.86   28.73    0.94     C[C@H](CN1CC[NH+](C)C[C@@H]1C)C(=O)NNC(=O)C(=O)NC1CC1\n",
            " -24.04   -33.85   24.30    0.97     COC(=O)[C@H]1CCCN(C(=O)N[C@@H](CC(C)C)C(=O)NC(=O)NC(C)(C)C)C1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 38   Fraction valid SMILES: 92.2  Time elapsed: 0.20h Time left: 15.13h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -18.87   -24.03   34.90    0.98     COC1CC[NH+](CC(=O)NC[C@@H](c2ccc(F)cc2F)N2CCOCC2)CC1\n",
            " -22.35   -29.89   29.57    0.99     CC(C)CC[C@H](C)NC(=O)[C@H](C)N(C)C(=O)NCCc1cnn(C)c1\n",
            " -21.36   -23.22   36.26    0.99     C[C@H](C(=O)NNC(=O)Cc1cccc(F)c1)[S@@](=O)Cc1ccc(Cl)cc1\n",
            " -18.37   -21.88   38.12    1.00     CCCCNC(=O)N(CC)[C@@H](C)Cc1ccc(F)cc1\n",
            " -15.67   -15.92   42.14    0.97     CC(C)[C@@H](CO)NC(=O)N[C@H]1CCN(C(=O)OC(C)(C)C)C1\n",
            " -22.75   -27.01   32.91    1.00     C[C@H](CCS(C)(=O)=O)N(CCC(N)=O)Cc1ccc(F)cc1\n",
            " -17.52   -19.67   39.74    0.99     C/C(=N\\NC(=O)Cn1cnc(C(C)C)n1)C1CCCCC1\n",
            " -21.07   -24.85   34.74    0.99     C[NH+](C)[C@@H](CNC(=O)C1CCN(C(=O)CCC(=O)c2ccc(F)cc2)CC1)C1CC1\n",
            " -20.11   -22.75   36.46    0.99     O=C(CN1C(=O)CCCc2ccccc21)N[C@H](CO)C1CC1\n",
            " -21.94   -30.63   28.03    0.98     COC(=O)C1(C(=O)C(C)C)CCN(C(=O)COC)C[C@H]1C\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 39   Fraction valid SMILES: 92.2  Time elapsed: 0.29h Time left: 21.74h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -20.84   -21.63   36.33    0.97     O=C(c1ccc(N2C(=O)[C@@H]3[C@@H]4C=C[C@@H](CC4)[C@H]3C2=O)cc1)N1CCCCC1\n",
            " -28.99   -38.48   20.88    0.99     Cc1cc(C(=O)NC[C@@H](c2ccccc2C(F)(F)F)N2CCc3ccccc3C2)c(C[NH+](C)C)c(C)n1\n",
            " -17.86   -16.83   42.00    0.98     CCOC(=O)c1nnn(C[C@H](O)C2CC2)c1Cl\n",
            " -16.83   -21.44   37.43    0.98     C/C(=N/NC(=O)C(=O)NCc1ccco1)c1ccc(F)cc1\n",
            " -18.76   -21.50   37.84    0.99     C[C@H](CNC(=O)[C@H]1C[C@@H]1c1ccc(N(C)C)cc1)[NH+](C)C\n",
            " -24.46   -25.49   34.02    0.99     COC1CCC(CN(CC(=O)N2CCCCC2)C(=O)Nc2ccccc2OC)CC1\n",
            " -17.35   -21.59  -21.59    0.00     C[C@H](CC(=O)N1CCN(Cc2ccccc2)CC1)(C(F)(F)F)C(=O)Nc1ccccc1\n",
            " -23.76   -25.05  -25.05    0.00     COc1cc(/C=C2/C(=N)N3N=CNN4(C)C(=O)N2c2ccccc2)cccc1OC\n",
            " -15.03   -17.71   42.18    1.00     O=C(NCCC(F)(F)F)N[C@H](Cc1ccccc1)C1CC1\n",
            " -23.67   -29.61   21.72    0.86     CCC(=O)N1CCN(C(=O)CN2C(=O)[C@H]3[C@@H]4CC[C@H](O3)[C@H]4C2=O)CC1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 40   Fraction valid SMILES: 89.1  Time elapsed: 0.30h Time left: 21.51h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -16.95   -23.69   36.28    1.00     C[C@H](CCO)CNC(=O)C[C@H](C)c1ccccc1\n",
            " -13.93   -19.65   39.81    0.99     CCNC(=O)C[S@@](=O)Cc1nc(C(C)C)cs1\n",
            " -17.44   -22.77   36.47    0.99     O=C(Cc1ccc(F)c(F)c1F)N1CCCC[C@H]1CC(=O)[O-]\n",
            " -17.66   -20.94   36.68    0.96     C[C@H](CCCO)NC(=O)N[C@H](C)C[NH+]1C[C@H](C)C[C@H](C)C1\n",
            " -18.85   -17.19   40.00    0.95     CCC[NH2+][C@H]1CCC[C@H](C)C1\n",
            " -13.89   -17.31   42.59    1.00     COC(=O)[C@H](CC(C)C)NC(=O)Cc1cccnc1\n",
            " -15.29   -16.60   41.39    0.97     CC[NH2+][C@H](COC)C1CCCC1\n",
            " -27.44   -33.81   25.26    0.98     CON(C)c1ccc(C(=O)NC(=O)[C@@H]2C[C@H]2c2ccccc2F)cc1\n",
            " -20.65   -20.73   37.62    0.97     CN(Cc1cnccn1)C(=O)CC1=c2ccccc2=[NH+][C@@H]1C\n",
            " -20.28   -18.56   39.87    0.97     C[C@@H](NC(=O)N1CCC(Nc2ccccc2)CC1)c1nccs1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 41   Fraction valid SMILES: 95.3  Time elapsed: 0.30h Time left: 21.28h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -18.78   -26.41   32.98    0.99     C[C@H](NC(=O)COC(=O)/C=C/C=C/c1ccc(F)c(F)c1)c1ccccc1\n",
            " -18.02   -23.59   35.55    0.99     COC(=O)C[C@H](NC(=O)c1cc(C2CC2)on1)[C@H]1CCCc2ccccc21\n",
            " -28.64   -34.75   25.25    1.00     CCC[NH2+]C[C@H]([C@@H](C)CC(C)C)[C@]1(C)C(=O)N(c2ccccc2)C1=O\n",
            " -19.87   -19.46   39.79    0.99     COC[C@H](C)N1CC(=O)Nc2cc(Br)ccc21\n",
            " -27.29   -35.37   24.03    0.99     C/C(C(=O)NNC(=O)C[C@@H](c1ccccc1)c1c(F)cccc1Cl)N1CCOCC1\n",
            " -20.30   -19.28   38.61    0.96     O=C([O-])C(=O)/C=C/c1ccccc1F\n",
            " -15.83   -20.87   38.20    0.98     C[C@H](NC(=O)NC[C@H](c1ccccc1F)N1CCOCC1)c1ccccc1\n",
            " -18.63   -23.17  -23.17    0.00     FC(F)(F)c1ccc(C(=O)Nc2cccnc2)n1\n",
            " -20.27   -23.43   36.19    0.99     CN(C[C@H]1CC[C@@H](C(=O)NCc2cccc(F)c2)C1=O)C1CCCCC1\n",
            " -35.84   -43.67   12.59    0.94     CC[C@H](C1=N[C@H]2N=C(N)N1c1cccnc1)n1cnnc1C2\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 42   Fraction valid SMILES: 95.3  Time elapsed: 0.31h Time left: 21.09h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -23.79   -24.81   34.51    0.99     C=CCOC[C@H]1CCCN(C(=O)c2ccc(NC(=O)c3cccnc3)cc2)C1\n",
            " -22.42   -28.27   31.28    0.99     C[C@@H](C(=O)NC(=O)NCC1(O)CCCCC1)C(=O)Nc1ccccc1F\n",
            " -28.04   -31.47   28.07    0.99     Cc1ccc([C@H](C)OC(=O)[C@H]2CCCN(C(=O)C/C=C/c3ccccc3)C2)o1\n",
            " -21.61   -24.85   34.89    1.00     CCCC[C@H](C)/C([O-])=N/S(=O)(=O)c1ccc(C)c(F)c1\n",
            " -19.46   -20.04   35.92    0.93     C[C@@H](CO)C[S@@](=O)[C@@H](C)C(=O)[O-]\n",
            " -22.00   -20.39   35.50    0.93     Cc1onc(-c2ccccc2)c1-c1nnc(CSc2ccc(F)cc2)o1\n",
            " -20.31   -23.27   35.78    0.98     C[C@@H]1CCC[C@H](NC(=O)C(=O)NCCCC[NH+]2CCN(c3ccccc3F)CC2)C1\n",
            " -30.15   -30.34   29.66    1.00     C[C@H]1CCC[C@@H](N(CC(C)(C)C)NC(=O)NCCc2cccc(F)c2)C1=O\n",
            " -17.58   -16.95   42.14    0.98     O=C(CCNS(=O)(=O)c1ccc(F)cc1)N1CCc2ccccc2C1\n",
            " -17.04   -18.14   41.74    1.00     CC(C)[NH2+]C[C@H](O)c1cccc(OC(F)F)c1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 43   Fraction valid SMILES: 93.8  Time elapsed: 0.31h Time left: 20.89h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -32.67   -40.61   17.97    0.98     COC(=O)[C@H](C)NC1(CO)CCN(C(=O)[C@H]2CC(=O)N(Cc3ccco3)C2=O)CC1\n",
            " -19.36   -27.42   31.89    0.99     C[C@H](C(=O)N[C@H](C[NH+](C)C)c1ccc(F)c(F)c1)c1ccccn1\n",
            " -19.77   -19.46   39.75    0.99     CC[NH2+][C@H](CC)[C@](C)(CC)c1ccccc1\n",
            " -25.15   -27.25   32.01    0.99     CCOC(=O)NNC1CCN(C(=O)[C@H]2C[C@H]2c2ccc(F)cc2)CC1\n",
            " -20.46   -26.83   32.23    0.98     COC(=O)C[C@H](NS(=O)(=O)/C=C/c1ccccc1)C(=O)N(C)C\n",
            " -26.07   -30.69   29.08    1.00     C[C@H](C(=O)N[C@@H](CO)Cc1ccc(F)c(F)c1)[N+](C)(C)C\n",
            " -24.82   -25.03   34.29    0.99     CC(C)C[C@@H](NS(=O)(=O)c1cnccn1)C(=O)NC(C)(C)C\n",
            " -18.70   -22.85   36.62    0.99     O=C(CCNC(=O)[C@H]1SCCc2ccccc21)NCC1=CCCC1\n",
            " -20.60   -22.07   37.61    0.99     CCNC(=O)c1ccc(CNC(=O)CCOc2ccccc2F)cc1\n",
            " -22.63   -28.15  -28.15    0.00     O=C(Cn1c(=O)c2c(nc3n2-c2ccccc2)sc1c1ccccc2OC1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 44   Fraction valid SMILES: 93.8  Time elapsed: 0.31h Time left: 20.68h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -19.94   -27.85   32.15    1.00     COCC[C@H](C)C(=O)N(CC(=O)OC(C)C)c1ccc(F)c(F)c1\n",
            " -25.93   -24.92   35.08    1.00     CCCC[C@@](C(C)C)(C(=O)[O-])c1ccncc1\n",
            " -22.03   -19.42   38.97    0.97     CCOc1ccc(CNC(=O)Cn2cnnn2)cc1OC\n",
            " -13.70   -17.72   42.06    1.00     C[C@H]1C[C@@H](C)CN(C(=O)COc2cccc(F)c2F)C1\n",
            " -35.53   -33.11  -33.11    0.00     Cc1nc(CCSCC(=O)N[C@H]2CCc3cc(OC)ccc32)cc1C\n",
            " -22.33   -24.35   34.50    0.98     CCc1nc(C)cc(N[C@H](C)[C@H](C)c2ccccc2C)n1\n",
            " -19.01   -23.16   35.25    0.97     C[C@@H](OC(=O)[C@H](C)n1c(=O)oc2ccccc21)C(N)=O\n",
            " -26.10   -28.95  -28.95    0.00     C[C@H]1CN(C(=O)c2cnc3ccc(C(F)(F)F)cn3)c2C(=O)[C@H](C)O1\n",
            " -17.98   -25.73   32.59    0.97     O=C(Cc1ccc(F)c(F)c1F)Cc1ccc(Cl)cc1\n",
            " -26.17   -28.92   30.46    0.99     CC(C)[C@H](C)[C@H](NC(=O)[C@H]1CC(=O)N(C2CC2)C1=O)c1ccc(Cl)c(Cl)c1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 45   Fraction valid SMILES: 92.2  Time elapsed: 0.32h Time left: 20.46h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -26.49   -32.81   26.86    0.99     CC[NH2+][C@@H](Cc1ccc(C(=O)[O-])c(F)c1F)[C@H](C)CO\n",
            " -21.40   -24.45   34.97    0.99     O=C(COC(=O)[C@H]1CCCN(C(=O)c2cccc(F)c2)C1)N1CCCCC1\n",
            " -21.24   -23.69  -23.69    0.00     Cc1oc(C(=O)N2CCN([C@H](C(N)=O)c3ccccc3)CC2)c2ccccc2)c1C\n",
            " -17.96   -21.97   36.95    0.98     COc1ccc(NC(=O)C(=O)N/N=C/C(C)=C/c2ccccc2)cc1\n",
            " -26.74   -32.51   26.55    0.98     C[C@H]([NH2+]CCCN1C(=O)[C@H](C)O1)c1ncc(C(=O)[O-])cc1Cl\n",
            " -20.40   -22.21   35.87    0.97     CC(C)C[C@](C)(O)C[NH2+][C@H](C)[C@@H]1CN2CCCC[C@@H]2CO1\n",
            " -18.56   -26.76   32.73    0.99     C[C@@H]1C[C@H](C)CN(C(=O)CN2CCN(C(=O)COc3ccccc3F)C2)C1\n",
            " -23.29   -29.20   30.80    1.00     CCN(CCC[NH3+])C(=O)C[C@H](O)c1ccc(C(C)(C)C)cc1\n",
            " -18.50   -26.45   33.08    0.99     COC(=O)[C@H](N)[C@H](F)C(=O)N1CCCc2ccccc21\n",
            " -21.36   -32.94   25.20    0.97     CCOC(=O)[C@H]1C[C@H](O)C[C@@H]1N1C[C@H](C(N)=O)CC1(C)C\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 46   Fraction valid SMILES: 87.5  Time elapsed: 0.32h Time left: 20.26h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -20.01   -23.57   35.63    0.99     COC(=O)NCCC(=O)N1CCC[C@H](C(=O)N2C[C@H](C)O[C@H](c3ccccc3)C2)C1\n",
            " -25.36   -29.48   30.29    1.00     Cc1cc(NC(=O)C(=O)N[C@@H](CNC(=O)Cc2ccc(F)cc2)C2CCCC2)ccc1C\n",
            " -27.39   -29.25   28.51    0.96     N[C@H](c1cc(C(F)(F)F)cc([N+](=O)[O-])c1)C(=O)OCc1nccs1\n",
            " -14.88   -17.10   42.00    0.98     CC[C@H](C)[C@H](C[NH3+])[C@H](C)c1ccccn1\n",
            " -30.13   -31.73  -31.73    0.00     C[C@H](COC[C@H](O)CN1CC(=O)N2CCC[C@]2(C)CCC(=O)N1Cc1ccc(F)cc1\n",
            " -14.96   -19.84   39.13    0.98     C[C@H](OC(=O)C[C@H](O)c1ccc(Cl)cc1)C(=O)NN\n",
            " -14.53   -20.84   37.60    0.97     C[C@H]([NH2+][C@H](CO)C1CC1)c1ccc(-c2ccc(F)cc2)cc1\n",
            " -25.70   -27.95   31.55    0.99     CNC(=O)[C@H](C)c1ccccc1OCC(=O)N1CCC[C@H]1c1ccc(F)cc1\n",
            " -16.05   -17.91   40.94    0.98     NC(=O)[C@H](Cc1ccccc1)NC(=O)c1cccc(I)c1\n",
            " -19.85   -20.69   37.12    0.96     CN1C(=O)C[C@@H](C(=O)N[C@H]2CCCN(CC(F)(F)F)C2)C1=O\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 47   Fraction valid SMILES: 93.8  Time elapsed: 0.38h Time left: 23.61h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -38.24   -43.37   15.87    0.99     C[C@H](C(=O)NN1C[C@H](CCO)[C@H](C(=O)NC(C)C)C1)N1CCc2ccccc2C1\n",
            " -20.94   -28.38  -28.38    0.00     CC[C@H](C(=O)N(C)[C@@H](C)C(=O)N1CC[C@@H]([NH+]2CCCC2)C1\n",
            " -17.48   -21.47   37.01    0.97     CN1C(=O)[C@@H](Cc2ccccc2)O[C@]1(C)O\n",
            " -15.07   -21.33   38.40    1.00     CCOC[C@H]1CCCN1[C@@H](C[NH3+])c1cc(F)ccc1F\n",
            " -18.34   -18.95   37.67    0.94     COc1ccc(C(=O)[O-])cc1OCc1nc(-c2ccco2)no1\n",
            " -19.26   -23.42   36.12    0.99     COC(=O)C[C@H](NCC(F)(F)F)c1nc(C2CC2)cs1\n",
            " -18.16   -20.79   39.21    1.00     CCOC[C@H]1CCN(C(=O)c2ccc(CNC(=O)C(C)C)cc2)C1\n",
            " -17.98   -19.58   39.99    0.99     CC(C)C1([C@H]([NH3+])Cc2c(F)cccc2F)CC1\n",
            " -20.04   -30.38   29.21    0.99     CCOC(=O)[C@H](CC(=O)Nc1ccc(Cl)c(F)c1F)N1CCOCC1\n",
            " -23.53   -26.87   26.31    0.89     CO[C@H]1[C@@H]2CC[C@H](O2)[C@@H]1C(=O)NC[C@H](c1ccc(F)cc1)N1CCOCC1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 48   Fraction valid SMILES: 95.3  Time elapsed: 0.39h Time left: 23.36h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -14.92   -15.58   41.79    0.96     O[C@H]1CCC[C@@H]1CCOC1CCOCC1\n",
            " -13.23   -17.43   41.82    0.99     C[C@H](Oc1ccc(C#N)cc1)C(=O)NC[C@H](O)c1ccc(Cl)cc1\n",
            " -23.82   -25.17   34.83    1.00     C[C@H]1C[C@H](CNC(=O)CCC(=O)c2ccc(F)cc2)CC[C@@H]1C\n",
            " -20.72   -25.32   32.34    0.96     C[C@@H](Sc1nnc(-c2cccnc2)n1-c1ccc(F)cc1)C(=O)NNC(=O)c1ccc(F)cc1\n",
            " -22.12   -25.26   34.34    0.99     CC[C@H](NC(=O)NNC(=O)Nc1ccc(C)c(Cl)c1)c1ccc(C(C)C)cc1\n",
            " -27.48   -31.06  -31.06    0.00     Cc1cccc(-n2ncc(C(=O)N3CCN(C(=O)c4cccc5ccccc5c4)CC3)c2C)c1\n",
            " -18.66   -19.62   38.20    0.96     C[C@H](NC(=O)NCc1ccc(Cn2cccn2)cc1)c1cccnc1\n",
            " -17.95   -23.03   33.91    0.95     N#C[C@H]1CNCCN1C(=O)NC1(C(N)=O)CCCC1\n",
            " -19.27   -24.77   34.79    0.99     CN(CCCS(C)(=O)=O)C(=O)[C@H](C)NC(=O)c1ccc(F)cc1F\n",
            " -21.68   -32.72   25.70    0.97     COC[C@H](C)CC(=O)N([C@H]1CCS(=O)(=O)C1)C(=O)C1C[C@H](C)O[C@H](C)C1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 49   Fraction valid SMILES: 92.2  Time elapsed: 0.39h Time left: 23.11h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -17.67   -21.69   36.66    0.97     O=C(Cn1cc(C(=O)C2CC2)[nH]c1=O)NC1CC1\n",
            " -17.63   -20.05   37.84    0.96     O=C(CN1C(=O)CC2(CCCC2)C1=O)N1CCC[C@H](CO)C1\n",
            " -18.30   -21.16   38.09    0.99     C[C@@H](c1cccc(F)c1)[S@@](=O)Cc1noc(C(C)C)n1\n",
            " -21.54   -25.89   34.11    1.00     CN(C)C(=O)NC1(CNC(=O)[C@H](C)Cc2ccc(F)cc2)CCCC1\n",
            " -20.23   -21.11   38.89    1.00     CCN(C)C(=O)C(=O)Nc1c(C(C)C)cccc1C(C)C\n",
            " -18.39   -20.81   38.62    0.99     C[C@H](O)CCNC(=O)[C@H](O)c1ccccc1F\n",
            " -25.43   -24.82   34.74    0.99     C#CCOc1ccc(CN(C(=O)c2cc(C(C)C)n[nH]2)C2CC2)cc1\n",
            " -24.01   -26.24   33.40    0.99     CC(C)COC1CCN(C(=O)[C@@H](Cc2ccccc2)NC(=O)c2ccccc2Br)CC1\n",
            " -21.15   -35.87  -35.87    0.00     O=C(NCC(=O)N1CCC[C@@H](C(=O)N2CCN(CC(=O)N3CCCCCCC2)CC1)c1ccccc1\n",
            " -16.50   -18.73   40.79    0.99     C[C@H](NC(=O)c1ccc(Cl)c(S(C)(=O)=O)c1)C(=O)N1CCCC1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 50   Fraction valid SMILES: 90.6  Time elapsed: 0.47h Time left: 27.35h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -23.64   -23.37   35.09    0.97     CN(C)C(=O)CCCC/C=C/CO\n",
            " -22.24   -22.53   36.10    0.98     COc1ccc(CN(CC(C)C)c2nc3ccccc3s2)c(OC)c1\n",
            " -16.93   -16.96   41.16    0.97     CC1(C[NH2+][C@H]2CCCc3cccnc32)CC1\n",
            " -22.29   -22.56   37.23    1.00     CC(C)(C)NC(=O)C[NH+]1CCC[C@H](CCOc2ccccc2F)C1\n",
            " -22.89   -25.08   34.03    0.99     COc1cc(CNC(=O)C2CCN(C(=O)c3ccncc3F)CC2)ccc1O\n",
            " -18.24   -19.16   40.56    1.00     CC(C)OCC(=O)N1CCO[C@H](c2ccc(F)cc2)C1\n",
            " -22.65   -24.92   33.87    0.98     COC(C)(C)[C@H]1CCCC[C@H]1NC(=O)[C@@H]1C[C@@H]1C\n",
            " -20.47   -20.83   38.03    0.98     COc1ccc(O[C@H]2CCC[C@H](O)C2)c(CO)c1\n",
            " -43.47   -47.45    9.75    0.95     Oc1cccc([C@H]2[NH+]=C3CC[NH2+]CC3)c2[C@H](O)[C@@H]1NC(=O)[C@H]1COc2ccccc21\n",
            " -21.97   -26.28   32.65    0.98     FC(F)(F)O[C@@H]1C[C@H](c2ccccc2)CC1=O\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 51   Fraction valid SMILES: 90.6  Time elapsed: 0.50h Time left: 28.11h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -23.12   -22.17   37.58    1.00     CS[C@H]1CC[C@H](NC(=O)c2c(F)ccc(NC(=O)NC(C)C)c2)C1\n",
            " -29.20   -31.83   27.92    1.00     COCC[C@@H]1CCN(C(=O)[C@H](C)NC(=O)CC(=O)Nc2ccc(F)cc2)C1\n",
            " -17.31   -17.61   38.56    0.94     C[C@@H](C[NH2+]C1CC1)[NH+](C)C1CC1\n",
            " -17.84   -17.99   41.68    0.99     CO[C@H]1CCCC[C@@H]1OC(=O)Cc1ccc(OC)c(OC)c1\n",
            " -15.33   -20.20   37.59    0.96     O[C@H](C[NH2+][C@H]1CC(C)(C)OC[C@@H]1C)C1CC1\n",
            " -28.56   -35.45   22.97    0.97     CCOC(=O)[C@H]1CO[C@H](c2cc(CO)ccc2F)NN1\n",
            " -21.04   -20.03   39.79    1.00     Cc1cccc(CNS(=O)(=O)CC(=O)NC(C)(C)C)c1\n",
            " -20.31   -20.33   38.52    0.98     C[C@H](CCCO)NC(=O)NNC(=O)c1c[nH]nc1-c1ccc(F)cc1\n",
            " -33.46   -39.43  -39.43    0.00     Cc1sc(C#N)c(C2CC2)n1C[C@H](C)OCC(=O)N(C)C\n",
            " -21.36   -19.25   38.50    0.96     CCCCCO[C@H]1CCN(CCS(N)(=O)=O)C1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 52   Fraction valid SMILES: 93.8  Time elapsed: 0.53h Time left: 29.25h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -31.24   -36.06   22.77    0.98     O=C(C[NH2+]c1ccc(O)cc1O)C1[C@H]2CCCC[C@H]12\n",
            " -23.01   -25.19   34.31    0.99     C[C@H]([NH3+])[C@H](C)OC(=O)c1ccc(Cl)c(OC(F)F)c1\n",
            " -24.34   -33.49   25.05    0.98     O=C(/C=C/c1cccc(F)c1)C1[C@H](C(=O)[O-])CCN1C(=O)c1ccccn1\n",
            " -24.78   -24.69   33.88    0.98     C[C@H]1C[NH+](CCCCNC(=O)[C@H]2C[C@@H]2c2ccccc2)C[C@H]1CO\n",
            " -21.98   -25.64   33.22    0.98     Cc1nnc(NC(=O)C[C@H](NC(=O)Nc2ccc(F)cc2F)C2CC2)s1\n",
            " -20.54   -20.57   37.37    0.97     COc1ccnc(NC(=O)c2ccc(-c3cccc(C(F)(F)F)c3)s2)c1\n",
            " -25.03   -27.29   32.33    0.99     Cc1cc(NC(=O)N2CCC[C@H]2c2cccc(NC(=O)C(C)(C)C)c2)c(F)cc1F\n",
            " -15.17   -19.80   40.20    1.00     CCOC1CCN(C(=O)NCC(C)(C)c2ccccc2F)CC1\n",
            " -24.83   -27.89   31.86    1.00     CCCC(CC)[C@]1(CC)CCCN1C(=O)C1=Cc2ccccc2OC1\n",
            " -26.29   -33.87   25.87    1.00     CN(C[C@H](C)CSc1ccc(F)cc1F)C1C[C@@H](C)C[C@H](C)C1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 53   Fraction valid SMILES: 95.3  Time elapsed: 0.53h Time left: 28.92h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -26.34   -27.47   31.44    0.98     CN(C(=O)[C@]1([O-])CCCO1)C1CCC(C(C)(C)C)CC1\n",
            " -17.65   -19.42   40.01    0.99     CNC(=O)CN1CCN(C(=O)CNC(=O)Cc2ccc(F)cc2)CC1\n",
            " -16.39   -22.72   37.28    1.00     CN(C[C@H](O)COc1ccc(F)cc1F)CC(C)(C)C[NH3+]\n",
            " -20.46   -30.11   28.54    0.98     COC(=O)N1[C@H](C(=O)OC)C[C@@H]1c1ccc(F)cn1\n",
            " -17.39   -18.13   41.47    0.99     CC(C)[NH2+][C@]1(CO)CCC[C@H](Oc2cccc(F)c2)C1\n",
            " -25.52   -27.98   30.05    0.97     COC(=O)[C@H](C)Oc1ccc(-c2ccc(NC(=O)c3ccco3)cc2)nn1\n",
            " -20.12   -23.32   35.14    0.97     COCC[C@H](NC(=O)N1CCC[C@H](C(=O)N(C)C)C1)C1CCC1\n",
            " -16.52   -15.03   43.26    0.97     COc1ccccc1[C@H]1Nc2ccccc2C(=O)N1C(C)C\n",
            " -17.78   -20.57   39.37    1.00     C[C@H](Nc1ccccc1F)C(=O)NC(C)(C)C\n",
            " -17.10   -19.76   39.60    0.99     O[C@H](CNC[C@H]1CCCCO1)Cc1cccc(F)c1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 54   Fraction valid SMILES: 95.3  Time elapsed: 0.59h Time left: 31.38h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -25.29   -30.87   29.00    1.00     CC[C@@H](NC(=O)N[C@H](C)Cc1ccccc1F)C(=O)N1C[C@H](C)C[C@H]1C\n",
            " -16.17   -19.42   38.83    0.97     CC(C)(C)OC(=O)C1CCC([NH2+]C[C@@H]2CCC[NH2+]2)CC1\n",
            " -25.76   -30.99   27.65    0.98     Cc1nc(CC(C)(C)[C@@H](C)[NH3+])ncc1-c1ccccn1\n",
            " -23.86   -23.09   34.69    0.96     O=C(Nc1ncn[nH]1)NC1(CC(=O)NC2CC2)CCC1\n",
            " -21.76   -27.18   31.18    0.97     O=C(C[C@H](c1ccccc1)c1ccccn1)N(C1CCCC1)C1CC1\n",
            " -20.82   -25.97   33.39    0.99     COc1ccc(NC(=O)[C@H](OC(=O)c2cc(F)ccc2F)C2CCCC2)cc1\n",
            " -16.71   -18.51   41.10    0.99     CCC[NH2+][C@@H](Cc1ccccc1F)[C@H]1CN(CC)CCO1\n",
            " -23.33   -28.55   25.67    0.90     COC(=O)[C@H](C)OC(=O)[C@H]1[C@H]2CC[C@@H](O2)[C@@H]1c1ccc(C)cc1\n",
            " -23.55   -26.23   32.26    0.97     OCCO/C=C(\\C#N)c1ncc(-c2ccccc2)o1\n",
            " -22.63   -22.53   36.74    0.99     C[C@H](CSCC(=O)Nc1nc2ccc(F)cc2s1)OC\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 55   Fraction valid SMILES: 93.8  Time elapsed: 0.59h Time left: 31.02h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -26.95   -39.97  -39.97    0.00     O=C(C[C@@H](NC(N)=O)c1ccc(F)cc1F)N(Cc1ccccc1\n",
            " -23.20   -25.36  -25.36    0.00     O=C(NCCCn1nc2ccccc2n1-c1ccccc1)N[C@H](c1ccccc1)C1CC1\n",
            " -17.02   -18.92   40.93    1.00     CC(C)[C@@](C)(O)CNC(=O)C[C@H](O)c1ccc(F)cc1\n",
            " -16.42   -19.39   39.41    0.98     Cn1ncnc1CCNC(=O)CCNC(=O)C1CC1\n",
            " -17.23   -17.36   41.66    0.98     CCOC(=O)C1CCN(C(=O)c2ncccc2-c2ccccc2)CC1\n",
            " -23.02   -22.02   35.50    0.96     Cc1ccc(O[C@H](C)C(=O)Nc2nc(-c3ccccn3)n[nH]2)cc1\n",
            " -20.48   -25.72   33.29    0.98     O=C(CCC(=O)N1C[C@@H](O)C[C@@H]1c1ccco1)NCc1ccccc1F\n",
            " -21.63   -25.42   34.37    1.00     COC[C@@H](C)OC(=O)[C@H](C#N)c1nc(C(C)(C)C)cs1\n",
            " -22.98   -26.66   28.99    0.93     CC(C)[C@H](O)[C@H](C)NC(=O)/C=N/O\n",
            " -16.27   -19.07   39.43    0.98     O=C(CN1C(=O)COc2ccccc21)N/N=C\\c1ccc(Cl)c(Cl)c1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 56   Fraction valid SMILES: 95.3  Time elapsed: 0.59h Time left: 30.68h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -14.70   -18.05   39.00    0.95     CC[C@H](CO)N1C[C@H]([NH3+])C[C@H](C)C1\n",
            " -14.38   -15.50   42.34    0.96     CCOC(=O)[C@H](CC(C)C)C(=O)OC\n",
            " -34.14   -36.72   22.00    0.98     O=C(c1cnc([C@@H]2CCCO2)s1)N1CCO[C@H](C(=O)N(C/Cc2ccccc2F)C2CC2)C1\n",
            " -17.11   -17.58   41.65    0.99     C[C@H]1C[C@H]1C(=O)N1CCN(C(=O)CNC(=O)c2ccccc2)CC1\n",
            " -16.29   -17.47   40.57    0.97     CC[NH2+][C@@H](CC(C)(C)C)C1CCC1\n",
            " -15.26   -14.89   39.99    0.91     C[C@H]([NH3+])C(=O)NCCC(=O)[O-]\n",
            " -19.32   -24.74   35.19    1.00     CO[C@H](CNC(=O)NC1CCCC1)c1ccc(F)c(C)c1\n",
            " -21.35   -23.65   36.00    0.99     C[C@H](OC(=O)C[C@H]1C[C@@H]1C)C(=O)N1CCc2ccccc21\n",
            " -16.04   -18.17   41.83    1.00     CCOCCCNC(=O)[C@@H](C)Oc1cccc(C#N)c1\n",
            " -33.53   -46.87  -46.87    0.00     COc1ccccc1[C@H]1OCC2=C(N)CCC[C@]3(C(=O)OC)C1)CO2\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 57   Fraction valid SMILES: 92.2  Time elapsed: 0.60h Time left: 30.35h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -32.60   -36.32  -36.32    0.00     CCO[C@H](C=C)[C@H](O)c1cc[nH+]c(N(C)CC\n",
            " -24.99   -31.53   27.57    0.98     CC[C@H]1CN(CCOC)[C@H]([NH3+])[C@H](c2ccccc2C)C1\n",
            " -19.13   -21.33   37.01    0.97     Cc1ccc(COc2ccc(C(=O)Nc3ccc(CC#N)cc3)cc2)o1\n",
            " -16.77   -21.11   36.71    0.96     COC(=O)[C@H](NC(C)=O)[C@H]1CCC[NH+](C2CCCC2)C1\n",
            " -21.42   -29.91   28.52    0.97     CNC(=O)COC(=O)c1ccccc1NC(=O)C1=C[C@H](C)OC1=O\n",
            " -20.19   -20.85   37.87    0.98     CCn1c(CNC(=O)Nc2ccccc2COC)nc2ccccc21\n",
            " -18.73   -20.77   38.72    0.99     Cc1ccc(OCC(=O)NCc2ccc(OC(C)C)cc2)nc1\n",
            " -18.16   -19.51   39.79    0.99     COc1cccc(CNC(=O)[C@H](C)Nc2ccc(OC)cc2)c1\n",
            " -25.92   -32.74  -32.74    0.00     C[C@@H]([NH2+]C[C@H](C)C1(c2ccccc2)CCOCC1(C)C1CC1\n",
            " -19.85   -26.62   33.18    1.00     C[C@H](CNC(=O)NCC1CCN(c2ccc(F)cc2F)CC1)C[C@@H](C)O\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 58   Fraction valid SMILES: 96.9  Time elapsed: 0.60h Time left: 30.02h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -22.21   -23.82   35.37    0.99     COc1ccc(C(=O)NC(=S)NC(=O)c2ccccc2C(F)(F)F)c(OC)c1\n",
            " -18.80   -18.94   40.18    0.99     CC[C@H]1CCC[C@@H](OC(=O)C2(c3ccccc3)CC2)C1\n",
            " -18.81   -25.03   34.70    1.00     C/C(CCl)=C\\CCc1ccccn1\n",
            " -27.09   -20.78  -20.78    0.00     Cc1cccc2[nH]cc(C(=O)N3CCC4(c4cc[nH+]cc4)CC3)c12\n",
            " -16.21   -18.76   39.35    0.97     CC(C)(CNC(=O)N1CCOC[C@H]1C1CC1)C(=O)[O-]\n",
            " -15.87   -17.80   42.17    1.00     CCNC(=O)CCNC(=O)[C@H](C)Oc1ccccc1F\n",
            " -20.41   -20.58   39.30    1.00     Cc1cc(OCC(=O)Nc2cccc(C(=O)NCC(F)(F)F)c2)ccc1C(C)C\n",
            " -15.28   -18.84   40.52    0.99     C[C@H](OC(=O)c1ccc(F)c(S(C)(=O)=O)c1)C(=O)N1CCCC1\n",
            " -15.34   -20.44   37.74    0.97     OC[C@H]([NH2+][C@H]1CC[NH2+]C1)c1ccc(F)cn1\n",
            " -15.64   -18.12   40.13    0.97     CNC(=O)COC(=O)CNC(=O)C1CCCCC1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 59   Fraction valid SMILES: 89.1  Time elapsed: 0.61h Time left: 29.69h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -25.63   -26.04   32.26    0.97     Cc1nsnc1C[NH+]1CCC[C@@H](CC(=O)N2CCc3ccccc32)C1\n",
            " -15.00   -20.47   38.21    0.98     CO[C@H](CNC(=O)NCc1ccc(C(=O)[O-])o1)c1ccccc1\n",
            " -18.02   -18.03   39.63    0.96     C[NH2+][C@H]1COC[C@H]1C(=O)NC1CCCCCCC1\n",
            " -17.35   -20.43   38.09    0.98     O=C(/C=C/c1ccccc1F)N[C@H]1CCc2ccc(F)cc21\n",
            " -13.85   -14.25   43.63    0.96     C[C@H]([NH3+])c1ccc(OCc2ccccn2)cc1\n",
            " -18.72   -24.09   34.88    0.98     Cc1ccc(OC[C@H](O)C[NH2+][C@@H]2CCCc3ccc(F)cc32)cc1\n",
            " -42.85   -47.55  -47.55    0.00     Cc1ccc(CC(=O)N[C@H](C(=O)Nc2ccc(N3CCOCC3)cc2Br)CC[C@H]2C(C)=O)cc1\n",
            " -15.38   -17.87   41.25    0.99     CC[C@@H](C(=O)N1CCC(C(=O)Nc2ccccc2)CC1)c1ccccc1\n",
            " -14.04   -15.40   43.49    0.98     COC(C)(C)CNC(=O)C1C[C@@H](C)O[C@H](C)C1\n",
            " -23.92   -29.10  -29.10    0.00     CC(C)(C#N)CC1(O)CCC2)CCC1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 60   Fraction valid SMILES: 90.6  Time elapsed: 0.61h Time left: 29.38h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -23.99   -25.31   34.67    1.00     C=CCCCC[C@H](C)OC(=O)[C@H](O)c1ccccc1\n",
            " -20.64   -28.64   30.59    0.99     O=C(NCCCc1ccccn1)[C@H](Oc1ccccc1F)C1CC1\n",
            " -17.64   -17.88   41.22    0.99     NC(=O)[C@@H]1COCCN1C(=O)C[C@@H](O)c1ccc(Cl)cc1\n",
            " -15.93   -32.41  -32.41    0.00     C/C(CCc1ccccc1)=C(C)=N\\N\n",
            " -23.31   -23.61   34.24    0.96     CN1CCN(C(=O)[C@H]2COc3ccccc3O2)C[C@H](C)[NH2+]1\n",
            " -20.27   -21.85   36.76    0.98     CCn1nccc1NC(=O)N[C@H](COC)c1ccco1\n",
            " -21.63   -25.96   33.69    0.99     CCC[C@@H](NC(=O)[C@@H](C)O/N=C(/N)C(F)(F)F)c1ccncc1\n",
            " -26.38   -25.06   34.94    1.00     CCC(C)(C)OC[C@@H](O)Cn1cc(C(F)(F)F)cc1C\n",
            " -21.10   -24.66   33.87    0.98     CCO[C@H](C)C(=O)N[C@H]1CC(C)(C)NC(=O)C1(C)C\n",
            " -16.13   -17.53   42.03    0.99     C[C@H]1CN(C(=O)c2cccc(OCC(F)(F)F)c2)CCO1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 61   Fraction valid SMILES: 93.8  Time elapsed: 0.61h Time left: 29.07h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -13.71   -15.45   44.55    1.00     CC[C@H](C)NC(=O)CCOc1ccc(F)cc1\n",
            " -20.08   -22.44   35.22    0.96     CN(C)c1ncccc1C(=O)NNc1ncnc(Nc2ccccc2F)c1N\n",
            " -18.82   -20.06   39.32    0.99     CC[C@H](CSC)NC(=O)C1CCC(C)(C)C1\n",
            " -13.30   -21.54   36.99    0.98     C[C@H](CCO)C[NH2+]C1(C)CCCOCC1(C)C\n",
            " -20.23   -24.43   35.57    1.00     N#C[C@@H](C(=O)CCOCCc1ccccc1)C1CCCCC1\n",
            " -21.62   -28.66   28.90    0.96     COC[C@H](C)Cc1ncc(-c2cccc(F)c2)c(-c2ccccc2)n1\n",
            " -16.38   -17.35   39.30    0.94     O=C(/C=C/c1ccccc1)Nc1ccc(Oc2cccnc2)cc1\n",
            " -22.07   -23.28   35.67    0.98     Cc1noc(CC(=O)NNC(=O)CCc2cccc(F)c2)n1\n",
            " -29.24   -34.06  -34.06    0.00     CCOc1ccc(CCC(=O)N([C@@H]2COc3ccccc3C2OC)cc1\n",
            " -20.14   -25.73   33.32    0.98     COC[C@H](C)NC(=O)[C@@H](c1ccccc1F)N1CC(=O)Nc2ccccc21\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 62   Fraction valid SMILES: 95.3  Time elapsed: 0.62h Time left: 28.78h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -15.64   -17.89   39.88    0.96     COC(=O)[C@H](NC(=O)C1CCCC1)C(=O)OC\n",
            " -27.01   -29.79   29.12    0.98     CCn1ccnc1[C@@H](NC(=O)Nc1cccc(NC(=O)C(C)C)c1)Cc1ccccc1\n",
            " -17.82   -19.62   37.78    0.96     Cn1cnn(C2CCN(c3ncccc3F)CC2)c1=O\n",
            " -26.60   -32.76  -32.76    0.00     CC(C)C1(CNC(=O)C[C@H](O)c2ccccc2)CC1)COc1cccc(F)c1\n",
            " -17.43   -17.72   41.45    0.99     COc1ccc(CNC(=O)[C@H]2C[C@@H]2c2cccc(F)c2)cc1OC\n",
            " -30.64   -27.48   30.23    0.96     COC(=O)C[C@H]1COC2(CC[NH+](Cc3ccccc3-n3cccn3)CC2)N1c1ccccc1\n",
            " -12.36   -22.65   37.05    1.00     COC[C@H](O)[C@H](C)c1ncccc1F\n",
            " -17.01   -18.28   39.99    0.97     NC(=O)[C@H]1CN(C(=O)NCc2ccccn2)CCO1\n",
            " -16.83   -19.66   40.34    1.00     Cc1cccc(OCCNC(=O)[C@H](C)CC(C)(C)C)c1\n",
            " -20.28   -23.21   36.79    1.00     CNC(=O)[C@@H](C)CN(C)C(=O)CC1(Cc2ccc(F)cc2)CCCC1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 63   Fraction valid SMILES: 98.4  Time elapsed: 0.62h Time left: 28.50h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -14.73   -16.26   41.67    0.97     C[C@@H]1CCCC[C@H]1NC(=O)Cn1cnnn1\n",
            " -15.13   -17.04   41.36    0.97     COc1ncccc1C(=O)NC[C@H](c1ccco1)[NH+]1CCCC1\n",
            " -19.80   -24.02   35.73    1.00     Cc1cc(C(=O)NCC(=O)NC2CCCC2)cc(C(F)(F)F)c1F\n",
            " -31.29   -34.85   22.89    0.96     Cc1nn(Sc2ccc(C(=O)NCCc3ccccc3F)cn2)c(=O)c2ccccc21\n",
            " -25.00   -28.13   31.26    0.99     CCCC(CC)C(=O)N1CC[S@@](=C([O-])[C@H]2CC(=O)N(c3ccccc3)C2=O)CC1\n",
            " -17.51   -21.32   37.55    0.98     O=C(Cc1ccccc1F)N[C@H]1CCCN(c2ccccc2Br)C1=O\n",
            " -13.92   -13.87   43.90    0.96     C[NH2+][C@H](CC1CC1)[C@]1(C)CCCO1\n",
            " -15.36   -16.64   42.85    0.99     C[C@H](c1ccccc1)N(C)C(=O)Cc1cccc(OCC#N)c1\n",
            " -16.43   -19.46   39.81    0.99     CCOc1ccccc1OCC(=O)Nc1ccc(F)c(C#N)c1\n",
            " -17.49   -18.41   40.73    0.99     COc1ccc([C@@H](C)NC(=O)NCc2ccncc2)cc1F\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 64   Fraction valid SMILES: 96.9  Time elapsed: 0.66h Time left: 30.00h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -16.03   -18.79   41.04    1.00     CCC[NH2+][C@@H](COC(C)C)[C@H](C)c1ccncc1\n",
            " -23.56   -29.04   29.57    0.98     O[C@H](CNc1ccc(OCC(=O)N2CCOCC2)cn1)c1ccccc1\n",
            " -23.68   -32.96  -32.96    0.00     CCCCCNC(=O)NC[C@@H](Cc1ccccc1)N1C[C@H]1CCCO1\n",
            " -14.28   -16.86   42.97    1.00     CC(C)[C@@H](CO)NC(=O)COc1cccc(I)c1\n",
            " -17.69   -19.05   38.84    0.96     O=C(Nc1ccccc1)c1ccc(=O)n(CCOc2cccc(F)c2)c1\n",
            " -17.53   -20.99   38.36    0.99     O=C(CCNC(=O)[C@H]1CCOC1)Nc1ccccc1\n",
            " -16.78   -21.27   37.69    0.98     C[C@H](NC(=O)CN1C(=O)Cc2ccccc21)c1ccccc1F\n",
            " -15.11   -16.40   42.85    0.99     CCCOc1ccc(C(=O)NNC(=O)c2cccc(F)c2)cc1\n",
            " -24.03   -25.18   32.89    0.97     CCc1ncc(C(=O)N[C@@H](C)c2nc(-c3ccccc3F)no2)cn1\n",
            " -25.29   -29.13   30.34    0.99     COc1ccccc1N[C@@H](C(=O)N(CC(C)C)C)c1ccccc1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 65   Fraction valid SMILES: 93.8  Time elapsed: 0.67h Time left: 29.71h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -22.47   -27.88   30.03    0.97     N#C[C@H]1c2ccccc2CC[C@H]1N1C(=O)CCCN1c1ccccc1\n",
            " -28.61   -39.63  -39.63    0.00     C[C@]1(CC(=O)NNC(=O)NCC[C@@H]2CCCO2)CCC1)c1ccccc1\n",
            " -16.76   -19.19   40.81    1.00     C=CCNC(=O)CNC(=O)CCc1ccc(F)cc1\n",
            " -24.91   -29.17   29.62    0.98     C[C@@H](NC(=O)c1ccccc1F)C(=O)N1CC(=O)N(C)[C@H]1c1ccc(F)cc1\n",
            " -21.53   -26.08   33.61    0.99     CC(C)[C@H](NC(=O)CNC(=O)C1CCN(C(=O)OC(C)C)CC1)c1ccccc1\n",
            " -19.79   -24.12   35.12    0.99     C[C@@H](C(=O)Nc1cccc(C#N)c1)N1CCC[C@H](O)C1\n",
            " -19.79   -26.44   33.05    0.99     C[C@@H](c1ccc(F)c(F)c1)N(C)C(=O)C[S@@](=O)Cc1ncccc1F\n",
            " -14.26   -18.36   39.83    0.97     O=C(C[C@@H](c1ccccc1)N1CCOCC1)c1cccnc1\n",
            " -23.18   -26.35  -26.35    0.00     CCSCCC(=O)Nc1ccc(OCC(F)cc1F\n",
            " -20.58   -22.32   37.05    0.99     COC(=O)[C@H](C)Oc1cc(C)ccc1C(=O)NCc1ccccn1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 66   Fraction valid SMILES: 95.3  Time elapsed: 0.67h Time left: 29.42h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -18.15   -21.19   38.32    0.99     O=C(C[C@@H](O)c1ccccc1F)NNC(=O)C1CCCCC1\n",
            " -14.98   -15.48   41.28    0.95     CN(CCS(C)(=O)=O)C(=O)[C@](C)(N)C(F)(F)F\n",
            " -20.19   -19.70   39.41    0.99     Cc1nc(N(C)C)cc(C(=O)NC[C@](C)(O)c2ccsc2)n1\n",
            " -14.62   -15.50   43.89    0.99     COC[C@H](C)NC(=O)C(=O)Nc1c(F)cccc1F\n",
            " -17.29   -19.83   39.24    0.98     O=C(CS(=O)(=O)Cc1ccccc1)Nc1ccccc1N1CCCCCC1\n",
            " -23.05   -35.14   23.81    0.98     O=C(N/N=C/C1CCCC1)/C(=C/c1ccccc1)C(=O)Nc1cccc(C#N)c1\n",
            " -15.07   -19.58   39.16    0.98     C[C@H]([NH2+][C@@H](CO)C1CC1)c1ccccc1O\n",
            " -23.47   -25.14   34.66    1.00     Cc1cccc(CNC(=O)[C@@H](NC(=O)C2C(C)(C)C2(C)C)C(C)C)c1\n",
            " -18.05   -20.08   39.21    0.99     COC(=O)c1cccc(NC(=O)CN(C)C(C)=O)c1\n",
            " -16.24   -17.50   40.29    0.96     Cc1cccc(C)c1-n1nnnc1SCCOc1ccccc1F\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 67   Fraction valid SMILES: 95.3  Time elapsed: 0.68h Time left: 29.16h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -17.52   -20.30   39.13    0.99     C[C@H](NC(=O)c1ccccc1Cl)C(=O)NC[C@H](C)c1ccccc1\n",
            " -18.78   -19.86   39.26    0.99     CCOc1ccccc1OCCN1CC[C@H]([NH3+])C1\n",
            " -17.76   -22.00   37.28    0.99     CN1C[C@@H](C(=O)OCc2ccc(OC(F)F)cc2)CC1=O\n",
            " -18.74   -20.01   38.64    0.98     Cc1ccccc1OCC[NH+]1C[C@@H](C)O[C@H](C)C1\n",
            " -14.57   -20.36   36.68    0.95     O[C@H](COCc1ccccc1)CNc1ccccc1-n1cncn1\n",
            " -22.93   -24.39   33.57    0.97     NNCCCc1nc(-c2ccccc2Cl)cs1\n",
            " -16.88   -16.21   42.63    0.98     NC(=O)CCNc1ccc(Cl)c(C(=O)[O-])c1\n",
            " -18.00   -21.43   37.88    0.99     CC(C)c1ccccc1N1C[C@H](C(=O)N[C@@H]2CCCC[C@H]2C)CC1=O\n",
            " -14.71   -17.45   41.25    0.98     O=C(CCOC1CCOCC1)N[C@@H](c1ccccc1)c1ccccn1\n",
            " -17.03   -17.85   40.31    0.97     O=C(CN1C(=O)COc2ccccc21)N[C@@H]1CCN(c2ccccc2)C1=O\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 68   Fraction valid SMILES: 93.8  Time elapsed: 0.68h Time left: 28.88h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -11.52   -19.73   37.54    0.95     O[C@](Cc1ccccc1)Cc1ccccn1\n",
            " -13.98   -15.76   43.81    0.99     COCCNC(=O)[C@H]1CCCN(C(=O)Nc2ccccc2F)C1\n",
            " -17.85   -21.17   37.97    0.99     O=C(CC[NH2+]C1CC1)c1ccccc1C1CC1\n",
            " -19.27   -19.56   37.43    0.95     CCCNc1nccc(Oc2ccccc2[N+](=O)[O-])c1[N+](=O)[O-]\n",
            " -14.74   -13.34   43.86    0.95     CN(C)c1ccc2nccnc2c1\n",
            " -24.20   -28.32   31.00    0.99     Nc1ccccc1OCCCN1CCN(C(=O)NCc2ccccc2F)CC1\n",
            " -17.78   -22.01   37.54    0.99     C/C(C(=O)c1cccc(F)c1)=C1\\CCCCC1\n",
            " -19.33   -23.99   35.76    1.00     CNC(=O)COc1ccc(CNC(=O)C[C@H](C)c2ccc(F)cc2)cc1\n",
            " -19.60   -20.24   38.54    0.98     CCOc1nnc([C@H](C)NC(=O)Nc2ccccc2F)s1\n",
            " -17.61   -20.14   39.38    0.99     C[C@H](NC[C@H](O)c1ccc(F)c(F)c1)C1CC1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 69   Fraction valid SMILES: 98.4  Time elapsed: 0.68h Time left: 28.61h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -23.22   -25.06   34.23    0.99     CCc1csc([C@H](C)NC(=O)Nc2ccccc2C(F)F)n1\n",
            " -25.56   -36.10   21.44    0.96     NC1C(=O)N(CCO)C(=O)C12NC(=O)C[C@H](c1cccnc1)C2\n",
            " -19.34   -20.57   37.50    0.97     Cc1ccccc1-n1cc(C(=O)NCC2(c3cccc(F)c3)CCCC2)cn1\n",
            " -19.02   -19.36   40.26    0.99     Cc1ccc(NC(=O)[C@@H](C)N2CCOCC2)c(F)c1\n",
            " -17.82   -15.16   42.39    0.96     C[NH+]1[C@H]2CC[C@@H]1CN(C(=O)c1cnc3ccccc3c1)CC2\n",
            " -15.47   -17.63   41.15    0.98     O=C(NCc1cccc(F)c1)N1CCNCC1\n",
            " -21.66   -21.63   37.58    0.99     COCCn1cccc1S(=O)(=O)N1CCN(CC(C)C)CC1\n",
            " -19.63   -24.58   35.38    1.00     COC[C@H]([NH2+]CC1CC1)c1ccc(F)cc1OC\n",
            " -14.20   -16.32   41.74    0.97     O=C(Cc1ccccc1)NOCc1ccccc1\n",
            " -16.74   -19.52   39.48    0.98     Cc1ccc(C(=O)NNC(=O)[C@H](C)c2ccccc2F)s1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 70   Fraction valid SMILES: 95.3  Time elapsed: 0.69h Time left: 28.35h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -21.70   -23.55   35.80    0.99     CCCNC(=O)c1cccc(NCC(=O)N2CCCC[C@H]2c2ccccc2)c1\n",
            " -24.00   -27.94   31.47    0.99     Oc1ccccc1CN1CCO[C@H](CNC(=O)C(F)(F)F)C1\n",
            " -14.33   -18.31   39.46    0.96     [NH3+][C@H](c1ccccn1)[C@@H]1CCO[C@]2(CCOC2)C1\n",
            " -11.81   -17.42   41.84    0.99     COc1ccc(CNC(=O)[C@H](C)Oc2ccccc2F)cc1\n",
            " -27.81   -28.71   29.48    0.97     CSCC[C@@H](NC(=O)NC1CC[NH+](CC2CCCCC2)C(=O)C1)C(C)C\n",
            " -16.73   -20.92   36.96    0.96     NC(=O)c1ccccc1NC(=O)CN[C@H](c1ccccc1)c1ccccn1\n",
            " -16.38   -19.03   39.99    0.98     CNC(=O)c1ccc(NCc2ccc(C(F)(F)F)cc2)cc1\n",
            " -19.15   -19.40   39.39    0.98     N#Cc1cccnc1NCc1ccccc1C(=O)N1CCCCC1\n",
            " -18.76   -17.42   42.46    1.00     CSCC[C@@H](C)NC(=O)N[C@H]1CCO[C@@H]1c1ccc(Cl)c(F)c1\n",
            " -24.10   -25.82   33.23    0.98     Cc1ccc(OCc2ccccc2C(=O)N2CCC[C@H](C=O)C2)cn1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 71   Fraction valid SMILES: 98.4  Time elapsed: 0.69h Time left: 28.10h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -26.54   -30.11   29.46    0.99     CCN[C@@H](Cc1ccccc1OC)C[S@@](=O)c1ccc(F)cc1\n",
            " -13.72   -19.17   39.87    0.98     Cc1ccc(OC[C@H](O)CNC(=O)NCc2ccccc2)cc1\n",
            " -13.00   -17.08   39.28    0.94     Cc1cccc(NC(=O)c2ccccc2-c2cccnc2)c1\n",
            " -13.50   -17.25   40.93    0.97     OCC#Cc1ccccc1OC[C@H]1COc2ccccc21\n",
            " -20.47   -26.05  -26.05    0.00     CNC(=O)C[S@@](N)=[NH2+]Cc1ccccc1\n",
            " -20.26   -18.31   40.35    0.98     CCC[C@H](C)N(C)C(=O)[C@H]1COCCO1\n",
            " -26.70   -24.83   32.47    0.95     C[C@H](C(=O)N1CCCC1)N1CCN(CNC(=O)N2CCCCC2)CC1\n",
            " -19.96   -25.25   34.08    0.99     C[C@H](NC(=O)CNC(=O)Cc1ccc(F)cc1F)[C@H](O)c1ccccc1\n",
            " -23.86   -29.07   30.40    0.99     C[C@@H](NC(=O)CNCCc1cccnc1)C(C)(C)c1ccccc1\n",
            " -18.34   -24.07   35.08    0.99     CC[C@H](NC(=O)c1cccc(CN2C(=O)CCC2=O)c1)c1ccccn1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 72   Fraction valid SMILES: 92.2  Time elapsed: 0.69h Time left: 27.85h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -17.70   -19.16   40.62    1.00     CC1(C)c2ccccc2C(=O)N1CCOCCO\n",
            " -22.80   -28.39   29.86    0.97     O=C([O-])[C@@H](c1ccc(F)cc1F)[NH+]1CC[C@H](Oc2ccccc2F)C1\n",
            " -23.54   -23.92   35.91    1.00     CCOC[C@H]1CCCN(C(=O)COc2ccc(C(=O)OC)c(F)c2)C1\n",
            " -15.17   -20.77   38.46    0.99     COCc1ccccc1N[C@H](C)CN1CCOCC1\n",
            " -23.69   -31.62   25.85    0.96     Cc1cccc(Nc2ccccc2C(=O)Nc2ccccc2S(=O)(=O)Cc2ccccn2)c1\n",
            " -13.29   -16.83   43.01    1.00     CCOC[C@H]1CCN(C(=O)NCCCc2ccccc2)C1\n",
            " -23.49   -23.95   35.43    0.99     C[C@H]1CC[C@@H]([C@H](C)NC(=O)NNc2ccccc2F)C1\n",
            " -19.76   -22.84   37.01    1.00     CN(CCCc1ccccc1)C(=O)CN1CCOC[C@@H]1C\n",
            " -24.61   -27.22   30.42    0.96     Clc1ncc([C@](O)(c2ccccc2)C(F)(F)F)s1\n",
            " -25.51   -33.84  -33.84    0.00     CN(C)C(=O)CN(C)Cc1ccccc1C(=O)N1CCCC1)C(c1ccccc1)c1ccccc1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 73   Fraction valid SMILES: 89.1  Time elapsed: 0.70h Time left: 27.60h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -24.24   -34.18  -34.18    0.00     COCc1nnc(N[C@@H](CO)c2ccc(F)cc2F)sc1C\n",
            " -26.12   -33.89  -33.89    0.00     C[C@H](CNC(=O)CN1C(=O)NC(=O)C[C@]12C(C)CCCCC1=O\n",
            " -18.58   -23.61   34.93    0.98     O=C(OCc1ccccc1)[C@@H](c1ccccc1)N1C(=O)[C@H]2CCCC[C@H]2C1=O\n",
            " -17.81   -16.88   42.24    0.99     COc1ncccc1C(=O)OC[C@H]1CCCCO1\n",
            " -26.86   -31.06   27.76    0.98     Cc1ncccc1C(=O)N1CCC([C@]2(C[NH2+]Cc3ccccc3)CCO2)CC1\n",
            " -16.40   -21.38   37.80    0.99     NNC(=O)CCNC(=O)[C@H]1C[C@@H]1c1ccccc1F\n",
            " -19.82   -23.85   35.32    0.99     COc1ccc(O[C@@H](C)CN[C@H](C)c2ccccc2C(C)C)cc1\n",
            " -30.58   -25.56  -25.56    0.00     Cc1cc2ocnc2C(=O)N[C@H](C)c2ccc(F)c(F)c2)c1C\n",
            " -17.85   -21.07   38.53    0.99     Cc1ccc(CN(C)C(=O)NCCOc2ccccc2F)cc1\n",
            " -23.18   -24.48   34.42    0.98     CCN(CC)S(=O)(=O)c1ccccc1S(=O)(=O)N1CCO[C@H](c2ccccc2)C1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 74   Fraction valid SMILES: 95.3  Time elapsed: 0.70h Time left: 27.38h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -13.57   -17.69   41.41    0.98     CNC(=O)c1cccc(CNC(=O)N[C@H](CO)c2ccccc2F)c1\n",
            " -19.81   -27.19   31.77    0.98     Cc1ccc(NC(=O)[C@@H](C)OC(=O)c2cnccc2N)cc1\n",
            " -21.16   -24.36   33.97    0.97     O=C1NCCN(CCc2ccccc2F)C(=O)/C1=C\\c1ccc(OCc2ccccc2)cc1\n",
            " -28.72   -29.24   29.78    0.98     NNC(=O)CCCSCCN1CCN(C(=O)Nc2ccccc2)CC1\n",
            " -19.65   -22.70   35.99    0.98     C[C@H](NC(=O)N(Cc1ccc(C(F)(F)F)cc1)[C@H]1CCc2ccccc21)c1cccnc1\n",
            " -23.14   -30.72   28.33    0.98     O=C([C@H](NC(=O)CCc1ccccc1)c1ccccc1)CN1CC[NH2+]CC1\n",
            " -16.11   -16.53   40.40    0.95     O=C(NNC(=O)c1ccco1)N[C@H](c1ccccc1)c1ccccn1\n",
            " -19.88   -26.53   31.64    0.97     Cc1cccc(C)c1-c1noc(C2C[C@H](C)O[C@H](C)C2)n1\n",
            " -15.42   -22.20   36.13    0.97     O=C(N[C@H](c1ccccc1F)c1ccccn1)C1CCC1\n",
            " -15.91   -19.11   40.46    0.99     CCN1C(=O)C[C@@H](C(=O)OCC)[C@@H]1c1ccccc1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 75   Fraction valid SMILES: 95.3  Time elapsed: 0.71h Time left: 27.15h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -22.96   -27.29   32.10    0.99     CN[C@](C(=O)N[C@H](C)c1nccn1CC)C1CC1\n",
            " -20.34   -26.11   32.81    0.98     O=C1CN(C(=O)COc2ccccc2-c2ccccc2)C(=O)C1(C)C\n",
            " -18.06   -18.90   39.83    0.98     COCC[NH2+]Cc1coc(-c2ccccc2F)n1\n",
            " -20.97   -23.41   33.66    0.95     CN1C(=O)C[C@H](C(=O)N2C[C@H](C(=O)[O-])CCC[C@@H]2C)C1=O\n",
            " -11.88   -16.09   41.36    0.96     OC[C@H]1CN(Cc2ccccc2)CC[NH2+]1\n",
            " -17.07   -18.88   40.46    0.99     COCc1cccc(OC[C@H](O)CN2C[C@H](C)O[C@H](C)C2)c1\n",
            " -19.34   -22.21   37.49    1.00     CCCCCN(C(=O)[C@@H](C)Oc1ccccc1F)c1ccccc1\n",
            " -19.53   -23.94  -23.94    0.00     Cc1noc2nc(-c3ccccc3F)ccc2c1NCc1ccccc1\n",
            " -22.76   -32.37   26.50    0.98     O=C(NC[C@H](c1ccccc1)NC(=O)C1=CCCCO1)C(=O)Nc1ccccc1\n",
            " -14.77   -17.72   40.52    0.97     O=C(c1ccccc1F)N1CC[C@@H](c2ccc(F)cc2)C1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 76   Fraction valid SMILES: 89.1  Time elapsed: 0.71h Time left: 26.92h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -22.04   -34.96   22.68    0.96     NC(=O)[C@@H](NNC(=O)c1ccc(=O)c2ccccc2c1)c1ccccc1\n",
            " -19.18   -21.01   37.33    0.97     COCc1nc(NC(=O)c2cc(F)ccc2F)cs1\n",
            " -29.97   -36.45  -36.45    0.00     c1ccccc1[C@H]1C[C@@H]1c1ccccc1O)c1ccc(OCC[NH+](C2CC2)C2CC2)cc1\n",
            " -33.70   -38.15  -38.15    0.00     C/C(C[NH3+])=C([O-])C1=c2ccc(F)cc2S1(=O)=O\n",
            " -25.13   -28.35   31.49    1.00     CC[C@](C)(CCCl)Nc1ccncc1\n",
            " -22.61   -41.03  -41.03    0.00     CN1CCN(C(=O)[C@@H]2CCCN(CC(=O)NC3(C#N)Cc3ccccc3C2)CC1(C)C\n",
            " -15.42   -18.19   41.06    0.99     COc1cccc(NC(=O)C(=O)N[C@@H](c2ccccc2)C(C)C)c1\n",
            " -29.41   -35.21   24.01    0.99     CCN/C(NCc1ccc(F)cc1F)C(=O)NCc1cccnn1\n",
            " -13.78   -18.68   40.11    0.98     NC(=O)c1cccc(OCC(=O)Nc2ccccc2N2CCOCC2)c1\n",
            " -16.53   -17.10   41.43    0.98     NC(=O)[C@H](NCc1ccc(Cl)cc1)c1ccccc1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 77   Fraction valid SMILES: 95.3  Time elapsed: 0.71h Time left: 26.71h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -18.83   -21.52   38.48    1.00     COC(=O)[C@H](CC(C)C)[NH2+][C@H](C)c1ccc(F)cc1\n",
            " -23.62   -20.76   39.01    1.00     CC(C)CNC(=O)CCC(=O)Nc1ccc(C(N)=O)cc1F\n",
            " -28.70   -30.91  -30.91    0.00     Cc1ccc(C[NH+]([C@@H](C)C(=O)Nc2ncnc3c2CCCC3)cc1\n",
            " -21.76   -25.62   33.68    0.99     COC/C=C/c1ccc(OCC(=O)Nc2ccccc2C)cc1\n",
            " -15.63   -18.95  -18.95    0.00     COC[C@H](NC(=O)N[C@H](C)c1ccc(F)c(F)c1\n",
            " -17.94   -22.13   35.62    0.96     NC(=O)c1ccccc1NC(=O)COC(=O)c1n[nH]c(=O)c2ccccc12\n",
            " -31.38   -39.59   19.15    0.98     C/C(C(=O)NN=Cc1ccc(N2CCOCC2)cc1)C(=O)NNC(=O)c1ccccc1\n",
            " -17.21   -20.27   38.26    0.98     COCCN1CC(=O)N[C@H](c2ccccc2)C1=O\n",
            " -34.69   -42.48  -42.48    0.00     CCc1nccn1-c1ccccc1NC(=O)[C@H]1[C@@H]2C=C[C@@H]([C@@H]2CCl)C1)O2\n",
            " -19.40   -19.99   38.94    0.98     CCOC(=O)/C(C)=N/NC(=O)c1ccncc1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 78   Fraction valid SMILES: 93.8  Time elapsed: 0.72h Time left: 26.49h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -16.65   -22.32   36.85    0.99     O=C(NCCNC(=O)c1ccc(F)cc1F)c1ccccc1N1CCOCC1\n",
            " -20.94   -25.19   32.55    0.96     CCOc1ncc(Cn2ccccc2=O)cn1\n",
            " -29.97   -32.37   26.33    0.98     COCCOC(=O)c1cc(NC(=O)[C@@H]2C[C@H](O)CN2C)cs1\n",
            " -29.24   -27.71   30.94    0.98     CCSC(CO)(CO)NS(=O)(=O)c1ccc2c(c1)OCCO2\n",
            " -18.07   -20.85   37.05    0.96     O=C(CN1CCNC1=O)NNC(=O)c1cccc(F)c1\n",
            " -21.67   -27.24  -27.24    0.00     Cc1nnc(SCc2ccccc2F)n(-c2ccccc2F)c1N\n",
            " -14.49   -16.83   42.82    0.99     C[C@@H](NC(=O)N[C@@H]1CCN(CC(F)(F)F)C1)c1ccccc1\n",
            " -19.67   -23.07   36.67    1.00     CCC[NH2+]CC/C=C(/C(C)C)c1ccccn1\n",
            " -17.08   -23.64   36.03    0.99     COC[C@H](O)[C@@H](C)[C@@H](C)c1ccccc1OC\n",
            " -19.16   -20.86   38.36    0.99     C[C@@H](NC(=O)CN1CCCc2ccc(F)cc21)c1cccc(C#N)c1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 79   Fraction valid SMILES: 98.4  Time elapsed: 0.72h Time left: 26.29h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -16.58   -17.64   40.40    0.97     COc1cccc(CN2CCN(C(=O)Nc3ccccc3-c3ccccc3)CC2)c1\n",
            " -24.91   -26.07   31.40    0.96     FC(F)(F)c1cncc([C@H]2SCC(=O)Nc3ccccc32)n1\n",
            " -15.63   -21.83   36.74    0.98     C[C@H](NC(=O)CN(Cc1ccccc1)C(=O)c1ccccc1F)c1ccncc1\n",
            " -24.92   -26.78   31.95    0.98     COc1cc(C(=O)Nc2ccc(CC(=O)NC)cc2)ccc1OCc1ccncc1\n",
            " -21.44   -28.10   31.24    0.99     CCN(CC)c1ccc(CNC(=O)N2CCNC2)cc1\n",
            " -18.00   -21.29   37.99    0.99     COC[C@H](C)NC(=O)CN1C(=O)CCN(Cc2ccccc2)C1=O\n",
            " -19.55   -22.28   36.54    0.98     Cc1nn(C)cc1[C@H](C)[NH2+]C[C@@H](O)Cc1ccccc1\n",
            " -18.03   -20.75   35.98    0.95     [S-]c1nncn1CNCc1ccccc1\n",
            " -14.52   -15.35   44.26    0.99     CCN(CC)[C@@H](C[NH3+])c1ccc(OC)cc1\n",
            " -14.13   -15.88   43.09    0.98     C[C@H](NC(=O)N[C@@H]1CC(=O)N(C)C1)c1ccccc1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 80   Fraction valid SMILES: 98.4  Time elapsed: 0.77h Time left: 27.81h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -18.07   -24.44   34.46    0.98     CNC(=O)N[C@@H](C(=O)OCc1ccc(F)cc1)c1ccccn1\n",
            " -26.13   -29.35   30.18    0.99     COC[C@@H](C)n1cc(OCc2ccccc2F)c(C(C)=O)n1\n",
            " -17.35   -22.46   35.71    0.97     Cc1ccccc1NC(=O)[C@@H](C)Sc1nccn1Cc1ccccc1\n",
            " -23.93   -23.94   34.27    0.97     CN(CCS(C)(=O)=O)C(=O)[C@H]1CCCCC[C@H]1N\n",
            " -22.34   -24.92   33.87    0.98     N[C@](C(=O)N1CCO[C@H]2CCCC[C@H]21)c1ccccc1\n",
            " -24.18   -22.75   35.95    0.98     CN(C)S(=O)(=O)c1ccc(NC(=O)CNc2ccccc2Oc2ccc(F)cc2)cc1\n",
            " -16.11   -21.59   37.69    0.99     C[C@]1(O)CC[C@@H](OCc2ccccc2F)C1\n",
            " -21.84   -24.48   34.77    0.99     COc1ccc(NC(=O)NC[C@@H](c2ccccc2)N2CCOCC2)cc1N(C)C\n",
            " -16.04   -19.08   40.07    0.99     O=C(Cc1ccc(F)cc1F)NCCNc1ccc(F)cc1\n",
            " -14.98   -21.47   37.36    0.98     CNC(=O)[C@]1(Cc2cccc(-c3cccnc3)c2)CCCC1(C)C\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 81   Fraction valid SMILES: 96.9  Time elapsed: 0.78h Time left: 27.60h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -13.01   -15.14   43.58    0.98     O=C(NCc1ccccc1F)Nc1ccccc1N1CCCC1\n",
            " -16.97   -21.40   36.68    0.97     COc1ccc(NC(=O)[C@H](C)Nc2cccc(F)c2-c2ccccc2)cc1\n",
            " -14.58   -18.61   40.70    0.99     O[C@H]1CCC[C@@H](CNc2ccccc2C(F)(F)F)C1\n",
            " -18.46   -23.66   35.91    0.99     C/C(NCCO)Oc1ccc(F)cc1\n",
            " -18.67   -21.07   38.09    0.99     C[C@@H](NC(=O)N[C@@H]1CCCN(C(=O)c2ccccc2)C1)c1ccc(Cl)cc1\n",
            " -13.38   -21.52   36.83    0.97     O=C(NC[C@H](c1ccco1)[NH+]1CCN(Cc2ccccc2)CC1)c1ccc(F)c(F)c1\n",
            " -12.59   -14.42   43.77    0.97     C[C@H](NC(=O)c1ccccc1F)c1ccccc1\n",
            " -14.85   -16.34   43.43    1.00     COC(=O)C[C@H](C)NC(=O)c1cccc(I)c1\n",
            " -21.38   -26.27   32.68    0.98     CCOc1ccc(NC(=O)NC[C@@H](c2ccccc2)N2CCOCC2)cc1S(=O)(=O)c1ccc(F)cc1\n",
            " -17.63   -22.33   35.39    0.96     Cc1ccc(CNc2ccccc2NC(=O)Cc2ccccc2)s1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 82   Fraction valid SMILES: 89.1  Time elapsed: 0.78h Time left: 27.39h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -24.87   -31.40  -31.40    0.00     Cc1cc(-c2nc(-c3ccccc3)nc(NN)c2C)cc1C\n",
            " -17.44   -21.49   36.80    0.97     CNS(=O)(=O)N[C@H](CO)c1ccccc1F\n",
            " -21.78   -27.82   31.67    0.99     CC(C)[C@H](NC(=O)c1cccnc1OC(F)F)C(=O)N[C@@H](C)c1ccccc1\n",
            " -17.73   -23.14   33.26    0.94     O[C@H](c1cnccn1)Cc1ccccc1\n",
            " -23.20   -25.94   32.74    0.98     CCc1noc(CCNC(=O)N2CCN([C@H](CO)c3ccccn3)CC2)n1\n",
            " -15.46   -17.62   40.23    0.96     O=C(CSc1ccccc1)NCc1cccc(OCc2ccccc2)c1\n",
            " -29.72   -31.84   26.44    0.97     CONC(=O)COC(=O)c1ccc(Nc2cnccc2F)nc1\n",
            " -16.18   -18.45   40.75    0.99     COC1CCN(C(=O)NC[C@@H](c2ccc(C)o2)[NH+](C)C)CC1\n",
            " -14.77   -19.11   38.33    0.96     COCCNc1ncnc(N2CCNC(=O)C2)c1N\n",
            " -16.38   -17.76   39.92    0.96     O=C(C1CCCCCC1)N1CCN(CCO)CC1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 83   Fraction valid SMILES: 100.0  Time elapsed: 0.78h Time left: 27.18h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -19.19   -20.85   37.79    0.98     Cc1ccccc1/N=C(\\NCc1ccc(N(C)C)cc1)C1CC1\n",
            " -14.35   -17.51   41.62    0.99     C[C@@H](NC(=O)CN1CCN(c2ccccc2)CC1)C(=O)NCc1ccccc1\n",
            " -14.60   -19.25   39.89    0.99     CCNC(=O)N[C@@H](C)c1ccc(OCc2ccccc2)cc1\n",
            " -16.29   -17.52   42.48    1.00     CCCC(CC)(CC)CNC(=O)Nc1cccc(C#N)c1\n",
            " -18.47   -20.77   37.58    0.97     COc1cccc(C(=O)NC[C@H](c2ccccc2)N(C)Cc2ccccc2)c1\n",
            " -15.76   -18.47   39.71    0.97     N[C@@H](CC1=c2ccccc2=[NH+]C1)C(=O)[O-]\n",
            " -14.51   -18.40   40.54    0.98     C[C@](O)(CNC(=O)NC1CCN(C(=O)c2ccco2)CC1)c1ccccc1\n",
            " -21.74   -22.95   35.40    0.97     Cc1noc(CNC(=O)Nc2ccccc2N2CCN(CC(N)=O)CC2)n1\n",
            " -17.38   -25.23   33.45    0.98     COc1ccccc1N1CCN[C@H](C(=O)NCc2ccccc2F)C1\n",
            " -20.13   -24.80   33.81    0.98     CCS(=O)(=O)NCCNC(=O)CNC(=O)c1ccccn1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 84   Fraction valid SMILES: 95.3  Time elapsed: 0.79h Time left: 26.98h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -19.61   -22.11   36.53    0.98     Cc1cccc(NC(=O)Nc2cccc(C(=O)N[C@H]3CCS(=O)(=O)C3)c2)c1\n",
            " -19.55   -23.46   33.80    0.95     O[C@H]1C[C@@H](C(=O)Nc2ccccc2Cc2ccccc2)CN1c1ccccc1\n",
            " -16.01   -21.04   37.44    0.97     C[C@H](OCc1ccccc1)c1nnc(SCC(=O)Nc2ccccc2F)o1\n",
            " -16.83   -17.20   38.74    0.93     Cc1cccnc1NCc1nc(-c2ccco2)no1\n",
            " -21.26   -24.87  -24.87    0.00     O=C(NCCn1ncccc1-c1ccccc1)N[C@@H](CCO)c1ccccc1\n",
            " -14.84   -19.49   39.19    0.98     CO[C@@H](CNC(=O)NCc1ccc(C(=O)[O-])o1)c1ccccc1\n",
            " -17.35   -21.58   37.57    0.99     CNS(=O)(=O)c1ccc(N[C@@H](C)Cc2ccc(F)c(F)c2)cc1\n",
            " -21.06   -19.69   40.09    1.00     CCNC(=O)N(C)C[C@@H]1COc2ccccc2C1\n",
            " -22.57   -24.34   34.33    0.98     c1ccc([S@@](=O)[C@@H]2CCCN(C(=O)NCc3ccncc3)C2)cc1\n",
            " -19.26   -24.41   32.94    0.96     C[C@@H](O)[C@@H](NC(=O)Nc1ccccc1-c1cccnc1)c1ccncc1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 85   Fraction valid SMILES: 96.9  Time elapsed: 0.79h Time left: 26.79h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -17.89   -18.03   40.03    0.97     CCc1ccc([C@H](C[NH3+])N2CCc3ccccc32)cc1\n",
            " -15.29   -22.24   36.52    0.98     CCOCC[C@]1(O)CC[C@H](OC)C1\n",
            " -19.92   -23.60   35.78    0.99     CCC[C@@H](C)C(=O)NNC(=O)c1ncccc1C#N\n",
            " -21.01   -21.57   37.82    0.99     COc1ccc([C@H](C)NC(=O)NNC(=O)CCCOc2ccccc2)cc1\n",
            " -16.24   -15.83   41.69    0.96     Cn1cccc1C(=O)Oc1ccccc1\n",
            " -17.73   -26.70   32.37    0.98     CO[C@H](CNC(=O)N[C@@H]1CCc2c(F)cccc21)c1ccccn1\n",
            " -20.25   -23.03   36.34    0.99     CCCc1nc(CS(=O)(=O)c2ccc(OC)cc2)ccc1C\n",
            " -19.90   -23.49   34.93    0.97     Cc1cccc(C(=O)NCCc2ccc(NC(=O)/C=C\\c3ccccc3)cc2)c1\n",
            " -17.51   -22.91   33.77    0.94     CC[C@@H](CNC(=O)N[C@@H](CC(F)(F)F)C(F)(F)F)C(=O)[O-]\n",
            " -19.74   -22.28   36.79    0.98     C[C@@H]1C[C@H](NC(=O)C[C@@H](O)c2ccccc2)CCO1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 86   Fraction valid SMILES: 95.3  Time elapsed: 0.79h Time left: 26.59h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -17.24   -17.81   40.11    0.97     O=C(CCNC(=O)c1ccccc1)N[C@H](c1ccccc1)c1ccccc1\n",
            " -13.39   -18.25   41.17    0.99     CNC(=O)c1ccc(CNC(=O)NCCc2ccccc2F)cc1\n",
            " -18.53   -22.01   35.92    0.97     O=C(COc1ccccc1F)N[C@@H](c1ccccc1)c1c(F)cccc1F\n",
            " -13.61   -16.67   42.60    0.99     COc1cccc(CO[C@H](C)C(=O)Nc2ccc(F)cc2F)c1\n",
            " -18.18   -19.50   39.98    0.99     O=C(NNC(=O)C1(c2ccc(F)cc2F)CC1)C1CCCCC1\n",
            " -28.07   -31.58   25.35    0.95     O=C(Cc1ccc(Cl)cc1)/c1ccc(-c2ccccc2F)o1\n",
            " -24.74   -24.68   34.41    0.98     COc1cccc(NCCNC(=O)c2cnn(CC)c2)c1\n",
            " -16.32   -22.47   36.86    0.99     CNC(=O)CNC(=O)Nc1ccccc1C(=O)NC1CCCCC1\n",
            " -22.05   -20.05   39.03    0.98     CNC(=O)O[C@@H](C)C(=O)Nc1ccc(Br)cc1F\n",
            " -25.79   -25.81   33.57    0.99     CC(C)C[C@H](C(=O)NC[C@@H]1CCCN(c2cnccn2)C1)C(=O)[O-]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 87   Fraction valid SMILES: 95.3  Time elapsed: 0.80h Time left: 26.40h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -20.70   -25.42   33.48    0.98     C[C@@H](c1ccccc1F)N(C(=O)CCNC(=O)c1ccc(F)cc1F)c1ccccn1\n",
            " -11.72   -16.01   42.90    0.98     O=C(CNC(=O)Cc1ccccc1)NCc1ccccc1\n",
            " -17.77   -21.70   37.27    0.98     CCNC(=O)c1cccc(OC[C@]2(O)CCc3ccccc32)c1\n",
            " -17.68   -17.63   41.91    0.99     O=C(NCC(=O)N1CCCC1)NCc1ccccc1F\n",
            " -17.64   -17.45   40.66    0.97     CCOCCNC(=O)Nc1cn[nH]c1\n",
            " -23.71   -35.21   22.84    0.97     O=C(NCCCNC(=O)CN1C(=O)NC(=O)C1=O)c1cccc(F)c1\n",
            " -23.96   -28.23  -28.23    0.00     CCNC(=O)c1cc(C)ccc1NC(=O)[C@@H](c2ccccc2)N2CCCCC2=O)c1\n",
            " -14.13   -19.04   39.93    0.98     CNC(=O)NCCNC(=O)Nc1ccc(OCc2ccccc2)cc1\n",
            " -13.12   -15.54   44.02    0.99     COC(=O)CCSc1ccccc1\n",
            " -19.64   -23.97   35.22    0.99     C[C@@H](NCc1ccccc1F)C1CCN(C(=O)c2ccco2)CC1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 88   Fraction valid SMILES: 96.9  Time elapsed: 0.80h Time left: 26.21h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -19.04   -23.25   36.15    0.99     CC[C@@H](NC(=O)c1cccc(C(=O)N2CCCC2)c1)c1ccc(F)cc1\n",
            " -16.96   -22.25   36.81    0.98     CNC(=O)NCCC(=O)N[C@H](C)[C@H](O)c1ccccc1\n",
            " -16.93   -23.15   36.42    0.99     CCN(CC)C[C@@H](O)c1ccncc1\n",
            " -31.68   -37.36   20.16    0.96     CC(C)Cn1cc[nH+]c1-c1cnc(NNC(=O)COc2ccccc2F)[n-]1\n",
            " -19.41   -26.50   31.00    0.96     OC/C=C/CC[NH2+][C@@H]1CCCNC1=O\n",
            " -23.38   -19.99   37.19    0.95     Cc1n[nH]c2ncc(C(=O)Nc3ccccc3)c(Cl)c12\n",
            " -14.02   -17.82   41.12    0.98     CN(C)S(=O)(=O)c1ccc(NC(=O)C[C@@H](O)c2ccccc2)cc1\n",
            " -27.29   -28.58   29.65    0.97     O=C(c1ccco1)[C@H](N[C@@H]1CC[NH2+]C1)c1ccc(F)cn1\n",
            " -16.49   -20.83   37.88    0.98     C[C@H](NC(=O)N[C@H]1C[C@@H](C)N(c2ccccc2)C1=O)[C@H]1CCCO1\n",
            " -18.48   -21.65   37.96    0.99     CCOC(=O)COC(=O)[C@H](Cc1ccccc1)NC(C)=O\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 89   Fraction valid SMILES: 96.9  Time elapsed: 0.80h Time left: 26.03h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -21.96   -22.37   35.40    0.96     Cc1nc([C@@H](Cc2ccsc2)NC(=O)[C@@H]2COc3ccccc3O2)cs1\n",
            " -14.57   -17.84   41.01    0.98     C/C(=N\\NC(=O)COc1ccccc1F)c1ccccc1\n",
            " -18.73   -22.64   35.62    0.97     Fc1ccc(CNC[C@H](c2ccccc2)N2CCSCC2)cc1\n",
            " -30.17   -41.06   17.53    0.98     O=C(CNC(=O)[C@@H](c1ccc(F)cc1)N1CCOC[C@H]1C1CC1)N[C@H](c1ccccc1)c1nccn1C\n",
            " -25.21   -40.21  -40.21    0.00     Cc1cccc(NC(=O)CNC(=O)N[C@@H]2CC[C@@H]([C@H](C)c3ccccc4)C3)c2)c1\n",
            " -23.90   -25.27   32.75    0.97     C[C@H]([NH2+]CC(C)C)C1(C)CC1(C)C\n",
            " -15.13   -16.31   41.88    0.97     N#Cc1cccc(CNC(=O)c2ccco2)c1\n",
            " -25.28   -27.74   25.37    0.89     c1cncc(Nc2ccccc2-c2ccc[nH]2)c1\n",
            " -29.78   -32.11  -32.11    0.00     Cc1nn(C)cc1-c1ccccc1)c1cc(C(=O)Nc2ccc(OC(F)F)cc2)ccc1O\n",
            " -12.24   -16.59   42.47    0.98     CNC(=O)COc1ccccc1CNC(=O)c1ccccc1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 90   Fraction valid SMILES: 96.9  Time elapsed: 0.81h Time left: 25.86h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -19.97   -24.39   35.12    0.99     COc1ccc(OCCNC(=O)[C@](C)(O)c2ccc(F)cc2)cc1OC\n",
            " -12.48   -15.19   42.16    0.96     NC(=O)CNC(=O)Cn1nnc(-c2ccccc2)n1\n",
            " -14.69   -23.21   35.29    0.98     NC(=O)[C@H](NC(=O)N[C@@H]1C[C@@H]1c1ccccc1F)c1ccccc1\n",
            " -21.14   -19.32   40.32    0.99     CC[C@H](CCO)NS(=O)(=O)Cc1cccc(C)c1\n",
            " -16.97   -20.08   39.33    0.99     C[C@@H]([C@@H]([NH3+])Cc1ccccc1F)S(C)(=O)=O\n",
            " -18.62   -21.06   37.56    0.98     CONC(=O)Nc1cccc(C(=O)N2CCN(c3ccccc3)CC2)c1\n",
            " -15.43   -17.47   41.85    0.99     NC(=O)NCCCC(=O)N1CCN(Cc2ccccc2)CC1\n",
            " -17.99   -25.32   33.58    0.98     CO[C@H](CNCCc1cnccn1)c1ccccc1F\n",
            " -20.39   -21.86   36.33    0.97     O=C(NCc1ccccc1F)[C@@H]1CS(=O)(=O)c2ccccc2N1Cc1ccc(F)cc1\n",
            " -16.46   -21.54   37.64    0.99     C[C@@H](NC(=O)N[C@@H]1CCCN(c2ccccc2F)C1=O)c1ccc(OC(F)F)cc1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 91   Fraction valid SMILES: 93.8  Time elapsed: 0.81h Time left: 25.69h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -20.37   -27.04   32.75    1.00     COc1ccc([C@H](C)NC(=O)NCCCCOc2ccccc2F)cc1\n",
            " -14.11   -16.76   42.63    0.99     C[C@@H](CNC(=O)N1CCC(CO)CC1)c1ccccc1\n",
            " -24.58   -23.07   36.34    0.99     OCCC[NH2+][C@]1(Cc2ccccc2)CCCCC1=O\n",
            " -21.17   -20.49   38.06    0.98     CC(C)N(C[C@@H](C)O)C(=O)N1CCC[C@H](C)CC1\n",
            " -19.25   -21.41   36.51    0.97     COCCCN1C(=O)NC(=N)[C@@H]1c1ccccn1\n",
            " -13.69   -15.53   43.54    0.98     CCOC(=O)c1ccc(NC(=O)C[C@H](O)c2ccccc2)cc1\n",
            " -17.69   -22.87   37.00    1.00     CC[C@](C)([NH2+]CCO[C@@H](C)c1ccccn1)C(=O)[O-]\n",
            " -18.56   -20.97   39.03    1.00     CCOCCN(C)C(=O)[C@H](C)[NH2+]Cc1ccccc1\n",
            " -50.11   -51.29  -51.29    0.00     COC(OCC(=O)N1N=N[C@@H](CCCC=C2C(=O)c3ccccc3)SC2=C1CCCCO\n",
            " -18.44   -24.07   32.46    0.94     COc1ccc(N/N=C/c2ccccc2Sc2ccccc2)cc1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 92   Fraction valid SMILES: 95.3  Time elapsed: 0.82h Time left: 25.52h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -15.40   -15.82   41.94    0.96     C[C@@H](NC(=O)CSc1nnc(-c2ccccc2)o1)c1ccccc1\n",
            " -20.60   -21.62   37.96    0.99     Cc1ccc(CN(C)C(=O)COCc2ccccc2)c(OC)c1\n",
            " -17.07   -18.90   40.66    0.99     CNC(=O)NCCC1CCN(c2cccc(OC)c2)CC1\n",
            " -22.41   -24.23   35.31    0.99     CCOC(=O)N1CCCN(C(=O)Cc2ncccc2C)CC1\n",
            " -22.60   -30.35   28.83    0.99     CCNC(=O)NNC(=O)CNC(=O)C[C@](C)(O)c1ccc(C)cc1\n",
            " -13.88   -20.47   39.17    0.99     COC[C@H](C)Oc1ccc(CNC(=O)NCc2ccccc2C)cc1\n",
            " -12.92   -15.88   41.61    0.96     O[C@H](C[NH2+]Cc1ccco1)c1ccccc1\n",
            " -20.11   -24.66   34.67    0.99     CN(Cc1ccccc1N1CCOCC1)C(=O)[C@@H](c1ccccc1)C(C)C\n",
            " -19.48   -26.58   33.10    0.99     COCCNC(=O)N1C[C@@H](CN(C)Cc2ccccc2F)C1=O\n",
            " -18.70   -20.61   38.54    0.99     C[S@@](=O)CCN(Cc1ccccc1)C(=O)Nc1cnccc1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 93   Fraction valid SMILES: 95.3  Time elapsed: 0.82h Time left: 25.36h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -23.21   -32.68   27.13    1.00     C[C@@H](NC(=O)[C@@H](C)OCC(C)(C)C)c1ccccc1NC(=O)[C@H](C)Oc1ccccc1\n",
            " -12.10   -15.96   42.88    0.98     O=C(Cc1ccccc1)NNC(=O)COc1ccccc1F\n",
            " -14.81   -19.77   38.80    0.98     C[NH2+][C@H](Cc1ccccn1)[C@@H]1CN(C)CCO1\n",
            " -17.57   -18.76   39.53    0.97     Cc1nn(Cc2ccccc2)c(C)c1CC(=O)NCc1ccccc1\n",
            " -13.85   -25.62   33.95    0.99     CC[C@H](NC(=O)NC[C@@H](c1ccccc1F)N(C)C)c1ccccc1\n",
            " -16.45   -19.79   35.84    0.93     ONc1ccccc1[C@@H](O)c1ccccc1\n",
            " -15.02   -21.69   38.31    1.00     CCC(CC)COC(=O)N[C@@H](C)c1ccccc1\n",
            " -17.42   -19.65   38.70    0.97     COc1ccccc1[C@H](CNC(=O)Nc1ccc(C(N)=O)cc1)c1ccccc1\n",
            " -14.24   -18.60   41.18    1.00     CCO[C@H]1CCCN(C(=O)CNC(=O)c2ccccc2F)C1\n",
            " -23.04   -28.94   30.08    0.98     CC[C@@H]1CN(CC(C)(C)[C@@H](C)C)CCN1C(C)=O\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 94   Fraction valid SMILES: 95.3  Time elapsed: 0.82h Time left: 25.20h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -14.80   -19.30   40.44    1.00     CCCNC(=O)CNc1ccccc1CO\n",
            " -21.82   -24.23   35.33    0.99     COC[C@H](C)NC(=O)N[C@@H]1c2ccccc2SC[C@H]1C\n",
            " -13.01   -17.02   39.00    0.93     Cc1ccc(NCc2ccccc2)cc1\n",
            " -22.15   -23.69   36.22    1.00     CCOCCN(C)C(=O)CCCNC(=O)c1ccc(OC)c(OC)c1\n",
            " -14.49   -17.22   42.78    1.00     CCCCNC(=O)CCNC(=O)Nc1ccccc1C\n",
            " -23.35   -28.42   30.34    0.98     Cc1cnc(CN[C@@H](C)c2cccc(C(=O)[O-])c2)cc1\n",
            " -20.66   -24.32   34.97    0.99     O=C(N[C@@H](Cc1ccccc1F)c1ccccc1)C(=O)NCC1CCCCC1\n",
            " -22.96   -27.65   32.17    1.00     O[C@@H](CCCNC(=O)c1ccccc1C(F)(F)F)[C@@H]1CCCO1\n",
            " -23.05   -22.71   34.31    0.95     O=C(NNC(=O)c1ccc([N+](=O)[O-])cc1)[C@H]1Cc2ccccc2C(=O)N1\n",
            " -13.66   -17.40   42.44    1.00     COC[C@@H](O)CN(C)C(=O)Cc1ccccc1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 95   Fraction valid SMILES: 95.3  Time elapsed: 0.83h Time left: 25.04h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -18.30   -22.18   36.68    0.98     Cc1cccc(NC(=O)N(C)C[C@H](O)c2ccco2)c1\n",
            " -19.05   -28.31   30.35    0.98     NC(=O)CSc1ncc(-c2ccccc2)c([C@@H]2CCCN(C(=O)COc3ccccc3)C2)n1\n",
            " -13.91   -18.83   40.34    0.99     CCS(=O)(=O)NCCCNC(=O)NCc1ccccc1\n",
            " -22.03   -21.42   38.58    1.00     CCOC[C@H]1CCCN(C(=O)C(=O)Nc2ccc(SCC)cc2C)C1\n",
            " -23.81   -25.38   33.99    0.99     Cc1ccc(C(=O)NC[C@H](O)C(C)C)cc1S(=O)(=O)Nc1ccccc1F\n",
            " -17.71   -17.42   41.66    0.98     CC[C@](C)(NC(=O)NC[C@@H]1COc2ccccc2O1)C(=O)[O-]\n",
            " -16.94   -22.36   36.88    0.99     C[C@H](Oc1cccc(C#N)c1)C(=O)NC[C@@H](O)Cc1ccccc1\n",
            " -16.17   -19.79   38.32    0.97     O=C(CNC(=O)c1cocc1Br)Nc1cccnc1\n",
            " -22.09   -29.51   29.61    0.99     COCc1nc(CNC(=O)Nc2cccc(F)c2F)ccc1OC(F)F\n",
            " -12.40   -15.67   43.32    0.98     Cc1ccccc1COC1CCN(C(=O)c2ccccc2F)CC1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 96   Fraction valid SMILES: 98.4  Time elapsed: 0.83h Time left: 24.89h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -18.19   -20.58   38.66    0.99     CSC[C@H](C(=O)NCc1ccccc1CN1CCOCC1)c1ccccc1\n",
            " -33.48   -38.13   21.38    0.99     CO[C@H](CNC(=O)[C@H]1C=C2CCCCN2C[C@H]1C)c1ccc(F)cc1\n",
            " -16.20   -17.23   41.43    0.98     CN(C)c1ccc(S(=O)(=O)Cc2ccccc2)cc1\n",
            " -19.33   -22.77   36.50    0.99     COC(=O)CN(Cc1cccc(F)c1)C(=O)NCc1ccccn1\n",
            " -11.36   -15.91   42.86    0.98     C[C@@H](CNC(=O)N[C@H](CO)c1ccco1)c1ccccc1\n",
            " -29.56   -31.05   27.77    0.98     C[C@@H]1CN(Cc2cccc(CCNC(=O)[C@@H]3OCCc4ccccc43)c2)CO1\n",
            " -16.57   -23.50   34.61    0.97     O=C(CSCc1ccccc1Cl)NC[C@H](c1ccccc1)c1ccccc1\n",
            " -15.05   -20.17   38.34    0.98     COC(=O)[C@@H](C)Oc1ccccc1C(=O)N1CCNC1=O\n",
            " -13.91   -20.66   38.60    0.99     C[C@@H](Oc1cccc(C#N)c1)C(=O)NC[C@@H](c1ccccc1)[NH+](C)C\n",
            " -12.61   -16.73   41.96    0.98     C[C@@H](COc1ccc(F)c(F)c1)C(=O)[O-]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 97   Fraction valid SMILES: 93.8  Time elapsed: 0.84h Time left: 24.74h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -15.48   -21.17   36.71    0.96     OC[C@@H](O)C[NH+](Cc1ccccc1)Cc1ccccn1\n",
            " -15.43   -19.39   39.96    0.99     COC[C@H](C)NC(=O)NC[C@@H](O)c1ccccc1OC\n",
            " -19.54   -22.63   36.73    0.99     CCN(Cc1ccccc1)C(=O)CNC(=O)CN1CCN(C(=O)c2ccco2)CC1\n",
            " -20.04   -22.54   36.79    0.99     CC[C@@H](NS(=O)(=O)Cc1ccccc1)c1ccc(C(C)(C)C)cc1\n",
            " -19.32   -20.51   37.05    0.96     O=C(CNc1ccccc1)Nc1ccc(NC(=O)c2ccncc2)cc1\n",
            " -11.67   -20.05   37.08    0.95     CCOC[C@H](O)[C@@H](C)CO\n",
            " -27.23   -34.73   24.29    0.98     C[C@@H](Oc1ccccc1CN1CCOCC1)C(=O)N[C@H]1CCCC[C@@H]1NS(C)(=O)=O\n",
            " -14.38   -20.77   38.26    0.98     C[C@@H](Oc1ccc(F)cc1F)C(=O)NNC(=O)NCc1ccccc1\n",
            " -16.68   -20.42   39.58    1.00     CCCN(CCC(C)C)C(=O)NCc1ccccc1\n",
            " -21.19   -23.16   34.61    0.96     CC(C)NS(=O)(=O)NCCNC(=O)C1C[C@@H](C)O[C@H](C)C1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 98   Fraction valid SMILES: 96.9  Time elapsed: 0.84h Time left: 24.59h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -18.97   -24.39   35.04    0.99     CN(Cc1ccccc1O)C(=O)[C@@H](NC(=O)Cc1ccccc1)C(C)C\n",
            " -23.05   -24.70   34.99    0.99     CC(C)c1ccc(CNC(=O)C(=O)Nc2ccc(C(F)(F)F)cc2)c(C)c1\n",
            " -19.05   -19.37   39.60    0.98     COCCOc1ccc(NC(=O)c2occc2C)cc1\n",
            " -37.84   -36.23   21.30    0.96     C[C@H]1CN(c2ncccc2C(=O)c2ccc(N)[nH+]c2)[C@@H](C)CO1\n",
            " -16.42   -20.84   35.61    0.94     Cc1ccccc1NC(=O)c1ccccc1-c1cnccn1\n",
            " -15.70   -17.56   40.77    0.97     C[C@@H](Oc1ccc(F)cc1)C(=O)NN1C(=O)c2ccccc2C1=O\n",
            " -14.66   -19.86   38.36    0.97     N#Cc1ccccc1NC[C@](C)(O)c1ccccc1\n",
            " -16.14   -20.36   37.67    0.97     O[C@@H](c1ccccc1)C1CCN(C(=O)[C@@H]2C[C@@H]2c2ccco2)CC1\n",
            " -15.00   -18.20   41.80    1.00     COCCNC(=O)CCc1ccc(F)c(F)c1\n",
            " -19.68   -26.86   32.26    0.99     COc1ccccc1N1CCN[C@@H](C(=O)NCCc2ccc(F)cc2F)C1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 99   Fraction valid SMILES: 96.9  Time elapsed: 0.84h Time left: 24.45h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -25.24   -25.85   31.56    0.96     O=C(Nc1cccc(NS(=O)(=O)c2ccccc2)c1)c1ccc(NC(=O)[C@H]2C[C@@H]2c2ccccc2)cc1\n",
            " -11.84   -14.34   41.48    0.93     O[C@@H](Cc1nc2ccccc2o1)c1ccccc1\n",
            " -17.96   -19.51   36.91    0.94     O=C(Cc1ccc2ccccc2c1)Oc1ccccc1\n",
            " -14.49   -15.19   44.46    0.99     CNC(=O)NCCc1cccc(Cl)c1\n",
            " -18.90   -19.87   39.08    0.98     COc1cc(C(=O)N2CCOCC2)ccc1OCC(=O)Nc1ccccc1\n",
            " -19.56   -25.32   33.57    0.98     CCCOc1ccccc1[C@H]1NC(=O)[C@@H](CC(=O)Nc2ccccc2F)N1\n",
            " -12.19   -20.66   38.30    0.98     O[C@@H](CNC(=O)COc1ccc(F)cc1F)c1ccccc1\n",
            " -20.43   -28.76   29.85    0.98     N/C(=N/OC(=O)[C@@H]1C[C@@H]1c1ccccc1F)C(=O)c1ccccc1\n",
            " -17.95   -20.27   38.42    0.98     COc1ccc(C(=O)NCc2ccccc2)cc1NC(=O)COc1ccccc1F\n",
            " -15.45   -19.53   40.47    1.00     CCOC(=O)C[C@@H](C)Sc1ccccc1OC\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 100   Fraction valid SMILES: 95.3  Time elapsed: 0.85h Time left: 24.31h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -22.33   -21.49   38.06    0.99     CC[C@@H](C)CN(C)C(=O)CSc1nnc(C2CC2)n1-c1ccccc1\n",
            " -19.93   -27.68   30.11    0.96     NC(=O)CSCc1nc([O-])c(C(F)(F)F)c(Cl)c1Cl\n",
            " -13.87   -18.79   37.59    0.94     CCOC(=O)[C@@H]([NH3+])[C@@H](C)OC\n",
            " -15.73   -17.05   40.61    0.96     COCc1ccccc1NCc1cccs1\n",
            " -19.45   -18.44   40.80    0.99     CC(C)CCCNC(=O)Nc1ccccc1-c1nccs1\n",
            " -24.92   -29.11   29.54    0.98     CCNC(=O)c1ccccc1/N=C(/N)c1cccnc1\n",
            " -24.13   -37.49  -37.49    0.00     C[C@H](C(=O)N[C@@H](C)c1ccc(NC(=O)NCc2ccccc2)cc1NC(C)C\n",
            " -19.54   -19.11   39.88    0.98     CS(=O)(=O)N1CCC[C@@H](C(=O)Nc2ccc(NC(=O)C3CC3)cc2)C1\n",
            " -19.76   -22.89   36.39    0.99     CO[C@H](CNC(=O)N1CCCC[C@@H]1CN1CCOCC1)c1cccc(F)c1\n",
            " -16.96   -15.53   42.06    0.96     O=C(c1ccccc1Cn1cccn1)N1CCC(Cc2ccccc2)CC1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 101   Fraction valid SMILES: 96.9  Time elapsed: 0.85h Time left: 24.17h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -22.74   -24.33   34.34    0.98     O=C(CN1CCCN(c2ccccc2F)CC1)Nc1ccccc1C(=O)Nc1ccc(F)cc1\n",
            " -23.66   -24.80   34.69    0.99     Fc1ccc(F)cc1CNC(=O)CCCC(=O)c1ccc(F)cc1\n",
            " -12.82   -18.39   40.69    0.98     Cc1ccc(NC(=O)[C@@H](C)Oc2ccccc2F)cc1C\n",
            " -21.90   -27.36   32.08    0.99     C[C@@H](SC[C@H](O)CO)C(=O)NNC(=O)C(C)(C)c1ccccc1\n",
            " -15.71   -16.08   42.45    0.98     NS(=O)(=O)c1ccc(NCc2ccc(C(F)(F)F)cc2)cc1\n",
            " -14.07   -15.41   44.56    1.00     CCOC[C@H]1CCCN(C(=O)CCc2ccc(OC)cc2)C1\n",
            " -25.86   -25.13   34.38    0.99     CC[C@@H](C)[C@@H](NS(C)(=O)=O)C(=O)Nc1ccccc1[C@@H](C)N1CCOCC1\n",
            " -18.69   -16.35   43.32    0.99     CC(C)Oc1ccc(CNC(=O)C2C[C@H](C)O[C@H](C)C2)cc1\n",
            " -13.44   -23.74   35.76    0.99     COC(=O)C[C@H](C(N)=O)NCc1ccccc1\n",
            " -21.61   -22.29   36.29    0.98     CO[C@H](CNC(=O)Nc1ccc(C)c([N+](=O)[O-])c1)c1ccc(F)cc1F\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 102   Fraction valid SMILES: 95.3  Time elapsed: 0.85h Time left: 24.04h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -20.25   -26.65  -26.65    0.00     C[C@@H](NC(=O)c1ccccc1CNC(=O)[C@@H](C)Sc1ccccn1\n",
            " -12.80   -18.43   40.91    0.99     CO[C@@H](CNC(=O)c1ccc(OC(C)C)cc1)c1ccccc1\n",
            " -14.04   -18.44   40.26    0.98     COc1ncccc1CNC(=O)N[C@H](CO)c1ccccc1\n",
            " -19.54   -23.19   35.68    0.98     NC(=O)[C@H](NC(=O)[C@@H]1C[C@@H]1c1ccccc1)c1cccc(OC(F)F)c1\n",
            " -17.02   -25.88   32.76    0.98     Cc1ccccc1[C@@H](NC(=O)NCc1ccccc1COc1ccccc1)C(C)C\n",
            " -17.98   -21.00   36.79    0.96     COc1ccccc1N1CCN(C(=O)c2cnnc(-c3ccccc3F)n2)CC1\n",
            " -19.89   -26.20   32.83    0.98     O=C(NCCCNC(=O)c1ccccc1F)c1cccc(S(=O)(=O)N2CCN(c3ccccc3F)CC2)c1\n",
            " -15.80   -18.10   41.63    1.00     CC[C@@H](C)[C@@H](NS(=O)(=O)CC)c1ccccc1\n",
            " -39.91   -49.17  -49.17    0.00     O=c1c(OC[C@H]2N=C(C2)C2)oc2c(F)cccc12\n",
            " -15.69   -18.34   40.34    0.98     O=C(C[C@@H](c1ccccc1)N1CCOCC1)N1CCN(CCc2ccccc2)CC1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 103   Fraction valid SMILES: 95.3  Time elapsed: 0.86h Time left: 23.90h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -27.11   -26.95   32.13    0.98     CCS(=O)(=O)Nc1ccccc1[C@H](C)[NH2+][C@@H]1c2ccccc2C[C@H]1C\n",
            " -21.24   -22.89   36.47    0.99     C[C@@H](Oc1ccccc1C[NH3+])C(=O)NCc1ccccc1C(N)=O\n",
            " -15.81   -24.02   34.60    0.98     O=C(NCCNC(=O)N[C@@H](CO)c1ccco1)c1ccccc1\n",
            " -14.02   -27.29   31.73    0.98     CN(C)S(=O)(=O)N[C@@H](C)c1ccccc1NCc1ccccc1\n",
            " -13.75   -18.68   37.08    0.93     O=C(NNc1ccccc1-c1ccccc1)c1cnccn1\n",
            " -17.44   -20.68   37.05    0.96     CO[C@@H](C[NH2+][C@@H](C)c1cnc2ccccn12)c1ccccc1\n",
            " -15.91   -15.75   42.60    0.97     CCOCCN(C)S(=O)(=O)CC1CCC1\n",
            " -17.18   -22.16   37.75    1.00     C[C@@H](Cc1ccccc1)C(=O)NCC(C)(C)O\n",
            " -30.41   -30.62  -30.62    0.00     O=C(NC(C(=O)Oc1ccccc1)c1cnn(C(F)F)c1\n",
            " -13.05   -20.62   38.64    0.99     COC[C@H](O)COC(=O)c1ccccc1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 104   Fraction valid SMILES: 93.8  Time elapsed: 0.86h Time left: 23.77h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -32.34   -32.98   25.42    0.97     Cc1ccccc1N1CCN([C@@H](C)c2ccccc2)C(=S)N(CCc2ccccn2)C1=O\n",
            " -19.05   -21.85   35.42    0.95     O[C@H](CNc1ccccc1)[C@@H]1CCc2cccnc21\n",
            "  -9.27   -12.94   44.11    0.95     OC[C@H](Cc1ccccc1)Cc1ccccc1\n",
            " -14.73   -22.10   37.29    0.99     CC[C@@H](NC(=O)Nc1ccccc1NC(=O)[C@@H](C)OC)c1ccccc1\n",
            " -12.57   -19.53   39.58    0.99     Cc1ccc(CNC(=O)[C@@H](C)OCc2ccccc2)cc1\n",
            " -11.79   -16.24   42.67    0.98     COc1ccccc1NC(=O)C(=O)N[C@@H](C)c1ccccc1\n",
            " -13.58   -19.79   40.04    1.00     C[C@](O)(CNC(=O)CSCc1ccccc1)C1CCCCC1\n",
            " -35.31   -47.57  -47.57    0.00     O=C([O-])Cc1cccc(NS(=O)(=O)c2ccccc2CSC[C@H]1CCOCO1\n",
            " -21.51   -22.90   36.11    0.98     C[C@@H]([NH2+]Cc1ccc(NC(=O)c2ccccc2)cc1)[C@H]1CN(C)CCO1\n",
            " -36.23   -37.44   19.97    0.96     Cc1[nH+]cncc1NC(=O)c1ccccc1NC(=O)C(=O)NCCc1ccc[nH+]c1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 105   Fraction valid SMILES: 95.3  Time elapsed: 0.87h Time left: 23.63h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -12.71   -18.71   38.27    0.95     Cc1ncccc1N[C@@H](C)c1ccccc1\n",
            " -15.83   -21.27   36.33    0.96     CC[C@H](NC(=O)N[C@@H](c1ccccc1)c1ncccn1)c1ccccc1\n",
            " -15.82   -16.63   40.59    0.95     COc1ccc(Cl)cc1Nc1ncnc(Nc2ccccc2C)c1[N+](=O)[O-]\n",
            " -17.75   -19.46   40.54    1.00     CN(Cc1cccc(F)c1)C(=O)N[C@@H](CO)C(C)(C)C\n",
            " -21.21   -24.87   33.58    0.97     NC(=O)COc1ccccc1C(=O)N[C@](C)(C(=O)[O-])C(F)(F)F\n",
            " -24.32   -25.60   32.02    0.96     O=C(NCc1noc(COc2cccc(F)c2)n1)N[C@H](C(=O)[O-])c1ccco1\n",
            " -14.53   -17.53   42.35    1.00     COC1CCN(C(=O)CNC(=O)Cc2ccccc2Cl)CC1\n",
            " -19.10   -22.86   37.14    1.00     CC[C@@H](CSC)NC(=O)N[C@@H](C)c1ccc(OC)cc1\n",
            " -22.01   -28.93  -28.93    0.00     COC(=O)/C(=C(\\C#N)C(C)=O)c1ccccc1)C(F)(F)F\n",
            " -12.97   -15.07   43.63    0.98     COc1cccc(CNS(=O)(=O)c2cccc(C#N)c2)c1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 106   Fraction valid SMILES: 98.4  Time elapsed: 0.87h Time left: 23.52h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -25.24   -32.12   27.88    1.00     CC[C@H]([NH2+]C)[C@@H](c1ccccc1F)[C@H](C)[C@H](C)OC\n",
            " -27.49   -25.96   32.39    0.97     CCCn1nc(C)c(/C=C(/C#N)c2nc3ccccc3c(=O)[nH]2)c1O\n",
            " -19.63   -19.64   39.39    0.98     C[C@@H](C#N)N(C)S(=O)(=O)c1cccc(C#N)c1\n",
            " -17.28   -18.95   39.41    0.97     O=C(N[C@@H](CO)c1ccccc1F)[C@H]1CC(c2ccccc2)=NO1\n",
            " -12.21   -21.81   37.46    0.99     O=C(CSCC(F)(F)F)NC[C@@H](c1ccccc1)c1ccccc1\n",
            " -20.98   -26.69   31.49    0.97     CO[C@@H](CNC(=O)Nc1ccccc1-c1ccccc1)c1occc1C\n",
            " -16.56   -19.57   38.99    0.98     O=C(CCNC(=O)c1ccccc1)Nc1ccccc1C(=O)Nc1cccc(F)c1\n",
            " -11.47   -15.34   44.47    1.00     CCCNC(=O)COc1ccccc1\n",
            " -18.44   -27.83   30.61    0.97     O=C(NC[C@@H](c1ccco1)NC(=O)c1ccccc1)N1CC[C@@H](O)C1\n",
            " -24.12   -30.03   28.94    0.98     O=c1[nH]c(CNCc2ccccc2F)nc(C(C)C)c1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 107   Fraction valid SMILES: 95.3  Time elapsed: 0.87h Time left: 23.39h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -16.98   -22.47   35.58    0.97     N[C@@H](CS(=O)(=O)c1cccc(F)c1)C(=O)[O-]\n",
            " -24.12   -33.60  -33.60    0.00     C[C@@H]([NH2+]C[C@@H](C)c1nccc(OCC(F)(F)F)c1CO\n",
            " -17.49   -26.03   31.57    0.96     O=C(N[C@@H](c1ccccc1)C(=O)Nc1ccccc1)c1ccc(Cl)o1\n",
            " -21.72   -23.13   35.66    0.98     CCc1ccccc1NC(=O)c1cccc(NC(=O)N[C@@H](CO)c2ccco2)c1C\n",
            " -17.14   -22.14   37.47    0.99     C[C@@H](C(=O)[O-])N(C)Cc1ccc(N(C)C)cc1\n",
            " -13.51   -17.88   40.77    0.98     Cc1ccc(S(=O)(=O)NC[C@@H](O)Cc2ccccc2)cc1\n",
            " -16.85   -17.21   40.94    0.97     Cc1cccc(OC2CCOCC2)c1\n",
            " -19.90   -26.23   32.84    0.98     COc1cccc([C@@H](O)[C@@H](C)CCc2ccccc2F)c1O\n",
            " -19.69   -21.17   35.07    0.94     COc1ccccc1Nc1nnnn1NNC(=O)c1ccccc1\n",
            " -25.51   -30.90   27.58    0.97     CC[C@@H](NC(=O)CSc1ccncc1)c1ccc(OCc2ccccc2)cc1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 108   Fraction valid SMILES: 96.9  Time elapsed: 0.88h Time left: 23.27h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -20.49   -22.36   35.53    0.96     Cc1cccc(C)c1-n1nccc1C(=O)OCc1ccccc1F\n",
            " -17.22   -23.19   36.11    0.99     COCCNC(=O)NC[C@H](Cc1ccccc1)NC(=O)c1ccccc1\n",
            " -16.28   -19.67   38.97    0.98     Fc1ccc(F)cc1CNC(=O)[C@@H]1COc2ccccc2C1\n",
            " -19.32   -24.39   34.60    0.98     O=C(NCc1ccccc1CNC(=O)COc1ccccc1F)C(=O)NCc1ccccc1\n",
            " -16.08   -20.19   39.04    0.99     CC[C@@H](C)[C@@H](O)[C@H](C)c1cccnc1\n",
            " -20.54   -19.07   39.21    0.97     Cc1ccccc1-n1nc(C)c(C(=O)NCCc2ccccc2)c1C\n",
            " -18.79   -26.19  -26.19    0.00     CO[C@H](CNC(=O)[C@@H](C)Oc1cccc(C)c1C\n",
            " -24.78   -27.34   30.58    0.97     C[C@H]([NH3+])CCCS(=O)(=O)N1CCCCCCC1\n",
            " -15.13   -18.20   39.93    0.97     COc1cccc(CNS(=O)(=O)c2ccccn2)c1\n",
            " -12.73   -17.84   41.05    0.98     COCCNC(=O)[C@@H](C)Oc1ccc(S(N)(=O)=O)cc1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 109   Fraction valid SMILES: 93.8  Time elapsed: 0.88h Time left: 23.14h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -19.96   -27.29   31.27    0.98     CN(Cc1ccccc1)S(=O)(=O)N[C@@H](C)c1cccc(OCc2ccccc2)c1\n",
            " -18.56   -21.97   35.86    0.96     O=C(/C=C/c1ccc(S(=O)(=O)NCc2ccccc2)cc1)c1ccccc1\n",
            " -18.70   -24.98   34.50    0.99     CN(C(=O)[C@@H](C)NC(=O)COc1cccc(Cl)c1)c1ccccc1\n",
            " -15.75   -19.44   38.58    0.97     NNC(=O)Cc1cccc(C(=O)[O-])c1\n",
            " -20.44   -24.28   35.58    1.00     C=CCN(C)S(=O)(=O)N[C@@H](c1ccccc1F)C(C)C\n",
            " -18.02   -20.20   37.59    0.96     Cc1cc(CNC(=O)c2cccnc2NC(=O)c2ccccc2)on1\n",
            " -11.71   -16.47   41.53    0.97     Cc1ccc(NC(=O)[C@@H](NC(=O)c2ccccc2F)c2ccccc2)cc1\n",
            " -14.78   -15.87   39.86    0.93     CCN(CC)S(=O)(=O)NCCO\n",
            " -23.18   -28.92   28.10    0.95     Cc1ccccc1Oc1ccccc1NC(=O)C(=O)Nc1ccccc1-n1cccn1\n",
            " -14.12   -18.22   40.73    0.98     COc1cccc(NC(=O)[C@H](C)Oc2cccc(F)c2)c1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 110   Fraction valid SMILES: 93.8  Time elapsed: 0.88h Time left: 23.02h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -19.12   -23.25   34.35    0.96     Oc1ccccc1/C=C/CNCc1ccncc1\n",
            " -18.92   -21.13   37.45    0.98     O=C1C[C@@H](NCc2ccccn2)C(=O)N1CCc1ccccc1\n",
            " -14.69   -19.25   38.93    0.97     O=C(CNC(=O)[C@H](O)c1ccccc1)Nc1ccccc1\n",
            " -21.22   -20.59   37.95    0.98     COc1ccc2c(c1)[C@H]([NH2+][C@@H](C)CCc1cccnc1)CC2\n",
            " -13.78   -17.03   41.81    0.98     C[C@@H]1OCC[C@@H]1C(=O)Nc1ccccc1C(=O)NCc1ccccc1\n",
            " -13.89   -22.97   35.25    0.97     O=C(N[C@@H](CO)C(=O)Nc1ccccc1C(=O)[O-])c1ccccc1\n",
            " -24.89   -23.37   36.33    1.00     COCCCN(C)C(=O)N[C@@H](C)c1nc(C2CCC2)cs1\n",
            " -22.58   -25.69   32.36    0.97     CNC(=O)c1ccc(NC(=O)c2ccc(-c3cccc(F)c3)o2)cc1F\n",
            " -17.63   -20.66   38.22    0.98     C[C@@H](CNC(=O)c1cc(I)ccc1F)c1ccccc1\n",
            " -14.42   -17.68   40.52    0.97     COc1ccccc1NC(=O)c1ccc(OCC(=O)Nc2ccccc2)cc1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 111   Fraction valid SMILES: 98.4  Time elapsed: 0.89h Time left: 22.91h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -19.71   -26.06   32.71    0.98     COc1ccc(CCNC(=O)NC[C@@H](c2cccs2)c2ccccc2)cc1OC\n",
            " -19.25   -21.54   38.35    1.00     CCNC(=S)S[C@H](C(=O)Nc1ccccc1)C(C)C\n",
            " -19.62   -28.36   31.02    0.99     CNS(=O)(=O)c1cccc([C@@H](C)S[C@@H](C)CC[NH3+])c1\n",
            " -30.58   -49.43    8.77    0.97     CS[C@@H](Cc1cnc(N)sc1=[NH2+])Nc1ccc(F)cc1F\n",
            " -14.03   -18.21   40.62    0.98     O=C(OCc1ccccc1)[C@@H]1CCCN(C(=O)c2ccccc2)C1\n",
            " -17.60   -23.57   35.62    0.99     C[C@@H](NC(=O)CNC(=O)COc1ccccc1F)c1ccc(NC(N)=O)cc1\n",
            " -14.61   -19.14   38.46    0.96     C[C@@H](OCc1ccccc1)C(=O)Nc1ccccc1-c1ccncc1\n",
            " -18.37   -19.82   38.88    0.98     O=C([O-])[C@H](Cc1ccccc1)N[C@H](CCO)c1ccccc1\n",
            " -14.50   -19.48   38.73    0.97     COc1ccccc1NC(=O)[C@@H](C)Sc1nc2ccccc2[nH]1\n",
            " -13.12   -18.61   40.81    0.99     CNC(=O)COC(=O)[C@@H](C)Oc1ccccc1F\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 112   Fraction valid SMILES: 93.8  Time elapsed: 0.89h Time left: 22.80h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -16.05   -17.63   41.71    0.99     COCCOc1ccc(NC(=O)c2cccc(C(F)(F)F)c2)cc1\n",
            " -11.83   -17.42   42.28    1.00     CCO[C@@H](C)C(=O)Nc1ccccc1\n",
            " -11.01   -15.65   41.86    0.96     O=C(NCc1ccco1)c1ccccc1\n",
            " -23.14   -22.91   36.89    1.00     Cc1nn(CC(C)C)c(C)c1NC(=O)[C@H](C)Oc1ccccc1C(C)C\n",
            " -23.53   -23.77   34.79    0.98     COc1ccc(F)cc1C(=O)Nc1cc(C(=O)Nc2ccccc2C)ccc1C\n",
            " -20.99   -25.49   33.84    0.99     O=C(CSc1ccccc1)N1CCC[C@@H](CNC(=O)COc2ccccc2)C1\n",
            " -15.73   -20.73   35.59    0.94     O=C(N[C@@H](c1ccccc1)c1nccn1Cc1ccccc1)c1ccc(F)cc1\n",
            " -16.77   -22.43   36.26    0.98     C[C@@H](C[C@H](O)c1ccccc1)OCc1ccccc1F\n",
            " -13.74   -17.32   41.62    0.98     O=C(Cc1ccccc1F)NNC(=O)COc1ccccc1F\n",
            " -17.89   -22.52   36.85    0.99     COCc1ccccc1CNC(=O)CSCc1nccn1C\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 113   Fraction valid SMILES: 95.3  Time elapsed: 0.90h Time left: 22.69h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -15.54   -22.38   36.58    0.98     CSCC[C@@H](NC(=O)[C@H](O)c1ccccc1)c1ccccn1\n",
            " -25.67   -27.93   30.57    0.98     COc1cnc(NNC(=O)[C@@H](C)COC)nc1\n",
            " -25.51   -33.22   24.93    0.97     O[C@H](Cc1ccccc1)C[NH2+]Cc1nc(Cc2ccccc2F)on1\n",
            " -20.68   -24.32   33.54    0.96     O=C(c1ccccc1)N(Cc1ccccc1N1CCCCC1)C[C@H]1COc2ccccc21\n",
            " -17.16   -20.45   37.83    0.97     NC(=O)/C(=C\\c1cccc(C(F)(F)F)c1)C(=O)[O-]\n",
            " -18.11   -20.58   38.87    0.99     CNC(=O)NCCC(=O)N[C@@H](c1ccccc1)C(F)(F)F\n",
            " -20.50   -22.58   36.75    0.99     Cc1ccc(CNC(=O)C[C@H](C)Cc2ccccc2)cc1F\n",
            " -20.63   -25.68   33.64    0.99     CN(C(=O)CN(C)S(C)(=O)=O)C(=O)N[C@@H](c1ccccc1)C1CCC1\n",
            " -16.31   -20.50   37.60    0.97     Cc1ccc(CN(C)[C@@H](C)c2ccncc2)cc1\n",
            " -16.62   -21.23   38.46    0.99     CN[C@@H](CC(=O)OC)c1ccccc1OC(F)(F)F\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 114   Fraction valid SMILES: 98.4  Time elapsed: 0.90h Time left: 22.58h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -25.77   -31.10   28.19    0.99     CC(C)COC(=O)COc1cccc(O[C@H]2c3ccccc3C(=O)N2C)c1\n",
            " -26.10   -27.29   32.16    0.99     CC(C)C[C@H](NC(=O)C(=O)Nc1cccc(NC(=O)C2CCCC2)c1)c1noc(C)n1\n",
            " -15.82   -23.56   35.79    0.99     C[C@@H](NC(=O)[C@@H](C)Oc1ccccc1F)C(C)(C)C(=O)[O-]\n",
            " -18.78   -21.07   37.62    0.98     CCOC(=O)[C@@H]1CN(C(=O)[C@@H]2COc3ccccc3O2)C[C@H](C)O1\n",
            " -23.29   -33.21   25.63    0.98     O=C(c1ccc(F)c(F)c1)[C@@H]1CCCN(C(=O)[C@H](Cc2ccccc2)NC(=O)c2ccccc2)C1\n",
            " -17.18   -27.15   30.59    0.96     O=C(CSCCSc1ccccc1)Nc1cccc(-c2ccccc2)c1\n",
            " -15.53   -22.14   35.19    0.96     O[C@H](c1ccccc1)c1ccccc1NC[C@@H]1CN2CCC[C@@H]2CO1\n",
            " -13.17   -18.04   40.62    0.98     NC(=O)CSc1nnc(COc2cccc(C(F)(F)F)c2)o1\n",
            " -11.13   -15.65   43.65    0.99     CCNS(=O)(=O)[C@@H]1CCN(C(=O)[C@@H](C)Oc2ccccc2)C1\n",
            " -16.13   -19.15   40.22    0.99     Cc1ccccc1[C@@H](NC(=O)c1ccc([S@@](C)=O)cc1)C(C)C\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 115   Fraction valid SMILES: 96.9  Time elapsed: 0.90h Time left: 22.48h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -12.32   -21.53   37.29    0.98     COC(=O)[C@@H](C)OC(=O)[C@@H](c1ccccc1)c1ccccc1\n",
            " -29.09   -38.70   19.10    0.96     C1CCCn2c(CN3C(=O)NCC3(CCCC3)CCCC3)cnc21\n",
            " -22.39   -29.12   30.23    0.99     OCC[C@](C[NH+](C)Cc1ccc(F)cc1)C(=O)[O-]\n",
            " -21.58   -19.85   38.61    0.97     CC(C)[C@@H](C)NC(=O)N[C@@H]1CCCCC[C@@H]1C(=O)[O-]\n",
            " -18.08   -23.07   36.93    1.00     CSCC[C@@H]([NH2+]C(C)C)c1ccc(F)c(F)c1\n",
            " -16.26   -19.87   39.40    0.99     C[C@H](Oc1ccccc1C#N)C(=O)Nc1ccccc1C(C)C\n",
            " -17.56   -21.23   37.85    0.98     C[C@H](OC(=O)[C@@H](C)S(=O)(=O)c1ccc(F)cc1)c1ccccn1\n",
            " -20.91   -19.66   40.34    1.00     CSc1ccc(C(=O)NC[C@H](C(C)C)N(C)C(=O)OC(C)(C)C)cc1\n",
            " -26.49   -30.21   24.37    0.91     CNS(=O)(CC)c1ccccc1CNC(=O)COc1ccccc1F\n",
            " -12.92   -17.12   42.11    0.99     CSCCOCc1ccccc1C(=O)[O-]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 116   Fraction valid SMILES: 92.2  Time elapsed: 0.91h Time left: 22.38h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -13.27   -17.47   41.67    0.99     C[C@H](CNC(=O)NCc1ccccn1)CN1CCOCC1\n",
            " -15.52   -18.31   40.83    0.99     CC[C@@H](NC(=O)COc1ccccc1)c1ccc(C)cc1\n",
            " -15.21   -22.19  -22.19    0.00     O[C@@H](CN(C(=O)c1ccccc1F)C1CCCC1\n",
            " -17.25   -20.61   39.12    1.00     COc1ccccc1CN(C)C(=O)CSC[C@H](O)CO\n",
            " -19.40   -24.80   35.08    1.00     CSCCC[C@@H](O)CNC(=O)/C=C/c1ccccc1\n",
            " -15.28   -17.44   40.19    0.96     O=C(c1ccccc1F)N(CCc1ccccc1)Cc1ccccc1\n",
            " -19.23   -25.53   33.30    0.98     CNS(=O)(=O)c1ccccc1CNC(=O)Nc1ccc(F)cc1I\n",
            " -14.16   -20.04   39.42    0.99     Cc1cccc(C)c1NC(=O)CNC(=O)[C@@H](C)Oc1ccccc1\n",
            " -19.76   -24.03   34.08    0.97     O=C(NCCN[C@@H](c1ccc(F)cc1)c1nccs1)c1ccc(F)cc1\n",
            " -18.82   -23.04   35.00    0.97     c1ccc([C@@H](CNC(=O)[C@@H]2CC[NH2+]C2)c2ccccc2)cc1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 117   Fraction valid SMILES: 98.4  Time elapsed: 0.91h Time left: 22.27h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -22.43   -24.74   35.26    1.00     CCCOCCC(=O)NC[C@H](OC)c1ccc(F)cc1\n",
            " -26.70   -30.82   28.59    0.99     C[C@H](NC(=O)CN1C(=O)C(C)(c2ccc(F)cc2)CC1)c1cccc(C#N)c1\n",
            " -13.03   -15.60   43.89    0.99     NC(=O)C1CCN(C(=O)COc2ccc(F)cc2)CC1\n",
            " -17.76   -23.66   33.22    0.95     O=C(c1ccccc1CSc1nnc(C2CC2)n1-c1ccccc1)Nc1cccc(F)c1\n",
            " -17.32   -33.86   24.85    0.98     O=C(N[C@@H](CO)Cc1ccccc1)[C@@H](c1ccccc1)N1CCN(C(=O)c2ccccc2F)CC1\n",
            " -17.88   -19.08   40.09    0.99     C[C@H](NC(=O)CSc1ccc(F)cc1)c1ccc(N2CCOCC2)cc1\n",
            " -19.96   -25.84   33.35    0.99     CO[C@@H](CNC(=O)NC(C)(C)c1ccccn1)c1ccccc1\n",
            " -14.60   -24.89   33.90    0.98     FC(F)(F)OCCSc1ncccc1F\n",
            " -15.09   -16.01   43.99    1.00     CCOCCN(C)C(=O)c1cccc(SC)c1\n",
            " -17.57   -24.11   35.72    1.00     COC(C)(C)C[C@@H](C)[C@H]([NH3+])c1ccccc1F\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 118   Fraction valid SMILES: 96.9  Time elapsed: 0.92h Time left: 22.17h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -13.07   -20.62   38.23    0.98     NC(=O)[C@@H](Cc1ccccc1)N[C@@H](CO)c1ccccc1F\n",
            " -12.28   -15.50   42.78    0.97     COc1cccc(C(=O)Nc2ccc(C)cc2)c1\n",
            " -14.61   -20.46   37.57    0.97     COc1ccccc1CNC(=O)CS[C@H](c1ccccc1)c1ccccc1\n",
            " -14.57   -17.29   41.69    0.98     CC[C@H](NC(=O)N[C@@H](C)c1ccccc1)c1nccs1\n",
            " -23.27   -23.72   33.73    0.96     NNc1nc(COc2ccccc2Br)ccc1O\n",
            " -29.42   -33.07   25.50    0.98     C[C@H](Oc1cccc(C#N)c1)C(=O)N(N(C)C(=O)c1ccccc1F)c1nccs1\n",
            " -24.45   -26.97   31.84    0.98     CN(C(=O)NCc1ncccc1O)[C@H](C)c1ccccc1\n",
            " -27.66   -30.46   28.85    0.99     CO[C@@H](C)NC(=O)c1ccc(NC(=O)[C@H](C)NC(=O)COc2ccccc2)cc1\n",
            " -18.29   -22.61   36.88    0.99     C[C@H](C(=O)NC(C)(C)C)[C@H]([NH3+])c1ccccc1\n",
            " -44.34   -58.10    1.90    1.00     CSC[C@H](C(=O)N(C)c1ccccc1)N(CC(=O)C(C)(C)C)c1ccc(Cl)c(C(C)C)n1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 119   Fraction valid SMILES: 96.9  Time elapsed: 0.92h Time left: 22.07h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -21.61   -22.18   37.70    1.00     C[C@@H](Oc1ccccc1C#N)C(=O)N[C@H](C)C[C@@H]1CCCCO1\n",
            " -31.03   -41.05   16.27    0.96     O=C(COC(=O)c1ccccc1C1Nc2ccccc2)CNC1=O\n",
            " -16.35   -17.41   41.90    0.99     CNC(=O)c1ccccc1NC(=O)COc1c(C)cccc1C\n",
            " -14.84   -18.63   41.31    1.00     COC[C@H](C)NC(=O)N[C@@H](C)c1cccc(C(F)(F)F)c1\n",
            " -19.91   -22.55   36.94    0.99     Cc1noc(CCCC(=O)Nc2cnccc2N(C)C)c1C\n",
            " -15.39   -13.50   45.18    0.98     CC1(C)CCC(CC(=O)[O-])CC1\n",
            " -21.89   -22.32   35.14    0.96     COc1ncnc(OCC2CCN(C(=O)c3cnccn3)CC2)c1[N+](=O)[O-]\n",
            " -19.72   -24.46   35.17    0.99     CSC[C@@H](C)NC(=O)N[C@@H](C)Cc1ccccc1OCc1ccccc1\n",
            " -20.92   -23.06   36.64    0.99     COc1ccccc1[C@@H](O)[C@@H](Cl)OC(C)C\n",
            " -15.77   -25.44   33.37    0.98     NC(=O)[C@@H](C/C(N)=O)Nc1ccccc1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 120   Fraction valid SMILES: 100.0  Time elapsed: 0.92h Time left: 21.97h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -13.87   -17.91   41.65    0.99     COCCNC(=O)CNC(=O)Nc1cc(C)ccc1F\n",
            " -18.33   -20.99   38.70    0.99     COC(=O)[C@@H](O)c1cc(F)ccc1OCC(C)C\n",
            " -19.40   -23.61   35.34    0.98     Cn1ccnc1C(=O)CSCC(=O)Nc1ccccc1\n",
            " -17.76   -31.62   28.29    1.00     C[C@@H](NC(=O)[C@@H](C)OCC(C)(C)C)c1ccccc1NC(=O)CSc1ccccc1\n",
            " -18.85   -23.92   34.40    0.97     CCOc1ccccc1C(=O)c1cccc(C(=O)[O-])c1\n",
            " -17.90   -26.93   32.53    0.99     CN[C@](C)(CCS(C)(=O)=O)C(=O)Nc1ccccc1N1CCOCC1\n",
            " -19.21   -24.15   34.45    0.98     C[C@@H](c1ccccc1)S(=O)(=O)c1cccc(C(=O)N2CCN(S(=O)(=O)c3cccc(F)c3)CC2)c1\n",
            " -18.53   -22.88   36.55    0.99     Cc1ccccc1NC(=O)[C@H](C)NC(=O)CNC(=O)Cc1ccccc1\n",
            " -18.38   -18.12   40.44    0.98     COc1ccc(C(=O)NCC(=O)[O-])cc1Sc1ccccc1\n",
            " -28.80   -33.94   24.52    0.97     C[C@H](Sc1ccccc1)C(=O)NCc1ccccc1N(Cc1cccnc1)C1CCC1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 121   Fraction valid SMILES: 96.9  Time elapsed: 0.93h Time left: 21.87h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -17.71   -21.81   37.42    0.99     CCNS(=O)(=O)CCCSCc1ccncc1\n",
            " -16.85   -19.27   40.49    1.00     CCCCNC(=O)[C@@H](C)NC(=O)Nc1cccc(OC)c1\n",
            " -13.73   -23.12   35.89    0.98     FC(F)(F)Oc1ccccc1CN[C@@H](CO)c1ccccc1F\n",
            " -16.06   -18.43   40.04    0.97     C[C@@H](O)CNC(=O)C(=O)Nc1cccnc1\n",
            " -15.68   -18.68   39.37    0.97     Cc1ccccc1CNC(=O)c1cccc(S(=O)(=O)Nc2ccccc2)c1\n",
            " -13.58   -15.80   44.20    1.00     CCOCCN(C)C(=O)Cc1ccc(OC)cc1\n",
            " -22.66   -19.30   40.70    1.00     CC[NH2+]CCC(=O)N[C@H](C)c1ccc(C#N)cc1\n",
            " -16.06   -22.84   36.69    0.99     CCOC(=O)CCNC(=O)c1ccccc1NC(=O)c1cccc(F)c1\n",
            " -20.86   -22.97   36.95    1.00     COC[C@@H](C)Oc1cccc(CNC(=O)NCC(F)(F)F)c1\n",
            " -27.94   -42.08  -42.08    0.00     Cc1ccccc1NC(=O)[C@H](Sc1nc(C(C)(C)c2nc3ccccc3nc2N(C)C)n(C)c1=O\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 122   Fraction valid SMILES: 95.3  Time elapsed: 0.93h Time left: 21.78h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -16.99   -21.60   37.93    0.99     CN(Cc1cc(C(=O)N(C)C)ccc1F)Cc1ccccc1\n",
            " -12.18   -17.03   41.74    0.98     O=C(N[C@H](CO)c1ccccc1F)c1cccc(C(F)(F)F)c1\n",
            " -26.44   -24.42   34.42    0.98     C[C@@H](Nc1ccc(O[C@H]2CCOC2)cc1)C(=O)N1C[C@H]2CCCC[C@H]2C1\n",
            " -19.31   -24.75   33.44    0.97     Oc1ccccc1CSCc1cc(Cl)ccc1F\n",
            " -11.28   -11.26   47.82    0.98     CC(C)Cn1ccccc1=O\n",
            " -24.06   -29.22   30.40    0.99     CC[C@](C)(CO)NC(=O)c1ccccc1N[C@@H]1CCCO[C@@H]1C\n",
            " -20.78   -28.71   29.78    0.97     Cn1cnn(CCNC(=O)C(=O)N[C@@H]2CCCC[C@@H]2C)c1=O\n",
            " -15.49   -18.80   36.80    0.93     CS(=O)(=O)NCCSC[C@@H](O)CO\n",
            " -17.52   -25.29   33.48    0.98     CS(=O)(=O)NCC[NH2+]C[C@@H](c1ccccc1)c1ccccn1\n",
            " -20.84   -22.73   36.78    0.99     CCNC(=O)c1ccc(C(=O)NCCNC(=O)c2cccc(F)c2)cc1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 123   Fraction valid SMILES: 96.9  Time elapsed: 0.93h Time left: 21.68h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -17.14   -22.79   36.44    0.99     C[C@H](NC(=O)C[S@@](=O)c1ccccc1F)c1ccc(Cl)c(F)c1\n",
            " -31.47   -35.84   24.10    1.00     COC(=O)CC[C@@H](C)NS(=O)(=O)/C(C)=C/C=C/c1ccc(C)cc1\n",
            " -12.15   -14.94   44.14    0.98     COc1ccccc1CNC(=O)CNC(=O)c1ccccc1\n",
            " -21.42   -25.24   34.13    0.99     Cc1cccc(OCCCNC(=O)c2cccc([C@@H](C)O)c2)c1\n",
            " -16.27   -21.03   38.57    0.99     C[C@@H](CNC(=O)Nc1ccccc1C(=O)[O-])C(C)(C)C\n",
            " -18.50   -25.43   34.57    1.00     CCN(C)S(=O)(=O)NCCC(C)(C)c1ccccc1F\n",
            " -19.75   -23.36   36.64    1.00     CCCC[C@@H](COC)NC(=O)[C@@H](C)Oc1cccc(I)c1\n",
            " -18.66   -26.81   30.05    0.95     O[C@@H](CNc1ccccc1SCc1ccccc1)c1ccccn1\n",
            " -20.75   -24.12   34.37    0.97     OCCOc1ccnc(N[C@@H]2CCN(c3ccccc3F)C2)c1\n",
            " -26.02   -36.53   20.95    0.96     COCCn1c(SCc2noc(COc3ccccc3)n2)nc(C)c1-c1ccncc1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 124   Fraction valid SMILES: 96.9  Time elapsed: 0.94h Time left: 21.60h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -23.10   -28.71   30.88    0.99     CCO[C@@H](C)C(=O)[C@@H](C)S(=O)(=O)c1cc(F)ccc1N\n",
            " -19.28   -18.83   40.52    0.99     CCOCc1ccc(CNC(=O)Nc2ccc(C#N)cc2)cc1\n",
            " -31.96   -43.59   15.05    0.98     CC[C@@H](NC(=O)c1cn(CC)c(C)c1-c1ccccn1)[C@@H](C)c1cccnc1\n",
            " -13.60   -16.87   40.80    0.96     CNC(=O)CSc1nnc(Cc2ccccc2)n1-c1ccccc1\n",
            " -18.74   -24.99   34.67    0.99     CCOC(=O)[C@@H](NC(=O)CSCc1ccc(OC)cc1)c1ccccc1\n",
            " -15.24   -24.00   36.00    1.00     CCN(C[C@H](C)C#N)C(=O)C[C@@H](C)Oc1ccc(F)c(F)c1\n",
            " -15.98   -23.74   35.92    0.99     C[C@H](Oc1ccc(C(C)(C)C)cc1)C(=O)N[C@@H](C)c1ccc(F)cc1F\n",
            " -25.40   -35.31   22.16    0.96     CC(C)(C)OC(=O)CNC(=O)[C@@H](C)NC(C)(C)O\n",
            " -17.88   -20.01   39.18    0.99     COc1cccc([C@@H](C)NC(=O)C[C@H](O)c2ccc(C)cc2)c1\n",
            " -16.59   -21.36   37.43    0.98     COCCOc1ccccc1NC(=O)CNC(=O)c1cnccn1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 125   Fraction valid SMILES: 92.2  Time elapsed: 0.94h Time left: 21.50h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -16.08   -16.78   41.32    0.97     O=C(CNc1ccccc1)Nc1ccc(I)cc1\n",
            " -19.82   -20.97   38.38    0.99     O=C(OCC(=O)N1CCC(Cc2ccccc2)CC1)c1cc(F)ccc1F\n",
            " -12.50   -15.80   43.13    0.98     COC(=O)COc1ccc(OC)c(OC)c1\n",
            " -25.96   -32.72   26.90    0.99     CNC(=O)c1ccc(Cn2ccc(N[C@H](C)C(=O)NC(C)(C)C)c2)cc1\n",
            " -21.83   -24.23   34.26    0.97     COc1ccc(NC(=O)N2CCO[C@@H](CCO)C2)cc1NS(C)(=O)=O\n",
            " -21.14   -24.28  -24.28    0.00     CC(C)(C)NC(=O)COC(=O)c1nc2ccccc2c(=O)c1[O-]\n",
            " -19.06   -21.43   37.60    0.98     COc1ccc([C@H](NC(=O)c2cccc(C(=O)[O-])c2)C(C)C)cc1\n",
            " -20.39   -35.35  -35.35    0.00     C[C@H](NC(=O)COCC(=O)[O-])C1(C)Cc2ccccc2C1)c1ccc(F)c(F)c1\n",
            " -15.39   -21.08   38.17    0.99     O=C(CSc1ccccc1)NCCS(C)(=O)=O\n",
            " -16.95   -24.05   35.02    0.98     Cn1ccc(C(=O)Nc2cccc(F)c2)c1C(=O)N(C)C\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 126   Fraction valid SMILES: 98.4  Time elapsed: 0.95h Time left: 21.41h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -14.50   -15.20   39.66    0.91     c1ccc(NCc2ccccc2)cc1\n",
            " -18.59   -24.18   35.82    1.00     CCOCCCNC(=O)c1cc(C)ccc1NC(=O)[C@@H](C)OC\n",
            " -20.22   -22.12   37.58    0.99     COc1ccccc1NC(=O)CSC[C@H](C)c1ccc(C(F)(F)F)cc1\n",
            " -16.35   -19.43   40.57    1.00     CC[C@@H](C)[S@@](=O)[C@@H](C)CC(=O)Nc1cccc(C#N)c1\n",
            " -12.27   -16.78   42.65    0.99     COc1cccc(CNC(=O)CN(C)S(=O)(=O)c2ccc(C)cc2)c1\n",
            " -20.67   -20.81   38.37    0.99     Cc1ccc(S(=O)(=O)N[C@@H](c2cccc(C)c2)C(C)C)cc1C\n",
            " -19.78   -21.55   35.46    0.95     Cc1ccc(Oc2ccc(C(=O)Nc3nccs3)cc2)cc1\n",
            " -21.03   -27.75   31.89    0.99     OCCOc1ccc(/C=C\\C(=O)c2ccc(NC(=O)C(C)(C)C)cc2)cc1\n",
            " -18.94   -25.19   34.31    0.99     COc1ccc(C)cc1NC(=O)CNC(=O)CNC(=O)/C=C/c1ccc(F)cc1\n",
            " -20.36   -20.95   39.05    1.00     CCCc1cc(NC(=O)N[C@H](C)CSC)ccc1OC\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 127   Fraction valid SMILES: 92.2  Time elapsed: 0.95h Time left: 21.32h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -23.23   -31.05  -31.05    0.00     CCOCC[C@H](C)NC(=O)[C@@H](C)NS(=O)(=O)c1cc(C)c(C)n1\n",
            " -18.10   -25.17   34.83    1.00     CCOC[C@H](C)[C@@H]([NH2+]C)c1ccccc1F\n",
            " -16.27   -20.05   39.33    0.99     COc1ccccc1NC(=O)C(=O)N[C@@H](C)c1ccccc1N(C)C\n",
            " -29.93   -32.61   26.70    0.99     C[C@H](CNC(=O)C(=O)NC1CCN(C(=O)CC[C@H]2CCCO2)CC1)Nc1ccccc1\n",
            " -20.03   -26.77   32.24    0.98     Cc1nc(O)c(C(=O)N[C@@H](C)C(=O)N(C)C)c(C)c1C\n",
            " -19.93   -25.89   32.42    0.97     O=C(CNc1ccc(F)cc1O)c1ccc(F)cc1F\n",
            " -15.08   -16.81   42.06    0.98     COCCCNc1ncnc(Nc2ccc(F)cc2F)c1N\n",
            " -16.28   -19.53   37.62    0.95     CC(C)[C@@H](NC(=O)[C@](C)(N)C(=O)[O-])C(C)(C)C\n",
            " -21.30   -24.26   35.69    1.00     C[C@@H](O)CCN(C)C(=O)c1ccc(CC(=O)N(C)C)cc1\n",
            " -14.86   -20.90   38.21    0.99     CCOC(=O)CSc1ccnc(C(=O)Nc2ccccc2)c1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 128   Fraction valid SMILES: 93.8  Time elapsed: 0.95h Time left: 21.23h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -26.59   -31.36   27.76    0.99     C(=C/C(=O)NNC(=O)c1ccccc1)C(=O)N[C@@H](C)C(C)C\n",
            " -22.86   -26.36   32.74    0.98     CNC(=O)N[C@@H](CC(=O)c1ccccc1)c1ccc(F)c(F)c1\n",
            " -14.72   -19.66   40.34    1.00     CCOC(=O)[C@@H](CC)c1ccc(F)c(C)c1\n",
            " -18.74   -22.28   37.72    1.00     CSCCNC(=O)NCc1cc(C)c(F)c(C)c1\n",
            " -24.08   -32.38   27.62    1.00     C[C@@H](OC(=O)COC(=O)CC1CCC(C)(C)CC1)c1ccc(F)cn1\n",
            " -21.93   -22.10   36.67    0.98     COC([O-])=C(NC[C@]1(O)CCc2ccccc21)c1ccccn1\n",
            " -18.92   -18.95   40.09    0.98     COC(=O)c1ccccc1NC(=O)CN(C)S(=O)(=O)c1ccc(Br)cc1\n",
            " -16.27   -20.81   38.35    0.99     C[C@@H](SCC(=O)Nc1ccc(F)c(F)c1F)C(N)=O\n",
            " -16.34   -19.00   40.29    0.99     Cc1ccc(O[C@H](C)CNC(=O)c2cccc(F)c2)cc1F\n",
            " -24.85   -29.11   29.65    0.98     CCC[C@]1(C)CO[C@H](c2ccc(C)cc2)CCO1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 129   Fraction valid SMILES: 98.4  Time elapsed: 0.96h Time left: 21.15h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -21.95   -22.74   36.37    0.99     O=C(CN[C@H](c1ccccn1)c1ccc(F)cc1)NCC(F)(F)F\n",
            " -11.62   -14.51   45.46    1.00     COCCCNC(=O)Cc1ccccc1\n",
            " -20.46   -32.30   27.27    0.99     COCCn1ccc(NC(=O)CO[C@@H](C)[C@@H](C)c2ccccc2)n1\n",
            " -17.61   -22.14   37.86    1.00     COCCNC(=O)[C@@H](C)[NH2+][C@H](C)c1ccc(F)c(F)c1\n",
            " -13.66   -17.14   42.24    0.99     C[C@@H](c1ccc(S(C)(=O)=O)cc1)N(C)CCc1ccccn1\n",
            " -26.37   -26.28   33.04    0.99     CCN(CC)c1ccc(S(=O)(=O)Nc2ccc3c(c2)C(C)(C)C(=O)N3)cc1\n",
            " -16.67   -20.29   38.50    0.98     COC(=O)[C@H](C)NC(=O)CNC(=O)c1cccnc1\n",
            " -18.88   -19.21   39.38    0.98     CO[C@H]1C[C@@H](C(=O)[O-])N(C(=O)c2ccccc2)C1\n",
            " -16.85   -29.87   28.90    0.98     O[C@@H](CN[C@H](c1ccc(F)cc1)C(C)C)c1ccncc1\n",
            " -19.69   -25.14   34.04    0.99     NC(=O)Cn1c(CC(CO)CCC2CC2)nc2ccccc21\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 130   Fraction valid SMILES: 92.2  Time elapsed: 0.96h Time left: 21.05h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -20.33   -26.96   31.22    0.97     O=C(CCNC(=O)c1ccc(F)c(F)c1)NCc1ccccc1-n1cnnn1\n",
            " -16.94   -19.88   39.76    0.99     COc1ccc(CN(C)C(=O)[C@@H](NC(=O)c2ccccc2)C(C)C)cc1\n",
            " -24.15   -27.01   32.51    0.99     COCCNC(=O)COc1c(F)c(C(C)=O)ccc1OC\n",
            " -13.80   -18.05   41.66    1.00     CCNC(=O)COC(=O)[C@@H](C)Oc1ccccc1F\n",
            " -14.50   -23.31   36.69    1.00     COCCOc1ccc(NC(=O)[C@@H](C)OC(C)(C)C)cc1F\n",
            " -16.95   -22.73   36.96    0.99     CCNC(=O)CSCC(=O)Nc1ccc(F)c(N)c1\n",
            " -16.98   -17.81   41.00    0.98     COCCNCC(=O)N(C)CC1CCCCC1\n",
            " -26.91   -27.60   32.24    1.00     CCCC(=O)Oc1cc(C(C)=O)ccc1O[C@@H](C)C#N\n",
            " -17.71   -21.10   38.48    0.99     CC(=O)C[C@@H](C)c1nc(C)cs1\n",
            " -24.55   -23.72   35.77    0.99     CC(C)(C)OC[C@H]1CCCN1C(=O)Cc1ccccc1[N+](=O)[O-]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 131   Fraction valid SMILES: 95.3  Time elapsed: 0.96h Time left: 20.97h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -17.35   -22.16   37.45    0.99     CNC(=O)[C@H](C)Oc1cccc(C(=O)N(C)CCc2cccs2)c1\n",
            " -24.20   -34.63   23.84    0.97     CNC(=O)CNC(=O)CO[C@H]1CCC(O)(C(F)(F)F)CC1\n",
            " -17.30   -20.22   38.77    0.98     O=C(NCc1cccc(F)c1)c1ccnc(OCC(F)(F)F)c1\n",
            " -25.02   -32.87   26.78    0.99     CS(=O)(=O)N1CCCSC[C@H]1CC(=O)C(C)(C)c1ccccc1\n",
            " -16.35   -19.03   40.36    0.99     COc1ccc(CCNC(=O)CSc2ccccn2)cc1OC\n",
            " -16.84   -17.85   42.15    1.00     COCCNCc1cccc(OC(C)(C)C)c1\n",
            " -15.28   -20.70   38.84    0.99     COC(=O)C[C@@H](NC(=O)Nc1ccc(F)c(F)c1F)C(C)C\n",
            " -27.04   -36.90   19.99    0.95     CC(C)n1c(CNc2ncccc2C2CC2)nc[nH+]1\n",
            " -27.30   -30.62   27.15    0.96     COC(=O)CC(=O)N[C@H]1C[C@H](C(=O)OC)N(C(C)C)C1\n",
            " -29.44   -33.27   24.96    0.97     CC(C)(C)[C@H]([NH3+])C[C@](C)(O)[C@H]1CCOC(C)(C)C1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 132   Fraction valid SMILES: 96.9  Time elapsed: 0.97h Time left: 20.89h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -14.39   -22.78   35.97    0.98     FC(F)(F)Oc1ccc(CNC(=O)Nc2ccccc2)cc1\n",
            " -17.55   -25.89   34.11    1.00     CSCC[C@H](C)N(C)C(=O)CNC(=O)c1ccc(OCC(F)(F)F)cc1\n",
            " -22.54   -27.23   32.31    0.99     CC[C@@H](C)NC(=O)CN(C)C(=O)c1ccc(NC(=O)NCC(C)(C)NC(C)=O)cc1\n",
            " -14.76   -20.93   39.07    1.00     COCCCC(=O)N[C@@H](C)[C@H](C)c1ccccc1\n",
            " -11.56   -15.52   43.74    0.99     COCCNC(=O)C(=O)Nc1ccc(OC)cc1\n",
            " -17.89   -23.55   35.32    0.98     O=C(N[C@@H](c1ccccc1)C(=O)NC1CC1)c1ccc(F)c(F)c1\n",
            " -23.98   -34.34   24.90    0.99     COC(=S)N(C[C@@H](O)c1ccc(F)c(F)c1)Cc1cc(F)cc(F)c1\n",
            " -14.68   -15.60   42.86    0.97     O=C(N[C@H](CO)c1ccco1)c1cc(F)ccc1F\n",
            " -18.06   -28.37   31.63    1.00     CC(C)NC(=O)CSC[C@@H](O)c1ccc(F)c(C)c1\n",
            " -25.56   -24.58   34.07    0.98     CCN(Cc1cnn(C)c1)CC1(C[NH2+]CC2(C)CCCC2)CCC1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 133   Fraction valid SMILES: 96.9  Time elapsed: 0.97h Time left: 20.81h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -14.57   -20.03   36.85    0.95     CNC(=O)CSCC(=O)N[C@H](C)CO\n",
            " -23.71   -28.67   30.16    0.98     [NH3+]C[C@H](c1ccncc1)[C@@H](O)c1ccc(F)c(C(F)(F)F)c1\n",
            " -28.11   -29.61   28.64    0.97     CCCSc1nc(-c2ccco2)nc([O-])c1-c1cccc(C(=O)N2CCCC2)c1\n",
            " -17.38   -27.09   32.91    1.00     C[C@H](CC(C)C)NC(=O)[C@H](C)Oc1ccc(F)c(F)c1\n",
            " -13.04   -21.31   38.54    1.00     COCCN(C)C(=O)CNC(=O)Cc1ccc(F)c(F)c1\n",
            " -19.91   -21.61   36.16    0.96     CC[C@@H](C)SCC(=O)N[C@H](C)C(N)=O\n",
            " -19.21   -30.74   29.25    1.00     O=C(CCC(=O)NCC(F)(F)F)C(=O)NCC(C)(C)c1ccccc1\n",
            " -15.90   -19.01   39.62    0.98     CN(C)C(=O)CCCNC(=O)C(=O)NC1CCC(C)CC1\n",
            " -30.05   -46.94   12.62    0.99     COCCc1nc(CNC(=O)NCCc2ccc(F)c(F)c2)cc(C(N)=O)c1F\n",
            " -15.21   -25.95   33.23    0.99     CNC(=O)CNC(=O)COc1cccc(C(=O)Nc2cccc(F)c2)c1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 134   Fraction valid SMILES: 98.4  Time elapsed: 0.98h Time left: 20.74h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -19.65   -24.37   35.42    1.00     CSCC(=O)NNC(=O)C[C@@H](C)Oc1ccc(OC(C)C)cc1\n",
            " -31.96   -47.46   11.15    0.98     Cc1cc([C@H](c2ccc(O)c(C(=O)[O-])c2)NC(=O)C(c2ccccc2)NC(=O)[C@H]2CCCO2)oc1C\n",
            " -20.22   -20.85   38.07    0.98     O=C(c1ccc(F)cc1F)N1CCN(Cc2ccc(F)c(C(F)(F)F)c2)CC1\n",
            " -20.66   -21.11   37.35    0.97     C[C@@H](CC(=O)Nc1ncncc1N)c1ccccc1\n",
            " -16.49   -17.59   41.46    0.98     Cc1ccc(CNC(=O)NNC(=O)[C@@H]2CCCO2)cc1\n",
            " -19.52   -22.57   37.33    1.00     CCC(CC)[NH2+]CC(C)(C)Oc1cccnc1\n",
            " -24.60   -27.21   31.19    0.97     O=C(CSc1nc(COc2ccccc2)cs1)N[C@@H]1CCCC[C@H]1Cc1ccccc1\n",
            " -17.10   -23.08   36.41    0.99     COCCN1CCN(C(=O)N[C@@H](C)c2ccc(NC(=O)C(C)C)cc2)CC1=O\n",
            " -17.89   -22.41   37.09    0.99     C[C@@H](c1ccccc1)N(C)C(=O)CNC(=O)CNC(=O)c1ccc(F)cc1\n",
            " -16.99   -22.89   36.48    0.99     CCOC(=O)CCN(C)C(=O)c1cnc([C@@H](C)OC)s1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 135   Fraction valid SMILES: 92.2  Time elapsed: 0.98h Time left: 20.66h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -23.89   -30.51   28.12    0.98     CC(C)(O)c1nccn1CC(C)(C)c1ccncc1\n",
            " -19.82   -24.60   35.08    0.99     C[C@H](OCCOc1cc(F)ccc1F)C(=O)N[C@H](C)c1ccc(F)cc1\n",
            " -13.27   -18.54   40.37    0.98     O=C(OC(C)(C)C)C1CCC(O)CC1\n",
            " -21.86   -25.28  -25.28    0.00     CCCS(C)(=O)=Oc1ccc(C(=O)Nc2ccccc2C)cc1\n",
            " -18.92   -23.43   36.18    0.99     O=C(CNC(=O)Cc1cccs1)Nc1ccccc1C(=O)NC(C)(C)C\n",
            " -23.27   -27.57   31.88    0.99     CCCCC[C@@H](C)NC(=O)c1nnc(CNC(C)=O)s1\n",
            " -25.26   -27.40   30.32    0.96     Oc1ccc(OCC(=O)[O-])cc1OC(F)(F)C(F)F\n",
            " -15.44   -18.21   40.89    0.99     O=C(CSc1ccc(F)cc1)NCc1ccccc1OC(F)(F)F\n",
            " -21.42   -26.48   33.33    1.00     CCN(C(C)=O)C[C@H](N)c1ccc(C)s1\n",
            " -17.98   -21.07   38.35    0.99     COC(=O)c1ccc(N2CCN(C(=O)C(C)C)CC2)nc1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 136   Fraction valid SMILES: 95.3  Time elapsed: 0.98h Time left: 20.58h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -17.99   -23.75   35.68    0.99     Cc1nn([C@@H](C)C(=O)NCCc2ccc(F)cc2)c(=O)c(C#N)c1C\n",
            " -18.90   -21.16   36.59    0.96     CNC(=O)c1ccc(OC(=O)[C@@H](c2ccccc2)n2cccc2)cc1\n",
            " -16.14   -24.58   35.17    1.00     C[C@@H](NC(=O)CNc1ccc(C(N)=O)c(C)c1)c1ccc(C(C)(C)C)cc1\n",
            " -15.80   -19.37   40.16    0.99     CCOc1ccc(NC(=O)CNC(=O)c2ccc(OC)cc2)cc1C\n",
            " -16.44   -19.62   39.81    0.99     Cc1cc(NC(=O)[C@@H](C)Oc2ccccc2F)ccc1N(C)C\n",
            " -20.16   -23.19   35.81    0.98     CC[NH2+][C@H](C)[C@@H](C)c1cc(F)ccc1Oc1ccccc1\n",
            " -25.66   -28.06   31.39    0.99     CC[C@@H](C)NS(=O)(=O)CCNC(=O)c1cn(C)nc1-c1cccc(F)c1\n",
            " -13.08   -15.90   44.09    1.00     CCC[NH2+]Cc1cc(F)c(OC)c(OC)c1\n",
            " -14.09   -17.38   41.95    0.99     O=C(CCc1ccc(F)c(F)c1)NC[C@H](c1ccccc1)N1CCOCC1\n",
            " -22.30   -20.19   39.67    1.00     CC[C@](C)(NC(=O)C[C@H](C)c1ccccc1Cl)C(=O)[O-]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 137   Fraction valid SMILES: 93.8  Time elapsed: 0.99h Time left: 20.50h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -13.58   -15.20   42.96    0.97     CCC[NH2+][C@H](COC(C)C)C(C)C\n",
            " -19.62   -23.29   34.99    0.97     Cc1cc(=O)[nH]c(-c2ccccc2)c1C(=O)NCC(=O)[O-]\n",
            " -14.10   -18.10  -18.10    0.00     O=C(CNC(=O)c1ccc(OCC(F)F)n1)Nc1ccc(F)cc1\n",
            " -15.31   -19.60   40.06    0.99     Cc1noc(CN(C)C(=O)NCCC(C)(C)c2ccccc2)n1\n",
            " -17.62   -19.55   40.26    1.00     CC[S@@](=O)[C@@H](C)CNC(=O)Nc1cccc(C(=O)N2CCCCC2)c1\n",
            " -17.35   -18.05   40.67    0.98     O=C(CSc1ccccc1)NCc1ccc(C#N)cc1\n",
            " -23.20   -29.41   30.09    0.99     CC(C)COCCNC(=O)C1CCN(Cn2c(N)ccc2C)CC1\n",
            " -19.60   -22.48   36.94    0.99     Oc1cc(F)cc(CNC(=O)N2CCCCCC2)c1F\n",
            " -20.65   -24.69   34.86    0.99     CCOc1ncc(CNc2cccc(C(=O)N(C)C)c2)cc1C\n",
            " -17.68   -21.64   37.70    0.99     COc1cc(C(=O)NCCc2ccccc2OC)cc(OC)c1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 138   Fraction valid SMILES: 96.9  Time elapsed: 0.99h Time left: 20.43h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -16.44   -22.21   37.16    0.99     COC(=S)N[C@@H](C)c1ccncc1\n",
            " -20.04   -16.89   40.79    0.96     O=C(NCc1cccc(Cn2cccnc2=O)c1)Nc1cccc(F)c1\n",
            " -12.87   -16.88   41.62    0.98     COC(=O)C1(N)CCCCC1\n",
            " -18.22   -19.25   39.75    0.98     COc1ccccc1NC(=O)Nc1ccc(NC(=O)NC(C)C)cc1\n",
            " -16.96   -26.10   30.88    0.95     CC(C)[C@H](O)c1cnn(Cc2ccccc2)c1-c1ccncc1\n",
            " -22.89   -25.89   33.96    1.00     Cc1ccc(OCCCCNC(=O)Cc2ccc(OCC#N)cc2)cc1\n",
            " -27.59   -29.61   29.17    0.98     C[C@@H](SCC(=O)Nc1cc([N+](=O)[O-])ccc1C(=O)N1CCN(C(=O)c2ccccc2F)CC1)c1ccccc1\n",
            " -21.04   -23.17   35.25    0.97     Cc1ccn(C(=O)CCc2nc(C)cs2)n1\n",
            " -13.86   -19.72   39.42    0.99     CCCCNC(=O)CNC(=O)CNC(=O)c1ccco1\n",
            " -17.59   -24.67   31.92    0.94     CCCNC(=O)CCNC(=O)CNS(C)(=O)=O\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 139   Fraction valid SMILES: 93.8  Time elapsed: 1.00h Time left: 20.36h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -21.22   -23.83   35.95    1.00     CCc1onc(C)c1NC(=O)NC(CC)C1CCCC1\n",
            " -19.56   -21.93   38.02    1.00     COC(=O)C[C@H](C)N[C@H](C)c1cc(F)c(OC)c(F)c1\n",
            " -19.35   -26.18  -26.18    0.00     CCc1noc(CN(C)C(=O)[C@@H](NC(=O)C2CCCC2)c2ccccc2)C1\n",
            " -17.15   -20.91   38.47    0.99     O=C(c1ccc(F)c(F)c1)N1CCC(C(=O)NCC(F)(F)F)CC1\n",
            " -18.87   -26.41   33.34    1.00     CCOC(=O)CNC(=O)[C@H](C)Nc1cc(C#N)ccc1C\n",
            " -34.52   -37.39   22.33    1.00     CC1(C)C[C@H](CNC(=O)C(=O)CSc2ccccc2)C[C@@H](C)[C@H]1O\n",
            " -18.31   -21.84   37.84    0.99     Cc1cc(C(=O)NCCNC(=O)N(C)[C@@H](C)C(C)C)c(C)o1\n",
            " -20.45   -21.55   37.58    0.99     C[C@@H](Sc1ccncc1)C(=O)N1CCN(Cc2ccc(F)cc2)CC1\n",
            " -16.50   -25.02   34.91    1.00     C[C@@H](CNC(=O)Cc1ccc(O)cc1)NC(C)(C)C\n",
            " -16.59   -16.90   42.17    0.98     CCOC(=O)c1c(NC(C)=O)sc(C(N)=O)c1-c1ccccc1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 140   Fraction valid SMILES: 96.9  Time elapsed: 1.00h Time left: 20.29h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -25.22   -30.41  -30.41    0.00     CC[C@H](CC1CCCCC1)C(=O)N[C@@H](C)C(C)(C)C#N)c1C\n",
            " -17.39   -18.41   41.59    1.00     CCC(CC)[C@@H](C)[NH2+][C@@H](CO)c1ccc(F)c(F)c1\n",
            " -21.18   -22.27   36.86    0.99     O=C(CCNC(=O)c1cc(Cl)ccc1Cl)N/N=C/c1ccc(Cl)cc1\n",
            " -18.63   -27.42   31.89    0.99     CCCCNC(=O)Cn1cnc(NC(=O)CNC(=O)C2CCCCC2)c1\n",
            " -28.40   -35.11   24.64    1.00     C[C@@H](NC(=O)CN1CC[S@@](=O)C(C(C)(C)C)C1)[C@H](O)c1ccccc1F\n",
            " -19.53   -21.76   37.74    0.99     CCS(=O)(=O)[C@H](C)C(=O)Nc1cccc(C(=O)Nc2ccccc2C)c1\n",
            " -22.55   -26.83   33.17    1.00     CC[C@@H](C)CN(C)C(=O)[C@H](C)SCc1cc(C)ccn1\n",
            " -16.35   -23.25   36.45    0.99     O=C(CNC(=O)C1CCCCC1)Nc1ccc(F)c(CO)c1\n",
            " -25.79   -37.61   21.90    0.99     CCCCCNC(=O)CN1C(=O)C(C(=O)OC)(C2CC2)[C@H](c2ccccc2)C1=O\n",
            " -22.35   -22.22   36.84    0.98     CC(=O)N(C)S(=O)(=O)N1CCC(C(=O)Nc2ccc(F)cc2F)CC1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 141   Fraction valid SMILES: 100.0  Time elapsed: 1.00h Time left: 20.22h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -18.64   -20.16   39.12    0.99     COC1CCN(C(=O)c2cccc(NC(=O)CCc3ccccc3)c2)CC1\n",
            " -15.41   -16.92   42.34    0.99     Cc1cc(F)ccc1NC(=O)CNC(=O)c1ccccc1C\n",
            " -16.54   -24.07   35.05    0.99     CNC(=O)NCCS(=O)(=O)NCCc1ccc(F)c(F)c1\n",
            " -19.44   -17.22   40.24    0.96     NC(=O)CSc1nc(-c2ccc3c(c2)OCO3)cs1\n",
            " -21.96   -29.05   30.02    0.98     O=C(CCc1cccc(F)c1)NCCOc1ncccc1C(=O)[O-]\n",
            " -19.62   -24.40   33.52    0.97     CC(C)[NH2+]C[C@H](O)CSC[C@H](C)C[C@@H](C)O\n",
            " -24.01   -25.27   32.86    0.97     C[C@@H](CNS(N)(=O)=O)c1ccc(O)cc1\n",
            " -16.65   -21.81   38.19    1.00     CN(C(=O)CN(C)Cc1cc(F)cc(F)c1)C1CCCCC1\n",
            " -27.89   -36.20   22.30    0.98     C[C@@H](OCCOCC1CCCCC1)C(=O)NCCCCNC(N)=O\n",
            " -25.00   -24.64   33.31    0.97     COc1cccc(CN[C@H](C)c2cncc(-n3nc(C)cc3C)c2)c1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 142   Fraction valid SMILES: 95.3  Time elapsed: 1.01h Time left: 20.15h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -27.84   -34.49   24.52    0.98     CS(=O)(=O)NCCNC(=O)CN(C)S(=O)(=O)/C=C/c1ccc(OC2CCCC2)cc1\n",
            " -18.21   -33.59   25.68    0.99     Nc1nc(CNCCO)cc(C(F)(F)F)c1\n",
            " -17.63   -23.31   36.09    0.99     CCCCS(=O)(=O)CCNC(=O)N[C@@H](c1ccccc1)c1nccn1C\n",
            " -22.92   -33.44   26.24    0.99     C[C@H](CNC(=O)N[C@@H](C)CCO)NC1(C)Cc2ccccc2C1\n",
            " -21.24   -23.72   35.46    0.99     CCNC(=O)CNC(=O)[C@@H](C)OC(=O)c1nn(C)c2ccccc12\n",
            " -17.07   -23.05   36.90    1.00     CCCNC(=O)[C@@H](C)SCC(=O)N[C@H](C)c1ccncc1\n",
            " -21.19   -20.78   37.61    0.97     C[C@H](CNC(N)=O)N(C)C(=O)c1cscn1\n",
            " -16.34   -18.17   41.83    1.00     CCNC(=O)COc1cccc(Cl)c1C\n",
            " -14.15   -20.15   38.29    0.97     CCCN(CCO)CC(C)(C)C\n",
            " -22.89   -34.20   24.99    0.99     NC(=O)CONC(=O)C(=O)Nc1ccc(OCC(C)(C)F)cc1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 143   Fraction valid SMILES: 96.9  Time elapsed: 1.01h Time left: 20.09h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -24.40   -27.50   31.92    0.99     CC[C@@H](NC(=O)C[S@@](=O)c1ccccn1)[C@H](C)c1ccccc1\n",
            " -13.52   -19.79   37.55    0.96     CCNC(=O)CNC(=O)N[C@@H](C)C(C)C\n",
            " -26.03   -30.70  -30.70    0.00     O=C(OC(C)C)c1cnc[nH]c1NCc1ccccn1\n",
            " -24.56   -25.82   33.29    0.99     Cc1cccc([C@@H](N)CN2CCN(C(=O)C(=O)Nc3ccccc3)CC2)c1\n",
            " -25.19   -36.59   22.82    0.99     CCNC(=O)[C@@H](NC(=O)NCCNC(=O)c1ccccc1)CC\n",
            " -26.64   -26.02   33.63    0.99     CCNC(=O)CO[C@H](C)[C@H]([NH3+])c1ccc(OC)cc1OC\n",
            " -25.93   -27.38   31.83    0.99     COc1ccc(NC(=O)COC(=O)N2CCN(c3ccccc3F)CC2)cc1OC\n",
            " -16.65   -19.49   40.19    0.99     COc1ccccc1NC(=O)CN1CCN(C(=O)C(C)(C)OC)CC1\n",
            " -14.85   -17.26   41.79    0.98     CCOC(=O)Nc1ccc(NC(=O)C[C@H](O)c2ccccc2)cc1\n",
            " -16.46   -22.99   36.98    1.00     CCCOCCNC(=O)Nc1ccc(OC(C)C)c(OC)c1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 144   Fraction valid SMILES: 95.3  Time elapsed: 1.02h Time left: 20.02h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -21.15   -22.35   37.20    0.99     CCN(CC)C(=O)NCc1ccc(NC(=O)/C=C\\c2cccs2)cc1\n",
            " -15.55   -18.15   40.13    0.97     CCCCN(C)C(=O)N[C@H](C)C(C)C\n",
            " -17.62   -23.61   33.71    0.96     NC(=O)CNC(=O)[C@@H]1C[C@@H]2CCCCN2C1=O\n",
            " -13.46   -17.23   42.48    1.00     NC(=O)C1CCN(C(=O)CCC(=O)c2ccc(F)cc2)CC1\n",
            " -27.87   -29.66   30.21    1.00     CCN(C)c1ccc(NC(=O)CCC(=O)Nc2ccc(F)c(C(=O)N(C)C)c2)cc1\n",
            " -22.04   -38.08   21.13    0.99     CCNC(=O)NCCCNC(=O)CNC(=O)CN1CCN(C(=O)c2ccc(F)cc2)CC1\n",
            " -23.10   -38.36   20.36    0.98     C[C@H](CNC(=O)c1ccoc1)CNC(=O)C(=O)Nc1ccc(F)c(C(=O)[O-])c1\n",
            " -20.62   -29.21   29.69    0.98     CC[C@](C)(CO)NC(=O)CN1CCN(C(=O)Nc2ccnn2Cc2ccccn2)CC1\n",
            " -15.44   -22.36  -22.36    0.00     CCNC(=O)NC(=O)CSc1nc([O-])cc(C(C)=O)c1=O\n",
            " -22.67   -25.76   32.63    0.97     CS(=O)(=O)Nc1ccccc1COc1ccc(C[NH2+]Cc2ccccc2)cc1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 145   Fraction valid SMILES: 95.3  Time elapsed: 1.02h Time left: 19.95h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -12.27   -15.67   43.94    0.99     C[C@H](CNC(=O)CC1(O)CCCCC1)c1ccccc1\n",
            " -15.78   -21.38   38.48    1.00     CCNC(=O)NC(C)(C)COCc1ccncc1\n",
            " -15.27   -15.92   43.40    0.99     CCc1ncc(CN(C)C(=O)c2ccc(OC)c(OC)c2)s1\n",
            " -17.18   -25.13   33.29    0.97     CCNC(=O)c1cnn([C@@H](C)C(=O)N2CCNCC2)c1\n",
            " -19.28   -20.50   38.41    0.98     C[C@H](SCC(=O)N[C@H](C)c1ccncc1)c1nccs1\n",
            " -21.66   -21.11   36.72    0.96     CCOc1ccc(C(=O)Nc2ccc(F)c(-n3cccc3)c2)cc1\n",
            " -32.88   -33.63   23.81    0.96     COc1cc(CN/C=C/c2ccccn2)ccc1SCc1nccs1\n",
            " -22.07   -24.97   34.57    0.99     CC(C)[C@@H](C)NS(=O)(=O)c1cc(C(=O)N2CCCCC2)ccc1N\n",
            " -26.71   -40.83   17.84    0.98     O=C(c1cccc(F)c1)N(CCN(Cc1cccs1)Cc1ccccn1)C1CCCCC1\n",
            " -18.22   -20.68   38.37    0.98     Cc1nn(C)c(C)c1CCNC(=O)N1CC[C@H](C)[C@@H](O)C1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 146   Fraction valid SMILES: 89.1  Time elapsed: 1.02h Time left: 19.88h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -21.21   -24.96   34.37    0.99     CCc1nc(C)nc(N(C)Cc2ccc(C(N)=O)cc2)c1C\n",
            " -21.01   -25.51   33.59    0.98     CC(C)CCNC(=O)N[C@@H](C)C[C@@H]1CCCCCC1=O\n",
            " -22.07   -28.67   28.64    0.96     O=C(c1cnn(-c2ccccn2)c1)N(CCNC(=O)Cc1ccccc1)c1ccccc1\n",
            " -12.24   -19.16   36.67    0.93     COCCNC(=O)NCCCNC(N)=O\n",
            " -26.45   -40.18   18.47    0.98     COCCNC(=O)[C@@H](C)NC(=O)CS[C@@H]1NN=CC=C1C(=O)Nc1ccc(F)cc1\n",
            " -25.52   -27.55  -27.55    0.00     Cc1nc(COC(=O)c2cnn(-c3cccc(F)c3)c2=O)cs1\n",
            " -13.75   -20.80   38.63    0.99     CCNC(=O)CNC(=O)NCCCc1ccccn1\n",
            " -19.41   -20.85   38.44    0.99     CC(C)NC(=O)c1cccc(C(=O)N[C@@H](C)c2ccc(C)cc2)c1\n",
            " -17.98   -22.12   36.14    0.97     O=C(OCCC(=O)[O-])c1cc(F)ccc1F\n",
            " -14.97   -18.43   39.75    0.97     O=C(CCc1ccccn1)NCc1cccnc1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 147   Fraction valid SMILES: 95.3  Time elapsed: 1.03h Time left: 19.81h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -13.28   -17.12   42.13    0.99     CCCCCNC(=O)C1CCN(C(=O)C(C)(C)C)CC1\n",
            " -17.89   -22.86  -22.86    0.00     COc1ccc(NC(=O)Cn2cnc(C(=O)NC)cc2)cc1\n",
            " -23.41   -27.64   31.59    0.99     C[C@@H]1CCCC[C@@H]1OCCCNC(=O)NC[C@@H](c1ccccc1)N1CCOCC1\n",
            " -13.45   -18.62   40.51    0.99     CCN(CC)c1ncnc(NNC(=O)c2ccc(C)c(F)c2)c1N\n",
            " -21.63   -26.68   32.32    0.98     CCC[C@]1(CC)CC(=O)NC(=O)N[C@H]1c1ccccc1ON\n",
            " -19.49   -24.11   35.33    0.99     C[C@@H](NC(=O)CN1CCN(CC(F)(F)F)CC1)C(=O)c1cccs1\n",
            " -15.05   -19.42   40.58    1.00     CCC(CC)CC(=O)NNC(=O)c1cccc(OC)c1\n",
            " -23.30   -29.24   30.07    0.99     Cc1cc(=O)c(C(=O)N2C[C@@H](C)O[C@@H](C)C2)ccc1C\n",
            " -17.22   -19.24   40.32    0.99     CC[C@@H](C)NC(=O)CNC(=O)C(=O)Nc1ccc(C(F)(F)F)cc1\n",
            " -32.24   -32.41   25.95    0.97     CC(=O)NCNCCC(=O)N[C@@H]1CCCC[C@@H]1NC(=O)OC(C)(C)C\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 148   Fraction valid SMILES: 95.3  Time elapsed: 1.03h Time left: 19.74h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -13.10   -17.92   40.86    0.98     NC(=O)CONC(=O)CCC1=c2ccccc2=[NH+]C1\n",
            " -24.64   -37.51   22.05    0.99     CC[NH2+]C[C@@H](Cc1cccc(OC)c1)C1CCN(C(=O)c2ccc(=O)n(C)c2)CC1\n",
            " -23.12   -25.06   33.40    0.97     O=C(Nc1ccccc1)N1CCN(C(=O)C(=O)NCCC[NH+]2CCCCC2)CC1\n",
            " -18.75   -22.97   34.60    0.96     C[C@H](CNC(=O)CNC(N)=O)N1CCCCC1\n",
            " -24.38   -24.85   34.37    0.99     CSc1nc2ccccc2cc1C(=O)O[C@H](C)[C@H]1CN(C)CCO1\n",
            " -16.87   -17.78   41.48    0.99     COc1ccc(NC(=O)[C@@H](NC(=O)C(C)C)c2ccccc2)cc1\n",
            " -12.56   -18.42   40.37    0.98     NC(=O)CNC(=O)CNC(=O)c1c(F)cccc1F\n",
            " -19.05   -19.49   39.27    0.98     COCCNCC(=O)N1CCC[C@](C)(C(=O)OCC)C1\n",
            " -14.52   -17.59   42.41    1.00     CCC(C)(C)NC(=O)CNc1ccc(F)cc1C\n",
            " -14.79   -21.90   37.97    1.00     CCCCOCCNC(=O)c1cnn(C(C)C)c1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 149   Fraction valid SMILES: 95.3  Time elapsed: 1.04h Time left: 19.68h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -18.58   -18.71   39.64    0.97     CCc1ncc(CNC(=O)N2CCCN(S(C)(=O)=O)CC2)s1\n",
            " -16.10   -19.51   38.64    0.97     CC[C@@H](C)NC(=O)NNC(=O)c1cnn(C)c1\n",
            " -13.16   -20.34   39.12    0.99     CCCNC(=O)CN(C)S(=O)(=O)Cc1ccccc1N\n",
            " -24.31   -31.13   28.10    0.99     Cc1cc(CNC(=O)CNC(=O)N[C@H](C)c2ccc(NC(=O)c3ccccc3F)cc2)c(C)o1\n",
            " -18.45   -23.77   34.85    0.98     CCN[C@H](c1ccncc1)[C@@H]1CN(C)CCS1\n",
            " -15.84   -19.08   40.28    0.99     CC[C@@H](NC(=O)CN1CCN(CC(F)(F)F)CC1)c1nccs1\n",
            " -34.71   -44.07   14.97    0.98     O=C(COC(=O)COc1ccc(Cl)c(Cl)c1)\\c1nnn(C2CCCC2)c1\n",
            " -20.28   -21.24   37.19    0.97     CC(C)(C)NC(=O)NC[C@@H]1CCCN(C(=O)NC2CCCCC2)C1\n",
            " -44.11   -51.23  -51.23    0.00     CCc1ccc(N(C[C@H]2CCC[C@H]2O)C(=O)[C@H]2c3cc(C)ccc3C)ccc1O[C@H]1CCOC2(CCCC2)C1\n",
            " -17.43   -21.53   37.69    0.99     CCOC(=O)[C@](NC(=O)Cc1cnn(C)c1)c1ccccc1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 150   Fraction valid SMILES: 96.9  Time elapsed: 1.04h Time left: 19.61h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -18.72   -18.14   40.46    0.98     O=C(NCc1ccccc1F)c1ccnc(N2CCCC2)c1\n",
            " -25.20   -23.44  -23.44    0.00     Cc1nc2ccc(C)cc2c1[C@@H](O)C(C)C\n",
            " -20.82   -25.46   33.86    0.99     CCOc1ccc(CNc2ccccc2NC(=O)CC)nc1\n",
            " -16.85   -20.60   39.19    1.00     CCOC(=O)CCNC(=O)C1CCN(C(=O)COc2ccc(F)cc2)CC1\n",
            " -22.58   -22.98   33.73    0.95     COc1ccc(N[C@H](C)[C@H](c2ccccc2)c2cccs2)cc1\n",
            " -21.25   -23.56   35.71    0.99     CCc1ccc(OCCNC(=O)Nc2ccc(F)cc2)nc1\n",
            " -19.59   -23.26   36.19    0.99     CCNC(=O)CNC(=O)N1CCC(N[C@@H](C)c2ccccc2)CC1\n",
            " -14.70   -19.08   39.85    0.98     CNS(=O)(=O)c1cccc(NC(=O)CNC(=O)Cc2ccccc2)c1\n",
            " -19.94   -29.80   29.43    0.99     O=C(CNC(=O)C1=Cc2ccccc2OC1)NCCC(=O)c1ccc(F)cc1\n",
            " -18.00   -29.10   30.15    0.99     CNC(=O)CCSCC(=O)N[C@@H](c1ccccc1)c1cccs1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 151   Fraction valid SMILES: 96.9  Time elapsed: 1.04h Time left: 19.55h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -20.63   -23.55   36.29    1.00     CCC[C@]1(CO)CCN(C(=O)NC[C@@H](C)c2ccccc2)C1\n",
            " -16.28   -21.57   38.13    0.99     COc1cccc(NC(=O)CNC[C@]2(C)CCCO2)c1\n",
            " -19.42   -25.44   33.23    0.98     OC[C@H](O)CNc1cccc(CCN2CCOCC2)c1\n",
            " -20.18   -24.14   35.22    0.99     COc1ccc(OCC(=O)Nc2ccc(OCC(=O)NC3CCCC3)cc2)cc1\n",
            " -20.48   -22.80   36.44    0.99     O[C@@H](c1ccc(Cl)cn1)[C@]1(O)CCCC1(C)C\n",
            " -14.01   -18.92   39.66    0.98     CCCNC(=O)[C@H](C)Sc1nnc(NC(C)=O)s1\n",
            " -19.09   -21.55   38.45    1.00     CCCCNC(=O)NCC(=O)N1CCC(c2cc(C)ccc2C)CC1\n",
            " -22.43   -31.41   26.18    0.96     C[C@H](Oc1ccc(OCC)cc1)c1nc(-c2cnn(C)c2)no1\n",
            " -18.43   -24.59   35.06    0.99     CNC(=O)NCCC(=O)N[C@@H](C)CN1CCCc2ccccc21\n",
            " -14.39   -18.87   40.34    0.99     CC(C)NC(=O)CNC(=O)Nc1ccc(C#N)cc1F\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 152   Fraction valid SMILES: 100.0  Time elapsed: 1.05h Time left: 19.49h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -21.03   -27.26   31.84    0.99     CCn1cnnc1[C@@H]1CCN(C(=O)CCc2cccc(C(N)=O)c2)C1\n",
            " -27.28   -32.47   26.25    0.98     COc1nc(C(C)(C)C)ccc1OS(=O)(=O)c1cccc(C(=O)Nc2ccccn2)c1\n",
            " -17.40   -23.76   36.02    1.00     Cc1cccc(CNC(=O)CNC(=O)NCCc2ccc(C(C)C)cc2)c1\n",
            " -14.42   -18.49   41.11    0.99     CCNC(=O)[C@H](C)Nc1cccc(C(=O)NC)c1\n",
            " -15.05   -16.53   42.03    0.98     CCOc1ncnc(N(C)Cc2ccccc2)c1N\n",
            " -21.76   -28.39   30.56    0.98     CC[S@@](=O)[C@H](C)CNC(=O)C1=NNCCN1c1ccccc1\n",
            " -22.45   -22.24   37.21    0.99     Cc1csc(CCCNC(=O)[C@@H](C)NC(=O)NC2CCCC2)n1\n",
            " -22.63   -36.58   22.83    0.99     CC[NH2+]CCNCCNC(=O)CNC(=O)c1cc(C)sc1C\n",
            " -20.58   -20.21   39.48    0.99     COC(=O)CNC(=O)N(C)Cc1cccc(Cl)c1\n",
            " -19.93   -22.48   36.74    0.99     CCNC(=O)c1cccc(NCc2ccc(C)cc2F)n1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 153   Fraction valid SMILES: 96.9  Time elapsed: 1.05h Time left: 19.43h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -15.05   -19.12   38.99    0.97     NC(=O)CNC(=O)c1ccncc1N\n",
            " -14.34   -22.50   36.35    0.98     C[C@@H](NC(=O)CNC(=O)OCCO)c1cccnc1\n",
            " -26.32   -45.64   13.84    0.99     CCCO[C@H]1CCNC(=O)N[C@H]1c1cccc(OC(=O)/C=C/C(C)=C)c1\n",
            " -13.75   -18.76   39.93    0.98     CNC(=O)COc1cccnc1\n",
            " -16.80   -21.02   38.39    0.99     COC(=O)[C@H](CC(C)C)NC(=O)CNC(=O)c1ccncc1\n",
            " -15.22   -21.05   38.30    0.99     CNC(=O)[C@@H](CC(=O)Nc1cc(C)cc(C)c1)c1ccccc1\n",
            " -16.33   -23.87   33.63    0.96     CCCCOCCNC(=O)CN1CCN(CC[NH3+])CC1\n",
            " -12.86   -19.30   39.56    0.98     Cc1ccccc1NC(=O)CNC(=O)NCc1ccncc1\n",
            " -18.70   -20.53   38.49    0.98     COc1ccc(NCc2ccnn2C)cc1OC(C)C\n",
            " -24.11   -24.31   35.00    0.99     CCCC[C@H]1NC(=O)N(CC(=O)c2ccccc2OC)C1=O\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 154   Fraction valid SMILES: 98.4  Time elapsed: 1.06h Time left: 19.37h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -23.28   -22.75   36.59    0.99     CCCn1ccnc1C[C@@H](O)[C@H](O)CC(C)C\n",
            " -18.46   -25.28   34.72    1.00     CCO[C@@H](C)CNC(=O)Cc1cccc(CNC(C)=O)c1\n",
            " -18.41   -24.90   33.78    0.98     O=C(NCC(=O)N1CCCCCCC1)c1cnn(C[C@H]2CCCO2)c1\n",
            " -15.81   -23.85   34.96    0.98     CS(=O)(=O)NCCCCNC(=O)NCc1cccnc1\n",
            " -25.58   -30.63   29.26    1.00     CC1CCN(C(=O)CCCCOC(=O)c2ccncc2)CC1\n",
            " -13.33   -17.60   42.00    0.99     CCCNC(=O)CN1CCN(C(=O)Nc2ccc(OCC)cc2)CC1\n",
            " -21.13   -26.79   33.07    1.00     CCOC(=O)CNCC(=O)N[C@@H](C)c1cccc(N2CCCC2)c1\n",
            " -19.94   -23.71   35.42    0.99     Cc1ccccc1N1CCN(C(=O)c2ccc(O[C@H](C)C)cc2)CC1\n",
            " -20.59   -22.20   36.64    0.98     C[NH2+][C@H](Cc1cccc(OCC)c1)c1cccc(F)c1\n",
            " -13.82   -18.78   40.01    0.98     CCOC(=O)CCNC(=O)NNC(=O)c1ccc(C#N)cc1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 155   Fraction valid SMILES: 96.9  Time elapsed: 1.06h Time left: 19.31h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -15.87   -22.46   36.32    0.98     COCCOc1ncccc1NC(=O)NCCc1cnn(C)c1\n",
            " -18.71   -23.72   35.75    0.99     CC[C@](C)(NC(=O)NCc1ccc(C(=O)NC)cc1)c1ccccn1\n",
            " -28.43   -43.64   15.29    0.98     C=CCNCCNC(=O)C(=O)Nc1cnn(CCC(=O)NCc2cccnc2)c1\n",
            " -17.80   -15.53   44.24    1.00     CCCC(=O)Oc1cccc(C)c1\n",
            " -15.82   -20.13   37.92    0.97     NC(=O)CNC(=O)NCc1nc(C(F)(F)F)cs1\n",
            " -18.33   -19.93   38.49    0.97     CCCNC(=O)CNC(=O)N1CCCC[C@H]1C1CCCC1\n",
            " -13.75   -20.33   38.72    0.98     C[C@@H](CNC(=O)C1CCN(C(=O)Nc2ccccc2)CC1)c1ccncc1\n",
            " -16.46   -20.03   38.97    0.98     O=C(OCc1ccccc1)C1CCN(C(=O)/C=C/c2cccnc2)CC1\n",
            " -16.22   -20.72   38.27    0.98     C[C@@H](CS(C)(=O)=O)NC(=O)N[C@H](C)c1cnn(-c2ccccc2)c1\n",
            " -20.41   -26.04   33.38    0.99     CCn1c(CNC(=O)Cc2ccccc2F)cn1C\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 156   Fraction valid SMILES: 93.8  Time elapsed: 1.06h Time left: 19.25h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -16.37   -22.37  -22.37    0.00     CNC(=S)N1CCN(CCO)C(C)C\n",
            " -19.72   -23.34   36.66    1.00     CCCSCCSCC(=O)Nc1cccc(Cl)c1\n",
            " -18.28   -25.21   34.50    1.00     CCCCNC(=O)CNC(=O)C1CCN(C(=O)C(=O)Nc2cc(C)ccc2F)CC1\n",
            " -16.34   -19.46   39.76    0.99     CC[C@@H](C)CN(CC)c1ccc(C[NH3+])cc1[N+](=O)[O-]\n",
            " -17.91   -19.08   38.78    0.96     O=C([O-])c1nnc(NC(=O)CCc2ccccc2)s1\n",
            " -16.72   -25.52   33.38    0.98     COCCNC(=O)CNC(=O)[C@@H]1CCCN(C(=O)Nc2ccccn2)C1\n",
            " -15.72   -18.74   40.90    0.99     CCOC(=O)C1CCN(Cc2ccc(NC=O)cc2)CC1\n",
            " -17.37   -20.38   39.26    0.99     CSCC[C@@H](C)NC(=O)N1CCN(C(=O)Nc2cccc(Cl)c2)CC1\n",
            " -13.96   -16.73   40.74    0.96     CC(C)CCNC(=O)CN1CCNC(=O)C1=O\n",
            " -18.45   -22.00   36.18    0.97     CSCCNC(=O)Nc1cnc(C(=O)[O-])c(C)n1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 157   Fraction valid SMILES: 96.9  Time elapsed: 1.07h Time left: 19.19h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -27.90   -32.21   25.98    0.97     CCn1cn[nH+]c1CNC(=O)NCc1ccccc1OC1CCCCC1\n",
            " -14.64   -23.12   34.99    0.97     CC(C)OCCOCC(=O)N1CCNCC1\n",
            " -12.88   -25.84   32.81    0.98     CNC(=O)CNC(=O)CNC(=O)Nc1ccc(OC)cc1\n",
            " -19.98   -23.46   35.91    0.99     CC(C)[C@@H](OC(=O)CN(C)c1ccccc1[N+](=O)[O-])C(C)(C)C\n",
            " -11.49   -21.77   37.11    0.98     CCCNC(=O)CNc1cnccn1\n",
            " -18.07   -21.04   38.50    0.99     CS[C@H]1CCCCN(C(=O)C[C@@H](O)c2ccccc2)C1\n",
            " -16.42   -25.08   34.15    0.99     CCNC(=O)NCCNC(=O)[C@H]1CCCN(C(=O)Cc2cccs2)C1\n",
            " -21.35   -31.99   27.19    0.99     CCCCNC(=O)Nc1ncn(CCOC)c1-c1cccs1\n",
            " -15.25   -21.64   37.16    0.98     CC(C)NC(=O)CNC(=O)NNC(=O)c1cc(F)ccc1F\n",
            " -26.34   -24.22   34.61    0.98     O=C1CCCC(=O)N1CCNC(=O)C[NH+]1CCC[C@@H]1c1ccc(F)cc1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 158   Fraction valid SMILES: 95.3  Time elapsed: 1.07h Time left: 19.13h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -27.56   -34.44   24.45    0.98     CCC[C@]1(Cc2cncc3ccccc23)CCCC(=O)N1CC1CCC1\n",
            " -28.27   -32.80  -32.80    0.00     CCCc1cc(=O)noc1N(CC1CC[NH2+]CC1)C1CCCCC1\n",
            " -19.97   -26.51   33.19    1.00     CCCCc1cc(NC(=O)Cc2ccc(OC)cc2)n(C)c1\n",
            " -25.09   -27.95   30.70    0.98     O=C(N[C@H]1CCCCN1C(=O)c1cncnc1)C1CCCCC1\n",
            " -17.99   -21.21   38.07    0.99     O=C(COc1ccc(CCC(=O)N2CCCCC2)cc1)Nc1cccnc1\n",
            " -19.08   -18.97   40.05    0.98     C[C@H](CNC(=O)Nc1cccnc1Cl)Oc1ccccc1F\n",
            " -13.03   -14.86   45.14    1.00     CCOC(=O)C1CCN(C(=O)CCc2ccc(C)cc2)CC1\n",
            " -12.40   -15.07   43.45    0.98     CCCC(=O)N1CCCCCCC1\n",
            " -21.64   -26.81   31.73    0.98     CN[C@H](CCO)c1ccn(Cc2ccccc2)c1C\n",
            " -16.49   -18.04   41.75    1.00     CC(C)[NH2+][C@]1(CO)CCC[C@H](Oc2ccc(F)c(F)c2)C1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 159   Fraction valid SMILES: 100.0  Time elapsed: 1.07h Time left: 19.07h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -18.23   -19.83   39.69    0.99     CCCC(=O)N1CCCC[C@H]1CCSc1nnc(C)n1C\n",
            " -13.52   -25.06   33.96    0.98     CCNC(=O)CNC(=O)c1cnn([C@H](C)c2ccccc2)c1N\n",
            " -18.31   -18.72   40.33    0.98     CC/C(=N\\NC(=O)c1cnn(C)c1)c1ccc(C)cc1\n",
            " -20.31   -26.19   33.00    0.99     CCCNC(=O)CNC(=O)c1cccc(CNC(=O)C2CC[NH+](C)CC2)c1\n",
            " -19.56   -27.79   32.08    1.00     CCCNC(=O)COc1cccc(C#CCO)c1OC\n",
            " -30.28   -40.53   19.08    0.99     CC(C)[C@@H](NC(=O)[C@@H](C)CNC(=O)c1ccccc1N1CCCC1=O)c1ccc(F)cn1\n",
            " -18.01   -20.76   38.04    0.98     O=C(CSc1ccccn1)NC1(c2cccc(F)c2)CCCC1\n",
            " -16.36   -24.41   35.05    0.99     CCC[NH2+][C@H](CCCC)c1nccn1CC(C)C\n",
            " -12.55   -19.28   40.17    0.99     CCNC(=O)NCCC(=O)Nc1ccc(OC)c(OC)c1\n",
            " -18.32   -32.49   26.84    0.99     COCCNCc1cnn(CC(=O)N[C@H](C)c2ccccc2)c1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 160   Fraction valid SMILES: 93.8  Time elapsed: 1.08h Time left: 19.01h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -25.24   -31.11   28.18    0.99     CC[C@](C)(CC1CCCC1)CC(=O)N[C@H]1CCN(CC(F)(F)F)C1\n",
            " -16.42   -24.25   34.81    0.98     CCNCCSc1nnc(C)n1/N=C/c1ccc(OC)cc1\n",
            " -11.45   -16.56   40.92    0.96     CCCCC1CCC(CCCC)CC1\n",
            " -19.10   -28.51   30.40    0.98     CC[C@](C)(CO)NC(=O)C[C@]1(O)CCC[C@@H](C)C1\n",
            " -17.79   -22.45   36.68    0.99     Cc1ccc(NCC[NH2+]CC(=O)NCc2ccccc2)cc1\n",
            " -16.47   -19.99   38.00    0.97     CNC(=O)c1cc(NCc2cccnc2)ccn1\n",
            " -14.77   -37.21  -37.21    0.00     CC[S@@](=O)[C@@H]1CCCCCN1C(=O)CN(C)C1=O\n",
            " -30.49   -39.97   19.95    1.00     CC1(C)/C(=C\\C(=O)CCc2ccc(F)cc2)CN(C)C1=O\n",
            " -20.34   -29.35   30.58    1.00     CCCCCCCCNC(=O)C(=O)Nc1ccc(O[C@H]2CCCCO2)cc1\n",
            " -21.08   -19.25   38.56    0.96     O=C(COc1ccc(F)cc1)NNC(=O)c1ccc(-c2ccccc2)cc1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 161   Fraction valid SMILES: 92.2  Time elapsed: 1.08h Time left: 18.95h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -23.81   -35.21   24.32    0.99     CCC[NH2+]C[C@H]1CCCN(CCNS(=O)(=O)c2ccc(OC)c(F)c2)C1\n",
            " -19.21   -25.50   33.77    0.99     CC1CCC(CCNC(=O)NCc2ccc(OCc3ccccn3)cc2)CC1\n",
            " -11.63   -18.21   40.05    0.97     CCC[C@@H]1CNC(=O)N(CC(C)C)C1=O\n",
            " -11.59   -15.40   42.87    0.97     CCOC(=O)CCNC(=O)N1CCCCC1\n",
            " -24.54   -32.48   25.49    0.97     C[C@H]([NH2+]CC(=O)Nc1nccsc1=O)c1nccs1\n",
            " -20.61   -28.28   31.15    0.99     FC(F)(F)Oc1ccccc1CNC1CCN(C(=O)COc2ccc(F)cc2F)CC1\n",
            " -19.78   -24.55   33.46    0.97     CC[C@@H](C)CSC[C@@H](N)CO\n",
            " -16.22   -18.70   40.34    0.98     O=C(Nc1ccc(F)cc1N1CCCCC1)C1CCCCC1\n",
            " -24.22   -35.75  -35.75    0.00     COC[C@H](NC(=O)CSCC(C)(C)Oc1ccc(F)cc1F\n",
            " -12.33   -17.88   40.86    0.98     CCOC1CCN(C(=O)CCCNC(C)=O)CC1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 162   Fraction valid SMILES: 98.4  Time elapsed: 1.09h Time left: 18.90h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -15.94   -19.02   40.83    1.00     CC[C@H]1CCCCN1C(=O)[C@H](C)Nc1ccc(OC)cc1\n",
            " -16.51   -20.73   38.60    0.99     CCOc1cccc(NC(=O)CNC(=O)NCc2ccc(C#N)cc2)c1\n",
            " -17.02   -19.33   38.93    0.97     CCCNC(=O)[C@H](C)[NH2+]CCC(=O)NC1CC1\n",
            " -19.71   -20.77   37.90    0.98     Cc1ccc(NC(=O)COc2ccccc2F)cc1S(=O)(=O)N(C)c1ccccc1\n",
            " -16.33   -21.89   38.11    1.00     C[C@@H]([NH2+]CCNC(=O)C1CCCCC1)c1ccc(OC(C)(C)C)cc1\n",
            " -22.75   -33.75   24.16    0.97     Cc1n[nH]c(C)c1[C@H](C)C[NH2+][C@@H](C)c1nnnn1Cc1ccccn1\n",
            " -19.24   -18.73   40.03    0.98     CSc1ccc(CNC(=O)NCc2ccccc2)cn1\n",
            " -18.13   -21.91   37.37    0.99     CC[C@@H](C)NC(=O)c1ccc(CNS(=O)(=O)c2ccccn2)cc1\n",
            " -15.28   -12.00   44.33    0.94     CS(=O)(=O)N1CCC2(CC1)OCCO2\n",
            " -17.87   -21.48   38.01    0.99     CC1CCN(C(=O)CCC(=O)Nc2ccccc2OCc2ccccc2)CC1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 163   Fraction valid SMILES: 98.4  Time elapsed: 1.09h Time left: 18.85h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -15.77   -16.64   42.54    0.99     Cc1cccc(CNC(=O)Cn2nc(C)cc2C)c1\n",
            " -24.08   -23.09   36.72    1.00     CCCc1ccc(CO[C@H]2CCC[C@@]([NH2+]C)(C(=O)OC)C2)o1\n",
            " -14.79   -20.16   38.06    0.97     CCOc1ncnc(N(C)C)c1-c1ccncc1\n",
            " -15.94   -23.09   36.87    1.00     CC[C@](C)(CO)NC(=O)CCOc1ccc(C[NH3+])cc1\n",
            " -33.40   -45.52  -45.52    0.00     CSCCCNC(=O)C[C@]1(Cc2ccccc2[N+](=O)[O-])CCCN(C(=O)C1CCCCC1)c1ccccc1\n",
            " -14.73   -17.82   41.23    0.98     CCOC(=O)CCNC(=O)NCc1nc(C)cs1\n",
            " -21.99   -21.56   36.61    0.97     Oc1ccccc1N1CCC[C@H](C(=O)N2CCN(c3ccccc3)CC2)C1\n",
            " -30.37   -41.63   17.66    0.99     CC[C@H](C)NC(=O)COc1ccc(I)cc1[C@H]1C(C)=CC(=O)[C@H]1c1cccnn1\n",
            " -20.54   -29.07   30.56    0.99     COCCCOCCCNC(=O)NNC(=O)Cc1ccc(F)cc1F\n",
            " -16.07   -24.18   35.82    1.00     CC1(C)CCCN(C(=O)CNC(=O)CCc2ccc(F)cc2)C1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 164   Fraction valid SMILES: 95.3  Time elapsed: 1.09h Time left: 18.79h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -21.08   -21.26   36.89    0.97     C[C@H]1CN(CC(=O)NC2CCCCCCC2)C[C@@H](C)O1\n",
            " -16.08   -24.08   35.15    0.99     CCCNC(=O)CCCNC(=O)C1(CC)CCC1\n",
            " -15.82   -21.93   37.82    1.00     CC(C)COCCNC(=O)C1=Cc2ccccc2CCN1\n",
            " -19.91   -30.91   28.82    1.00     CCCNC(=O)COc1ccc(OCC)c(O[C@H]2CCOC2)c1\n",
            " -15.63   -26.89   30.60    0.96     CCNC(=O)NCCSc1nnc(COC)n1N\n",
            " -14.86   -17.18   42.00    0.99     CCOC(=O)CCNC(=O)NNC(=O)c1ccc(Cl)cc1\n",
            " -13.38   -17.22   42.17    0.99     CCNC(=O)CNC(=O)Nc1ccc(SC(F)F)cc1\n",
            " -21.85   -29.74   30.10    1.00     CC1(C)[C@@H](CNC(=O)N[C@@H](C)c2ccc(C(F)(F)F)cc2)C1(C)C\n",
            " -16.64   -26.16   32.13    0.97     CNC(=O)CSCCN1CCN([C@H](C)C(=O)NC(C)C)CC1\n",
            " -20.30   -33.08  -33.08    0.00     C[C@H](Oc1ccc(OCC(C)(C)C)cc1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 165   Fraction valid SMILES: 100.0  Time elapsed: 1.10h Time left: 18.74h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -14.10   -14.37   45.10    0.99     CCOCCN(C)S(=O)(=O)c1ccc(Cl)cn1\n",
            " -21.34   -25.76   33.69    0.99     CCc1cc(CNC(=O)NC[C@H](c2ccc(F)cc2)N2CCOCC2)cn1C\n",
            " -20.28   -26.01   32.17    0.97     CCOC(=O)CNC(=O)[C@@H](C)N1CCN(C(=O)NCCC(C)C)CC1\n",
            " -17.88   -20.54   37.64    0.97     Cc1csc(CCNC(=O)Cc2csc3ccccc23)n1\n",
            " -18.79   -20.71   38.57    0.99     Cc1nnnn1CCCC(=O)N[C@H](C)c1ccc(Cl)cc1\n",
            " -21.40   -24.91   34.27    0.99     O=C(CO[C@H]1CCCCO1)NCc1ccccc1CN1CCCC1\n",
            " -17.90   -21.04   38.62    0.99     C[C@](O)(CNC(=O)c1cccc(F)c1)C1CCOCC1\n",
            " -24.91   -28.37   31.24    0.99     CC[C@H](C)CN(CC)[C@H](c1ccc(Cl)cc1)c1nc(C)n[nH]1\n",
            " -19.44   -25.92   31.84    0.96     OCCOc1ccc([C@@H](O)[C@@H](O)c2ccncc2)cc1\n",
            " -12.24   -17.31   40.80    0.97     C[C@H]([NH2+]C1CCN(CC(F)F)CC1)C1CCCCC1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 166   Fraction valid SMILES: 98.4  Time elapsed: 1.10h Time left: 18.69h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -21.14   -30.93   27.90    0.98     COCCNC(=O)CCNC(=O)c1ccc(Cl)nc1NN\n",
            " -14.90   -18.39   40.43    0.98     COC(=O)CCC(=O)N1CCC(C)CC1\n",
            " -19.78   -21.47   37.80    0.99     CCC(CC)NC(=O)COC(=O)CCC1CCCCC1\n",
            " -16.60   -21.46   37.98    0.99     COCCC[NH2+]CC1CCN(c2cccc(F)c2)CC1\n",
            " -19.95   -22.48   35.36    0.96     COC(=O)C1=C(C)NC(=O)N[C@H]1c1cccnc1Nc1ccccc1\n",
            " -19.43   -23.85   35.02    0.98     COc1ccccc1C1(CCCO)CCNCC1\n",
            " -18.30   -25.04   34.96    1.00     CCNC(=O)CC1CCN(C(=O)C(=O)Nc2ccc(C(C)(C)C)cc2)CC1\n",
            " -17.82   -26.88   33.00    1.00     CCOc1ccc(CNC(=O)COc2ccc(Cl)cc2NC(=O)CC)cc1\n",
            "  -8.75   -14.44   43.52    0.97     CCC(CC)C1(C[NH2+]C)CC1\n",
            " -15.52   -16.78   42.71    0.99     Cc1nc(CNC(=O)C[C@H](C)c2ccc(F)cc2)sc1C\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 167   Fraction valid SMILES: 93.8  Time elapsed: 1.10h Time left: 18.63h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -14.82   -17.64   42.12    1.00     CCOC(=O)[C@H]1CCCN(C(=O)Cc2c(OC)cccc2OC)C1\n",
            " -27.02   -26.96   31.87    0.98     CCNc1nc(C)cc(NCc2cc(F)c(O)c(F)c2)n1\n",
            " -17.10   -22.55   36.29    0.98     OCCOc1ccccc1CN1CCN(CCO)C1\n",
            " -19.37   -20.79   38.18    0.98     CC1(C)CCC(NC(=O)c2cnc([C@H]3CCCO3)s2)CC1\n",
            " -21.95   -27.25   30.65    0.97     O[C@H](c1ccccc1F)c1cccc(NCC(=O)NCc2ccccc2)c1\n",
            " -24.96   -34.70   24.56    0.99     COC[C@H](O)c1cccc(NC(=O)NNC(=O)COc2cccc(C(C)C)c2)c1\n",
            " -16.71   -18.63   40.00    0.98     C[C@@H]1C[C@H](C)CCN1C(=O)CNC(=O)C1CCCCC1\n",
            " -21.71   -29.20   28.05    0.95     Clc1nc(Oc2ccncc2)ccc1N1CCN(c2ccccc2F)CC1\n",
            " -20.39   -32.23   26.79    0.98     COc1ccc(CCNC(=O)[C@@H]2Nc3ccccc3NC2=O)cc1OC(C)C\n",
            " -20.10   -21.79   37.38    0.99     Cc1cc(O[C@H](C)C(=O)N[C@H](C)c2ccccc2)n(C)c1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 168   Fraction valid SMILES: 95.3  Time elapsed: 1.11h Time left: 18.58h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -16.13   -18.80   38.63    0.96     CC(C)CNC(=O)NNC(=O)[C@H]1CCOC1\n",
            " -17.08   -18.64   39.82    0.97     Cc1cc(NCc2cccnc2)ncc1C(=O)N1CCOCC1\n",
            " -13.54   -17.45   42.46    1.00     COCCCNC(=O)C1CCN(C(=O)COc2ccc(C)cc2)CC1\n",
            " -41.78   -50.56  -50.56    0.00     CC[NH2+][C@H]1CC[C@H](Nc2ccc(C)sc2)[C@@H]1C)c1cccc(C2CC2)c1\n",
            " -17.85   -19.97   39.50    0.99     CCOc1ccc(OCC(=O)N[C@@H](C)Cc2ccccc2)cc1\n",
            " -14.18   -13.01   46.48    0.99     CNC(=O)[C@H](C)Sc1ccccc1\n",
            " -18.92   -17.28   40.21    0.96     Cc1ncsc1C(=O)N[C@H](C)c1ccc(-n2ccnc2)cc1\n",
            " -21.79   -27.17   30.49    0.96     CC[NH2+][C@@H]1CCCC[C@H](c2nccn2Cc2ccccc2)C1\n",
            " -16.67   -18.23   41.00    0.99     CCN(Cc1cnn(C)c1)Cc1cc(C(=O)OC)cs1\n",
            " -12.86   -15.59   39.69    0.92     CCNC(=O)C[NH2+]CC(=O)[O-]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 169   Fraction valid SMILES: 95.3  Time elapsed: 1.11h Time left: 18.53h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -27.42   -29.35  -29.35    0.00     CC[NH2+][C@@H]1[C@H](CC)Cc1ccccc1C(=O)NC(C)(C)C\n",
            " -16.11   -18.40   40.91    0.99     CC(C)NC(=O)CNc1ccccn1\n",
            " -11.86   -16.92   41.70    0.98     CC(C)NC(=O)CN1CCN(CC(F)(F)F)CC1\n",
            " -20.07   -22.95   35.28    0.97     CC1(C)S[C@H](c2cccc(OCC(=O)[O-])c2)C(=O)O1\n",
            " -28.33   -36.78  -36.78    0.00     COc1cccc(OC2CCN(C(=O)C[C@H](O)c3ccccc3)CC2)cc1O\n",
            " -16.54   -21.06   38.84    1.00     CC(C)CCOC[C@H]1CCCN(C(=O)CCc2cccs2)C1\n",
            " -19.64   -21.72   37.68    0.99     COc1ccc([C@H](O)CNC(=O)[C@H](C)c2ccc(C)s2)cc1OC\n",
            " -17.38   -21.56   38.23    1.00     CC1(C)C(C(=O)Nc2ccc(OCCO)cc2)C1(C)C\n",
            " -13.37   -18.10   41.80    1.00     CCCSCC(=O)N1CCCc2ccccc21\n",
            " -18.04   -20.71   38.88    0.99     CCOCCNC(=O)C(=O)Nc1ccc(NC(C)=O)cc1C\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 170   Fraction valid SMILES: 95.3  Time elapsed: 1.12h Time left: 18.48h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -21.90   -25.27   32.84    0.97     CCCNC(=O)CNc1ncnc(Nc2cnn(C)c2)c1-c1ccccc1\n",
            " -15.34   -18.75   39.69    0.97     CSCC[C@H](C)[NH2+][C@H]1CCCCC1(C)C\n",
            " -12.02   -16.01   42.41    0.97     C[NH2+]Cc1cnn(CCOC)c1\n",
            " -33.35   -46.22   13.18    0.99     CC[C@@H](CNC(=O)C[C@]1(c2ccccn2)C(=O)O1)NCc1ccc(C#N)cc1\n",
            " -21.18   -24.01   35.38    0.99     CC(C)n1nc(C(=O)NNC(=O)CCc2ccccc2)cc1C\n",
            " -23.93   -33.77   25.18    0.98     CCOc1ccc([C@@H]2C[C@H](C)NC(=O)N2CC(N)=O)cc1OCc1ccncc1\n",
            " -15.85   -18.28   41.72    1.00     CCCCNC(=O)CN1CCN(C(=O)/C=C(/C)c2ccc(F)cc2)CC1\n",
            " -29.85   -33.47   24.98    0.97     CC[C@H]1CCc2ncncc2CN1C[C@H](CS)c1ccccc1\n",
            " -21.79   -23.29   35.75    0.98     O=C1CCc2c1cnn2CCNC(=O)NCCc1ccccc1\n",
            " -21.13   -21.58   38.03    0.99     CCCOc1ccccc1/C=N/NC(=O)COc1cc(Cl)ccc1OC\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 171   Fraction valid SMILES: 98.4  Time elapsed: 1.12h Time left: 18.43h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -17.14   -21.40   37.63    0.98     CC(C)Oc1ccc(CNC(=O)NCc2ccccn2)cn1\n",
            " -19.03   -26.76   32.17    0.98     CC1(C)NCCN(C(=O)NC[C@@H](c2cnccn2)C2CC2)C1(C)C\n",
            " -16.47   -20.59   38.44    0.98     COc1ccccc1NC(=O)NNC1CCCCC1\n",
            " -18.36   -30.88   28.17    0.98     COC(=O)C1(C(=O)OCC(C)C)CCN(CC)CC1\n",
            " -19.06   -26.51   30.96    0.96     O=C(c1cccs1)N(CCc1ccccn1)c1ncccc1F\n",
            " -21.01   -23.00   35.37    0.97     Cc1ccccc1C(=O)NCC(=O)Nc1ncnn1C\n",
            " -16.36   -18.86   40.30    0.99     CCCOc1ccc([C@H]([NH3+])c2ccc(OC)c(OC)c2)cc1\n",
            " -16.24   -19.06   40.22    0.99     COc1ccc(Cl)c(NCC(=O)N[C@H](C)c2ccccc2)c1\n",
            " -19.81   -24.49   35.11    0.99     CNC(=O)[C@H](C)c1ccccc1NC(=O)COc1c(C)cccc1C\n",
            " -19.96   -21.32   35.98    0.96     O=C(c1cn[nH]n1)N1CC[NH+](CCc2ccccc2)CC1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 172   Fraction valid SMILES: 92.2  Time elapsed: 1.12h Time left: 18.38h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -15.57   -15.78   42.30    0.97     COc1ncnc(N2CCC(Cc3ccccc3)CC2)c1[N+](=O)[O-]\n",
            " -19.37   -18.95   40.11    0.98     CC(C)[C@H]([NH2+]CC(C)(C)c1ccncc1)c1ccc2c(c1)OCCO2\n",
            " -16.83   -23.70   35.56    0.99     CCC[NH2+][C@@H]1CCN(CCNC(=O)c2ccncc2)C1\n",
            " -19.12   -22.36   37.08    0.99     CC[C@](C)(NC(=O)C1(c2ccc(F)cc2)CC1)C(=O)Nc1nccs1\n",
            " -18.66   -19.76   40.12    1.00     COCCSCC(=O)N1CCN(Cc2cccc(C)c2)CC1\n",
            " -24.19   -32.29   26.66    0.98     O=C([C@H]1CCCN(c2ccccc2)C1)N1CCC[C@H](C(=O)OCCc2ccccc2)C1\n",
            " -35.59   -34.00   23.85    0.96     CCn1ccnc1C(=O)N1CCC[C@H](c2cc(N3CCOCC3)nn2Cc2cccnc2)C1\n",
            " -18.06   -25.18   34.53    1.00     COCCSCC1CCN(C(=O)Nc2ccc(Cl)cn2)CC1\n",
            " -18.73   -19.68   39.91    0.99     CCCCOc1cccc(C(=O)NCC(=O)N2CCc3ccccc32)c1\n",
            " -22.73   -30.89   27.33    0.97     O=C(Cc1ccccc1)NNC(=O)[C@H](C)Oc1ccc(F)c([N+](=O)[O-])c1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 173   Fraction valid SMILES: 100.0  Time elapsed: 1.13h Time left: 18.33h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -18.32   -21.17   36.60    0.96     Cc1noc(CNC(=O)Nc2ccc(N)cc2)n1\n",
            " -15.37   -24.85   32.83    0.96     COc1ncnc(NNc2ccc(F)cc2I)c1N\n",
            " -16.54   -19.72   38.30    0.97     CC[NH2+][C@H]1CC[C@H](c2cccs2)C1\n",
            " -22.16   -25.04   32.99    0.97     OCCn1nnc2ccc(NC(=O)COc3cccc(F)c3)cc21\n",
            " -20.53   -21.90   36.35    0.97     C=CCNC(=O)NNC(=O)Nc1ccnn1C1CCCCC1\n",
            " -19.86   -24.81   34.12    0.98     Cc1nnc(COc2ccccc2)c(O)c1CC(C)C\n",
            " -23.27   -26.90   32.51    0.99     CCNC(=O)CC1CCN(CC2Cc3ccccc3C2)CC1\n",
            " -18.81   -18.93   39.81    0.98     C[C@H](CNC(=O)NCCNS(C)(=O)=O)N1CCN(c2ccccc2)CC1\n",
            " -15.11   -18.32   41.61    1.00     CCC1(CC)CCN(C(=O)N[C@H](CC(C)C)c2ccccc2)C1\n",
            " -18.20   -21.41   38.59    1.00     CCCS[C@H](C)C(=O)N[C@H](C)c1cc(C)cc(C)c1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 174   Fraction valid SMILES: 96.9  Time elapsed: 1.14h Time left: 18.45h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -19.66   -16.37   42.64    0.98     CC(C)c1nc(NC(=O)c2ccccc2Cl)sc1C\n",
            " -22.65   -27.33   32.32    0.99     CC1(C)CCSCN1C(=O)CC1CCN(C(=O)Cc2ccccc2F)CC1\n",
            " -26.81   -22.14   35.83    0.97     C[C@H]1CN(CC(=O)N2CC[C@H]3CC[C@@H](C2)[NH+]3Cc2ccccc2)C[C@@H](C)O1\n",
            " -19.03   -27.21   32.79    1.00     CCN(C[C@H](C)CCO)C(=O)COc1ccccc1I\n",
            " -12.26   -18.79   39.90    0.98     Cc1nc(NC(=O)COc2ccc(F)cc2F)sc1C\n",
            " -17.12   -23.09   35.65    0.98     CCCOC[C@H]1CCN(C(=O)CNC(=O)C2CCCC2)C1\n",
            " -20.11   -22.19   36.18    0.97     O=C([C@H]1C[C@@H]1c1ccc(F)cc1)N1CCc2c(F)cc(F)cc2C1\n",
            " -14.95   -17.66   41.55    0.99     CCOc1ccccc1N1C[C@H](C(=O)OC[C@H]2CCCCO2)CC1=O\n",
            " -14.11   -19.69   39.81    0.99     CCOc1ccc(OCC(=O)N[C@H](C)c2ccccc2OC)cc1\n",
            " -26.70   -34.03  -34.03    0.00     Cc1cc(CN(C)C(=O)Cn2cc(N)cnc2N)cn1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 175   Fraction valid SMILES: 93.8  Time elapsed: 1.15h Time left: 18.40h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -19.97   -21.08   37.40    0.97     Cc1nc(COc2ccc(NC(=O)COc3c(C)cccc3C)cc2)no1\n",
            " -24.01   -36.68   22.59    0.99     C[C@H](OCCNC(=O)c1cccnc1NCC(=O)[O-])c1ccc(Cl)cc1\n",
            " -23.12   -27.78   31.16    0.98     CCOc1ccc(C(=O)Nc2nc(CNC(=O)c3ccc(C(C)C)cc3)no2)cc1\n",
            " -13.49   -18.76   40.24    0.98     O=C(c1ccnc(OCC(F)(F)F)c1)N1CCC2(CC1)OCCO2\n",
            " -17.20   -17.28   40.79    0.97     CCS(=O)(=O)N1CCC(c2nc(C)n[nH]2)CC1\n",
            " -19.90   -23.73   35.80    0.99     CCOC(=O)C1CCN(c2ccc(S(=O)(=O)C(F)F)cc2NC(=O)c2ccccc2Cl)CC1\n",
            " -19.96   -27.17   32.61    1.00     CCO[C@H]1CN(C(=O)C(C)(C)CCc2cccs2)CCO1\n",
            " -25.60   -34.93   24.34    0.99     C[C@H](OC(=O)N1CC[C@@H](OCc2ccccn2)C1)C1(C[NH3+])CCCCCC1\n",
            " -20.67   -25.77   33.81    0.99     C[C@H]1CCCC[C@@H]1OCCNC(=O)C1CN(C(=O)Cc2ccccc2)C1\n",
            " -22.98   -37.62   21.79    0.99     COC1CCN(C(=O)[C@@H](C)Oc2ccc(OC)cc2NC(=O)Nc2ccccc2F)CC1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 176   Fraction valid SMILES: 96.9  Time elapsed: 1.15h Time left: 18.35h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -20.52   -21.13   38.53    0.99     C[C@]1(C(=O)NCC(=O)Nc2ccc(C(F)(F)F)cc2)CCCO1\n",
            " -15.18   -18.66   38.80    0.96     O=C(NC[C@H](O)c1ccccc1F)c1cnn(-c2ccccc2)c1\n",
            " -14.55   -15.98   43.62    0.99     Cc1ccccc1NC(=O)CSC[C@H](O)CO\n",
            " -20.19   -29.36   29.69    0.98     CCCSc1nc([O-])c(C(=O)Nc2ccccn2)nc1C(C)C\n",
            " -15.80   -21.10   37.20    0.97     CCOC(=O)CSc1nnc(NC(=O)c2ccc(S(C)(=O)=O)cc2)s1\n",
            " -16.87   -23.76   34.80    0.98     CCC[C@](C)(O)CN1CCCCCC1(C)C\n",
            " -17.79   -18.24   40.43    0.98     COc1ccc(NC(=O)CC2(c3ccccc3)CCC2)cc1\n",
            " -23.05   -24.85   33.63    0.97     C[C@H](C(=O)[O-])[S@@](=O)[C@H](C)C(=O)Nc1cc(F)ccc1F\n",
            " -19.20   -21.38   37.04    0.97     O=C(Cc1cccs1)NN1C(=O)CC[C@H]1c1ccc(F)cc1\n",
            " -16.03   -18.18   39.13    0.96     COc1cccc(Oc2cncc(C(=O)[O-])c2)c1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 177   Fraction valid SMILES: 93.8  Time elapsed: 1.15h Time left: 18.30h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -24.20   -24.89   32.86    0.96     CCN(Cc1ccccn1)c1ncnc(NNC(=O)CNC(C)=O)c1[N+](=O)[O-]\n",
            " -15.10   -24.58   33.97    0.98     FC(F)(F)Oc1ccc(Cl)c(CNc2cccc(I)c2)c1\n",
            " -19.18   -27.50  -27.50    0.00     CCOC(=O)CSc1nnc(N(C)Cc2ccccc2)n1\n",
            " -18.36   -24.16   34.80    0.98     O=C(OCc1ccc(F)c(F)c1)C(=O)Nc1ccc(OCC(F)(F)F)cc1\n",
            " -14.56   -18.37   39.39    0.96     CCC[NH2+][C@H](C(C)C)C1CCC1\n",
            " -22.96   -22.15   36.22    0.97     CC(C)S(=O)(=O)NCC(=O)N[C@H]1CCC[C@@H](C)[C@@H]1C\n",
            " -14.27   -17.15   41.76    0.98     ClCC1([C@H](O)c2ccccc2)CCC1\n",
            " -17.94   -17.79   41.06    0.98     CCOC(=O)c1ccsc1NC(=O)[C@H]1COc2ccccc2C1\n",
            " -19.42   -22.12   35.65    0.96     O=C1O[C@H](Cc2ccccc2)C[C@@H]1Cc1ccncc1\n",
            " -22.53   -28.27   30.94    0.99     COCCNCC1=C(C(=O)NCc2cccnc2)c2ccccc21\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Best score in memory: 1.00\n",
            "\n",
            "       Step 178   Fraction valid SMILES: 93.8  Time elapsed: 1.16h Time left: 18.25h\n",
            "  Agent    Prior   Target   Score             SMILES\n",
            " -21.79   -21.62   37.63    0.99     C[C@H]1CCC[C@H]([NH+](C)CCNC(=O)Nc2ccc(C(N)=O)cc2)C1\n",
            " -17.84   -20.06   36.75    0.95     CCOc1ncncc1-c1nc(C)no1\n",
            " -30.61   -30.98   26.61    0.96     Cc1c([N+](=O)[O-])ccc(S(=O)(=O)NCCC(=O)NCC(F)(F)F)c1O\n",
            " -21.65   -22.62   37.38    1.00     COc1ccc(N[C@H](C)C(=O)NCCCSC)cc1\n",
            " -19.43   -21.57   36.26    0.96     Cc1cnccc1NC(=O)C[S@@](=O)Cc1ncn(-c2ccccc2)n1\n",
            " -16.01   -17.15   41.51    0.98     CCNC(=O)CNC(=O)N[C@H]1CCC[C@@H](C(F)(F)F)C1\n",
            " -28.18   -37.81   21.71    0.99     COc1ccc(OC)c([C@@H]2CN(CC[NH+](C)C)CCN(C(=O)Cc3ccccc3)C[C@@H]2C)c1\n",
            " -18.03   -19.73   39.33    0.98     Cc1cc(C(=O)NNC(=O)Cc2ccc(F)cc2)ccc1Cl\n",
            " -18.56   -18.91   40.21    0.99     CN(C)C(=O)c1ccc(NC(=O)N2CCCC[C@@H]2c2ccccc2)cc1\n",
            " -16.84   -19.64   39.88    0.99     Cc1csc(CNC(=O)c2cc(NC(=O)OC(C)(C)C)ccc2F)n1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:93: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:94: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:59: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:60: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Zzv_ezqQiLIG"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}