{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pathlib import Path\n",
    "from warnings import filterwarnings\n",
    "import time\n",
    "\n",
    "\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "from sklearn import svm, metrics, clone\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.neural_network import MLPClassifier\n",
    "from sklearn.model_selection import KFold, train_test_split\n",
    "from sklearn.metrics import auc, accuracy_score, recall_score\n",
    "from sklearn.metrics import roc_curve, roc_auc_score\n",
    "import matplotlib.pyplot as plt\n",
    "from rdkit import Chem\n",
    "from rdkit import DataStructs\n",
    "from rdkit.Chem import MACCSkeys\n",
    "from rdkit.Chem.AllChem import GetMorganFingerprintAsBitVect\n",
    "\n",
    "\n",
    "\n",
    "# Silence some expected warnings\n",
    "filterwarnings(\"ignore\")\n",
    "# Fix seed for reproducible results\n",
    "#SEED = 22\n",
    "#seed_everything(SEED)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pathlib import Path\n",
    "from warnings import filterwarnings\n",
    "import time\n",
    "\n",
    "\n",
    "import pandas as pd\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set path to this notebook\n",
    "DATA =\"/Users/viqor/Desktop/CADD/\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape of dataframe :  (292, 3)\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>molecule_chembl_id</th>\n",
       "      <th>smiles</th>\n",
       "      <th>selective</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>CHEMBL3670668</td>\n",
       "      <td>COc1ccc(-c2cc(-c3ccccc3)[nH]c2C(=O)NCc2ccc(C(=...</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>CHEMBL4170617</td>\n",
       "      <td>CC(C)CCN(CCCCCCC(=O)NO)c1ncc(C(=O)NCCCn2ccnc2)s1</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>CHEMBL3670669</td>\n",
       "      <td>COc1ccc(-c2cc(-c3ccccc3)[nH]c2C(=O)NCc2ccc(C(=...</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>CHEMBL1631914</td>\n",
       "      <td>COc1cc2cc(c1)COc1ccccc1NC(=O)[C@H](CCCCCC(=O)N...</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>CHEMBL3670674</td>\n",
       "      <td>Nc1ccccc1NC(=O)c1ccc(CNC(=O)c2[nH]c(-c3ccsc3)c...</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  molecule_chembl_id                                             smiles  \\\n",
       "0      CHEMBL3670668  COc1ccc(-c2cc(-c3ccccc3)[nH]c2C(=O)NCc2ccc(C(=...   \n",
       "1      CHEMBL4170617   CC(C)CCN(CCCCCCC(=O)NO)c1ncc(C(=O)NCCCn2ccnc2)s1   \n",
       "2      CHEMBL3670669  COc1ccc(-c2cc(-c3ccccc3)[nH]c2C(=O)NCc2ccc(C(=...   \n",
       "3      CHEMBL1631914  COc1cc2cc(c1)COc1ccccc1NC(=O)[C@H](CCCCCC(=O)N...   \n",
       "4      CHEMBL3670674  Nc1ccccc1NC(=O)c1ccc(CNC(=O)c2[nH]c(-c3ccsc3)c...   \n",
       "\n",
       "   selective  \n",
       "0        1.0  \n",
       "1        1.0  \n",
       "2        1.0  \n",
       "3        1.0  \n",
       "4        1.0  "
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Read data \n",
    "chembl_df = pd.read_csv(\n",
    "    DATA + \"HDAC_292_S_or_notS.csv\",\n",
    "    index_col=0,\n",
    ")\n",
    "\n",
    "# Look at head\n",
    "print(\"Shape of dataframe : \", chembl_df.shape)\n",
    "chembl_df.head()\n",
    "# NBVAL_CHECK_OUTPUT"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Molecule encoding\n",
    "\n",
    "Now we define a function `smiles_to_fp` to generate fingerprints from SMILES.\n",
    "For now, we incorporated the choice between the following fingerprints:\n",
    "\n",
    "* maccs\n",
    "* morgan2 and morgan3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def smiles_to_fp(smiles, method=\"morgan3\", n_bits=2048):\n",
    "    \"\"\"\n",
    "    Encode a molecule from a SMILES string into a fingerprint.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    smiles : str\n",
    "        The SMILES string defining the molecule.\n",
    "\n",
    "    method : str\n",
    "        The type of fingerprint to use. Default is MACCS keys.\n",
    "\n",
    "    n_bits : int\n",
    "        The length of the fingerprint.\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    array\n",
    "        The fingerprint array.\n",
    "\n",
    "    \"\"\"\n",
    "\n",
    "    # convert smiles to RDKit mol object\n",
    "    mol = Chem.MolFromSmiles(smiles)\n",
    "\n",
    "    if method == \"maccs\":\n",
    "        return np.array(MACCSkeys.GenMACCSKeys(mol))\n",
    "    if method == \"morgan2\":\n",
    "        return np.array(GetMorganFingerprintAsBitVect(mol, 2, nBits=n_bits))\n",
    "    if method == \"morgan3\":\n",
    "        return np.array(GetMorganFingerprintAsBitVect(mol, 3, nBits=n_bits))\n",
    "    else:\n",
    "        # NBVAL_CHECK_OUTPUT\n",
    "        print(f\"Warning: Wrong method specified: {method}. Default will be used instead.\")\n",
    "        return np.array(MACCSkeys.GenMACCSKeys(mol))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "compound_df = chembl_df.copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>molecule_chembl_id</th>\n",
       "      <th>smiles</th>\n",
       "      <th>selective</th>\n",
       "      <th>fp</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>CHEMBL3670668</td>\n",
       "      <td>COc1ccc(-c2cc(-c3ccccc3)[nH]c2C(=O)NCc2ccc(C(=...</td>\n",
       "      <td>1.0</td>\n",
       "      <td>[0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, ...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>CHEMBL4170617</td>\n",
       "      <td>CC(C)CCN(CCCCCCC(=O)NO)c1ncc(C(=O)NCCCn2ccnc2)s1</td>\n",
       "      <td>1.0</td>\n",
       "      <td>[0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, ...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>CHEMBL3670669</td>\n",
       "      <td>COc1ccc(-c2cc(-c3ccccc3)[nH]c2C(=O)NCc2ccc(C(=...</td>\n",
       "      <td>1.0</td>\n",
       "      <td>[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  molecule_chembl_id                                             smiles  \\\n",
       "0      CHEMBL3670668  COc1ccc(-c2cc(-c3ccccc3)[nH]c2C(=O)NCc2ccc(C(=...   \n",
       "1      CHEMBL4170617   CC(C)CCN(CCCCCCC(=O)NO)c1ncc(C(=O)NCCCn2ccnc2)s1   \n",
       "2      CHEMBL3670669  COc1ccc(-c2cc(-c3ccccc3)[nH]c2C(=O)NCc2ccc(C(=...   \n",
       "\n",
       "   selective                                                 fp  \n",
       "0        1.0  [0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, ...  \n",
       "1        1.0  [0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, ...  \n",
       "2        1.0  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ...  "
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Add column for fingerprint\n",
    "compound_df[\"fp\"] = compound_df[\"smiles\"].apply(smiles_to_fp)\n",
    "compound_df.head(3)\n",
    "# NBVAL_CHECK_OUTPUT"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Machine Learning (ML)\n",
    "\n",
    "In the following, we will try several ML approaches to classify our molecules. We will use:\n",
    "\n",
    "* Random Forest (RF)\n",
    "* Support Vector Machine (SVM) \n",
    "* Artificial Neural Network (ANN) \n",
    "\n",
    "Additionally, we will comment on the results.\n",
    "\n",
    "The goal is to test the ability of the model to predict data which it has never seen before in order to flag problems known as over fitting and to assess the generalization ability of the model.\n",
    "\n",
    "We start by defining a function `model_training_and_validation` which fits a model on a random train-test split of the data and returns measures such as accuracy, sensitivity, specificity and AUC evaluated on the test set. We also plot the ROC curves using `plot_roc_curves_for_models`.\n",
    "\n",
    "We then define a function named `crossvalidation` which executes a cross validation procedure and prints the statistics of the results over the folds."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Helper functions\n",
    "Helper function to plot customized ROC curves. Code inspired by [stackoverflow](https://stackoverflow.com/questions/42894871/how-to-plot-multiple-roc-curves-in-one-plot-with-legend-and-auc-scores-in-python)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_roc_curves_for_models(models, test_x, test_y, save_png=False):\n",
    "    \"\"\"\n",
    "    Helper function to plot customized roc curve.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    models: dict\n",
    "        Dictionary of pretrained machine learning models.\n",
    "    test_x: list\n",
    "        Molecular fingerprints for test set.\n",
    "    test_y: list\n",
    "        Associated activity labels for test set.\n",
    "    save_png: bool\n",
    "        Save image to disk (default = False)\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    fig:\n",
    "        Figure.\n",
    "    \"\"\"\n",
    "\n",
    "    fig, ax = plt.subplots()\n",
    "\n",
    "    # Below for loop iterates through your models list\n",
    "    for model in models:\n",
    "        # Select the model\n",
    "        ml_model = model[\"model\"]\n",
    "        # Prediction probability on test set\n",
    "        test_prob = ml_model.predict_proba(test_x)[:, 1]\n",
    "        # Prediction class on test set\n",
    "        test_pred = ml_model.predict(test_x)\n",
    "        # Compute False postive rate and True positive rate\n",
    "        fpr, tpr, thresholds = metrics.roc_curve(test_y, test_prob)\n",
    "        # Calculate Area under the curve to display on the plot\n",
    "        auc = roc_auc_score(test_y, test_prob)\n",
    "        # Plot the computed values\n",
    "        ax.plot(fpr, tpr, label=(f\"{model['label']} AUC area = {auc:.2f}\"))\n",
    "\n",
    "    # Custom settings for the plot\n",
    "    ax.plot([0, 1], [0, 1], \"r--\")\n",
    "    ax.set_xlabel(\"False Positive Rate\")\n",
    "    ax.set_ylabel(\"True Positive Rate\")\n",
    "    ax.set_title(\"Receiver Operating Characteristic\")\n",
    "    ax.legend(loc=\"lower right\")\n",
    "    # Save plot\n",
    "    if save_png:\n",
    "        fig.savefig(f\"{DATA}/roc_auc\", dpi=300, bbox_inches=\"tight\", transparent=True)\n",
    "    return fig"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Helper function to calculate model performance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import accuracy_score, recall_score, roc_auc_score, f1_score, balanced_accuracy_score\n",
    "\n",
    "def model_performance(ml_model, test_x, test_y, verbose=True):\n",
    "    \"\"\"\n",
    "    Helper function to calculate model performance\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    ml_model: sklearn model object\n",
    "        The machine learning model to train.\n",
    "    test_x: list\n",
    "        Molecular fingerprints for test set.\n",
    "    test_y: list\n",
    "        Associated activity labels for test set.\n",
    "    verbose: bool\n",
    "        Print performance measure (default = True)\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    tuple:\n",
    "        Accuracy, sensitivity, specificity, auc, f1 score, balanced accuracy on test set.\n",
    "    \"\"\"\n",
    "\n",
    "    # Prediction probability on test set\n",
    "    test_prob = ml_model.predict_proba(test_x)[:, 1]\n",
    "\n",
    "    # Prediction class on test set\n",
    "    test_pred = ml_model.predict(test_x)\n",
    "\n",
    "    # Performance of model on test set\n",
    "    accuracy = accuracy_score(test_y, test_pred)\n",
    "    sens = recall_score(test_y, test_pred)\n",
    "    spec = recall_score(test_y, test_pred, pos_label=0)\n",
    "    auc = roc_auc_score(test_y, test_prob)\n",
    "    f1 = f1_score(test_y, test_pred)\n",
    "    balanced_acc = balanced_accuracy_score(test_y, test_pred)\n",
    "\n",
    "    if verbose:\n",
    "        # Print performance results\n",
    "        # NBVAL_CHECK_OUTPUT        \n",
    "        print(f\"Accuracy: {accuracy:.2f}\")\n",
    "        print(f\"Sensitivity: {sens:.2f}\")\n",
    "        print(f\"Specificity: {spec:.2f}\")\n",
    "        print(f\"AUC: {auc:.2f}\")\n",
    "        print(f\"F1 Score: {f1:.2f}\")\n",
    "        print(f\"Balanced Accuracy: {balanced_acc:.2f}\")\n",
    "\n",
    "    return accuracy, sens, spec, auc, f1, balanced_acc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " Helper function to fit a machine learning model on a random train-test split of the data and return the performance measures."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "import psutil\n",
    "\n",
    "def model_training_and_validation(ml_model, name, splits, verbose=True, **mols):\n",
    "    \"\"\"\n",
    "    Fit a machine learning model on a random train-test split of the data\n",
    "    and return the performance measures.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    ml_model: sklearn model object\n",
    "        The machine learning model to train.\n",
    "    name: str\n",
    "        Name of machine learning algorithm: RF, SVM, ANN\n",
    "    splits: list\n",
    "        List of descriptor and label data: train_x, test_x, train_y, test_y.\n",
    "    verbose: bool\n",
    "        Print performance info (default = True)\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    tuple:\n",
    "        Accuracy, sensitivity, specificity, auc, f1 score, balanced accuracy on test set, time taken, memory used.\n",
    "    \"\"\"\n",
    "    train_x, test_x, train_y, test_y = splits\n",
    "\n",
    "    # Start time and memory usage\n",
    "    start_time = time.time()\n",
    "    start_memory = psutil.Process().memory_info().rss\n",
    "\n",
    "    # Fit the model\n",
    "    ml_model.fit(train_x, train_y)\n",
    "\n",
    "    # Calculate model performance results\n",
    "    accuracy, sens, spec, auc, f1, balanced_acc = model_performance(ml_model, test_x, test_y, verbose)\n",
    "\n",
    "    # End time and memory usage\n",
    "    end_time = time.time()\n",
    "    end_memory = psutil.Process().memory_info().rss\n",
    "\n",
    "    # Calculate time and memory taken\n",
    "    time_taken = end_time - start_time\n",
    "    memory_used = end_memory - start_memory\n",
    "\n",
    "    if verbose:\n",
    "        print(f\"Time Taken: {time_taken:.2f} seconds\")\n",
    "        print(f\"Memory Used: {memory_used / (1024 ** 2):.2f} MB\")  # Memory in MB\n",
    "\n",
    "    return accuracy, sens, spec, auc, f1, balanced_acc, time_taken, memory_used"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "import psutil\n",
    "from sklearn.metrics import accuracy_score, recall_score, roc_auc_score, f1_score, balanced_accuracy_score\n",
    "\n",
    "def model_performance(ml_model, test_x, test_y, verbose=True):\n",
    "    \"\"\"\n",
    "    Helper function to calculate model performance\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    ml_model: sklearn model object\n",
    "        The machine learning model to train.\n",
    "    test_x: list\n",
    "        Molecular fingerprints for test set.\n",
    "    test_y: list\n",
    "        Associated activity labels for test set.\n",
    "    verbose: bool\n",
    "        Print performance measure (default = True)\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    tuple:\n",
    "        Accuracy, sensitivity, specificity, auc, f1 score, balanced accuracy on test set.\n",
    "    \"\"\"\n",
    "\n",
    "    # Prediction probability on test set\n",
    "    test_prob = ml_model.predict_proba(test_x)[:, 1]\n",
    "\n",
    "    # Prediction class on test set\n",
    "    test_pred = ml_model.predict(test_x)\n",
    "\n",
    "    # Performance of model on test set\n",
    "    accuracy = accuracy_score(test_y, test_pred)\n",
    "    sens = recall_score(test_y, test_pred)\n",
    "    spec = recall_score(test_y, test_pred, pos_label=0)\n",
    "    auc = roc_auc_score(test_y, test_prob)\n",
    "    f1 = f1_score(test_y, test_pred)\n",
    "    balanced_acc = balanced_accuracy_score(test_y, test_pred)\n",
    "\n",
    "    if verbose:\n",
    "        # Print performance results\n",
    "        print(f\"Accuracy: {accuracy:.2f}\")\n",
    "        print(f\"Sensitivity: {sens:.2f}\")\n",
    "        print(f\"Specificity: {spec:.2f}\")\n",
    "        print(f\"AUC: {auc:.2f}\")\n",
    "        print(f\"F1 Score: {f1:.2f}\")\n",
    "        print(f\"Balanced Accuracy: {balanced_acc:.2f}\")\n",
    "\n",
    "    return accuracy, sens, spec, auc, f1, balanced_acc\n",
    "\n",
    "def model_training_and_validation(ml_model, name, splits, verbose=True, **mols):\n",
    "    \"\"\"\n",
    "    Fit a machine learning model on a random train-test split of the data\n",
    "    and return the performance measures.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    ml_model: sklearn model object\n",
    "        The machine learning model to train.\n",
    "    name: str\n",
    "        Name of machine learning algorithm: RF, SVM, ANN\n",
    "    splits: list\n",
    "        List of descriptor and label data: train_x, test_x, train_y, test_y.\n",
    "    verbose: bool\n",
    "        Print performance info (default = True)\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    tuple:\n",
    "        Accuracy, sensitivity, specificity, auc, f1 score, balanced accuracy on test set, time taken, memory used.\n",
    "    \"\"\"\n",
    "    train_x, test_x, train_y, test_y = splits\n",
    "\n",
    "    # Start time and memory usage\n",
    "    start_time = time.time()\n",
    "    start_memory = psutil.Process().memory_info().rss\n",
    "\n",
    "    # Fit the model\n",
    "    ml_model.fit(train_x, train_y)\n",
    "\n",
    "    # Calculate model performance results\n",
    "    accuracy, sens, spec, auc, f1, balanced_acc = model_performance(ml_model, test_x, test_y, verbose)\n",
    "\n",
    "    # End time and memory usage\n",
    "    end_time = time.time()\n",
    "    end_memory = psutil.Process().memory_info().rss\n",
    "\n",
    "    # Calculate time and memory taken\n",
    "    time_taken = end_time - start_time\n",
    "    memory_used = end_memory - start_memory\n",
    "\n",
    "    if verbose:\n",
    "        print(f\"Time Taken: {time_taken:.2f} seconds\")\n",
    "        print(f\"Memory Used: {memory_used / (1024 ** 2):.2f} MB\")  # Memory in MB\n",
    "\n",
    "    return accuracy, sens, spec, auc, f1, balanced_acc, time_taken, memory_used"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Preprocessing**: Split the data (will be reused for the other models)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training data size: 233\n",
      "Test data size: 59\n"
     ]
    }
   ],
   "source": [
    "fingerprint_to_model = compound_df.fp.tolist()\n",
    "label_to_model = compound_df.selective.tolist()\n",
    "\n",
    "# Split data randomly in train and test set\n",
    "# note that we use test/train_x for the respective fingerprint splits\n",
    "# and test/train_y for the respective label splits\n",
    "(\n",
    "    static_train_x,\n",
    "    static_test_x,\n",
    "    static_train_y,\n",
    "    static_test_y,\n",
    ") = train_test_split(fingerprint_to_model, label_to_model, test_size=0.2)\n",
    "splits = [static_train_x, static_test_x, static_train_y, static_test_y]\n",
    "# NBVAL_CHECK_OUTPUT\n",
    "print(\"Training data size:\", len(static_train_x))\n",
    "print(\"Test data size:\", len(static_test_x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0      [0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, ...\n",
       "1      [0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, ...\n",
       "2      [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ...\n",
       "3      [0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, ...\n",
       "4      [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, ...\n",
       "                             ...                        \n",
       "287    [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ...\n",
       "288    [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ...\n",
       "289    [0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, ...\n",
       "290    [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ...\n",
       "291    [0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, ...\n",
       "Name: fp, Length: 292, dtype: object"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compound_df.fp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Random forest classifier\n",
    "\n",
    "We start with a random forest classifier, where we first set the parameters."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We train the model on a random train-test split and plot the results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set model parameter for random forest\n",
    "param = {\n",
    "    \"n_estimators\": 10000,  # number of trees to grows\n",
    "    \"criterion\": \"entropy\",  # cost function to be optimized for a split\n",
    "}\n",
    "model_RF = RandomForestClassifier(**param)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.76\n",
      "Sensitivity: 0.63\n",
      "Specificity: 0.82\n",
      "AUC: 0.89\n",
      "F1 Score: 0.63\n",
      "Balanced Accuracy: 0.73\n",
      "Time Taken: 26.03 seconds\n",
      "Memory Used: 74.36 MB\n"
     ]
    }
   ],
   "source": [
    "# Fit model on single split\n",
    "performance_measures = model_training_and_validation(model_RF, \"RF\", splits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize the list that stores all models. First one is RF.\n",
    "models = [{\"label\": \"Model_RF\", \"model\": model_RF}]\n",
    "# Plot roc curve\n",
    "plot_roc_curves_for_models(models, static_test_x, static_test_y);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Support vector classifier\n",
    "Here we train a SVM with a radial-basis function kernel (also: squared-exponential kernel). \n",
    "For more information, see [sklearn RBF kernel](http://scikit-learn.org/stable/modules/generated/sklearn.gaussian_process.kernels.RBF.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.75\n",
      "Sensitivity: 0.26\n",
      "Specificity: 0.97\n",
      "AUC: 0.85\n",
      "F1 Score: 0.40\n",
      "Balanced Accuracy: 0.62\n",
      "Time Taken: 0.34 seconds\n",
      "Memory Used: 5.92 MB\n"
     ]
    }
   ],
   "source": [
    "# Specify model\n",
    "model_SVM = svm.SVC(kernel=\"rbf\", C=1, gamma=0.1, probability=True)\n",
    "\n",
    "# Fit model on single split\n",
    "performance_measures = model_training_and_validation(model_SVM, \"SVM\", splits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "tags": [
     "nbsphinx-thumbnail"
    ]
   },
   "outputs": [],
   "source": [
    "# Append SVM model\n",
    "models.append({\"label\": \"Model_SVM\", \"model\": model_SVM})\n",
    "# Plot roc curve\n",
    "plot_roc_curves_for_models(models, static_test_x, static_test_y);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Neural network classifier\n",
    "The last approach we try here is a neural network model. We train an MLPClassifier (Multi-layer Perceptron classifier) with 3 layers, each with 5 neurons. As before, we do the crossvalidation procedure and plot the results. For more information on MLP, see [sklearn MLPClassifier](http://scikit-learn.org/stable/modules/generated/sklearn.neural_network.MLPClassifier.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.81\n",
      "Sensitivity: 0.68\n",
      "Specificity: 0.88\n",
      "AUC: 0.89\n",
      "F1 Score: 0.70\n",
      "Balanced Accuracy: 0.78\n",
      "Time Taken: 18.87 seconds\n",
      "Memory Used: 113.82 MB\n"
     ]
    }
   ],
   "source": [
    "# Specify model\n",
    "model_ANN = MLPClassifier(hidden_layer_sizes=(2048,256))\n",
    "\n",
    "# Fit model on single split\n",
    "performance_measures = model_training_and_validation(model_ANN, \"ANN\", splits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Append ANN model\n",
    "models.append({\"label\": \"Model_ANN\", \"model\": model_ANN})\n",
    "# Plot roc curve\n",
    "plot_roc_curves_for_models(models, static_test_x, static_test_y, True);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our models show very good values for all measured values, e.g. AUCs of 0.89 or 0.90, and thus seem to be predictive."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "from tensorflow.keras.layers import Dense, GlobalAveragePooling2D\n",
    "from tensorflow.keras.models import Model, Sequential\n",
    "from tensorflow.keras.applications import ResNet50, DenseNet121\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from xgboost import XGBClassifier\n",
    "from lightgbm import LGBMClassifier\n",
    "from sklearn.metrics import roc_curve, auc\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Helper function to plot ROC curves\n",
    "def plot_roc_curves_for_models(models, test_x, test_y, verbose=True):\n",
    "    plt.figure()\n",
    "    for model_info in models:\n",
    "        label = model_info[\"label\"]\n",
    "        model = model_info[\"model\"]\n",
    "        probas = model.predict_proba(test_x)\n",
    "        fpr, tpr, thresholds = roc_curve(test_y, probas[:, 1])\n",
    "        roc_auc = auc(fpr, tpr)\n",
    "        plt.plot(fpr, tpr, lw=2, label=f'{label} (AUC = {roc_auc:.2f})')\n",
    "\n",
    "    plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')\n",
    "    plt.xlim([0.0, 1.0])\n",
    "    plt.ylim([0.0, 1.05])\n",
    "    plt.xlabel('False Positive Rate')\n",
    "    plt.ylabel('True Positive Rate')\n",
    "    plt.title('Receiver Operating Characteristic')\n",
    "    plt.legend(loc=\"lower right\")\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.76\n",
      "Sensitivity: 0.84\n",
      "Specificity: 0.72\n",
      "AUC: 0.89\n",
      "F1 Score: 0.70\n",
      "Balanced Accuracy: 0.78\n",
      "Time Taken: 0.02 seconds\n",
      "Memory Used: 3.46 MB\n",
      "Accuracy: 0.73\n",
      "Sensitivity: 0.58\n",
      "Specificity: 0.80\n",
      "AUC: 0.81\n",
      "F1 Score: 0.58\n",
      "Balanced Accuracy: 0.69\n",
      "Time Taken: 1.63 seconds\n",
      "Memory Used: 12.95 MB\n",
      "[LightGBM] [Info] Number of positive: 79, number of negative: 154\n",
      "[LightGBM] [Info] Auto-choosing row-wise multi-threading, the overhead of testing was 0.001841 seconds.\n",
      "You can set `force_row_wise=true` to remove the overhead.\n",
      "And if memory is not enough, you can set `force_col_wise=true`.\n",
      "[LightGBM] [Info] Total Bins 312\n",
      "[LightGBM] [Info] Number of data points in the train set: 233, number of used features: 156\n",
      "[LightGBM] [Info] [binary:BoostFromScore]: pavg=0.339056 -> initscore=-0.667505\n",
      "[LightGBM] [Info] Start training from score -0.667505\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "Accuracy: 0.71\n",
      "Sensitivity: 0.47\n",
      "Specificity: 0.82\n",
      "AUC: 0.82\n",
      "F1 Score: 0.51\n",
      "Balanced Accuracy: 0.65\n",
      "Time Taken: 0.27 seconds\n",
      "Memory Used: 1.30 MB\n"
     ]
    }
   ],
   "source": [
    "# k-NN Model\n",
    "model_kNN = KNeighborsClassifier(n_neighbors=5)\n",
    "performance_measures = model_training_and_validation(model_kNN, \"k-NN\", splits)\n",
    "models.append({\"label\": \"Model_kNN\", \"model\": model_kNN})\n",
    "\n",
    "# XGBoost Model\n",
    "model_XGB = XGBClassifier()\n",
    "performance_measures = model_training_and_validation(model_XGB, \"XGBoost\", splits)\n",
    "models.append({\"label\": \"Model_XGB\", \"model\": model_XGB})\n",
    "\n",
    "# LightGBM Model\n",
    "model_LGBM = LGBMClassifier()\n",
    "performance_measures = model_training_and_validation(model_LGBM, \"LightGBM\", splits)\n",
    "models.append({\"label\": \"Model_LGBM\", \"model\": model_LGBM})\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot ROC curves\n",
    "plot_roc_curves_for_models(models, static_test_x, static_test_y, True);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Cross-validation\n",
    "\n",
    "Next, we will perform cross-validation experiments with the three different models.\n",
    "Therefore, we define a helper function for machine learning model training and validation in a cross-validation loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import KFold\n",
    "from sklearn.base import clone\n",
    "from sklearn.metrics import accuracy_score, precision_score, recall_score, roc_auc_score, f1_score, balanced_accuracy_score\n",
    "import numpy as np\n",
    "import time\n",
    "import pandas as pd\n",
    "\n",
    "def model_performance(model, test_x, test_y, verbose=False):\n",
    "    \"\"\"\n",
    "    Compute performance metrics for the model.\n",
    "    \"\"\"\n",
    "    predictions = model.predict(test_x)\n",
    "    accuracy = accuracy_score(test_y, predictions)\n",
    "    sensitivity = recall_score(test_y, predictions)  # Sensitivity (Recall) is the same as recall\n",
    "    specificity = recall_score(test_y, predictions, pos_label=0)  # Specificity (Recall of the negative class)\n",
    "    auc = roc_auc_score(test_y, model.predict_proba(test_x)[:, 1])\n",
    "    f1 = f1_score(test_y, predictions)\n",
    "    balanced_acc = balanced_accuracy_score(test_y, predictions)\n",
    "    \n",
    "    if verbose:\n",
    "        print(f\"Accuracy: {accuracy:.2f}, Sensitivity: {sensitivity:.2f}, Specificity: {specificity:.2f}, AUC: {auc:.2f}, F1: {f1:.2f}, Balanced Accuracy: {balanced_acc:.2f}\")\n",
    "    \n",
    "    return accuracy, sensitivity, specificity, auc, f1, balanced_acc\n",
    "\n",
    "def crossvalidation(ml_model, df, n_folds=5, verbose=False):\n",
    "    \"\"\"\n",
    "    Machine learning model training and validation in a cross-validation loop.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    ml_model: sklearn model object\n",
    "        The machine learning model to train.\n",
    "    df: pd.DataFrame\n",
    "        Data set with SMILES and their associated activity labels.\n",
    "    n_folds: int, optional\n",
    "        Number of folds for cross-validation.\n",
    "    verbose: bool, optional\n",
    "        Performance measures are printed.\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    None\n",
    "\n",
    "    \"\"\"\n",
    "    t0 = time.time()\n",
    "    # Shuffle the indices for the k-fold cross-validation\n",
    "    kf = KFold(n_splits=n_folds, shuffle=True)\n",
    "\n",
    "    # Results for each of the cross-validation folds\n",
    "    acc_per_fold = []\n",
    "    sens_per_fold = []\n",
    "    spec_per_fold = []\n",
    "    auc_per_fold = []\n",
    "    f1_per_fold = []\n",
    "    bal_acc_per_fold = []\n",
    "\n",
    "    # Loop over the folds\n",
    "    for train_index, test_index in kf.split(df):\n",
    "        # clone model -- we want a fresh copy per fold!\n",
    "        fold_model = clone(ml_model)\n",
    "        # Training\n",
    "\n",
    "        # Convert the fingerprint and the label to a list\n",
    "        train_x = df.iloc[train_index].fp.tolist()\n",
    "        train_y = df.iloc[train_index].selective.tolist()\n",
    "\n",
    "        # Fit the model\n",
    "        fold_model.fit(train_x, train_y)\n",
    "\n",
    "        # Testing\n",
    "\n",
    "        # Convert the fingerprint and the label to a list\n",
    "        test_x = df.iloc[test_index].fp.tolist()\n",
    "        test_y = df.iloc[test_index].selective.tolist()\n",
    "\n",
    "        # Performance for each fold\n",
    "        accuracy, sens, spec, auc, f1, bal_acc = model_performance(fold_model, test_x, test_y, verbose)\n",
    "\n",
    "        # Save results\n",
    "        acc_per_fold.append(accuracy)\n",
    "        sens_per_fold.append(sens)\n",
    "        spec_per_fold.append(spec)\n",
    "        auc_per_fold.append(auc)\n",
    "        f1_per_fold.append(f1)\n",
    "        bal_acc_per_fold.append(bal_acc)\n",
    "\n",
    "    # Print statistics of results\n",
    "    print(\n",
    "        f\"Mean accuracy: {np.mean(acc_per_fold):.2f} \\t\"\n",
    "        f\"and std : {np.std(acc_per_fold):.2f} \\n\"\n",
    "        f\"Mean sensitivity: {np.mean(sens_per_fold):.2f} \\t\"\n",
    "        f\"and std : {np.std(sens_per_fold):.2f} \\n\"\n",
    "        f\"Mean specificity: {np.mean(spec_per_fold):.2f} \\t\"\n",
    "        f\"and std : {np.std(spec_per_fold):.2f} \\n\"\n",
    "        f\"Mean AUC: {np.mean(auc_per_fold):.2f} \\t\"\n",
    "        f\"and std : {np.std(auc_per_fold):.2f} \\n\"\n",
    "        f\"Mean F1 Score: {np.mean(f1_per_fold):.2f} \\t\"\n",
    "        f\"and std : {np.std(f1_per_fold):.2f} \\n\"\n",
    "        f\"Mean Balanced Accuracy: {np.mean(bal_acc_per_fold):.2f} \\t\"\n",
    "        f\"and std : {np.std(bal_acc_per_fold):.2f} \\n\"\n",
    "        f\"Time taken : {time.time() - t0:.2f}s\\n\"\n",
    "    )\n",
    "\n",
    "    return acc_per_fold, sens_per_fold, spec_per_fold, auc_per_fold, f1_per_fold, bal_acc_per_fold"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Cross-validation**\n",
    "\n",
    "We now apply cross-validation and show the statistics for all three ML models. In real world conditions, cross-validation usually applies 5 or more folds, but for the sake of performance we will reduce it to 3. You can change the value of `N_FOLDS` in this cell below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "N_FOLDS = 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_Note_: Next cell takes long to execute"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "======= \n",
      "Model_RF\n",
      "Mean accuracy: 0.79 \tand std : 0.03 \n",
      "Mean sensitivity: 0.63 \tand std : 0.10 \n",
      "Mean specificity: 0.88 \tand std : 0.02 \n",
      "Mean AUC: 0.89 \tand std : 0.00 \n",
      "Mean F1 Score: 0.66 \tand std : 0.06 \n",
      "Mean Balanced Accuracy: 0.75 \tand std : 0.05 \n",
      "Time taken : 66.75s\n",
      "\n",
      "\n",
      "======= \n",
      "Model_SVM\n",
      "Mean accuracy: 0.70 \tand std : 0.03 \n",
      "Mean sensitivity: 0.10 \tand std : 0.03 \n",
      "Mean specificity: 0.99 \tand std : 0.01 \n",
      "Mean AUC: 0.88 \tand std : 0.06 \n",
      "Mean F1 Score: 0.18 \tand std : 0.05 \n",
      "Mean Balanced Accuracy: 0.55 \tand std : 0.01 \n",
      "Time taken : 0.53s\n",
      "\n",
      "\n",
      "======= \n",
      "Model_ANN\n",
      "Mean accuracy: 0.79 \tand std : 0.02 \n",
      "Mean sensitivity: 0.67 \tand std : 0.06 \n",
      "Mean specificity: 0.86 \tand std : 0.01 \n",
      "Mean AUC: 0.86 \tand std : 0.01 \n",
      "Mean F1 Score: 0.68 \tand std : 0.06 \n",
      "Mean Balanced Accuracy: 0.76 \tand std : 0.04 \n",
      "Time taken : 44.34s\n",
      "\n",
      "\n",
      "======= \n",
      "Model_kNN\n",
      "Mean accuracy: 0.77 \tand std : 0.02 \n",
      "Mean sensitivity: 0.81 \tand std : 0.04 \n",
      "Mean specificity: 0.74 \tand std : 0.03 \n",
      "Mean AUC: 0.86 \tand std : 0.01 \n",
      "Mean F1 Score: 0.70 \tand std : 0.03 \n",
      "Mean Balanced Accuracy: 0.78 \tand std : 0.02 \n",
      "Time taken : 0.09s\n",
      "\n",
      "\n",
      "======= \n",
      "Model_XGB\n",
      "Mean accuracy: 0.79 \tand std : 0.01 \n",
      "Mean sensitivity: 0.70 \tand std : 0.02 \n",
      "Mean specificity: 0.84 \tand std : 0.02 \n",
      "Mean AUC: 0.87 \tand std : 0.01 \n",
      "Mean F1 Score: 0.69 \tand std : 0.04 \n",
      "Mean Balanced Accuracy: 0.77 \tand std : 0.01 \n",
      "Time taken : 1.94s\n",
      "\n",
      "\n",
      "======= \n",
      "Model_LGBM\n",
      "[LightGBM] [Info] Number of positive: 65, number of negative: 129\n",
      "[LightGBM] [Info] Auto-choosing row-wise multi-threading, the overhead of testing was 0.001285 seconds.\n",
      "You can set `force_row_wise=true` to remove the overhead.\n",
      "And if memory is not enough, you can set `force_col_wise=true`.\n",
      "[LightGBM] [Info] Total Bins 236\n",
      "[LightGBM] [Info] Number of data points in the train set: 194, number of used features: 118\n",
      "[LightGBM] [Info] [binary:BoostFromScore]: pavg=0.335052 -> initscore=-0.685425\n",
      "[LightGBM] [Info] Start training from score -0.685425\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Info] Number of positive: 60, number of negative: 135\n",
      "[LightGBM] [Info] Auto-choosing row-wise multi-threading, the overhead of testing was 0.000923 seconds.\n",
      "You can set `force_row_wise=true` to remove the overhead.\n",
      "And if memory is not enough, you can set `force_col_wise=true`.\n",
      "[LightGBM] [Info] Total Bins 238\n",
      "[LightGBM] [Info] Number of data points in the train set: 195, number of used features: 119\n",
      "[LightGBM] [Info] [binary:BoostFromScore]: pavg=0.307692 -> initscore=-0.810930\n",
      "[LightGBM] [Info] Start training from score -0.810930\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Info] Number of positive: 71, number of negative: 124\n",
      "[LightGBM] [Info] Auto-choosing row-wise multi-threading, the overhead of testing was 0.000947 seconds.\n",
      "You can set `force_row_wise=true` to remove the overhead.\n",
      "And if memory is not enough, you can set `force_col_wise=true`.\n",
      "[LightGBM] [Info] Total Bins 246\n",
      "[LightGBM] [Info] Number of data points in the train set: 195, number of used features: 123\n",
      "[LightGBM] [Info] [binary:BoostFromScore]: pavg=0.364103 -> initscore=-0.557602\n",
      "[LightGBM] [Info] Start training from score -0.557602\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "Mean accuracy: 0.76 \tand std : 0.01 \n",
      "Mean sensitivity: 0.62 \tand std : 0.08 \n",
      "Mean specificity: 0.83 \tand std : 0.06 \n",
      "Mean AUC: 0.84 \tand std : 0.01 \n",
      "Mean F1 Score: 0.63 \tand std : 0.01 \n",
      "Mean Balanced Accuracy: 0.73 \tand std : 0.01 \n",
      "Time taken : 0.47s\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for model in models:\n",
    "    print(\"\\n======= \")\n",
    "    print(f\"{model['label']}\")\n",
    "    crossvalidation(model[\"model\"], compound_df, n_folds=N_FOLDS)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We look at the cross-validation performance for molecules encoded using Morgan fingerprint and not MACCS keys."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_Note_: Next cell takes long to execute"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'label': 'Model_RF',\n",
       "  'model': RandomForestClassifier(criterion='entropy', n_estimators=10000)},\n",
       " {'label': 'Model_SVM', 'model': SVC(C=1, gamma=0.1, probability=True)},\n",
       " {'label': 'Model_ANN',\n",
       "  'model': MLPClassifier(hidden_layer_sizes=(2048, 256))},\n",
       " {'label': 'Model_kNN', 'model': KNeighborsClassifier()},\n",
       " {'label': 'Model_XGB',\n",
       "  'model': XGBClassifier(base_score=0.5, booster='gbtree', callbacks=None,\n",
       "                colsample_bylevel=1, colsample_bynode=1, colsample_bytree=1,\n",
       "                early_stopping_rounds=None, enable_categorical=False,\n",
       "                eval_metric=None, gamma=0, gpu_id=-1, grow_policy='depthwise',\n",
       "                importance_type=None, interaction_constraints='',\n",
       "                learning_rate=0.300000012, max_bin=256, max_cat_to_onehot=4,\n",
       "                max_delta_step=0, max_depth=6, max_leaves=0, min_child_weight=1,\n",
       "                missing=nan, monotone_constraints='()', n_estimators=100,\n",
       "                n_jobs=0, num_parallel_tree=1, predictor='auto', random_state=0,\n",
       "                reg_alpha=0, reg_lambda=1, ...)},\n",
       " {'label': 'Model_LGBM', 'model': LGBMClassifier()}]"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "models"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "teachopencadd",
   "language": "python",
   "name": "teachopencadd"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.10"
  },
  "toc-autonumbering": true,
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {},
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}