code_Figure_5.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Conformal prediction of molecule-induced cancer cell growth inhibition challenged by strong distribution shifts "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Code to replicate results from Fig. 5 The prediction of the pGI50 of molecule-cell line pairs improves when CP is used. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Libraries\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import math\n",
    "import os.path\n",
    "\n",
    "from sklearn.metrics import r2_score, mean_squared_error  \n",
    "from sklearn.metrics import confusion_matrix, matthews_corrcoef, accuracy_score, balanced_accuracy_score\n",
    "\n",
    "from scipy import stats  # for Rp and Rs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Validity measures -> those from NC package\n",
    "from nonconformist.evaluation import reg_mean_errors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create output folders\n",
    "\n",
    "def check_output_folder(output_directory):\n",
    "    if not(os.path.isdir(output_directory)):\n",
    "        os.makedirs(output_directory, exist_ok=True)\n",
    "    return None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Metrics "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def rmse(y_true, y_pred):\n",
    "    return np.sqrt(mean_squared_error(y_true, y_pred))\n",
    "\n",
    "\n",
    "def get_rp(y_true, y_pred):\n",
    "    \"\"\"\n",
    "    Pearson correlation\n",
    "    The Pearson correlation coefficient measures the linear relationship between two datasets. Like other correlation coefficients, this one varies between -1 and +1 with 0 implying no correlation. Correlations of -1 or +1 imply an exact linear relationship. Positive correlations imply that as x increases, so does y. Negative correlations imply that as x increases, y decreases.\n",
    "    \"\"\"\n",
    "    r = stats.pearsonr(y_true, y_pred)\n",
    "    return r[0]\n",
    "\n",
    "\n",
    "def get_rs(y_true, y_pred):\n",
    "    \"\"\" \n",
    "    Spearman correlation\n",
    "    The Spearman rank-order correlation coefficient is a nonparametric measure of the monotonicity of the relationship between two datasets. Like other correlation coefficients, this one varies between -1 and +1 with 0 implying no correlation. Correlations of -1 or +1 imply an exact monotonic relationship. Positive correlations imply that as x increases, so does y. Negative correlations imply that as x increases, y decreases.\n",
    "    \"\"\"\n",
    "    return stats.spearmanr(y_true, y_pred).correlation\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def read_one_cell_line(cell, dir_main, cp_model=['RF', 'RF'], c_lvl='80'):    \n",
    "    dir_cell_aux = dir_main+'/'+cp_model[0]+'_'+cp_model[1]+'/CELL_LINE_'+cell\n",
    "    dir_cell_in = dir_cell_aux + '/predictions/confidence_'       \n",
    "    data_in = dir_cell_in + c_lvl + '/' + cell + '_OUTLIERS_CL_' + c_lvl + '.feather'\n",
    "    df_one_cell = pd.read_feather(data_in)\n",
    "    df_one_cell['CP-valid prediction'] = np.where((df_one_cell['Observed pGI50'] >= df_one_cell['min']) & (df_one_cell['Observed pGI50'] <= df_one_cell['max']), 'CP-valid', 'CP-invalid')\n",
    "        \n",
    "    return df_one_cell"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# first main function\n",
    "\n",
    "def get_performance_values_one_model(cell_lines, dir_main, head_cols, cp_model=['RF', 'RF'], most_p=None,\n",
    "                                     c_lvl=None, cp_valid=False):\n",
    "    \"\"\"\n",
    "    Return: perf_per_cell is to get the top-n, and the best and worst predicted cell line\n",
    "    \"\"\"\n",
    "    if most_p is None:\n",
    "        pgi50 = 'ALL'  # 'pGI50: all'\n",
    "    else:\n",
    "        pgi50 = 'pGI50 >= ' + str(most_p)\n",
    "        \n",
    "    perf_per_cell = []\n",
    "    print('MODEL: ', cp_model[0], '-', cp_model[1])\n",
    "    for cell in cell_lines:\n",
    "        dir_cell_in = dir_main+'/'+cp_model[0]+'_'+cp_model[1]+'/CELL_LINE_'+cell + '/predictions/confidence_' \n",
    "\n",
    "        perf_values = get_metric_val_one_cell_line(dir_cell_in=dir_cell_in, cell=cell, most_potent=most_p,\n",
    "                                                   c_lvl=c_lvl, cp_valid=cp_valid) \n",
    "\n",
    "        a = ['Outliers', cp_valid, cell, cp_model[0]+'-'+cp_model[1], trained_on, calibrated_on, pgi50]\n",
    "        a.extend(perf_values)\n",
    "        perf_per_cell.append(a)\n",
    "        \n",
    "    df_performance_cells = pd.DataFrame(data=perf_per_cell, columns=head_cols)\n",
    "    return df_performance_cells\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_metric_val_one_cell_line(dir_cell_in, cell,  c_lvl='80', cp_valid=True, most_potent=None):\n",
    "    \"\"\"\n",
    "    - - - - - CP models\n",
    "    \"\"\"\n",
    "    if c_lvl is None:  # No confidence level\n",
    "        c_lvl = '80'\n",
    "        cp_valid = False  \n",
    "        cl_label = 'None'\n",
    "    else:\n",
    "        cp_valid = True  # make sure CP molecules are retrieved   \n",
    "        cl_label = c_lvl\n",
    "    \n",
    "    data_in = dir_cell_in + c_lvl + '/' + cell + '_OUTLIERS_CL_' + c_lvl + '.feather'\n",
    "    df_one_cell = pd.read_feather(data_in)\n",
    "    \n",
    "    # ADD CP INFORMATION\n",
    "    df_one_cell['CP-valid prediction'] = np.where((df_one_cell['Observed pGI50'] >= df_one_cell['min']) & (df_one_cell['Observed pGI50'] <= df_one_cell['max']), 'CP-valid', 'CP-invalid')\n",
    "    if cp_valid:\n",
    "        df_one_cell = df_one_cell.loc[df_one_cell.loc[:, 'CP-valid prediction'] == 'CP-valid']        \n",
    "    \n",
    "    # Most potent molecules\n",
    "    if most_potent is not None:\n",
    "        df_one_cell = df_one_cell[df_one_cell['Observed pGI50'] >= most_potent]                   \n",
    "    \n",
    "    print('\\t\\t Computing metrics over: ', df_one_cell['CP-valid prediction'].unique())\n",
    "    prediction = df_one_cell.loc[:, 'Predicted pGI50'].to_numpy()  \n",
    "    y = df_one_cell.loc[:, 'Observed pGI50'].to_numpy()            \n",
    "    \n",
    "    rmse_in_cell = rmse(y, prediction)\n",
    "    rp_in_cell = get_rp(y, prediction)\n",
    "    rs_in_cell = get_rs(y, prediction)\n",
    "    # CP metrics\n",
    "    prediction_int = df_one_cell.loc[:, ['min', 'max']].to_numpy()   # values min and max \n",
    "    eff_in_cell = np.mean(df_one_cell['size'].to_numpy())  \n",
    "    val_in_cell = reg_mean_errors(prediction_int, y, None)\n",
    "    \n",
    "    # Size\n",
    "    n_rows = df_one_cell.shape[0]    \n",
    "    return [cl_label, rmse_in_cell, rp_in_cell, rs_in_cell, eff_in_cell, val_in_cell, n_rows]\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## To plot best/worst predicted cell line "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_predicted_vs_observed_pGI50value(df_best_cl, true_val, pred_val, hx, type_mol,\n",
    "                                          title_plot, metrics_res, cell, name_plot, color='teal',\n",
    "                                          highest_p=None, type_val='non-CP', save_fig=False):  \n",
    "    plt.rcParams['font.size'] = 20\n",
    "    fig, ax = plt.subplots(figsize=(8, 8))   \n",
    "    \n",
    "    # To place the metrics information\n",
    "    props = dict(boxstyle='round', facecolor='whitesmoke', alpha=0.5)\n",
    "    # [hr_cell, rmse_noncp, rp_noncp, rs_noncp]   type_mol +\n",
    "    textstr = '# Molecules: '+str(metrics_res[-1]) +'\\nRMSE: '+str(metrics_res[2]) + '\\nRp: '+str(metrics_res[3])+ '\\nRs: '+str(metrics_res[4])\n",
    "    # place a text box in upper left in axes coords\n",
    "    ax.text(0.02, 0.98, textstr, transform=ax.transAxes, fontsize=16,\n",
    "            verticalalignment='top', bbox=props)       \n",
    "    # Full plot\n",
    "    sns.scatterplot(data=df_best_cl, x=true_val, y=pred_val, color=color,\n",
    "                    legend=False, ax=ax, alpha=0.5,)  # palette=cmap,\n",
    "    \n",
    "    plt.xlim(3.5, 11.2)\n",
    "    plt.ylim(3.5, 11.2)\n",
    "    plt.ylabel('Predicted pGI50')\n",
    "    plt.xlabel('Measured pGI50')\n",
    "    plt.xticks([4,5,6,7,8,9,10,11], [4,5,6,7,8,9,10,11])\n",
    "    ax.set_aspect('equal')    \n",
    "    plt.title(label=title_plot+'('+cell+', '+hx+')', fontdict={\"fontsize\":16})\n",
    "    plt.grid(which='both', linestyle=':', linewidth=1.5)   \n",
    "\n",
    "    if save_fig:\n",
    "        d_out = dir_out_images + '/scatter_plots' + '/' + type_val + '/'\n",
    "        check_output_folder(d_out)\n",
    "        name_save_fig = d_out + cell + '_' + name_plot + '_obsVSpred.png'\n",
    "        plt.savefig(name_save_fig, bbox_inches='tight')\n",
    "    return None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# MAIN FOLDER\n",
    "\n",
    "# Replace:\n",
    "dir_main = '/home/hernadez/Documents/conformal_prediction/retrainSTL_LDMO/'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 60 cell lines\n",
    "cells = ['MCF7', 'MDA-MB-231_ATCC' ,'HS_578T', 'BT-549', 'T-47D',\n",
    "         'SF-268','SF-295','SF-539','SNB-19', 'SNB-75', 'U251',\n",
    "         'COLO_205', 'HCC-2998', 'HCT-116', 'HCT-15','HT29', 'KM12','SW-620',\n",
    "         'CCRF-CEM', 'HL-60(TB)','K-562','MOLT-4','RPMI-8226','SR',\n",
    "         'LOX_IMVI','MALME-3M','MDA-MB-435','MDA-N','M14', 'SK-MEL-2','SK-MEL-28','SK-MEL-5','UACC-257','UACC-62',\n",
    "         'A549_ATCC','EKVX','HOP-62','HOP-92','NCI-H226','NCI-H23','NCI-H322M','NCI-H460','NCI-H522',\n",
    "         'IGROV1', 'NCI_ADR-RES','OVCAR-3','OVCAR-4', 'OVCAR-5', 'OVCAR-8', 'SK-OV-3',\n",
    "         'PC-3', 'DU-145',\n",
    "         '786-0','A498','ACHN','CAKI-1','RXF_393', 'SN12C','TK-10','UO-31']\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Columns dataframe\n",
    "\n",
    "head_cols = ['Dataset', 'Is_CPvalid', 'Cell line', 'CP models', 'Molecules potency', 'Confidence level',\n",
    "             'RMSE', 'Rp', 'Rs', 'Uncertainty', 'Error', '# Molecules']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Compute metrics "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "hx = 'XGB'\n",
    "gx = 'RF'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MODEL:  XGB - RF\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n",
      "\t\t Computing metrics over:  ['CP-valid']\n"
     ]
    }
   ],
   "source": [
    "df = get_performance_values_one_model(cell_lines=cells, dir_main=dir_main, head_cols=head_cols, \n",
    "                                      cp_model=[hx, gx], most_p=None, c_lvl='80', cp_valid=True)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  Top n and bottom n cell lines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_top_bottom_cells(df_one_model, sort_cells_by, top_n=10):\n",
    "    \"\"\"\n",
    "    Get the top n and bottom n - performing cells\n",
    "    \"\"\"    \n",
    "    if ('HR'== sort_cells_by) or ('MCC'==sort_cells_by) or ('Rp'==sort_cells_by) or ('Rs'==sort_cells_by):\n",
    "        df_sort = df_one_model.sort_values(by=[sort_cells_by], ascending=False)\n",
    "        df_topn_b = df_sort.head(top_n)\n",
    "        df_topn_w = df_sort.tail(top_n)\n",
    "        df_topn_w = df_topn_w.sort_values(by=[sort_cells_by])\n",
    "    else:\n",
    "        df_sort = df_one_model.sort_values(by=[sort_cells_by])\n",
    "        df_topn_b = df_sort.head(top_n)\n",
    "        df_topn_w = df_sort.tail(top_n)\n",
    "        df_topn_w = df_topn_w.sort_values(by=[sort_cells_by], ascending=False)\n",
    "    df_topn_b.insert(df_topn_b.shape[1], 'Rank', 'Top cell lines')\n",
    "    df_topn_w. insert(df_topn_w.shape[1], 'Rank', 'Bottom cell lines')\n",
    "    \n",
    "    df_aux = pd.concat([df_topn_b, df_topn_w], copy=False)\n",
    "    df_aux_1 = df_aux.loc[:, ['Cell line', 'Rank']]\n",
    "    \n",
    "    df_one_model_f = df_one_model.merge(df_aux_1, how='left', on='Cell line')\n",
    "    df_one_model_f.fillna('Middle cell lines', inplace=True)\n",
    "    \n",
    "    return df_topn_b, df_topn_w, df_one_model_f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_topb, df_topw, df_top = get_top_bottom_cells(df_one_model=df, sort_cells_by='HR', top_n=10)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  Best-performing cell line"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_bw_cells(df_one_model, sort_cells_by, tie_break_val='MCC'):\n",
    "    \"\"\"\n",
    "    Get best and worst performing cell lines. If tie_break is not MCC, check the code\n",
    "    \"\"\"    \n",
    "    if ('HR'== sort_cells_by) or ('MCC'==sort_cells_by) or ('Rp'==sort_cells_by) or ('Rs'==sort_cells_by): \n",
    "        # Best\n",
    "        df_best = df_one_model[df_one_model.loc[:, sort_cells_by] == df_one_model[sort_cells_by].max()]\n",
    "        df_topn_b = df_best.sort_values(by=[tie_break_val], ascending=False)\n",
    "        # Worst\n",
    "        df_worst = df_one_model[df_one_model.loc[:, sort_cells_by] == df_one_model[sort_cells_by].min()]\n",
    "        df_topn_w = df_worst.sort_values(by=[tie_break_val])        \n",
    "    else:\n",
    "        # Best\n",
    "        df_best = df_one_model[df_one_model.loc[:, sort_cells_by] == df_one_model[sort_cells_by].min()]\n",
    "        df_topn_b = df_best.sort_values(by=[tie_break_val])\n",
    "        # Worst\n",
    "        df_worst = df_one_model[df_one_model.loc[:, sort_cells_by] == df_one_model[sort_cells_by].max()]\n",
    "        df_topn_w = df_worst.sort_values(by=[tie_break_val], ascending=False)        \n",
    "    \n",
    "    df_topn_b.insert(df_topn_b.shape[1], 'Rank', 'Top cell lines')\n",
    "    df_topn_w. insert(df_topn_w.shape[1], 'Rank', 'Bottom cell lines')\n",
    "    return df_topn_b, df_topn_w"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_b1, df_w1 = get_bw_cells(df_one_model=df, sort_cells_by='HR', tie_break_val='MCC')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.05"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "percentage_mols = 5\n",
    "\n",
    "val_perc = percentage_mols/100\n",
    "\n",
    "val_perc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_25_smallest_largest(df_one_cell, percetage_retrieved):\n",
    "    df_sorted_size = df_one_cell.sort_values(by=['size'])\n",
    "    number_25 = round(df_one_cell.shape[0] * percetage_retrieved)\n",
    "    df_head_25 = df_sorted_size.head(number_25)\n",
    "    df_tail_25 = df_sorted_size.tail(number_25)\n",
    "    df_head_25['CP-valid prediction'] = 'CP-valid'\n",
    "    df_tail_25['CP-valid prediction'] = 'CP-invalid'\n",
    "    df_new_25_25 = pd.concat([df_head_25, df_tail_25], ignore_index=True, copy=False)\n",
    "    return df_new_25_25"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "def main_best_worst_cell_line(bw_cell, dir_data_in, hx, gx, c_lvl='80',\n",
    "                              th_class=6, get_cm=True, percentage_retrieved=50):            \n",
    "    \n",
    "    cell_name = bw_cell['Cell line'].values[0]  # 'OVCAR-5' # \n",
    "    df_one_cell_aux = read_one_cell_line(cell=cell_name, dir_main=dir_data_in, trained_on=trained_on,\n",
    "                                     calibrated_on=calibrated_on, cp_model=[hx, gx], c_lvl=c_lvl)    \n",
    "    print('Model:', hx, '-', gx,\n",
    "          '\\n\\t Cell line: ', cell_name, '\\n\\t Total molecules: ', df_one_cell_aux.shape[0])\n",
    "    \n",
    "    df_one_cell = get_25_smallest_largest(df_one_cell_aux, percentage_retrieved)\n",
    "    # CP valid molecules        \n",
    "    df_cpval = df_one_cell.loc[df_one_cell.loc[:, 'CP-valid prediction'] == 'CP-valid']        \n",
    "    prediction = df_cpval.loc[:, 'Predicted pGI50'].to_numpy()  # prediction value\n",
    "    y = df_cpval.loc[:, 'Observed pGI50'].to_numpy()            # true value  \n",
    "    rmse_cpval = round(rmse(y, prediction), 3)\n",
    "    rp_cpval = round(get_rp(y, prediction), 3)\n",
    "    rs_cpval = round(get_rs(y, prediction), 3)   \n",
    "    # CP invalid molecules        \n",
    "    df_cpinval = df_one_cell.loc[df_one_cell.loc[:, 'CP-valid prediction'] == 'CP-invalid']        \n",
    "    prediction_inv = df_cpinval.loc[:, 'Predicted pGI50'].to_numpy()  # prediction value\n",
    "    y_inv = df_cpinval.loc[:, 'Observed pGI50'].to_numpy()            # true value  \n",
    "    rmse_cpinval = round(rmse(y_inv, prediction_inv), 3)\n",
    "    rp_cpinval = round(get_rp(y_inv, prediction_inv), 3)\n",
    "    rs_cpinval = round(get_rs(y_inv, prediction_inv), 3) \n",
    "    all_m = [[rmse_cpval, rp_cpval, rs_cpval, df_cpval.shape[0]],  \n",
    "             [rmse_cpinval,  rp_cpinval, rs_cpinval, df_cpinval.shape[0]]]    \n",
    "    return [df_one_cell, df_cpval, df_cpinval], cell_name, all_m\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list_one_cell_b, cell_b, metrics_res_b = main_best_worst_cell_line(bw_cell=df_b1, \n",
    "                                                                   dir_data_in=dir_main, hx=hx, gx=gx,\n",
    "                                                                   c_lvl='80', th_class=6, \n",
    "                                                                   percentage_retrieved=val_perc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "true_val = \"Observed pGI50\"\n",
    "pred_val = \"Predicted pGI50\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MODEL: XGB-RF\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# CP VALID\n",
    "\n",
    "print('MODEL: '+hx+'-'+gx)\n",
    "\n",
    "title_plot = str(percentage_mols) +\"% of the molecules with the smallest uncertainty\\nfrom the best-predicted cell line \"\n",
    "name_plot = hx+'_'+gx+'BEST_CP_hx' # name to save the plot\n",
    "\n",
    "plot_predicted_vs_observed_pGI50value(df_best_cl=list_one_cell_b[1], true_val=true_val, pred_val=pred_val,\n",
    "                                      hx=hx+'-'+gx, type_mol='CP-valid molecules \\n', \n",
    "                                      color='lightseagreen',\n",
    "                                      metrics_res=metrics_res_b[0], title_plot=title_plot,\n",
    "                                      cell=cell_b, name_plot=name_plot, \n",
    "                                      highest_p=6, type_val='', save_fig=False)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MODEL: XGB-RF\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# CP invalid\n",
    "print('MODEL: '+hx+'-'+gx)\n",
    "\n",
    "title_plot_2 = str(percentage_mols) +\"% of the molecules with the largest uncertainty \\nfrom the best-predicted cell line \"\n",
    "\n",
    "plot_predicted_vs_observed_pGI50value(df_best_cl=list_one_cell_b[2], true_val=true_val, pred_val=pred_val,\n",
    "                                      hx=hx+'-'+gx, type_mol='CP-invalid molecules \\n',\n",
    "                                      color='lightcoral',\n",
    "                                      metrics_res=metrics_res_b[1], title_plot=title_plot_2,\n",
    "                                      cell=cell_b, name_plot=name_plot, \n",
    "                                      highest_p=6, type_val='', save_fig=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}