Evaluation and Refinement.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Description\n",
    "\n",
    "This notebook is used to process and evalutate the initial universe of generated smiles, and then retain the network applying techniques and principles from both transfer learning and genetic algorithms to increasingly improve molecule generation for the specific task of binding with cornovirus protease."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## First process initial generated smiles for PyRx analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from rdkit import Chem, DataStructs\n",
    "import random\n",
    "import numpy as np\n",
    "import rdkit.Chem.PropertyMol"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "gen0_table = pd.read_csv('./generations/gen0_smiles.smi',sep=',', header=None)\n",
    "gen0 = list(gen0_table[0])[0:10000]\n",
    "len(gen0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def validate_mols(list_of_smiles):\n",
    "    valid_mols = []\n",
    "    for smi in list_of_smiles:\n",
    "        mol = Chem.MolFromSmiles(smi)\n",
    "        if mol is not None:\n",
    "            valid_mols.append(mol)\n",
    "    return valid_mols\n",
    "\n",
    "def convert_mols_to_smiles(list_of_mols):\n",
    "    valid_smiles = [Chem.MolToSmiles(mol) for mol in list_of_mols]\n",
    "    return valid_smiles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gen0_mols = validate_mols(gen0)\n",
    "len(gen0_mols)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''Intakes a list of smiles, randomly shuffles them, then adds first thirty,\n",
    "then sets a max-similarity threshold between any new molecule and existing list\n",
    "and iteratively increases the treshold until X components are picked to ensure diveristy'''\n",
    "\n",
    "def initialize_generation_from_mols(list_of_mols,desired_length):  \n",
    "    assert desired_length >30\n",
    "    random.shuffle(list_of_mols)\n",
    "    random.shuffle(list_of_mols)\n",
    "    \n",
    "    #Prepare fingerprints for similarity calcs\n",
    "    mol_fingerprints = []\n",
    "    for mol in list_of_mols:\n",
    "        mol_fingerprints.append(Chem.RDKFingerprint(mol))\n",
    "    \n",
    "    selected_mols = list_of_mols[0:30]\n",
    "    selected_fingerprints = mol_fingerprints[0:30]\n",
    "    remaining_mols = list_of_mols[30:]\n",
    "    remaining_fingerprints = mol_fingerprints[30:]\n",
    "    \n",
    "    similarity_threshold = .05   \n",
    "    while len(selected_mols) < desired_length:\n",
    "        for fingerprint, mol in zip(remaining_fingerprints, remaining_mols):\n",
    "            max_similarity = np.max(DataStructs.BulkTanimotoSimilarity(fingerprint,selected_fingerprints))\n",
    "            if (max_similarity <= similarity_threshold) and (max_similarity < 1):\n",
    "                selected_fingerprints.append(fingerprint)\n",
    "                selected_mols.append(mol)\n",
    "        print(\"Completed loop with threshold at: \", similarity_threshold, \". Length is currently: \", len(selected_mols))\n",
    "        similarity_threshold += .05\n",
    "    return selected_mols"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gen0_mols = initialize_generation_from_mols(gen0_mols,1000)\n",
    "print(len(gen0_mols))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "master_table = pd.read_csv('./generations/master_results_table.csv',sep=',')\n",
    "master_table.shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''Certainly not opimized and not strictly necessary, but in the PyRx GUI\n",
    "molecule names would sort oddly when in any numeric order, so ordering\n",
    "molcules by a four letter code. This function iterates the four letter code.'''\n",
    "def iterate_alpha(alpha_code):\n",
    "    numbers = []\n",
    "    for letter in alpha_code:\n",
    "        number = ord(letter)\n",
    "        numbers.append(number)\n",
    "    \n",
    "    if numbers[3]+1 > 90:\n",
    "        if numbers[2]+1 > 90:\n",
    "            if numbers[1]+1 > 90:\n",
    "                if numbers[0]+1 > 90:\n",
    "                    raise ValueError('Too long for alpha code')\n",
    "                else:\n",
    "                    numbers[3] = 65\n",
    "                    numbers[2] = 65\n",
    "                    numbers[1] = 65\n",
    "                    numbers[0] = numbers[0] + 1\n",
    "            else:\n",
    "                numbers[3] = 65\n",
    "                numbers[2] = 65\n",
    "                numbers[1] = numbers[1] + 1\n",
    "        else:\n",
    "            numbers[3] = 65\n",
    "            numbers[2] = numbers[2] + 1\n",
    "    else:\n",
    "        numbers[3] = numbers[3] + 1\n",
    "    \n",
    "\n",
    "    new_code = \"\"\n",
    "    for number in numbers:\n",
    "        new_code += chr(number)\n",
    "    return new_code\n",
    "iterate_alpha('AAAA')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def append_to_tracking_table(master_table,mols_to_append, source, generation):\n",
    "    # Assign IDs for tracking to each mol, and assign a pandas table entry for each\n",
    "    mols_to_export = []\n",
    "    rows_list = []\n",
    "    \n",
    "    master_table_gen = master_table[master_table['gen'] == generation]\n",
    "    if master_table_gen.shape[0] == 0:\n",
    "        id_code = 'AAAA'\n",
    "    else:\n",
    "        master_table_gen_ids = master_table_gen.sort_values('id', ascending=True)\n",
    "        master_table_gen_max_id = master_table_gen_ids.tail(1)\n",
    "        key = master_table_gen_max_id['id'].keys()[0]\n",
    "        id_code = iterate_alpha(str(master_table_gen_max_id['id'][key]))\n",
    "        \n",
    "    training_data = pd.read_csv('./datasets/all_smiles_clean.smi', header=None)\n",
    "    training_set = set(list(training_data[0]))\n",
    "    \n",
    "    for mol in mols_to_append:\n",
    "        pm = Chem.PropertyMol.PropertyMol(mol)\n",
    "        title = 'id' + str(id_code) + 'gen'+ str(generation)\n",
    "        print(title)\n",
    "        # Enables for tracking which molecule is which in PyRx GUI and PyRx results export\n",
    "        pm.SetProp('Title', title)\n",
    "        mols_to_export.append(pm)\n",
    "\n",
    "        #And track in pandas\n",
    "        mol_dict = {}\n",
    "        mol_dict['id'] = id_code\n",
    "        mol_dict['gen'] = generation\n",
    "        smile = Chem.MolToSmiles(mol)\n",
    "        assert type(smile) == type('string')\n",
    "        mol_dict['smile'] = smile\n",
    "\n",
    "        if (source!= 'hiv' and source != 'manual' and source != 'baseline') and (smile in training_set):\n",
    "            mol_dict['source'] = 'training'\n",
    "        else:\n",
    "            mol_dict['source'] = source\n",
    "        mol_dict['score'] = 99.9\n",
    "\n",
    "        rows_list.append(mol_dict)\n",
    "        id_code = iterate_alpha(id_code)\n",
    "        \n",
    "    df = pd.DataFrame(rows_list)\n",
    "    return df, mols_to_export"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_mols_to_test = append_to_tracking_table(master_table,gen0_mols, 'generated', 0)\n",
    "mols_for_pd = new_mols_to_test[0]\n",
    "mols_for_export = new_mols_to_test[1]\n",
    "master_table = master_table.append(mols_for_pd)\n",
    "len(mols_for_export)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "master_table = master_table.reset_index(drop=True)\n",
    "master_table.to_csv(r'./generations/master_results_table.csv', index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Add HIV inhibitors manually into the table\n",
    "hiv_smiles = pd.read_csv('./datasets/hiv_inhibitors_cleaned.smi',sep=',', header=None)\n",
    "hiv_smiles = list(hiv_smiles[0])\n",
    "hiv_mols = validate_mols(hiv_smiles)\n",
    "\n",
    "master_table = pd.read_csv('./generations/master_results_table.csv',sep=',')\n",
    "new_mols_to_test = append_to_tracking_table(master_table,hiv_mols, 'hiv', 0)\n",
    "mols_for_pd = new_mols_to_test[0]\n",
    "mols_for_export = mols_for_export + new_mols_to_test[1]\n",
    "\n",
    "master_table = master_table.append(mols_for_pd)\n",
    "master_table = master_table.reset_index(drop=True)\n",
    "master_table.to_csv(r'./generations/master_results_table.csv', index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Add a few other smiles manually into the table (\"control group\" of training smiles)\n",
    "manual_smiles = pd.read_csv('./datasets/manual_testing_cleaned.smi',sep=',', header=None)\n",
    "manual_smiles = list(manual_smiles[0])\n",
    "manual_mols = validate_mols(hiv_smiles)\n",
    "\n",
    "master_table = pd.read_csv('./generations/master_results_table.csv',sep=',')\n",
    "new_mols_to_test = append_to_tracking_table(master_table,manual_mols, 'manual', 0)\n",
    "mols_for_pd = new_mols_to_test[0]\n",
    "mols_for_export = mols_for_export + new_mols_to_test[1]\n",
    "\n",
    "master_table = master_table.append(mols_for_pd)\n",
    "master_table = master_table.reset_index(drop=True)\n",
    "master_table.to_csv(r'./generations/master_results_table.csv', index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def write_gen_to_sdf(mols_for_export, generation, batch_size):\n",
    "    if len(mols_for_export) > batch_size:\n",
    "        batches = (len(mols_for_export) // 1000)+1\n",
    "        for i in range(0,batches):\n",
    "            batch_to_export = mols_for_export[i*batch_size:(i+1)*batch_size]\n",
    "            w = Chem.SDWriter('./generations/gen' +str(generation) + '_batch_' + str(i+1) + '.sdf')\n",
    "            for m in batch_to_export: w.write(m)\n",
    "    else:\n",
    "        w = Chem.SDWriter('./generations/gen' +str(generation) + '.sdf')\n",
    "        for m in mols_for_export:\n",
    "            w.write(m)\n",
    "    \n",
    "    # Noticed an issue where the very last line item of an sdf write is not written correctly until another arbitary write is made\n",
    "    w = Chem.SDWriter('./generations/junk/test.sdf')\n",
    "    w.write(m)\n",
    "    \n",
    "    return mols_for_export"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "write_gen_to_sdf(mols_for_export, 0, 2000)\n",
    "print('ok')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NOW GO TO PyRx: Analyze the SDF file and create a csv of binding score results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Afterwards, process binding simulation results to 'evolve' the molecules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''This number must be MANUALLY iterated each generation. I did not write the entire process into a smooth function or loop but that would be the next steps.''' \n",
    "GLOBAL_GENERATION = 11"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "master_table = pd.read_csv('./generations/master_results_table_gen' + str(GLOBAL_GENERATION-1) + '.csv',sep=',')\n",
    "master_table.tail()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_scores = pd.read_csv('./generations/results/results_gen' + str(GLOBAL_GENERATION-1) + '.csv',sep=',')\n",
    "new_scores.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_scores = new_scores.groupby(\"Ligand\").min()[\"Binding Affinity\"].reset_index()\n",
    "new_scores['id'] = new_scores['Ligand'].str.split(\"_\").str[1].str.split(\"gen\").str[0].str.split(\"id\").str[1]\n",
    "new_scores['gen'] = new_scores['Ligand'].str.split(\"_\").str[1].str.split(\"gen\").str[1]\n",
    "new_scores['score'] = new_scores[\"Binding Affinity\"]\n",
    "new_scores = new_scores[['id','gen','score']]\n",
    "new_scores.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_scores.id = new_scores.id.astype(str)\n",
    "new_scores.gen = new_scores.gen.astype(int)\n",
    "master_table.id = master_table.id.astype(str)\n",
    "master_table.gen = master_table.gen.astype(int)\n",
    "new_table = pd.merge(master_table, new_scores, on=['id','gen'], suffixes=('_old','_new'), how='left')\n",
    "new_table['score'] = np.where(new_table['score_new'].isnull(), new_table['score_old'], new_table['score_new'])\n",
    "new_table = new_table.drop(['score_old','score_new'], axis=1)\n",
    "new_table['weight'] = new_table['smile'].apply(lambda x: Chem.Descriptors.MolWt(Chem.MolFromSmiles(x)))\n",
    "new_table = new_table.sort_values('score', ascending=True)\n",
    "new_table.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_table.to_csv(r'./generations/master_results_table_gen' + str(GLOBAL_GENERATION-1) + '.csv', index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Select top X ranked by score for training data to refine the molecule generator RNN\n",
    "training_smiles = list(set(list(new_table.head(35)['smile'])))\n",
    "len(training_smiles)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "training_fingerprints = []\n",
    "for smile in training_smiles:\n",
    "    training_fingerprints.append(Chem.RDKFingerprint(Chem.MolFromSmiles(smile)))\n",
    "\n",
    "def calc_similarity_score(row):\n",
    "    fingerprint = Chem.RDKFingerprint(Chem.MolFromSmiles(row['smile']))\n",
    "    similarity = np.max(DataStructs.BulkTanimotoSimilarity(fingerprint,training_fingerprints))\n",
    "    adj_factor = (1 / similarity) **.333\n",
    "    adj_score = row['score'] * adj_factor\n",
    "    return adj_score\n",
    "\n",
    "similarity_adjusted = new_table.copy(deep=True)\n",
    "similarity_adjusted = similarity_adjusted[similarity_adjusted['weight'] < 900]\n",
    "similarity_adjusted['similarity_adj_score'] = similarity_adjusted.apply(calc_similarity_score, axis=1)\n",
    "similarity_adjusted = similarity_adjusted.sort_values('similarity_adj_score', ascending=True)\n",
    "similarity_adjusted.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Select top X ranked by similarity adjusted score for training data to refine the molecule generator RNN (ensures diverity)\n",
    "training_smiles += list(similarity_adjusted.head(5)['smile'])\n",
    "len(training_smiles)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calc_weight_score(row):\n",
    "    adj_factor = (900 / row['weight']) ** .333\n",
    "    if adj_factor < 1:\n",
    "        adj_score = 0\n",
    "    else:\n",
    "        adj_score = row['score'] * adj_factor\n",
    "    return adj_score\n",
    "\n",
    "weight_adjusted = new_table.copy(deep=True)\n",
    "weight_adjusted['weight_adj_score'] = weight_adjusted.apply(calc_weight_score, axis=1)\n",
    "weight_adjusted = weight_adjusted.sort_values('weight_adj_score', ascending=True)\n",
    "weight_adjusted.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Select top X ranked by similarity adjusted score for training data to refine the molecule generator RNN (ensures diverity)\n",
    "training_smiles += list(weight_adjusted.head(5)['smile'])\n",
    "len(training_smiles)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow\n",
    "tensorflow.test.is_gpu_available()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from copy import copy\n",
    "\n",
    "import keras\n",
    "\n",
    "from lstm_chem.utils.config import process_config\n",
    "from lstm_chem.model import LSTMChem\n",
    "from lstm_chem.generator import LSTMChemGenerator\n",
    "from lstm_chem.trainer import LSTMChemTrainer\n",
    "from lstm_chem.data_loader import DataLoader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generate some with the base original model\n",
    "CONFIG_FILE = 'experiments/2019-12-23/LSTM_Chem/config.json'\n",
    "config = process_config(CONFIG_FILE)\n",
    "modeler = LSTMChem(config, session='generate')\n",
    "generator = LSTMChemGenerator(modeler)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sample_number = 20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "base_generated = generator.sample(num=sample_number)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "base_generated_mols = validate_mols(base_generated)\n",
    "base_generated_smiles = convert_mols_to_smiles(base_generated_mols)\n",
    "random.shuffle(base_generated_smiles)\n",
    "random.shuffle(base_generated_smiles)\n",
    "# Select X for training data to refine the molecule generator RNN (ensures diverity)\n",
    "training_smiles += base_generated_smiles[0:5]\n",
    "len(training_smiles)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "master_table = pd.read_csv('./generations/master_results_table_gen' + str(GLOBAL_GENERATION-1) + '.csv',sep=',')\n",
    "master_table.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Save the list of smiles to train on\n",
    "with open('./generations/training/gen' + str(GLOBAL_GENERATION) + '_training.smi', 'w') as f:\n",
    "    for item in training_smiles:\n",
    "        f.write(\"%s\\n\" % item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Retrain the network to create molecules more like those selected above"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from lstm_chem.finetuner import LSTMChemFinetuner"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "config = process_config('experiments/2019-12-23/LSTM_Chem/config.json')\n",
    "config['model_weight_filename'] = 'experiments/2019-12-23/LSTM_Chem/checkpoints/finetuned_gen' + str(GLOBAL_GENERATION-1) + '.hdf5'\n",
    "config['finetune_data_filename'] = './generations/training/gen' + str(GLOBAL_GENERATION) + '_training.smi'\n",
    "print(config)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "modeler = LSTMChem(config, session='finetune')\n",
    "finetune_dl = DataLoader(config, data_type='finetune')\n",
    "\n",
    "finetuner = LSTMChemFinetuner(modeler, finetune_dl)\n",
    "finetuner.finetune()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "finetuner.model.save_weights('experiments/2019-12-23/LSTM_Chem/checkpoints/finetuned_gen' + str(GLOBAL_GENERATION) + '.hdf5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "config['model_weight_filename'] = 'experiments/2019-12-23/LSTM_Chem/checkpoints/finetuned_gen' + str(GLOBAL_GENERATION) + '.hdf5'\n",
    "modeler = LSTMChem(config, session='generate')\n",
    "generator = LSTMChemGenerator(modeler)\n",
    "print(config)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "sample_number = 5000\n",
    "sampled_smiles = generator.sample(num=sample_number)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "valid_mols = []\n",
    "for smi in sampled_smiles:\n",
    "    mol = Chem.MolFromSmiles(smi)\n",
    "    if mol is not None:\n",
    "        valid_mols.append(mol)\n",
    "# low validity\n",
    "print('Validity: ', f'{len(valid_mols) / sample_number:.2%}')\n",
    "\n",
    "valid_smiles = [Chem.MolToSmiles(mol) for mol in valid_mols]\n",
    "# high uniqueness\n",
    "print('Uniqueness: ', f'{len(set(valid_smiles)) / len(valid_smiles):.2%}')\n",
    "\n",
    "# Of valid smiles generated, how many are truly original vs ocurring in the training data\n",
    "import pandas as pd\n",
    "training_data = pd.read_csv('./datasets/all_smiles_clean.smi', header=None)\n",
    "training_set = set(list(training_data[0]))\n",
    "original = []\n",
    "for smile in list(set(valid_smiles)):\n",
    "    if not smile in training_set:\n",
    "        original.append(smile)\n",
    "print('Originality: ', f'{len(set(original)) / len(set(valid_smiles)):.2%}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "valid_smiles = list(set(valid_smiles))\n",
    "len(valid_smiles)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#take the valid smiles from above and run them through process to add to tracking table and to generate next PyRx testing data\n",
    "mols_for_next_generation = validate_mols(valid_smiles)\n",
    "\n",
    "master_table = pd.read_csv('./generations/master_results_table_gen' + str(GLOBAL_GENERATION-1) +'.csv',sep=',')\n",
    "new_mols_to_test = append_to_tracking_table(master_table,mols_for_next_generation, 'generated', GLOBAL_GENERATION)\n",
    "mols_for_pd = new_mols_to_test[0]\n",
    "mols_for_export = new_mols_to_test[1]\n",
    "\n",
    "master_table = master_table.append(mols_for_pd)\n",
    "master_table = master_table.reset_index(drop=True)\n",
    "master_table.to_csv(r'./generations/master_results_table_gen' + str(GLOBAL_GENERATION) + '.csv', index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(mols_for_export)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "write_gen_to_sdf(mols_for_export, GLOBAL_GENERATION, 2000)\n",
    "print('ok')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}