analysis_jak2_smiles_ga.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Assay and run directory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T06:56:27.456509Z",
     "iopub.status.busy": "2023-05-18T06:56:27.456153Z",
     "iopub.status.idle": "2023-05-18T06:56:27.462100Z",
     "shell.execute_reply": "2023-05-18T06:56:27.461446Z"
    }
   },
   "outputs": [],
   "source": [
    "assay_name = \"CHEMBL3888429_cleaned\"\n",
    "run_name = \"JAK2_smiles_GA\"\n",
    "run_name_low = str.lower(run_name)\n",
    "rundir = \"results/jak2/smiles_ga/CHEMBL3888429_cleaned/\"\n",
    "pca_components = 50\n",
    "kmeans = True \n",
    "runs_to_display = ['range_physchem_range_ecfp4_counts', 'range_ecfp4_counts', 'range_physchem_range_ecfp4',\n",
    "                   'smiles_validity_ecfp4', 'range_physchem', \n",
    "                   'maxsim_ecfp4', 'range_qed', 'range_ecfp4']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T06:56:27.464576Z",
     "iopub.status.busy": "2023-05-18T06:56:27.464307Z",
     "iopub.status.idle": "2023-05-18T06:56:37.620664Z",
     "shell.execute_reply": "2023-05-18T06:56:37.620116Z"
    }
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import numpy as np\n",
    "import json\n",
    "from rdkit import Chem\n",
    "from rdkit.Chem import AllChem\n",
    "from sklearn.decomposition import PCA\n",
    "from utils import data_split, ClusterFps, get_n_clusters, ecfp4, find_cluster, max_tanimoto_similarity, indexes_identical_fps, average_tanimoto_similarity, tanimoto_similarities, calculateScore, Descriptors, quantitative_analysis\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import math\n",
    "import scipy\n",
    "import pandas as pd\n",
    "import seaborn as sns \n",
    "import matplotlib\n",
    "from sklearn.cluster import KMeans\n",
    "\n",
    "font = {'family' : 'normal',\n",
    "        'size'   : 35}\n",
    "\n",
    "matplotlib.use(\"pgf\")\n",
    "# Needed for figures\n",
    "matplotlib.rcParams.update({\n",
    "    \"pgf.texsystem\": \"pdflatex\",\n",
    "    'font.family': 'serif',\n",
    "    'font.size': 35,\n",
    "    'text.usetex': True,\n",
    "    'pgf.rcfonts': False,\n",
    "})\n",
    "\n",
    "\n",
    "matplotlib.rcParams['axes.unicode_minus'] = False\n",
    "sns.set()\n",
    "%matplotlib inline "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T06:56:37.623236Z",
     "iopub.status.busy": "2023-05-18T06:56:37.622733Z",
     "iopub.status.idle": "2023-05-18T06:56:38.291909Z",
     "shell.execute_reply": "2023-05-18T06:56:38.291445Z"
    }
   },
   "outputs": [],
   "source": [
    "# Load classifiers and test set for downstream analysis \n",
    "scores_test, smiles_test, activities_test, clf = data_split(assay_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T06:56:38.294427Z",
     "iopub.status.busy": "2023-05-18T06:56:38.294200Z",
     "iopub.status.idle": "2023-05-18T06:56:38.336810Z",
     "shell.execute_reply": "2023-05-18T06:56:38.336373Z"
    }
   },
   "outputs": [],
   "source": [
    "# Get actives and inactives from test set \n",
    "actives = []\n",
    "inactives = []\n",
    "smiles_actives = []\n",
    "smiles_inactives = []\n",
    "\n",
    "for i, s in enumerate(smiles_test):\n",
    "    mol = Chem.MolFromSmiles(s)\n",
    "    if float(activities_test[i])==1:\n",
    "        actives.append(AllChem.GetMorganFingerprintAsBitVect(mol, 2))\n",
    "        smiles_actives.append(s)\n",
    "    else:\n",
    "        inactives.append(AllChem.GetMorganFingerprintAsBitVect(mol, 2))\n",
    "        smiles_inactives.append(s)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T06:56:38.338935Z",
     "iopub.status.busy": "2023-05-18T06:56:38.338599Z",
     "iopub.status.idle": "2023-05-18T06:56:42.437912Z",
     "shell.execute_reply": "2023-05-18T06:56:42.437435Z"
    }
   },
   "outputs": [],
   "source": [
    "# Extract runs and results from generative models \n",
    "runs = []\n",
    "smiles_list = []\n",
    "scores_list = []\n",
    "scores_trajectories = []\n",
    "replica_per_run = {}\n",
    "top_kept_per_run = {}\n",
    "\n",
    "all_ads = os.listdir(rundir)\n",
    "\n",
    "try:\n",
    "    all_ads.remove('ecfp4_filters_validity_ecfp4')\n",
    "except:\n",
    "    pass\n",
    "\n",
    "print(all_ads)\n",
    "\n",
    "for directory in all_ads:\n",
    "    smiles = []\n",
    "    scores = []\n",
    "    trajectories = []\n",
    "    top_kept = []\n",
    "    replica = 0\n",
    "\n",
    "    \n",
    "    for result_dir in os.listdir(os.path.join(rundir, directory)):\n",
    "        with open(os.path.join(rundir, directory, result_dir, 'results.json'), 'r') as f:\n",
    "            results = json.load(f)\n",
    "            curr_smiles = [row['smiles'] for row in results['statistics']][-1]\n",
    "            smiles.extend(curr_smiles)\n",
    "            top_kept.extend([len(curr_smiles)])\n",
    "            scores.extend([row['preds']['scores'] for row in results['statistics']][-1])\n",
    "            trajectories.extend([np.array(row['preds']['scores']) for row in results['statistics']])\n",
    "            average_trajectories = np.array([np.array(row['preds']['scores']) for row in results['statistics']])\n",
    "            replica +=1\n",
    "    if len(smiles)>0:\n",
    "        curr_run = directory[6:]\n",
    "        runs.append(curr_run)\n",
    "        scores_trajectories.append(average_trajectories)\n",
    "        smiles_list.append(smiles)\n",
    "        scores_list.append(scores)\n",
    "        replica_per_run[curr_run] = replica\n",
    "        top_kept_per_run[curr_run] = top_kept"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T06:56:42.440490Z",
     "iopub.status.busy": "2023-05-18T06:56:42.440120Z",
     "iopub.status.idle": "2023-05-18T06:56:42.444691Z",
     "shell.execute_reply": "2023-05-18T06:56:42.444223Z"
    }
   },
   "outputs": [],
   "source": [
    "from rdkit.Chem.Draw import MolsToGridImage\n",
    "\n",
    "def show_grid_mols(ad):\n",
    "    mols = [Chem.MolFromSmiles(s) for s in smiles_list[runs.index(ad)][:50]]\n",
    "    img = MolsToGridImage(mols, legends=[str(i) for i in range(len(mols))], molsPerRow=5, returnPNG=True)\n",
    "    return img\n",
    "\n",
    "def save_mols(ad, indexes):\n",
    "    mols = []\n",
    "    for i, s in enumerate(smiles_list[runs.index(ad)][:50]):\n",
    "        if i in indexes:\n",
    "            mols.append(Chem.MolFromSmiles(s))\n",
    "    img=MolsToGridImage(mols, molsPerRow=len(mols), subImgSize=(300, 160), useSVG=True)\n",
    "    img_pathname = 'images/' + run_name + '/' + run_name_low + '_typical_structures_' + '{}.svg'.format(ad)\n",
    "    with open(img_pathname , 'w') as f_handle:\n",
    "        f_handle.write(img.data)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T06:56:42.446641Z",
     "iopub.status.busy": "2023-05-18T06:56:42.446251Z",
     "iopub.status.idle": "2023-05-18T06:56:42.455478Z",
     "shell.execute_reply": "2023-05-18T06:56:42.455023Z"
    }
   },
   "outputs": [],
   "source": [
    "# Summary of the number of replica per run and of the number of molecules generated per replica\n",
    "for k,v in top_kept_per_run.items():\n",
    "    print(k, len(v), np.mean(np.array(v)),np.std(np.array(v)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T06:56:42.457492Z",
     "iopub.status.busy": "2023-05-18T06:56:42.457205Z",
     "iopub.status.idle": "2023-05-18T06:56:43.271207Z",
     "shell.execute_reply": "2023-05-18T06:56:43.270482Z"
    }
   },
   "outputs": [],
   "source": [
    "# Cluster the test set for downstream analysis \n",
    "X = np.array(actives + inactives)\n",
    "clustering = KMeans(n_clusters=5, random_state=0).fit(X)\n",
    "\n",
    "kmeans_clusters = clustering.labels_\n",
    "training_set_clusters = ClusterFps(actives + inactives, cutoff=0.5)\n",
    "centroids = [cluster[0] for cluster in training_set_clusters]\n",
    "fp_list = actives + inactives\n",
    "centroids_fp = [fp_list[centroid] for centroid in centroids]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T06:56:43.274544Z",
     "iopub.status.busy": "2023-05-18T06:56:43.274300Z",
     "iopub.status.idle": "2023-05-18T06:57:00.088975Z",
     "shell.execute_reply": "2023-05-18T06:57:00.088483Z"
    }
   },
   "outputs": [],
   "source": [
    "# Get all fingerprints to run all analysis faster \n",
    "fps_active_as_array = []\n",
    "fps_active_as_bitv = []\n",
    "fps_inactive_as_array = []\n",
    "fps_inactive_as_bitv = []\n",
    "fps_generated_as_array = []\n",
    "fps_generated_as_bitv = []\n",
    "\n",
    "for s in smiles_actives:\n",
    "    mol = Chem.MolFromSmiles(s)\n",
    "    fps_active_as_array.append(np.array(AllChem.GetMorganFingerprintAsBitVect(mol, 2)))\n",
    "    fps_active_as_bitv.append(AllChem.GetMorganFingerprintAsBitVect(mol, 2))\n",
    "    \n",
    "for s in smiles_inactives:\n",
    "    mol = Chem.MolFromSmiles(s)\n",
    "    fps_inactive_as_array.append(np.array(AllChem.GetMorganFingerprintAsBitVect(mol, 2)))\n",
    "    fps_inactive_as_bitv.append(AllChem.GetMorganFingerprintAsBitVect(mol, 2))\n",
    "    \n",
    "for i, run in enumerate(runs):\n",
    "    smiles_generated = smiles_list[i]\n",
    "    curr_fps_generated_as_array = []\n",
    "    curr_fps_generated_as_bv = []\n",
    "    for s in smiles_generated:\n",
    "        mol = Chem.MolFromSmiles(s)\n",
    "        curr_fps_generated_as_array.append(np.array(AllChem.GetMorganFingerprintAsBitVect(mol, 2)))\n",
    "        curr_fps_generated_as_bv.append(AllChem.GetMorganFingerprintAsBitVect(mol, 2))\n",
    "    fps_generated_as_array.append(curr_fps_generated_as_array)\n",
    "    fps_generated_as_bitv.append(curr_fps_generated_as_bv)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T06:57:00.091541Z",
     "iopub.status.busy": "2023-05-18T06:57:00.091124Z",
     "iopub.status.idle": "2023-05-18T06:57:01.225237Z",
     "shell.execute_reply": "2023-05-18T06:57:01.224551Z"
    }
   },
   "outputs": [],
   "source": [
    "# Fits PCA on test set \n",
    "pca = PCA(n_components=2).fit(np.concatenate((fps_inactive_as_array,fps_inactive_as_array)))\n",
    "pca_active = pca.transform(fps_active_as_array)\n",
    "pca_inactive = pca.transform(fps_inactive_as_array)\n",
    "\n",
    "pca_generated = []\n",
    "\n",
    "for i, run in enumerate(runs):\n",
    "    curr_fps_generated = fps_generated_as_array[i]\n",
    "    pca_generated.append(pca.transform(curr_fps_generated))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T06:57:01.229682Z",
     "iopub.status.busy": "2023-05-18T06:57:01.228560Z",
     "iopub.status.idle": "2023-05-18T06:57:01.235357Z",
     "shell.execute_reply": "2023-05-18T06:57:01.234568Z"
    }
   },
   "outputs": [],
   "source": [
    "xmin_ymin = np.amin(np.vstack([np.amin(p, axis=0) for p in pca_generated]), axis=0).tolist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T06:57:01.240051Z",
     "iopub.status.busy": "2023-05-18T06:57:01.238879Z",
     "iopub.status.idle": "2023-05-18T06:57:01.248036Z",
     "shell.execute_reply": "2023-05-18T06:57:01.247397Z"
    }
   },
   "outputs": [],
   "source": [
    "xmax_ymax = np.amax(np.vstack([np.amax(p, axis=0) for p in pca_generated]), axis=0).tolist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T06:57:01.252099Z",
     "iopub.status.busy": "2023-05-18T06:57:01.251038Z",
     "iopub.status.idle": "2023-05-18T06:57:01.258930Z",
     "shell.execute_reply": "2023-05-18T06:57:01.258401Z"
    }
   },
   "outputs": [],
   "source": [
    "x_lims = [xmin_ymin[0]] + [xmax_ymax[0]]\n",
    "y_lims = [xmin_ymin[1]] + [xmax_ymax[1]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T06:57:01.262824Z",
     "iopub.status.busy": "2023-05-18T06:57:01.261815Z",
     "iopub.status.idle": "2023-05-18T06:57:04.995979Z",
     "shell.execute_reply": "2023-05-18T06:57:04.995402Z"
    }
   },
   "outputs": [],
   "source": [
    "fig, axs = plt.subplots(figsize = (20, 20), nrows=max(1, math.ceil(len(runs_to_display)/3)) , ncols=3)\n",
    "fig.tight_layout(pad=1.5)\n",
    "\n",
    "for i, run in enumerate(runs_to_display):\n",
    "    index = runs.index(run)\n",
    "    pca_gen = pca_generated[index]\n",
    "    ax = axs.flatten()[i]\n",
    "    ax.set_title(run.replace('_', ' '), fontsize=30)\n",
    "    ax.set_ylim(y_lims)\n",
    "    ax.set_xlim(x_lims)\n",
    "    ax.scatter(pca_gen[:, 0], pca_gen[:, 1], c='b', label = 'generated', alpha=0.25)\n",
    "    ax.scatter(pca_inactive[:, 0], pca_inactive[:, 1], c='r', label = 'inactives', alpha=0.25)\n",
    "    ax.scatter(pca_active[:, 0], pca_active[:, 1], c='g', label = 'actives', alpha=0.75)\n",
    "    ax.tick_params(axis='both', which='major', labelsize=25)\n",
    "    ax.tick_params(axis='both', which='minor', labelsize=25)\n",
    "    if i==len(runs_to_display)-1: \n",
    "        ax.legend(loc='lower right',\n",
    "              ncol=1, fancybox=True, shadow=True, fontsize=30)\n",
    "    \n",
    "plt.tight_layout()\n",
    "fig_name = 'images/' + run_name + '/PCA.pdf'\n",
    "plt.savefig(fig_name, dpi=300)   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T06:57:04.999485Z",
     "iopub.status.busy": "2023-05-18T06:57:04.999234Z",
     "iopub.status.idle": "2023-05-18T06:57:05.277906Z",
     "shell.execute_reply": "2023-05-18T06:57:05.277426Z"
    },
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Computes entropy for the different runs \n",
    "pca_generated = []\n",
    "entropies = []\n",
    "entropies_all_per_rep = []\n",
    "clusters = []\n",
    "clusters_all_per_rep = []\n",
    "\n",
    "    \n",
    "pca = PCA(n_components=2).fit(np.concatenate((fps_active_as_array,fps_inactive_as_array)))\n",
    "pca_active = pca.transform(fps_active_as_array)\n",
    "pca_inactive = pca.transform(fps_inactive_as_array)\n",
    "predicted_actives = np.where(clf.predict_proba(ecfp4(smiles_actives))[:, 1]>0.5)[0]\n",
    "\n",
    "for i, run in enumerate(runs):\n",
    "    all_curr_fps_generated = fps_generated_as_array[i]\n",
    "    all_curr_fps_generated_bitv = fps_generated_as_bitv[i]\n",
    "    entropy_per_rep =[]\n",
    "    clusters_per_rep = []\n",
    "    nb_replicas = replica_per_run[run]    \n",
    "    for replica in range(nb_replicas):\n",
    "        curr_fps_generated = all_curr_fps_generated[replica*top_kept_per_run[run][replica]:(replica+1)*top_kept_per_run[run][replica]]\n",
    "        curr_fps_generated_bitv = all_curr_fps_generated_bitv[replica*top_kept_per_run[run][replica]:(replica+1)*top_kept_per_run[run][replica]]\n",
    "        pca_generated.append(pca.transform(curr_fps_generated))\n",
    "        if kmeans:\n",
    "            curr_clusters = clustering.predict(curr_fps_generated)  \n",
    "        else:\n",
    "            curr_clusters = [find_cluster(fp, centroids_fp) for fp in curr_fps_generated_bitv]\n",
    "        probs = []\n",
    "        for i in range(len(np.unique(centroids))):\n",
    "            probs.append(len(np.where(np.array(curr_clusters)==i)[0])/len(curr_clusters))\n",
    "        curr_entropy = scipy.stats.entropy(probs)/ np.log(len(curr_clusters))\n",
    "        entropy_per_rep.append(curr_entropy)\n",
    "        clusters_per_rep.append(curr_clusters)\n",
    "    entropies_all_per_rep.append(entropy_per_rep)\n",
    "    clusters_all_per_rep.append(clusters_per_rep)\n",
    "entropies = [x for sublist in entropies_all_per_rep for x in sublist]   \n",
    "clusters = [x for sublist in clusters_all_per_rep for x in sublist]   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T06:57:05.280399Z",
     "iopub.status.busy": "2023-05-18T06:57:05.279976Z",
     "iopub.status.idle": "2023-05-18T06:57:05.478061Z",
     "shell.execute_reply": "2023-05-18T06:57:05.477509Z"
    }
   },
   "outputs": [],
   "source": [
    "# compute number of clusters using RDKit's Butina algorithm\n",
    "\n",
    "n_clusters = []\n",
    "n_clusters_sd = []\n",
    "\n",
    "for i, run in enumerate(runs):\n",
    "    all_curr_fps_generated = fps_generated_as_bitv[i]\n",
    "    all_curr_n_clusters = []\n",
    "    nb_replicas = replica_per_run[run]\n",
    "    for replica in range(nb_replicas):\n",
    "        curr_fps_generated = all_curr_fps_generated[replica*top_kept_per_run[run][replica]:(replica+1)*top_kept_per_run[run][replica]]\n",
    "        all_curr_n_clusters.append(get_n_clusters(curr_fps_generated, cutoff=0.5))\n",
    "    n_clusters.append(np.mean(all_curr_n_clusters))\n",
    "    n_clusters_sd.append(np.std(all_curr_n_clusters))\n",
    "\n",
    "n_clusters_display = [ str(round(m,2))+\" (\"+str(round(sd,2))+\")\" for m,sd in zip(n_clusters, n_clusters_sd)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T06:57:05.480635Z",
     "iopub.status.busy": "2023-05-18T06:57:05.480299Z",
     "iopub.status.idle": "2023-05-18T06:57:05.486885Z",
     "shell.execute_reply": "2023-05-18T06:57:05.486420Z"
    }
   },
   "outputs": [],
   "source": [
    "xmin_ymin = np.amin(np.vstack([np.amin(p, axis=0) for p in pca_generated]), axis=0).tolist()\n",
    "xmax_ymax = np.amax(np.vstack([np.amax(p, axis=0) for p in pca_generated]), axis=0).tolist()\n",
    "x_lims = [xmin_ymin[0]] + [xmax_ymax[0]]\n",
    "y_lims = [xmin_ymin[1]] + [xmax_ymax[1]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T06:57:05.488822Z",
     "iopub.status.busy": "2023-05-18T06:57:05.488529Z",
     "iopub.status.idle": "2023-05-18T06:57:06.965933Z",
     "shell.execute_reply": "2023-05-18T06:57:06.965375Z"
    }
   },
   "outputs": [],
   "source": [
    "# Displays proportion of actives recovered at distance < 0.1 \n",
    "fig = plt.figure(figsize=(25, 25))\n",
    "\n",
    "novel_01_all_per_rep = []\n",
    "titles = []\n",
    "\n",
    "predicted_actives = np.where(clf.predict_proba(ecfp4(smiles_actives))[:, 1]>0.5)[0]\n",
    "for i, run in enumerate(runs):\n",
    "    all_curr_fps_generated = fps_generated_as_bitv[i]\n",
    "    novel_01_per_rep = []\n",
    "    nb_replicas = replica_per_run[run]\n",
    "    for replica in range(nb_replicas):\n",
    "        curr_fps_generated = all_curr_fps_generated[replica*top_kept_per_run[run][replica]:(replica+1)*top_kept_per_run[run][replica]]\n",
    "        n_new = 0\n",
    "        for s in np.array(smiles_actives)[predicted_actives]:\n",
    "            mol = Chem.MolFromSmiles(s)\n",
    "            if max_tanimoto_similarity([AllChem.GetMorganFingerprintAsBitVect(mol, 2)], curr_fps_generated)>0.9:\n",
    "                n_new += 1\n",
    "        novel_01_per_rep.append(n_new/len(predicted_actives))\n",
    "        titles.append(run.replace('_', ' '))\n",
    "    novel_01_all_per_rep.append(novel_01_per_rep)\n",
    "\n",
    "novel_01 = [x for sublist in novel_01_all_per_rep for x in sublist]    \n",
    "\n",
    "display_df = pd.DataFrame(zip(titles, novel_01), columns =['Applicability domain', 'Mean proportion of generated structures closer than 0.1 (Tanimoto distance, MFP2 FPs) from test set actives'])\n",
    "chart = sns.catplot(y=\"Applicability domain\", x='Mean proportion of generated structures closer than 0.1 (Tanimoto distance, MFP2 FPs) from test set actives', kind=\"bar\", data=display_df)\n",
    "for axes in chart.axes.flat:\n",
    "    _ = axes.set_xticklabels(axes.get_xticklabels(), rotation=90)\n",
    "plt.title(\"Actives recovered at distance $<$ 0.1\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T06:57:06.968122Z",
     "iopub.status.busy": "2023-05-18T06:57:06.967841Z",
     "iopub.status.idle": "2023-05-18T06:57:08.413077Z",
     "shell.execute_reply": "2023-05-18T06:57:08.412526Z"
    }
   },
   "outputs": [],
   "source": [
    "# Displays proportion of actives recovered \n",
    "\n",
    "fig = plt.figure(figsize=(25, 25))\n",
    "\n",
    "novel_recovered_all_per_rep = []\n",
    "titles = []\n",
    "\n",
    "predicted_actives = np.where(clf.predict_proba(ecfp4(smiles_actives))[:, 1]>0.5)[0]\n",
    "for i, run in enumerate(runs):\n",
    "    all_curr_fps_generated = fps_generated_as_bitv[i]\n",
    "    novel_recovered_per_rep = []\n",
    "    nb_replicas = replica_per_run[run]\n",
    "    for replica in range(nb_replicas):\n",
    "        curr_fps_generated = all_curr_fps_generated[replica*top_kept_per_run[run][replica]:(replica+1)*top_kept_per_run[run][replica]]\n",
    "        n_new = 0\n",
    "        for s in np.array(smiles_actives)[predicted_actives]:\n",
    "            mol = Chem.MolFromSmiles(s)\n",
    "            if max_tanimoto_similarity([AllChem.GetMorganFingerprintAsBitVect(mol, 2)], curr_fps_generated)>0.99:\n",
    "                n_new += 1\n",
    "        novel_recovered_per_rep.append(n_new/len(predicted_actives))\n",
    "        titles.append(run.replace('_', ' '))\n",
    "    novel_recovered_all_per_rep.append(novel_recovered_per_rep)\n",
    "\n",
    "novel_recovered = [x for sublist in novel_recovered_all_per_rep for x in sublist]    \n",
    "\n",
    "display_df = pd.DataFrame(zip(titles, novel_recovered), columns =['Applicability domain', 'Generated structures with similarity=1 (same structure, stereoisomer or very close structure) from test set actives'])\n",
    "chart = sns.catplot(y=\"Applicability domain\", x=\"Generated structures with similarity=1 (same structure, stereoisomer or very close structure) from test set actives\", kind=\"bar\", data=display_df)\n",
    "for axes in chart.axes.flat:\n",
    "    _ = axes.set_xticklabels(axes.get_xticklabels(), rotation=90)\n",
    "plt.title(\"Actives recovered\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T06:57:08.415369Z",
     "iopub.status.busy": "2023-05-18T06:57:08.414939Z",
     "iopub.status.idle": "2023-05-18T06:57:10.878535Z",
     "shell.execute_reply": "2023-05-18T06:57:10.878040Z"
    }
   },
   "outputs": [],
   "source": [
    "# Computes distances to training set molecules to display enrichment \n",
    "training_set_molecules_predicted_actives = np.where(clf.predict_proba(ecfp4(smiles_actives+smiles_inactives))[:, 1]>0.5)[0]\n",
    "training_set_molecules_predicted_inactives = np.where(clf.predict_proba(ecfp4(smiles_actives+smiles_inactives))[:, 1]<=0.5)[0]\n",
    "average_similarities = []\n",
    "max_similarities_actives = []\n",
    "max_similarities_inactives = []\n",
    "similarities_actives = []\n",
    "similarities_inactives = []\n",
    "similarities_to_closest_actives = []\n",
    "similarities_to_closest_inactives = []\n",
    "similarities_to_closest_predicted_actives = []\n",
    "similarities_to_closest_predicted_inactives = []\n",
    "\n",
    "ordered_runs = ['maxsim_ecfp4',\n",
    "                'range_physchem_range_ecfp4_counts']\n",
    "labels = [\n",
    " 'maxsim ecfp4',\n",
    " \n",
    " 'range physchem + range ecfp4 counts',]\n",
    "\n",
    "for i, run in enumerate(ordered_runs):\n",
    "    curr_fps_generated = fps_generated_as_bitv[runs.index(run)]\n",
    "    average_similarities.append(average_tanimoto_similarity(fps_active_as_bitv, curr_fps_generated))\n",
    "    max_similarities_actives.append(max_tanimoto_similarity(fps_active_as_bitv, curr_fps_generated))\n",
    "    max_similarities_inactives.append(max_tanimoto_similarity(fps_active_as_bitv, curr_fps_generated))\n",
    "    similarities_actives.append(tanimoto_similarities(fps_active_as_bitv, curr_fps_generated))\n",
    "    similarities_inactives.append(tanimoto_similarities(fps_inactive_as_bitv, curr_fps_generated))\n",
    "    curr_similarities_to_closest_actives = []\n",
    "    for fp in fps_active_as_bitv:\n",
    "        curr_similarities_to_closest_actives.append(max_tanimoto_similarity([fp], curr_fps_generated))\n",
    "    similarities_to_closest_actives.append(curr_similarities_to_closest_actives)\n",
    "    curr_similarities_to_closest_inactives = []\n",
    "    for fp in fps_inactive_as_bitv:\n",
    "        curr_similarities_to_closest_inactives.append(max_tanimoto_similarity([fp], curr_fps_generated))\n",
    "    similarities_to_closest_inactives.append(curr_similarities_to_closest_inactives)\n",
    "    curr_similarities_to_closest_predicted_actives = []\n",
    "    curr_similarities_to_closest_predicted_inactives = []\n",
    "    for j, fp in enumerate(fps_active_as_bitv + fps_inactive_as_bitv):\n",
    "        if j in training_set_molecules_predicted_actives:\n",
    "            curr_similarities_to_closest_predicted_actives.append(max_tanimoto_similarity([fp], curr_fps_generated))\n",
    "        if j in training_set_molecules_predicted_inactives:\n",
    "            curr_similarities_to_closest_predicted_inactives.append(max_tanimoto_similarity([fp], curr_fps_generated))\n",
    "    similarities_to_closest_predicted_actives.append(curr_similarities_to_closest_predicted_inactives)\n",
    "    similarities_to_closest_predicted_inactives.append(curr_similarities_to_closest_predicted_inactives)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T06:57:10.881260Z",
     "iopub.status.busy": "2023-05-18T06:57:10.880813Z",
     "iopub.status.idle": "2023-05-18T06:57:10.885474Z",
     "shell.execute_reply": "2023-05-18T06:57:10.884998Z"
    }
   },
   "outputs": [],
   "source": [
    "# Computes distances to training set molecules to display enrichment \n",
    "active_neighbours = []\n",
    "inactive_neighbours = []\n",
    "\n",
    "for i, run in enumerate(ordered_runs):\n",
    "    active_sims = similarities_to_closest_actives[i]\n",
    "    inactive_sims = similarities_to_closest_inactives[i]\n",
    "        \n",
    "    active_sims = np.array(active_sims)\n",
    "    inactive_sims = np.array(inactive_sims)\n",
    "    \n",
    "    sim_tresholds = [0.95, 0.9, 0.85, 0.8, 0.75, 0.7, 0.6, 0.5, 0]\n",
    "    curr_active_neighbours = []\n",
    "    curr_inactive_neighbours = []\n",
    "    sim_tresholds.reverse()\n",
    "    for s in sim_tresholds:\n",
    "        try:\n",
    "            curr_active_neighbours.append(len(np.where(active_sims>s)[0]))\n",
    "        except:\n",
    "            curr_active_neighbours.append(0)\n",
    "        try:\n",
    "            curr_inactive_neighbours.append(len(np.where(inactive_sims>s)[0]))\n",
    "            \n",
    "        except:\n",
    "            curr_inactive_neighbours.append(0)\n",
    "    active_neighbours.append(curr_active_neighbours)\n",
    "    inactive_neighbours.append(curr_inactive_neighbours)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T06:57:10.887518Z",
     "iopub.status.busy": "2023-05-18T06:57:10.887122Z",
     "iopub.status.idle": "2023-05-18T06:57:11.700648Z",
     "shell.execute_reply": "2023-05-18T06:57:11.700045Z"
    }
   },
   "outputs": [],
   "source": [
    "\n",
    "# Compares enrichment on a good and a bad AD \n",
    "labels = ['Bad AD: maxsim ecfp4', 'Good AD: range physchem + range ecfp4 counts']\n",
    "fig, axs = plt.subplots(figsize = (20, 10), nrows=max(1, math.ceil(len(ordered_runs)/2)) , ncols=2, sharey=True)\n",
    "fig.tight_layout(pad=1.5)\n",
    "fig.suptitle('Fraction of actives and inactives among the training set molecules close to the generated molecules',fontsize=30, y = 1.05)\n",
    "\n",
    "for i, run in enumerate(ordered_runs):\n",
    "    curr_active_neighbours = active_neighbours[i]\n",
    "    curr_inactive_neighbours = inactive_neighbours[i]\n",
    "    ax = axs.flatten()[i]\n",
    "    ax.set_title(labels[i], fontsize=30)\n",
    "    ax.bar(np.arange(len(sim_tresholds)), np.array(curr_active_neighbours)/len(fps_active_as_bitv), width=0.25, label='fraction actives')\n",
    "    ax.bar(np.arange(len(sim_tresholds))+ 0.25, np.array(curr_inactive_neighbours)/len(fps_inactive_as_bitv), width=0.25, label='fraction inactives')\n",
    "    \n",
    "    ax.set_xticks(np.arange(len(sim_tresholds)))\n",
    "    ax.set_xticklabels(['$<$0.5'] + sim_tresholds[1:])\n",
    "    ax.tick_params(axis='both', which='major', labelsize=25)\n",
    "\n",
    "    ax.set_ylim(0, 1.05)\n",
    "    if i == 0 :\n",
    "        ax.legend(loc=0, fontsize=25)\n",
    "        \n",
    "plt.tight_layout()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T06:57:11.703261Z",
     "iopub.status.busy": "2023-05-18T06:57:11.702825Z",
     "iopub.status.idle": "2023-05-18T06:57:14.204247Z",
     "shell.execute_reply": "2023-05-18T06:57:14.203708Z"
    }
   },
   "outputs": [],
   "source": [
    "# Computes distances to training set molecules to display enrichment \n",
    "training_set_molecules_predicted_actives = np.where(clf.predict_proba(ecfp4(smiles_actives+smiles_inactives))[:, 1]>0.5)[0]\n",
    "training_set_molecules_predicted_inactives = np.where(clf.predict_proba(ecfp4(smiles_actives+smiles_inactives))[:, 1]<=0.5)[0]\n",
    "average_similarities = []\n",
    "max_similarities_actives = []\n",
    "max_similarities_inactives = []\n",
    "similarities_actives = []\n",
    "similarities_inactives = []\n",
    "similarities_to_closest_actives = []\n",
    "similarities_to_closest_inactives = []\n",
    "similarities_to_closest_predicted_actives = []\n",
    "similarities_to_closest_predicted_inactives = []\n",
    "\n",
    "ordered_runs = ['maxsim_ecfp4',\n",
    "                'range_physchem_range_ecfp4_counts']\n",
    "labels = [\n",
    " 'maxsim ecfp4',\n",
    " \n",
    " 'range physchem + range ecfp4 counts',]\n",
    "\n",
    "for i, run in enumerate(ordered_runs):\n",
    "    all_curr_fps_generated = fps_generated_as_bitv[runs.index(run)]\n",
    "    nb_replicas = replica_per_run[run]\n",
    "    for replica in range(nb_replicas):\n",
    "        nb_kept = top_kept_per_run[run][replica]\n",
    "        curr_fps_generated = all_curr_fps_generated[replica*nb_kept:(replica+1)*nb_kept]\n",
    "        average_similarities.append(average_tanimoto_similarity(fps_active_as_bitv, curr_fps_generated))\n",
    "        max_similarities_actives.append(max_tanimoto_similarity(fps_active_as_bitv, curr_fps_generated))\n",
    "        max_similarities_inactives.append(max_tanimoto_similarity(fps_active_as_bitv, curr_fps_generated))\n",
    "        similarities_actives.append(tanimoto_similarities(fps_active_as_bitv, curr_fps_generated))\n",
    "        similarities_inactives.append(tanimoto_similarities(fps_inactive_as_bitv, curr_fps_generated))\n",
    "        curr_similarities_to_closest_actives = []\n",
    "        for fp in fps_active_as_bitv:\n",
    "            curr_similarities_to_closest_actives.append(max_tanimoto_similarity([fp], curr_fps_generated))\n",
    "        similarities_to_closest_actives.append(curr_similarities_to_closest_actives)\n",
    "        curr_similarities_to_closest_inactives = []\n",
    "        for fp in fps_inactive_as_bitv:\n",
    "            curr_similarities_to_closest_inactives.append(max_tanimoto_similarity([fp], curr_fps_generated))\n",
    "        similarities_to_closest_inactives.append(curr_similarities_to_closest_inactives)\n",
    "        curr_similarities_to_closest_predicted_actives = []\n",
    "        curr_similarities_to_closest_predicted_inactives = []\n",
    "        for j, fp in enumerate(fps_active_as_bitv + fps_inactive_as_bitv):\n",
    "            if j in training_set_molecules_predicted_actives:\n",
    "                curr_similarities_to_closest_predicted_actives.append(max_tanimoto_similarity([fp], curr_fps_generated))\n",
    "            if j in training_set_molecules_predicted_inactives:\n",
    "                curr_similarities_to_closest_predicted_inactives.append(max_tanimoto_similarity([fp], curr_fps_generated))\n",
    "        similarities_to_closest_predicted_actives.append(curr_similarities_to_closest_predicted_inactives)\n",
    "        similarities_to_closest_predicted_inactives.append(curr_similarities_to_closest_predicted_inactives)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T06:57:14.206816Z",
     "iopub.status.busy": "2023-05-18T06:57:14.206356Z",
     "iopub.status.idle": "2023-05-18T06:57:14.215482Z",
     "shell.execute_reply": "2023-05-18T06:57:14.215024Z"
    }
   },
   "outputs": [],
   "source": [
    "# Computes distances to training set molecules to display enrichment \n",
    "active_neighbours = []\n",
    "inactive_neighbours = []\n",
    "run_names = []\n",
    "curr_index = 0\n",
    "\n",
    "for i, run in enumerate(ordered_runs):\n",
    "    for replica in range(nb_replicas):\n",
    "        active_sims = similarities_to_closest_actives[curr_index+replica]\n",
    "        inactive_sims = similarities_to_closest_inactives[curr_index+replica]\n",
    "            \n",
    "        active_sims = np.array(active_sims)\n",
    "        inactive_sims = np.array(inactive_sims)\n",
    "        \n",
    "        sim_thresholds = [0.95, 0.9, 0.85, 0.8, 0.75, 0.7, 0.6, 0.5, 0]\n",
    "        curr_active_neighbours = []\n",
    "        curr_inactive_neighbours = []\n",
    "        sim_thresholds.reverse()\n",
    "        for s in sim_thresholds:\n",
    "            try:\n",
    "                curr_active_neighbours.append(len(np.where(active_sims>s)[0]))\n",
    "            except:\n",
    "                curr_active_neighbours.append(0)\n",
    "            try:\n",
    "                curr_inactive_neighbours.append(len(np.where(inactive_sims>s)[0]))\n",
    "                \n",
    "            except:\n",
    "                curr_inactive_neighbours.append(0)\n",
    "        curr_active_neighbours = [i/len(fps_active_as_bitv) for i in curr_active_neighbours ]\n",
    "        curr_inactive_neighbours = [i/len(fps_inactive_as_bitv) for i in curr_inactive_neighbours ]\n",
    "        active_neighbours.append(curr_active_neighbours)\n",
    "        inactive_neighbours.append(curr_inactive_neighbours)\n",
    "        run_names.append(run)\n",
    "    curr_index = curr_index + replica_per_run[run]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T06:57:14.217785Z",
     "iopub.status.busy": "2023-05-18T06:57:14.217378Z",
     "iopub.status.idle": "2023-05-18T06:57:14.229905Z",
     "shell.execute_reply": "2023-05-18T06:57:14.229487Z"
    }
   },
   "outputs": [],
   "source": [
    "sim_thresholds_colnames = ['$<$0.5'] + [ str(i) for i in sim_thresholds[1:]]\n",
    "fraction_active_col = [ \"Active\" for r in run_names]\n",
    "fraction_inactive_col = [ \"Inactive\" for r in run_names]\n",
    "\n",
    "#sim_thresholds_inact = [ \"i_\"+str(i) for i in sim_thresholds]\n",
    "\n",
    "display_df = pd.concat([pd.concat([pd.DataFrame(run_names,columns=['Applicability domain']),pd.DataFrame(fraction_active_col,columns=['Set']), pd.DataFrame(np.array(active_neighbours),columns=sim_thresholds_colnames)],axis=1,ignore_index=False), pd.concat([pd.DataFrame(run_names,columns=['Applicability domain']),pd.DataFrame(fraction_inactive_col,columns=['Set']),pd.DataFrame(np.array(inactive_neighbours),columns=sim_thresholds_colnames)],axis=1,ignore_index=False)])\n",
    "display_df = display_df.melt(id_vars=['Applicability domain','Set'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T06:57:14.231974Z",
     "iopub.status.busy": "2023-05-18T06:57:14.231664Z",
     "iopub.status.idle": "2023-05-18T06:57:14.240272Z",
     "shell.execute_reply": "2023-05-18T06:57:14.239845Z"
    }
   },
   "outputs": [],
   "source": [
    "display_df.rename(columns={'variable' : 'Similarity (Tanimoto)', 'value' : 'fraction'},inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T06:57:14.242178Z",
     "iopub.status.busy": "2023-05-18T06:57:14.241865Z",
     "iopub.status.idle": "2023-05-18T06:57:16.401445Z",
     "shell.execute_reply": "2023-05-18T06:57:16.400770Z"
    }
   },
   "outputs": [],
   "source": [
    "chart = sns.catplot(data=display_df, x='Similarity (Tanimoto)', y='fraction', hue=\"Set\", kind=\"bar\", col='Applicability domain')\n",
    "#fig.tight_layout(pad=1.5)\n",
    "#chart.fig.suptitle('Fraction of actives and inactives among the training set molecules close to the generated molecules',y = 1.05)\n",
    "\n",
    "fig_name = 'images/' + run_name + '/training_set_analogs_among_generated.pdf'\n",
    "\n",
    "chart.savefig(fig_name, dpi=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T06:57:16.403742Z",
     "iopub.status.busy": "2023-05-18T06:57:16.403292Z",
     "iopub.status.idle": "2023-05-18T06:57:17.462650Z",
     "shell.execute_reply": "2023-05-18T06:57:17.462104Z"
    }
   },
   "outputs": [],
   "source": [
    "# Compares enrichment on a good and a bad AD \n",
    "labels = ['Bad AD: maxsim ecfp4', 'Good AD: range physchem + range ecfp4 counts']\n",
    "fig, axs = plt.subplots(figsize = (20, 10), nrows=max(1, math.ceil(len(ordered_runs)/2)) , ncols=2, sharey=True)\n",
    "fig.tight_layout(pad=1.5)\n",
    "fig.suptitle('Fraction of actives and inactives among the training set molecules close to the generated molecules',fontsize=30, y = 1.05)\n",
    "\n",
    "for i, run in enumerate(ordered_runs):\n",
    "    curr_active_neighbours = active_neighbours[i]\n",
    "    curr_inactive_neighbours = inactive_neighbours[i]\n",
    "    ax = axs.flatten()[i]\n",
    "    ax.set_title(labels[i], fontsize=30)\n",
    "    ax.bar(np.arange(len(sim_tresholds)), np.array(curr_active_neighbours)/len(fps_active_as_bitv), width=0.25, label='fraction actives')\n",
    "    ax.bar(np.arange(len(sim_tresholds))+ 0.25, np.array(curr_inactive_neighbours)/len(fps_inactive_as_bitv), width=0.25, label='fraction inactives')\n",
    "    \n",
    "    ax.set_xticks(np.arange(len(sim_tresholds)))\n",
    "    ax.set_xticklabels(['$<$0.5'] + sim_tresholds[1:])\n",
    "    ax.tick_params(axis='both', which='major', labelsize=25)\n",
    "\n",
    "    ax.set_ylim(0, 1.05)\n",
    "    if i == 0 :\n",
    "        ax.legend(loc=0, fontsize=25)\n",
    "        \n",
    "plt.tight_layout()\n",
    "fig_name = 'images/' + run_name + '/enrichment.pdf'\n",
    "plt.savefig(fig_name, dpi=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T06:57:17.464786Z",
     "iopub.status.busy": "2023-05-18T06:57:17.464431Z",
     "iopub.status.idle": "2023-05-18T06:57:18.066683Z",
     "shell.execute_reply": "2023-05-18T06:57:18.066183Z"
    }
   },
   "outputs": [],
   "source": [
    "# Computes QED and SAS for the test set \n",
    "qed_dataset = []\n",
    "sas_dataset = []\n",
    "for s in smiles_actives + smiles_inactives:\n",
    "    mol = Chem.MolFromSmiles(s)\n",
    "    qed_dataset.append(Descriptors.qed(mol))\n",
    "    sas_dataset.append(calculateScore(mol))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T06:57:18.069192Z",
     "iopub.status.busy": "2023-05-18T06:57:18.068847Z",
     "iopub.status.idle": "2023-05-18T06:57:47.978168Z",
     "shell.execute_reply": "2023-05-18T06:57:47.977683Z"
    }
   },
   "outputs": [],
   "source": [
    "ordered_runs = ['smiles_validity_ecfp4', 'maxsim_ecfp4', 'maxsim_ecfp6', 'maxsim_ap', 'range_qed',\n",
    "                'range_ecfp4', 'range_ecfp4_counts', 'range_physchem', 'range_physchem_range_ap', 'range_physchem_range_ecfp4', 'range_physchem_range_ecfp6',\n",
    "                'range_physchem_range_ecfp4_counts', 'range_physchem_maxsim_ecfp4', 'range_physchem_maxsim_ecfp6', \n",
    "                'range_physchem_maxsim_ap']\n",
    "                \n",
    "# Computes QED and SAS for generated sets \n",
    "QED = []\n",
    "SAS = []\n",
    "\n",
    "SAS_for_results = []\n",
    "QED_for_results = []\n",
    "ad = []\n",
    "for i, run in enumerate(ordered_runs):\n",
    "    avg_sims = []\n",
    "    max_sim = []\n",
    "    smiles_generated = smiles_list[runs.index(run)]\n",
    "    qed_generated = []\n",
    "    sas_generated = []\n",
    "    for s in smiles_generated:\n",
    "        mol = Chem.MolFromSmiles(s)\n",
    "        qed_generated.append(Descriptors.qed(mol))\n",
    "        sas_generated.append(calculateScore(mol))\n",
    "        #QED.append(Descriptors.qed(mol))\n",
    "        #SAS.append(calculateScore(mol))\n",
    "        ad.append(run)\n",
    "    SAS_for_results.append(sas_generated)\n",
    "    QED_for_results.append(qed_generated)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T06:57:47.980815Z",
     "iopub.status.busy": "2023-05-18T06:57:47.980346Z",
     "iopub.status.idle": "2023-05-18T06:57:48.856316Z",
     "shell.execute_reply": "2023-05-18T06:57:48.855702Z"
    }
   },
   "outputs": [],
   "source": [
    "ordered_runs_4_display = list(reversed(ordered_runs))\n",
    "SAS_for_results_4display = list(reversed(SAS_for_results))\n",
    "\n",
    "# Plots SAS distributions \n",
    "matplotlib.rcParams.update({'font.size': 35})\n",
    "\n",
    "plt.figure(figsize= (15, 15))\n",
    "\n",
    "c = 'blue'\n",
    "box = plt.boxplot(SAS_for_results_4display, labels = [x.replace('validity_ecfp4', 'validity').replace('_', ' ') for x in ordered_runs_4_display], vert=False, patch_artist=True,\n",
    "            boxprops=dict(facecolor=c, color=c, alpha=0.5),\n",
    "            capprops=dict(color=c),\n",
    "            whiskerprops=dict(color='k'),\n",
    "            flierprops=dict(color=c, markeredgecolor=c),\n",
    "            medianprops=dict(color='k'),)\n",
    "\n",
    "\n",
    "\n",
    "plt.axvline(np.percentile(sas_dataset, 100), ls='--', label='Dataset extreme QED values', c='g')\n",
    "plt.axvline(np.percentile(sas_dataset, 0), ls='--', c='g')\n",
    "xmin, xmax, ymin, ymax = plt.axis()\n",
    "plt.fill_between([np.percentile(sas_dataset, 0), np.percentile(sas_dataset, 100)], ymin, ymax, color='g', alpha=0.1, label = 'Valid QED')\n",
    "plt.xlabel(\"Synthetic Accessibility Score Distribution\", fontsize=30)\n",
    "plt.xticks(fontsize=30)\n",
    "plt.yticks(fontsize=30)\n",
    "\n",
    "\n",
    "plt.tight_layout()\n",
    "fig_name = 'images/' + run_name + '/SAS_distribution.pdf'\n",
    "plt.savefig(fig_name, dpi=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T06:57:48.858776Z",
     "iopub.status.busy": "2023-05-18T06:57:48.858425Z",
     "iopub.status.idle": "2023-05-18T06:57:49.747364Z",
     "shell.execute_reply": "2023-05-18T06:57:49.746831Z"
    }
   },
   "outputs": [],
   "source": [
    "QED_for_results_4display = list(reversed(QED_for_results))\n",
    "\n",
    "# Plots QED distributions \n",
    "plt.figure(figsize= (15, 15))\n",
    "c = 'blue'\n",
    "box = plt.boxplot(QED_for_results_4display, labels = [x.replace('validity_ecfp4', 'validity').replace('_', ' ') for x in ordered_runs_4_display], vert=False, patch_artist=True,\n",
    "            boxprops=dict(facecolor=c, color=c, alpha=0.5),\n",
    "            capprops=dict(color=c),\n",
    "            whiskerprops=dict(color='k'),\n",
    "            flierprops=dict(color=c, markeredgecolor=c),\n",
    "            medianprops=dict(color='k'),)\n",
    "\n",
    "plt.axvline(np.percentile(qed_dataset, 100), ls='--', label='Dataset extreme QED values', c='g')\n",
    "plt.axvline(np.percentile(qed_dataset, 0), ls='--', c='g')\n",
    "xmin, xmax, ymin, ymax = plt.axis()\n",
    "plt.fill_between([np.percentile(qed_dataset, 0), np.percentile(qed_dataset, 100)], ymin, ymax, color='g', alpha=0.1, label = 'Valid QED')\n",
    "plt.xlabel(\"QED Distribution\", fontsize=30)\n",
    "plt.xticks(fontsize=30)\n",
    "plt.yticks(fontsize=30)\n",
    "\n",
    "\n",
    "plt.tight_layout()\n",
    "fig_name = 'images/' + run_name + '/QED_distribution.pdf'\n",
    "plt.savefig(fig_name, dpi=300)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Comparing different AD's outputs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T06:57:49.749600Z",
     "iopub.status.busy": "2023-05-18T06:57:49.749261Z",
     "iopub.status.idle": "2023-05-18T06:57:49.752374Z",
     "shell.execute_reply": "2023-05-18T06:57:49.751863Z"
    }
   },
   "outputs": [],
   "source": [
    "from utils import qualitative_analysis, return_distribution_cycle_size, return_distribution_mw, return_distribution_halogen, return_distribution_heteroatoms, return_distribution_radicals, return_distribution_sulphur, qualitative_analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T06:57:49.754293Z",
     "iopub.status.busy": "2023-05-18T06:57:49.754087Z",
     "iopub.status.idle": "2023-05-18T06:57:53.587848Z",
     "shell.execute_reply": "2023-05-18T06:57:53.587257Z"
    }
   },
   "outputs": [],
   "source": [
    "# Example on maxsim AP applicability domain of comparison of properties distribution with the test set \n",
    "properties = ['cycle_size', 'mw', 'halogen', 'sulphur', 'heteroatoms', 'radicals']\n",
    "properties_name = ['Cycle size', 'Molecular Weight', 'Halogen atoms', 'Sulfur atoms', 'Heteroatom-heteroatom bonds', 'Unpaired electrons']\n",
    "\n",
    "fig, axs = plt.subplots(figsize = (20, 20), nrows=max(1, math.ceil(len(properties)/3)) , ncols=3)\n",
    "\n",
    "fig.tight_layout(pad=1.5)\n",
    "for i, prop in enumerate(properties):\n",
    "    ax = axs.flatten()[i]\n",
    "    ax.set_xlabel(properties_name[i], fontsize=30)\n",
    "    ref_distribution = locals()[\"return_distribution_\" + prop](smiles_test)\n",
    "    generated_distribution = locals()[\"return_distribution_\" + prop](smiles_list[0])\n",
    "    if i%3==0:\n",
    "        ax.set_ylabel(\"Frequency\", fontsize=30)\n",
    "    ax.hist([ref_distribution, generated_distribution], label=['Dataset', 'Generated'], density=True)\n",
    "    if i==len(properties)-1:\n",
    "        ax.legend(loc='upper right',\n",
    "              ncol=1, fancybox=True, shadow=True, fontsize=30)\n",
    "    ax.tick_params(axis='both', which='major', labelsize=25)\n",
    "    ax.tick_params(axis='both', which='minor', labelsize=25)\n",
    "fig.tight_layout(pad=3.0)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T06:57:53.590263Z",
     "iopub.status.busy": "2023-05-18T06:57:53.589906Z",
     "iopub.status.idle": "2023-05-18T06:57:53.592682Z",
     "shell.execute_reply": "2023-05-18T06:57:53.592229Z"
    }
   },
   "outputs": [],
   "source": [
    "best_methods = ['range_physchem_range_ap', 'range_ecfp4_counts', 'range_physchem_range_ecfp4_counts', 'range_physchem_range_ecfp6', 'range_physchem_range_ecfp4']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T06:57:53.594604Z",
     "iopub.status.busy": "2023-05-18T06:57:53.594370Z",
     "iopub.status.idle": "2023-05-18T06:59:38.671038Z",
     "shell.execute_reply": "2023-05-18T06:59:38.670439Z"
    }
   },
   "outputs": [],
   "source": [
    "# Computes average similarities between runs from the \"best methods\"\n",
    "average_similarities = []\n",
    "max_similarities = []\n",
    "common_molecules = {}\n",
    "for i, run in enumerate(best_methods):\n",
    "    avg_sims = []\n",
    "    max_sim = []\n",
    "    smiles_generated = smiles_list[runs.index(run)]\n",
    "    fps_generated = fps_generated_as_bitv[runs.index(run)]\n",
    "    for j, comparison_run in enumerate(best_methods):\n",
    "        smiles_generated = smiles_list[runs.index(comparison_run)]\n",
    "        fps_other = fps_generated_as_bitv[runs.index(comparison_run)]\n",
    "        if j<i:\n",
    "            indexes, indexes_other = indexes_identical_fps(fps_generated, fps_other)\n",
    "            common_molecules[run + '_vs_' + comparison_run] = [indexes, indexes_other] \n",
    "        avg_sims.append(average_tanimoto_similarity(fps_generated, fps_other))\n",
    "        max_sim.append(max_tanimoto_similarity(fps_generated, fps_other))\n",
    "    average_similarities.append(avg_sims)\n",
    "    max_similarities.append(max_sim)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T06:59:38.673744Z",
     "iopub.status.busy": "2023-05-18T06:59:38.673277Z",
     "iopub.status.idle": "2023-05-18T06:59:44.390230Z",
     "shell.execute_reply": "2023-05-18T06:59:44.389731Z"
    }
   },
   "outputs": [],
   "source": [
    "# Displays average generated set - generated set similarities \n",
    "from mpl_toolkits.axes_grid1 import make_axes_locatable\n",
    "\n",
    "labels = ['range physchem + range ap', 'range ecfp4 counts', 'range physchem + range ecfp4 counts', 'range physchem + range ecfp6', 'range physchem + range ecfp4']\n",
    "labels_xaxis = ['range physchem \\n + range ap', 'range ecfp4 counts', 'range physchem \\n + range ecfp4 counts', 'range physchem \\n + range ecfp6', 'range physchem \\n + range ecfp4']\n",
    "\n",
    "\n",
    "fig, ax = plt.subplots(figsize = (20, 20), nrows=1 , ncols=1)\n",
    "\n",
    "fig.tight_layout(pad=1.5)\n",
    "divider = make_axes_locatable(ax)\n",
    "cax = divider.append_axes('right', size='5%', pad=0.05)\n",
    "\n",
    "\n",
    "\n",
    "ax.set_title(\"Average similarities between generated sets\", fontsize=35)\n",
    "\n",
    "im = ax.imshow(np.array(average_similarities), cmap='Blues')\n",
    "ax.set_yticks(ticks=range(len(best_methods)))\n",
    "ax.set_xticks(ticks=range(len(best_methods)))\n",
    "ax.set_xticklabels(labels_xaxis, rotation=45)\n",
    "ax.set_yticklabels(labels_xaxis, rotation=45)\n",
    "ax.tick_params(axis='both', which='major', labelsize=35)\n",
    "ax.tick_params(axis='both', which='minor', labelsize=35)\n",
    "#plt.colorbar()\n",
    "fig.tight_layout(pad=3.0)\n",
    "cbar = plt.colorbar(im, cax=cax, orientation='vertical')\n",
    "ax.grid(False)\n",
    "cbar.ax.tick_params(labelsize=35)\n",
    "\n",
    "plt.tight_layout()\n",
    "fig_name = 'images/' + run_name + '/similarities.pdf'\n",
    "plt.savefig(fig_name, dpi=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T06:59:44.393318Z",
     "iopub.status.busy": "2023-05-18T06:59:44.393089Z",
     "iopub.status.idle": "2023-05-18T06:59:51.343660Z",
     "shell.execute_reply": "2023-05-18T06:59:51.343112Z"
    }
   },
   "outputs": [],
   "source": [
    "# Scores distribution throughout optimization for the different AD\n",
    "ordered_runs = ['smiles_validity_ecfp4', 'maxsim_ecfp4', 'maxsim_ecfp6', 'maxsim_ap', 'range_qed',\n",
    "                'range_ecfp4', 'range_ecfp4_counts', 'range_physchem', 'range_physchem_range_ap', 'range_physchem_range_ecfp4', 'range_physchem_range_ecfp6',\n",
    "                'range_physchem_range_ecfp4_counts', 'range_physchem_maxsim_ecfp4', 'range_physchem_maxsim_ecfp6', \n",
    "                'range_physchem_maxsim_ap']\n",
    "fig, axs = plt.subplots(figsize = (20, 20), nrows=max(1, math.ceil(len(ordered_runs)/3)) , ncols=3, sharey=True)\n",
    "\n",
    "fig.tight_layout(pad=1.5)\n",
    "\n",
    "for i, run in enumerate(ordered_runs):\n",
    "    ax = axs.flatten()[i]\n",
    "    ax.set_title(run.replace('_', ' '))\n",
    "    scores = np.array(scores_trajectories[runs.index(run)])\n",
    "    median = np.median(scores, 1)\n",
    "    q25 = np.percentile(scores, 5, axis=1)\n",
    "    q75 = np.percentile(scores, 95, axis=1)\n",
    "    ax.plot(median, c='b', label='Generated scores')\n",
    "    ax.fill_between(\n",
    "        np.arange(median.shape[0]), q25, q75, alpha=.1, color='b')\n",
    "    ax.axhline(y=0.5, linewidth=1, ls='--', color='r', label='Predicted active threshold')\n",
    "    ax.axhline(y=np.max(scores_test), linewidth=1, ls='--', color='g', label='Maximum test set score')\n",
    "    ax.legend(loc=4)\n",
    "fig.suptitle('Evolution of scores distributions', fontweight =\"bold\", y=1.05)\n",
    "plt.tight_layout()\n",
    "fig_name = 'images/' + run_name + '/scores_distribution.pdf'\n",
    "plt.savefig(fig_name, dpi=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T06:59:51.346494Z",
     "iopub.status.busy": "2023-05-18T06:59:51.346044Z",
     "iopub.status.idle": "2023-05-18T06:59:53.946089Z",
     "shell.execute_reply": "2023-05-18T06:59:53.945530Z"
    }
   },
   "outputs": [],
   "source": [
    "internal_diversity = []\n",
    "internal_diversity_sd = []\n",
    "for i, run in enumerate(ordered_runs):\n",
    "    all_curr_fps_generated = fps_generated_as_bitv[runs.index(run)]\n",
    "    all_curr_internal_diversity = []\n",
    "    nb_replicas = replica_per_run[run]\n",
    "    for replica in range(nb_replicas):\n",
    "        curr_fps_generated = all_curr_fps_generated[replica*top_kept_per_run[run][replica]:(replica+1)*top_kept_per_run[run][replica]]\n",
    "        curr_internal_diversity = average_tanimoto_similarity(curr_fps_generated, curr_fps_generated)\n",
    "        all_curr_internal_diversity.append(curr_internal_diversity)\n",
    "    internal_diversity.append(np.mean(all_curr_internal_diversity))\n",
    "    internal_diversity_sd.append(np.std(all_curr_internal_diversity))\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T06:59:53.948756Z",
     "iopub.status.busy": "2023-05-18T06:59:53.948268Z",
     "iopub.status.idle": "2023-05-18T06:59:53.951709Z",
     "shell.execute_reply": "2023-05-18T06:59:53.951249Z"
    }
   },
   "outputs": [],
   "source": [
    "internal_diversity_display = [ str(round(1-m,2))+\" (\"+str(round(sd,2))+\")\" for m,sd in zip(internal_diversity,internal_diversity_sd)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T06:59:53.953763Z",
     "iopub.status.busy": "2023-05-18T06:59:53.953460Z",
     "iopub.status.idle": "2023-05-18T06:59:53.965007Z",
     "shell.execute_reply": "2023-05-18T06:59:53.964569Z"
    }
   },
   "outputs": [],
   "source": [
    "novel_01_display = [ str(round(100*np.mean(n),1))+\" (\"+str(round(100*np.std(n),1))+\")\" for n in novel_01_all_per_rep]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T06:59:53.967073Z",
     "iopub.status.busy": "2023-05-18T06:59:53.966785Z",
     "iopub.status.idle": "2023-05-18T06:59:53.976067Z",
     "shell.execute_reply": "2023-05-18T06:59:53.975630Z"
    }
   },
   "outputs": [],
   "source": [
    "novel_01_display = [novel_01_display[runs.index(run)] for run in ordered_runs]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T06:59:53.977982Z",
     "iopub.status.busy": "2023-05-18T06:59:53.977789Z",
     "iopub.status.idle": "2023-05-18T06:59:53.987171Z",
     "shell.execute_reply": "2023-05-18T06:59:53.986730Z"
    }
   },
   "outputs": [],
   "source": [
    "novel_01_num = [ round(100*np.mean(n),1) for n in novel_01_all_per_rep]\n",
    "novel_01_num = [novel_01_num[runs.index(run)] for run in ordered_runs]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T06:59:53.989326Z",
     "iopub.status.busy": "2023-05-18T06:59:53.988915Z",
     "iopub.status.idle": "2023-05-18T06:59:54.001532Z",
     "shell.execute_reply": "2023-05-18T06:59:54.001048Z"
    }
   },
   "outputs": [],
   "source": [
    "novel_recovered_display = [ str(round(100*np.mean(n),1))+\" (\"+str(round(100*np.std(n),1))+\")\" for n in novel_recovered_all_per_rep]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "novel_recovered_display= [novel_recovered_display[runs.index(run)] for run in ordered_runs]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "novel_recovered_num =  [ round(100*np.mean(n),1) for n in novel_recovered_all_per_rep]\n",
    "novel_recovered_num = [novel_recovered_num[runs.index(run)] for run in ordered_runs]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_clusters_display = [n_clusters_display[runs.index(run)] for run in ordered_runs]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "entropies_display = [ str(round(np.mean(np.nan_to_num(n,nan=0)),2)) + \" (\" + str(round(np.std(np.nan_to_num(n,nan=0)),2)) + \")\" for n in entropies_all_per_rep]\n",
    "entropies_display = [entropies_display[runs.index(run)] for run in ordered_runs]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ordered_runs = ['smiles_validity_ecfp4', 'maxsim_ecfp4', 'maxsim_ecfp6', 'maxsim_ap', 'range_qed',\n",
    "                'range_ecfp4', 'range_ecfp4_counts', 'range_physchem', 'range_physchem_range_ap', 'range_physchem_range_ecfp4', 'range_physchem_range_ecfp6',\n",
    "                'range_physchem_range_ecfp4_counts', 'range_physchem_maxsim_ecfp4', 'range_physchem_maxsim_ecfp6', \n",
    "                'range_physchem_maxsim_ap']\n",
    "                \n",
    "top_SAS = np.percentile(sas_dataset, 95)\n",
    "sas_in_range = []\n",
    "sas_in_range_sd = []\n",
    "for i, run in enumerate(ordered_runs):\n",
    "    all_curr_sas_in_range = []\n",
    "    nb_replicas = replica_per_run[runs[runs.index(run)]]\n",
    "    for replica in range(nb_replicas):\n",
    "        curr_sas_in_range = SAS_for_results[i][replica*top_kept_per_run[run][replica]:(replica+1)*top_kept_per_run[run][replica]]\n",
    "        curr_sas_in_range_x = [ x<top_SAS for x in curr_sas_in_range]\n",
    "        all_curr_sas_in_range.append(curr_sas_in_range_x)\n",
    "    sas_in_range.append(np.mean(all_curr_sas_in_range))\n",
    "    sas_in_range_sd.append(np.std(all_curr_sas_in_range))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T06:59:54.003441Z",
     "iopub.status.busy": "2023-05-18T06:59:54.003130Z",
     "iopub.status.idle": "2023-05-18T06:59:54.010945Z",
     "shell.execute_reply": "2023-05-18T06:59:54.010531Z"
    }
   },
   "outputs": [],
   "source": [
    "sas_in_range_display = [ str(round(m*100,2))+\" (\"+str(round(sd*100,2))+\")\" for m,sd in zip(sas_in_range,sas_in_range_sd)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T06:59:54.012971Z",
     "iopub.status.busy": "2023-05-18T06:59:54.012675Z",
     "iopub.status.idle": "2023-05-18T06:59:54.025608Z",
     "shell.execute_reply": "2023-05-18T06:59:54.025208Z"
    }
   },
   "outputs": [],
   "source": [
    "ordered_runs = ['smiles_validity_ecfp4', 'maxsim_ecfp4', 'maxsim_ecfp6', 'maxsim_ap', 'range_qed',\n",
    "                'range_ecfp4', 'range_ecfp4_counts', 'range_physchem', 'range_physchem_range_ap', 'range_physchem_range_ecfp4', 'range_physchem_range_ecfp6',\n",
    "                'range_physchem_range_ecfp4_counts', 'range_physchem_maxsim_ecfp4', 'range_physchem_maxsim_ecfp6', \n",
    "                'range_physchem_maxsim_ap']\n",
    "                \n",
    "bottom_QED = np.percentile(qed_dataset, 5)\n",
    "qed_in_range = []\n",
    "qed_in_range_sd = []\n",
    "for i, run in enumerate(ordered_runs):\n",
    "    all_curr_qed_in_range = []\n",
    "    nb_replicas = replica_per_run[runs[runs.index(run)]]\n",
    "    for replica in range(nb_replicas):\n",
    "        #print(replica, top_kept_per_run[run][replica])\n",
    "        curr_qed_in_range = QED_for_results[i][replica*top_kept_per_run[run][replica]:(replica+1)*top_kept_per_run[run][replica]]\n",
    "        curr_qed_in_range = [ x>bottom_QED for x in curr_qed_in_range]\n",
    "        all_curr_qed_in_range.append(curr_qed_in_range)\n",
    "    qed_in_range.append(np.mean(all_curr_qed_in_range))\n",
    "    qed_in_range_sd.append(np.std(all_curr_qed_in_range))\n",
    "\n",
    "qed_in_range_display = [ str(round(m*100,2))+\" (\"+str(round(sd*100,2))+\")\" for m,sd in zip(qed_in_range,qed_in_range_sd)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T06:59:54.027738Z",
     "iopub.status.busy": "2023-05-18T06:59:54.027363Z",
     "iopub.status.idle": "2023-05-18T07:00:45.374756Z",
     "shell.execute_reply": "2023-05-18T07:00:45.374261Z"
    }
   },
   "outputs": [],
   "source": [
    "cycle_size = []\n",
    "cycle_size_sd = []\n",
    "mw = []\n",
    "mw_sd = []\n",
    "heteroatoms = []\n",
    "heteroatoms_sd = []\n",
    "radicals = []\n",
    "radicals_sd = []\n",
    "for i, run in enumerate(ordered_runs):\n",
    "    all_curr_smiles = smiles_list[runs.index(run)]\n",
    "    all_curr_quantitative_analysis_results = []\n",
    "    nb_replicas = replica_per_run[runs[runs.index(run)]]\n",
    "    for replica in range(nb_replicas):\n",
    "        #print(replica, top_kept_per_run[run][replica])\n",
    "        curr_smiles = all_curr_smiles[replica*top_kept_per_run[run][replica]:(replica+1)*top_kept_per_run[run][replica]]\n",
    "        curr_quantitative_analysis_results = quantitative_analysis(curr_smiles, smiles_test)\n",
    "        all_curr_quantitative_analysis_results.append(curr_quantitative_analysis_results)\n",
    "    cycle_size.append(np.mean([x[0] for x in all_curr_quantitative_analysis_results]))\n",
    "    cycle_size_sd.append(np.std([x[0] for x in all_curr_quantitative_analysis_results]))\n",
    "    mw.append(np.mean([x[1] for x in all_curr_quantitative_analysis_results]))\n",
    "    mw_sd.append(np.std([x[1] for x in all_curr_quantitative_analysis_results]))\n",
    "    heteroatoms.append(np.mean([x[2] for x in all_curr_quantitative_analysis_results]))\n",
    "    heteroatoms_sd.append(np.std([x[2] for x in all_curr_quantitative_analysis_results]))\n",
    "    radicals.append(np.mean([x[3] for x in all_curr_quantitative_analysis_results]))\n",
    "    radicals_sd.append(np.std([x[3] for x in all_curr_quantitative_analysis_results]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T07:00:45.377412Z",
     "iopub.status.busy": "2023-05-18T07:00:45.377058Z",
     "iopub.status.idle": "2023-05-18T07:00:45.381686Z",
     "shell.execute_reply": "2023-05-18T07:00:45.381213Z"
    }
   },
   "outputs": [],
   "source": [
    "cycle_size_display = [ str(round(m,1))+\" (\"+str(round(sd,1))+\")\" for m,sd in zip(cycle_size,cycle_size_sd)]\n",
    "mw_display = [ str(round(m,1))+\" (\"+str(round(sd,1))+\")\" for m,sd in zip(mw,mw_sd)]\n",
    "heteroatoms_display = [ str(round(m,1))+\" (\"+str(round(sd,1))+\")\" for m,sd in zip(heteroatoms,heteroatoms_sd)]\n",
    "radicals_display = [ str(round(m,1))+\" (\"+str(round(sd,1))+\")\" for m,sd in zip(radicals,radicals_sd)]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T07:00:45.427298Z",
     "iopub.status.busy": "2023-05-18T07:00:45.426933Z",
     "iopub.status.idle": "2023-05-18T07:00:45.436627Z",
     "shell.execute_reply": "2023-05-18T07:00:45.436166Z"
    }
   },
   "outputs": [],
   "source": [
    "ordered_runs = ['smiles_validity_ecfp4', 'maxsim_ecfp4', 'maxsim_ecfp6', 'maxsim_ap', 'range_qed',\n",
    "                'range_ecfp4', 'range_ecfp4_counts', 'range_physchem', 'range_physchem_range_ap', 'range_physchem_range_ecfp4', 'range_physchem_range_ecfp6',\n",
    "                'range_physchem_range_ecfp4_counts', 'range_physchem_maxsim_ecfp4', 'range_physchem_maxsim_ecfp6', \n",
    "                'range_physchem_maxsim_ap']\n",
    "df_w_sd = pd.DataFrame(list(zip(n_clusters_display, entropies_display, internal_diversity_display, novel_01_display, novel_recovered_display,\n",
    "                           sas_in_range_display,qed_in_range_display, cycle_size_display, mw_display, heteroatoms_display, radicals_display)),\n",
    "               columns =['Number of clusters', 'Entropies', 'Internal diversity','Actives recovered at distance <0.1', \n",
    "                         'Actives recovered', 'Valid SAS', 'Valid QED', 'Valid cycle sizes',\n",
    "                        'Valid MW', 'Valid het-het bonds', 'Unpaired electrons'],\n",
    "                 index = ordered_runs)\n",
    "\n",
    "df_w_sd = df_w_sd.reset_index(drop=False)\n",
    "df_w_sd['index']=[s.replace('_', ' ') for s in df_w_sd['index']]\n",
    "df_w_sd.set_index('index',drop=True,inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_w_sd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T07:01:33.413851Z",
     "iopub.status.busy": "2023-05-18T07:01:33.413466Z",
     "iopub.status.idle": "2023-05-18T07:01:33.737490Z",
     "shell.execute_reply": "2023-05-18T07:01:33.737000Z"
    }
   },
   "outputs": [],
   "source": [
    "# The dataframe with the global results without SD is used to generate the background colors of the table\n",
    "ordered_runs = ['smiles_validity_ecfp4', 'maxsim_ecfp4', 'maxsim_ecfp6', 'maxsim_ap', 'range_qed',\n",
    "                'range_ecfp4', 'range_ecfp4_counts', 'range_physchem', 'range_physchem_range_ap', 'range_physchem_range_ecfp4', 'range_physchem_range_ecfp6',\n",
    "                'range_physchem_range_ecfp4_counts', 'range_physchem_maxsim_ecfp4', 'range_physchem_maxsim_ecfp6', \n",
    "                'range_physchem_maxsim_ap']\n",
    "df = pd.DataFrame(list(zip(n_clusters, [x*100 for x in entropies], 100*(1 - np.array(internal_diversity)), [x for x in novel_01_num], [x for x in novel_recovered_num],\n",
    "                           100 * np.array([np.mean(x<top_SAS) for x in SAS_for_results]),\n",
    "                           100 * np.array([np.mean(x>bottom_QED) for x in QED_for_results]), cycle_size, mw, heteroatoms, radicals)),\n",
    "               columns =['Number of clusters', 'Entropies', 'Internal diversity','Actives recovered at distance <0.1', \n",
    "                         'Actives recovered', 'Valid SAS', 'Valid QED', 'Valid cycle sizes',\n",
    "                        'Valid MW', 'Valid het-het bonds', 'Unpaired electrons'],\n",
    "                 index = ordered_runs)\n",
    "\n",
    "df = df.reset_index(drop=False)\n",
    "df['index']=[s.replace('_', ' ') for s in df['index']]\n",
    "df.set_index('index',drop=True,inplace=True)\n",
    "\n",
    "df_dummy = pd.DataFrame(list(zip([0, 10], [0, 1], [0, 100], [0, 100], [0, 100], [0, 100], [0, 100], [0, 100], [0, 100], [0, 100], [0, 100])),\n",
    "               columns =['Number of clusters','Entropies', 'Internal diversity','Actives recovered at distance <0.1', \n",
    "                         'Actives recovered', 'Valid SAS', 'Valid QED', 'Valid cycle sizes',\n",
    "                        'Valid MW', 'Valid het-het bonds', 'Unpaired electrons'],\n",
    "                 index = [\"dummy_low\", \"dummy_high\"])\n",
    "df = pd.concat([df, df_dummy])\n",
    "s = df.style.background_gradient(cmap = 'BuGn', axis = None, subset=['Number of clusters', 'Entropies', 'Actives recovered at distance <0.1',\n",
    "       'Actives recovered', 'Valid SAS', 'Valid QED', 'Internal diversity', 'Valid cycle sizes', 'Valid MW', 'Valid het-het bonds', 'Unpaired electrons'])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T07:01:33.740113Z",
     "iopub.status.busy": "2023-05-18T07:01:33.739686Z",
     "iopub.status.idle": "2023-05-18T07:01:33.769331Z",
     "shell.execute_reply": "2023-05-18T07:01:33.768843Z"
    }
   },
   "outputs": [],
   "source": [
    "df_4_display = pd.concat([df_w_sd, df_dummy])\n",
    "s_4_display = df_4_display.style.background_gradient(cmap = 'BuGn', axis=None, gmap=df)\n",
    "# Get latex code to display as table in article manuscript \n",
    "table_as_string = s_4_display.to_latex(convert_css=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T07:01:33.771364Z",
     "iopub.status.busy": "2023-05-18T07:01:33.771156Z",
     "iopub.status.idle": "2023-05-18T07:01:33.782813Z",
     "shell.execute_reply": "2023-05-18T07:01:33.782344Z"
    }
   },
   "outputs": [],
   "source": [
    "s_4_display"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T07:01:33.784784Z",
     "iopub.status.busy": "2023-05-18T07:01:33.784419Z",
     "iopub.status.idle": "2023-05-18T07:01:33.826371Z",
     "shell.execute_reply": "2023-05-18T07:01:33.825869Z"
    }
   },
   "outputs": [],
   "source": [
    "out_filename = \"results_\" + run_name_low + \"_raw.tex\"\n",
    "out_table_file = open(out_filename, \"w\")\n",
    "n = out_table_file.write(table_as_string)\n",
    "out_table_file.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Qualitative analysis "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T07:01:33.828726Z",
     "iopub.status.busy": "2023-05-18T07:01:33.828515Z",
     "iopub.status.idle": "2023-05-18T07:01:33.832038Z",
     "shell.execute_reply": "2023-05-18T07:01:33.831616Z"
    }
   },
   "outputs": [],
   "source": [
    "runs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T07:01:33.833936Z",
     "iopub.status.busy": "2023-05-18T07:01:33.833645Z",
     "iopub.status.idle": "2023-05-18T07:01:34.018925Z",
     "shell.execute_reply": "2023-05-18T07:01:34.018356Z"
    }
   },
   "outputs": [],
   "source": [
    "# example with run \"maxsim_ap\"\n",
    "\n",
    "# pick from runs list\n",
    "ad = 'maxsim_ap'\n",
    "show_grid_mols(ad)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T07:01:34.022362Z",
     "iopub.status.busy": "2023-05-18T07:01:34.021998Z",
     "iopub.status.idle": "2023-05-18T07:01:34.099942Z",
     "shell.execute_reply": "2023-05-18T07:01:34.099517Z"
    }
   },
   "outputs": [],
   "source": [
    "save_mols(ad, [0, 1, 4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T07:01:34.102322Z",
     "iopub.status.busy": "2023-05-18T07:01:34.101890Z",
     "iopub.status.idle": "2023-05-18T07:01:34.146308Z",
     "shell.execute_reply": "2023-05-18T07:01:34.145909Z"
    }
   },
   "outputs": [],
   "source": [
    "save_mols(ad, [0, 1, 11])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T07:01:34.148412Z",
     "iopub.status.busy": "2023-05-18T07:01:34.148202Z",
     "iopub.status.idle": "2023-05-18T07:01:34.306303Z",
     "shell.execute_reply": "2023-05-18T07:01:34.305736Z"
    }
   },
   "outputs": [],
   "source": [
    "ad = 'smiles_validity_ecfp4'\n",
    "show_grid_mols(ad)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T07:01:34.309392Z",
     "iopub.status.busy": "2023-05-18T07:01:34.309226Z",
     "iopub.status.idle": "2023-05-18T07:01:34.368709Z",
     "shell.execute_reply": "2023-05-18T07:01:34.368265Z"
    }
   },
   "outputs": [],
   "source": [
    "save_mols(ad, [0, 1, 24])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T07:01:34.370995Z",
     "iopub.status.busy": "2023-05-18T07:01:34.370592Z",
     "iopub.status.idle": "2023-05-18T07:01:34.553602Z",
     "shell.execute_reply": "2023-05-18T07:01:34.553073Z"
    }
   },
   "outputs": [],
   "source": [
    "ad = 'range_physchem_maxsim_ap'\n",
    "show_grid_mols(ad)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T07:01:34.557437Z",
     "iopub.status.busy": "2023-05-18T07:01:34.556954Z",
     "iopub.status.idle": "2023-05-18T07:01:34.616925Z",
     "shell.execute_reply": "2023-05-18T07:01:34.616482Z"
    }
   },
   "outputs": [],
   "source": [
    "save_mols(ad, [4, 5, 49])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T07:01:34.619175Z",
     "iopub.status.busy": "2023-05-18T07:01:34.618867Z",
     "iopub.status.idle": "2023-05-18T07:01:34.778272Z",
     "shell.execute_reply": "2023-05-18T07:01:34.777719Z"
    }
   },
   "outputs": [],
   "source": [
    "ad = 'range_physchem_range_ap'\n",
    "show_grid_mols(ad)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T07:01:34.781636Z",
     "iopub.status.busy": "2023-05-18T07:01:34.781111Z",
     "iopub.status.idle": "2023-05-18T07:01:34.847934Z",
     "shell.execute_reply": "2023-05-18T07:01:34.847490Z"
    }
   },
   "outputs": [],
   "source": [
    "save_mols(ad, [4, 20, 44])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T07:01:34.850143Z",
     "iopub.status.busy": "2023-05-18T07:01:34.849819Z",
     "iopub.status.idle": "2023-05-18T07:01:35.012666Z",
     "shell.execute_reply": "2023-05-18T07:01:35.012075Z"
    }
   },
   "outputs": [],
   "source": [
    "ad = 'range_ecfp4_counts'\n",
    "show_grid_mols(ad)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T07:01:35.015791Z",
     "iopub.status.busy": "2023-05-18T07:01:35.015526Z",
     "iopub.status.idle": "2023-05-18T07:01:35.079047Z",
     "shell.execute_reply": "2023-05-18T07:01:35.078599Z"
    }
   },
   "outputs": [],
   "source": [
    "save_mols(ad, [0, 8, 49])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T07:01:35.081506Z",
     "iopub.status.busy": "2023-05-18T07:01:35.081082Z",
     "iopub.status.idle": "2023-05-18T07:01:35.241299Z",
     "shell.execute_reply": "2023-05-18T07:01:35.240712Z"
    }
   },
   "outputs": [],
   "source": [
    "ad = 'range_physchem_range_ecfp4_counts'\n",
    "show_grid_mols(ad)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T07:01:35.244629Z",
     "iopub.status.busy": "2023-05-18T07:01:35.244181Z",
     "iopub.status.idle": "2023-05-18T07:01:35.318594Z",
     "shell.execute_reply": "2023-05-18T07:01:35.318125Z"
    }
   },
   "outputs": [],
   "source": [
    "save_mols(ad, [5, 6, 40])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T07:01:35.320982Z",
     "iopub.status.busy": "2023-05-18T07:01:35.320663Z",
     "iopub.status.idle": "2023-05-18T07:01:35.483171Z",
     "shell.execute_reply": "2023-05-18T07:01:35.482604Z"
    }
   },
   "outputs": [],
   "source": [
    "ad = 'range_physchem'\n",
    "show_grid_mols(ad)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T07:01:35.486573Z",
     "iopub.status.busy": "2023-05-18T07:01:35.486155Z",
     "iopub.status.idle": "2023-05-18T07:01:35.551524Z",
     "shell.execute_reply": "2023-05-18T07:01:35.551005Z"
    }
   },
   "outputs": [],
   "source": [
    "save_mols(ad, [ 6, 8, 25, 29 ])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T07:01:35.554031Z",
     "iopub.status.busy": "2023-05-18T07:01:35.553689Z",
     "iopub.status.idle": "2023-05-18T07:01:35.717576Z",
     "shell.execute_reply": "2023-05-18T07:01:35.717071Z"
    }
   },
   "outputs": [],
   "source": [
    "ad = 'maxsim_ecfp4'\n",
    "show_grid_mols(ad)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T07:01:35.721150Z",
     "iopub.status.busy": "2023-05-18T07:01:35.720706Z",
     "iopub.status.idle": "2023-05-18T07:01:35.782872Z",
     "shell.execute_reply": "2023-05-18T07:01:35.782413Z"
    }
   },
   "outputs": [],
   "source": [
    "save_mols(ad, [ 1, 30, 36 ])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T07:01:35.785436Z",
     "iopub.status.busy": "2023-05-18T07:01:35.785019Z",
     "iopub.status.idle": "2023-05-18T07:01:35.949251Z",
     "shell.execute_reply": "2023-05-18T07:01:35.948715Z"
    }
   },
   "outputs": [],
   "source": [
    "ad = 'range_physchem_maxsim_ecfp4'\n",
    "show_grid_mols(ad)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T07:01:35.952585Z",
     "iopub.status.busy": "2023-05-18T07:01:35.952223Z",
     "iopub.status.idle": "2023-05-18T07:01:36.020347Z",
     "shell.execute_reply": "2023-05-18T07:01:36.019778Z"
    }
   },
   "outputs": [],
   "source": [
    "save_mols(ad, [ 2, 9, 29 ])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T07:01:36.022887Z",
     "iopub.status.busy": "2023-05-18T07:01:36.022449Z",
     "iopub.status.idle": "2023-05-18T07:01:36.182178Z",
     "shell.execute_reply": "2023-05-18T07:01:36.181664Z"
    }
   },
   "outputs": [],
   "source": [
    "ad = 'range_physchem_range_ecfp6'\n",
    "show_grid_mols(ad)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T07:01:36.185678Z",
     "iopub.status.busy": "2023-05-18T07:01:36.185218Z",
     "iopub.status.idle": "2023-05-18T07:01:36.251428Z",
     "shell.execute_reply": "2023-05-18T07:01:36.250893Z"
    }
   },
   "outputs": [],
   "source": [
    "save_mols(ad, [ 4, 21, 28 ])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T07:01:36.254035Z",
     "iopub.status.busy": "2023-05-18T07:01:36.253534Z",
     "iopub.status.idle": "2023-05-18T07:01:36.411964Z",
     "shell.execute_reply": "2023-05-18T07:01:36.411264Z"
    }
   },
   "outputs": [],
   "source": [
    "ad = 'maxsim_ecfp6'\n",
    "show_grid_mols(ad)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T07:01:36.415187Z",
     "iopub.status.busy": "2023-05-18T07:01:36.414870Z",
     "iopub.status.idle": "2023-05-18T07:01:36.473374Z",
     "shell.execute_reply": "2023-05-18T07:01:36.472876Z"
    }
   },
   "outputs": [],
   "source": [
    "save_mols(ad, [ 0, 17, 29 ])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T07:01:36.475710Z",
     "iopub.status.busy": "2023-05-18T07:01:36.475355Z",
     "iopub.status.idle": "2023-05-18T07:01:36.635116Z",
     "shell.execute_reply": "2023-05-18T07:01:36.634540Z"
    }
   },
   "outputs": [],
   "source": [
    "ad = 'range_physchem_range_ecfp4'\n",
    "show_grid_mols(ad)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T07:01:36.638301Z",
     "iopub.status.busy": "2023-05-18T07:01:36.637956Z",
     "iopub.status.idle": "2023-05-18T07:01:36.694077Z",
     "shell.execute_reply": "2023-05-18T07:01:36.693600Z"
    }
   },
   "outputs": [],
   "source": [
    "save_mols(ad, [ 17, 19, 42 ])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T07:01:36.696518Z",
     "iopub.status.busy": "2023-05-18T07:01:36.696135Z",
     "iopub.status.idle": "2023-05-18T07:01:36.861060Z",
     "shell.execute_reply": "2023-05-18T07:01:36.860470Z"
    }
   },
   "outputs": [],
   "source": [
    "ad = 'range_qed'\n",
    "show_grid_mols(ad)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T07:01:36.864812Z",
     "iopub.status.busy": "2023-05-18T07:01:36.864587Z",
     "iopub.status.idle": "2023-05-18T07:01:36.932875Z",
     "shell.execute_reply": "2023-05-18T07:01:36.932424Z"
    }
   },
   "outputs": [],
   "source": [
    "save_mols(ad, [ 2, 4, 19 ])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T07:01:36.934880Z",
     "iopub.status.busy": "2023-05-18T07:01:36.934676Z",
     "iopub.status.idle": "2023-05-18T07:01:37.096213Z",
     "shell.execute_reply": "2023-05-18T07:01:37.095638Z"
    }
   },
   "outputs": [],
   "source": [
    "ad = 'range_physchem_maxsim_ecfp6'\n",
    "show_grid_mols(ad)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T07:01:37.099604Z",
     "iopub.status.busy": "2023-05-18T07:01:37.099243Z",
     "iopub.status.idle": "2023-05-18T07:01:37.162897Z",
     "shell.execute_reply": "2023-05-18T07:01:37.162439Z"
    }
   },
   "outputs": [],
   "source": [
    "save_mols(ad, [ 22, 31, 49 ])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T07:01:37.165315Z",
     "iopub.status.busy": "2023-05-18T07:01:37.164914Z",
     "iopub.status.idle": "2023-05-18T07:01:37.328983Z",
     "shell.execute_reply": "2023-05-18T07:01:37.328403Z"
    }
   },
   "outputs": [],
   "source": [
    "ad = 'range_ecfp4'\n",
    "show_grid_mols(ad)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-05-18T07:01:37.332365Z",
     "iopub.status.busy": "2023-05-18T07:01:37.331881Z",
     "iopub.status.idle": "2023-05-18T07:01:37.398657Z",
     "shell.execute_reply": "2023-05-18T07:01:37.398126Z"
    }
   },
   "outputs": [],
   "source": [
    "save_mols(ad, [ 0, 9, 25 ])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "env_AD4AI_analysis",
   "language": "python",
   "name": "env_ad4ai_analysis"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}