01_Preprocessing.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font size=5>**Download and Preprocessing of DD-PRiSM**</font>\n",
    "\n",
    "<font size=4>Monotherapy response dataset</font>\n",
    "-NCI60\n",
    "\n",
    "<font size=4>Combinationtherapy response dataset</font>\n",
    "-NCI-ALMANAC\n",
    "\n",
    "<font size=4>Cell line expression data</font>\n",
    "-CCLE\n",
    "\n",
    "<font size=4>Drug information</font>\n",
    "-NCI Chemical data\n",
    "\n",
    "<font size=4>Additional Drug information</font>\n",
    "-PubChem\n",
    "\n",
    "<font size=4>Pathway information</font>\n",
    "-MSigDB\n",
    "\n",
    "\n",
    "**The link for NCI60 response dataset**\n",
    "\n",
    "NCI60[ https://wiki.nci.nih.gov/display/NCIDTPdata/NCI-60+Growth+Inhibition+Data ] \n",
    "\n",
    "-file: DOSERESP.csv (CONCENTRATION/RESPONSE DATA)[ https://wiki.nci.nih.gov/download/attachments/147193864/DOSERESP.zip?version=10&modificationDate=1704733010000&api=v2 ]\n",
    "\n",
    "**The link for NCI-ALMANAC response dataset**\n",
    "\n",
    "NCI-ALMANAC[ https://wiki.nci.nih.gov/display/NCIDTPdata/NCI-ALMANAC ] \n",
    "\n",
    "-file: ComboDrugGrowth_Nov2017.csv[ https://wiki.nci.nih.gov/display/NCIDTPdata/NCI-ALMANAC?preview=/338237347/357699398/ComboDrugGrowth_Nov2017.zip ]\n",
    "\n",
    "**The link for CCLE expression data**\n",
    "\n",
    "DepMap[ https://depmap.org/portal/download/all/ ]\n",
    "\n",
    "-file: OmicsExpressionProteinCodingGenesTPMLogp1.csv [ https://depmap.org/portal/download/all/?releasename=DepMap+Public+23Q4&filename=OmicsExpressionProteinCodingGenesTPMLogp1.csv ]\n",
    "\n",
    "**The link for Cell line annotation for converting DepMap Model ID into Cell line name**\n",
    "\n",
    "-file: DepMap-2018q3-celllines.csv [ https://depmap.org/portal/download/all/?release=DepMap+Public+18Q3&file=DepMap-2018q3-celllines.csv ]\n",
    "\n",
    "**The link for Drug information**\n",
    "\n",
    "-file: Chem2D_Jun2016.sdf [ https://wiki.nci.nih.gov/display/NCIDTPdata/Chemical+Data?preview=/155844992/339380766/Chem2D_Jun2016.zip ]\n",
    "\n",
    "**The link for Pathway information**\n",
    "\n",
    "MSigDB[ http://www.gsea-msigdb.org/gsea/index.jsp ]\n",
    "\n",
    "-file: c2.cp.kegg_legacy.v2023.2.Hs.symbols.gmt (KEGG_LEGACY) [ https://www.gsea-msigdb.org/gsea/msigdb/download_file.jsp?filePath=/msigdb/release/2023.2.Hs/c2.cp.kegg_legacy.v2023.2.Hs.symbols.gmt ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "base_directory='Base directory that DD-PRiSM located'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loading Packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Import libraries\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import csv\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import seaborn as sns\n",
    "\n",
    "%config Completer.use_jedi=False\n",
    "import os\n",
    "\n",
    "import rdkit\n",
    "import rdkit.Chem as Chem\n",
    "from rdkit.Chem import AllChem\n",
    "from rdkit.Chem.Fingerprints import FingerprintMols\n",
    "\n",
    "import pickle\n",
    "import random\n",
    "import urllib.request\n",
    "import re\n",
    "\n",
    "from IPython.display import clear_output\n",
    "\n",
    "import random\n",
    "\n",
    "import tqdm\n",
    "\n",
    "from scipy.stats import zscore\n",
    "\n",
    "import difflib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import chain\n",
    "\n",
    "def flatten_list(list_of_list):\n",
    "    return list(chain.from_iterable(list_of_list))\n",
    "\n",
    "def concat_str(str_list):\n",
    "    str_tmp=\"\"\n",
    "    for str_element in str_list:\n",
    "        str_tmp+=str_element\n",
    "    return str_tmp\n",
    "\n",
    "def find_common(list1,list2):\n",
    "    return [x for x in list1 if x in list2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "　"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font size=6>Single-Drug response data (NCI60)</font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Preprocessing of Drugs for NCI60"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "suppl = Chem.SDMolSupplier(base_directory+'Raw/Chem2D_Jun2016.sdf')\n",
    "mols=[x for x in suppl]\n",
    "#The file 'NCI60_compound.sdf' is the sdf file with NCI compound informations\n",
    "\n",
    "mols_without_None=[x for x in mols if x!=None ]\n",
    "#Filtering 'None' molecules (molecule that were not processible with rdkit library)\n",
    "\n",
    "Mol_df=pd.DataFrame({'Mol':mols_without_None,'NSC':[x.GetProp('_Name') for x in mols_without_None]})\n",
    "#Dataframe with Molecules\n",
    "\n",
    "Mol_df['fingerprint']=[AllChem.GetMorganFingerprintAsBitVect(mol,2,nBits=512) for mol in Mol_df.Mol]\n",
    "#Get Morgan Fingerprint, that will be used as drug feature\n",
    "\n",
    "compound_morgan512=pd.DataFrame([list(x) for x in Mol_df.fingerprint.values])\n",
    "#Dataframe that consists of Morgan Fingerprints\n",
    "\n",
    "compound_morgan512.index=Mol_df['NSC']\n",
    "compound_morgan512.index=compound_morgan512.index.astype(int)\n",
    "#Index mapping\n",
    "\n",
    "NSC_list=compound_morgan512.index\n",
    "#NSC_list=Drug list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "compound_morgan512.to_csv(base_directory+'Input/Fingerprint_Morgan512.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Preprocessing Responses (NCI60)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "compound_morgan512=pd.read_csv(base_directory+'Input/Fingerprint_Morgan512.csv',index_col=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "nci60_raw=pd.read_csv(base_directory+'Raw/DOSERESP.csv')\n",
    "nci60_raw=nci60_raw[nci60_raw.CONCENTRATION_UNIT=='M'] #Others are not convertable into M (Molar)\n",
    "\n",
    "nci60_compact=nci60_raw[['NSC','CONCENTRATION','CELL_NAME','AVERAGE_GIPRCNT']]\n",
    "nci60_compact['CONCENTRATION']+=6 #Convert concentration in M (Molar) to uM (MicroMolar)\n",
    "\n",
    "cellline_annotation=pd.read_csv(base_directory+'Raw/DepMap-2018q3-celllines.csv')\n",
    "\n",
    "cellline_annotation.CCLE_Name=[x.split('_')[0] for x in cellline_annotation.CCLE_Name]\n",
    "nci60_cellline=nci60_compact.drop_duplicates(subset='CELL_NAME')[['CELL_NAME']]\n",
    "cellline_annotation_ccle=cellline_annotation[['Broad_ID','CCLE_Name']]\n",
    "cellline_annotation_ccle.columns=['Broad_ID','CELL_NAME']\n",
    "cellline_annotation_aliases=cellline_annotation[['Broad_ID','Aliases']]\n",
    "cellline_annotation_aliases.columns=['Broad_ID','CELL_NAME']\n",
    "\n",
    "nci60_cellline=pd.merge(nci60_cellline,cellline_annotation_ccle,how='left',on='CELL_NAME')\n",
    "nci60_cellline=pd.merge(nci60_cellline,cellline_annotation_aliases,how='left',on='CELL_NAME')\n",
    "\n",
    "nci60_cellline_valid=nci60_cellline[(~nci60_cellline.Broad_ID_x.isna())|(~nci60_cellline.Broad_ID_y.isna())]\n",
    "nci60_cellline_nan=nci60_cellline[(nci60_cellline.Broad_ID_x.isna())&(nci60_cellline.Broad_ID_y.isna())]\n",
    "\n",
    "nci60_cellline_valid['Broad_ID'] = np.where(~nci60_cellline_valid['Broad_ID_x'].isnull(),nci60_cellline_valid['Broad_ID_x'],nci60_cellline_valid['Broad_ID_y'])\n",
    "nci60_cellline_valid.index = nci60_cellline_valid.CELL_NAME\n",
    "nci60_cellline_valid = nci60_cellline_valid[['Broad_ID']]\n",
    "\n",
    "nci60_cellline_nan=nci60_cellline_nan[['CELL_NAME']]\n",
    "matched_cellline_name=[]\n",
    "for idx,x in nci60_cellline_nan.iterrows():\n",
    "    try:\n",
    "        matched_cellline_name.append(difflib.get_close_matches(x.CELL_NAME,cellline_annotation.CCLE_Name)[0])\n",
    "    except:\n",
    "        matched_cellline_name.append(None)\n",
    "nci60_cellline_nan=nci60_cellline_nan.reset_index(drop=True)\n",
    "nci60_cellline_nan['CELL_NAME_matched']=matched_cellline_name\n",
    "\n",
    "#Manually filtering based on the most similar cell line name (Using Cellosaurus->https://www.cellosaurus.org/)\n",
    "cellline_nan_dict={'CAKI-1':'CAKI1','RXF 393':'RXF393','786-0':'786O','A549/ATCC':'A549'\n",
    "                   ,'SF-268':'SF268','HCT-116':'HCT116','OVCAR-5':'OVCAR5','UO-31':'UO31','HOP-62':'HOP62'\n",
    "                    ,'MALME-3M':'MALME3M','UACC-257':'UACC257','SF-539':'SF539','TK-10':'TK10','NCI-H322M':'NCIH322M'\n",
    "                    ,'MDA-MB-231/ATCC':'MDAMB231','HCC-2998':'HCC2998','RPMI-8226':'RPMI8226','SNB-75':'SNB75','HS 578T':'HS578T'\n",
    "                   ,'U251':'U251MG','SW-620':'SW620','SK-MEL-2':'SKMEL2','769-P':'769P','SW-156':'SW156'\n",
    "                    ,'SW-1573':'SW1573','SW 1088':'SW1088','RPMI-7951':'RPMI7951','SF-767':'SF767'\n",
    "                   ,'MCF7/ATCC':'MCF7','CALU-1':'CALU1','CACO-2':'CACO2'}\n",
    "nci60_cellline_nan=pd.DataFrame.from_dict(cellline_nan_dict,orient='index').reset_index()\n",
    "nci60_cellline_nan.columns=['CELL_NAME','CELL_NAME_matched']\n",
    "\n",
    "cellline_annotation_ccle.index=cellline_annotation_ccle.CELL_NAME\n",
    "cellline_annotation_ccle=cellline_annotation_ccle[['Broad_ID']]\n",
    "nci60_cellline_nan['Broad_ID']=cellline_annotation_ccle.loc[nci60_cellline_nan.CELL_NAME_matched].values\n",
    "nci60_cellline_nan.index=nci60_cellline_nan.CELL_NAME\n",
    "nci60_cellline_nan=nci60_cellline_nan[['Broad_ID']]\n",
    "\n",
    "nci60_cellline_df=pd.concat([nci60_cellline_valid,nci60_cellline_nan],axis=0)\n",
    "\n",
    "\n",
    "nci60_compact.AVERAGE_GIPRCNT+=100\n",
    "nci60_compact.AVERAGE_GIPRCNT/=200\n",
    "\n",
    "nci60_compact=nci60_compact[nci60_compact.NSC.isin(compound_morgan512.index)]\n",
    "nci60_compact=nci60_compact[nci60_compact.CELL_NAME.isin(nci60_cellline_df.index)]\n",
    "\n",
    "nci60_compact['depmap_id'] = nci60_cellline_df.loc[nci60_compact.CELL_NAME].values\n",
    "cellline_expression_valid=list(expression_df_zscore.index)\n",
    "cellline_nci60=list(set(nci60_compact.depmap_id))\n",
    "cellline_common=find_common(cellline_expression_valid,cellline_nci60)\n",
    "nci60_compact=nci60_compact[nci60_compact.depmap_id.isin(cellline_common)]\n",
    "\n",
    "nci60_compact.columns=['NSC','CONCENTRATION','CELLNAME','VIABILITY','depmap_id']\n",
    "nci60_compact.to_csv(base_directory+'Processed/NCI60_matched.csv')\n",
    "\n",
    "expression_df=pd.read_csv(base_directory+'Raw/OmicsExpressionProteinCodingGenesTPMLogp1.csv',index_col=0)\n",
    "expression_df.columns=[gene.split(' (')[0] for gene in expression_df.columns]\n",
    "\n",
    "expression_df_zscore=expression_df.apply(zscore,axis=1)\n",
    "expression_df_zscore.to_csv(base_directory+'Processed/Expression_ZNormalized.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ccle2depmap_df=nci60_compact[['CELLNAME','depmap_id']].drop_duplicates(subset=['depmap_id'])\n",
    "ccle2depmap_df.to_csv(base_directory+'Processed/CCLE2DepMap.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nci60_compact=nci60_compact[(nci60_compact.VIABILITY<1.5)].groupby(by=['depmap_id','NSC','CONCENTRATION']).median().reset_index()\n",
    "nci60_compact=pd.merge(nci60_compact,ccle2depmap_df,how='left',on='depmap_id')\n",
    "nci60_compact=nci60_compact[['CELLNAME','NSC','CONCENTRATION','VIABILITY','depmap_id']]\n",
    "nci60_compact.to_csv(base_directory+'Processed/NCI60_semifiltered.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font size=6>Gene expression grouping (NCI60)</font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Grouping gene expression values by Pathway gene set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "expression_df_zscore=pd.read_csv(base_directory+'NCI60/Processed/Expression_ZNormalized.csv',index_col=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ccle2depmap=pd.read_csv(base_directory+'NCI60/Processed/CCLE2DepMap.csv',index_col=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ccle2depmap.index=ccle2depmap.depmap_id\n",
    "ccle2depmap=ccle2depmap[['CELLNAME']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "valid_gene_list=expression_df_zscore.columns\n",
    "\n",
    "#Loading Gene Set\n",
    "#Gene Set File (gmt) is from MSigDB (http://www.gsea-msigdb.org/gsea/msigdb/collections.jsp)\n",
    "KEGG_legacy_file='c2.cp.kegg_legacy.v2023.2.Hs.symbols.gmt' #186 gene sets\n",
    "\n",
    "GeneSet_List=[]\n",
    "GeneSetFile=base_directory+'Raw/'+KEGG_legacy_file\n",
    "with open(GeneSetFile) as f:\n",
    "    reader = csv.reader(f)\n",
    "    data = list(list(rec) for rec in csv.reader(f, delimiter='\\t')) #reads csv into a list of lists\n",
    "    for row in data:\n",
    "        GeneSet_List.append(row)\n",
    "\n",
    "GeneSet_Dic={}\n",
    "for GeneSet in GeneSet_List:\n",
    "    GeneSet_Dic[GeneSet[0]]=GeneSet[2:]\n",
    "\n",
    "GeneSet_Dic_valid={}\n",
    "for GeneSet in GeneSet_Dic:\n",
    "    GeneSet_tmp=pd.Series(GeneSet_Dic[GeneSet])\n",
    "    GeneSet_tmp=GeneSet_tmp[GeneSet_tmp.isin(valid_gene_list)]\n",
    "    GeneSet_Dic_valid[GeneSet]=GeneSet_tmp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def CelllineFeatureExtract(ExpressionMatrix, CellLine):\n",
    "    X_Feature=[]\n",
    "    for GeneSet in GeneSet_Dic_valid.keys():\n",
    "        Gene_in_GeneSet=[]\n",
    "        for Gene in GeneSet_Dic_valid[GeneSet]:\n",
    "            Gene_in_GeneSet.append(Gene)\n",
    "        X_Feature.append(ExpressionMatrix[Gene_in_GeneSet].loc[[CellLine]])\n",
    "    return X_Feature\n",
    "\n",
    "#The function for the cell line feature extraction (Formatting the expression into gene set forms)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "cellline_input=[]\n",
    "for i in range(len(GeneSet_Dic_valid)):\n",
    "    cellline_input.append(pd.DataFrame())\n",
    "for cellline in tqdm.tqdm(expression_df_zscore.index):\n",
    "    x=CelllineFeatureExtract(expression_df_zscore,cellline)\n",
    "    for j in range(len(GeneSet_Dic_valid)):\n",
    "        cellline_input[j]=pd.concat([cellline_input[j],x[j]],axis=0)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for idx,key in enumerate(GeneSet_Dic_valid.keys()):\n",
    "    cellline_input[idx].to_csv(base_directory+'CellLine_Overall/'+key+'.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nci60_cellline_expression_list=[]\n",
    "for df in tqdm.tqdm(cellline_input):\n",
    "    df=df.loc[ccle2depmap.index]\n",
    "    df.index=ccle2depmap.CELLNAME\n",
    "    nci60_cellline_expression_list.append(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for idx,key in enumerate(GeneSet_Dic_valid.keys()):\n",
    "    nci60_cellline_expression_list[idx].to_csv(base_directory+'Input/'+key+'.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Filtering pairs by Parameter&Concentration&Standard deviation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nci60_compact=pd.read_csv(base_directory+'Processed/NCI60_semifiltered.csv',index_col=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nci60_sorted=nci60_compact.sort_values(by=['CELLNAME','NSC','CONCENTRATION'])\n",
    "nci60_sorted['CONCENTRATION']=[np.around(conc,5) for conc in nci60_sorted.CONCENTRATION]\n",
    "nci60_sorted['conc_delta']=nci60_sorted.CONCENTRATION.shift(1)-nci60_sorted.CONCENTRATION\n",
    "nci60_sorted['identity']=(nci60_sorted.NSC.shift(1)==nci60_sorted.NSC)&(nci60_sorted.CELLNAME.shift(1)==nci60_sorted.CELLNAME)\n",
    "nci60_sorted['conc_delta_around']=np.around(nci60_sorted.conc_delta,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#Filtering pairs whose dilusion is not 10 (log10=1) -> Aggregation of multiple experiments with batch effects\n",
    "filtered_pair_df=nci60_sorted[(nci60_sorted.identity==True)&(nci60_sorted.conc_delta_around!=-1.0)].drop_duplicates(subset=['CELLNAME','NSC'])[['CELLNAME','NSC']]\n",
    "filtered_combination_df=pd.merge(nci60_sorted.reset_index(),filtered_pair_df,how='right',on=['CELLNAME','NSC'])\n",
    "column_list=['idx']\n",
    "column_list.extend(filtered_combination_df.columns[1:])\n",
    "filtered_combination_df.columns=column_list\n",
    "nci60_filtered=nci60_sorted[~nci60_sorted.index.isin(filtered_combination_df.idx)]\n",
    "nci60_filtered=nci60_filtered[['CELLNAME','NSC','CONCENTRATION','VIABILITY','depmap_id']]\n",
    "\n",
    "#Filtering pairs with zero std (no change of viability among all concentrations)\n",
    "nci60_std=nci60_filtered.groupby(['CELLNAME','NSC']).std()[['VIABILITY']].reset_index()\n",
    "filtered_pair_df=nci60_std[nci60_std.VIABILITY==0]\n",
    "filtered_combination_df=pd.merge(nci60_sorted.reset_index(),filtered_pair_df,how='right',on=['CELLNAME','NSC'])\n",
    "column_list=['idx']\n",
    "column_list.extend(filtered_combination_df.columns[1:])\n",
    "filtered_combination_df.columns=column_list\n",
    "nci60_filtered=nci60_filtered[~nci60_filtered.index.isin(filtered_combination_df.idx)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nci60_filtered.to_csv(base_directory+'Processed/NCI60_filtered.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Split NCI60"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "nci60=pd.read_csv(base_directory+'Processed/NCI60_filtered.csv',index_col=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cellline_list=list(set(nci60.CELLNAME))\n",
    "drug_list=list(set(nci60.NSC))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ratio_train_val=0.9\n",
    "ratio_test=1-ratio_train_val\n",
    "factor_train_val=(1-ratio_test/2)**0.5\n",
    "factor_test=1-factor_train_val\n",
    "\n",
    "\n",
    "#About the cell line\n",
    "num_cellline=len(cellline_list)\n",
    "num_seen_cellline_for_cycle=int(num_cellline/(factor_test*num_cellline))\n",
    "cellline_test_idx=np.arange(0,num_cellline,num_seen_cellline_for_cycle)\n",
    "cellline_training_idx=[x for x in np.arange(0,num_cellline,1) if x not in cellline_test_idx]\n",
    "cellline_count_df=nci60.groupby(by='CELLNAME').VIABILITY.count().sort_values(ascending=False)\n",
    "unseen_cellline_list=cellline_count_df.iloc[cellline_test_idx].index.values\n",
    "seen_cellline_list=cellline_count_df.iloc[cellline_training_idx].index.values\n",
    "\n",
    "#About the drug\n",
    "num_drug=len(drug_list)\n",
    "num_seen_drug_for_cycle=int(num_drug/(factor_test*num_drug))\n",
    "drug_test_idx=np.arange(0,num_drug,num_seen_drug_for_cycle)\n",
    "drug_training_idx=[x for x in np.arange(0,num_drug,1) if x not in drug_test_idx]\n",
    "drug_count_df=nci60.groupby(by='NSC').VIABILITY.count().sort_values(ascending=False)\n",
    "unseen_drug_list=drug_count_df.iloc[drug_test_idx].index.values\n",
    "seen_drug_list=drug_count_df.iloc[drug_training_idx].index.values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nci60_unseen_both_df=nci60[(nci60.NSC.isin(unseen_drug_list))&(nci60.CELLNAME.isin(unseen_cellline_list))]\n",
    "nci60_unseen_drug_df=nci60[(nci60.NSC.isin(unseen_drug_list))&(~nci60.CELLNAME.isin(unseen_cellline_list))]\n",
    "nci60_unseen_cellline_df=nci60[(~nci60.NSC.isin(unseen_drug_list))&(nci60.CELLNAME.isin(unseen_cellline_list))]\n",
    "nci60_seen_both_df=nci60[(~nci60.NSC.isin(unseen_drug_list))&(~nci60.CELLNAME.isin(unseen_cellline_list))]\n",
    "\n",
    "#Currently around 90% of whole data are in nci60_seen_both, so 1/18 of nci60_seen_both will be 5% of whole data, like unseen cell line or unseen drug\n",
    "nci60_pair_df=nci60_seen_both_df[['CELLNAME','NSC']].drop_duplicates()\n",
    "nci60_unseen_pair_df=nci60_pair_df.sample(frac=1/18)\n",
    "nci60_seen_pair_df=nci60_pair_df[~nci60_pair_df.index.isin(nci60_unseen_pair_df.index)]\n",
    "nci60_unseen_pair_df=pd.merge(nci60_seen_both_df,nci60_unseen_pair_df,how='inner',on=['CELLNAME','NSC'])\n",
    "nci60_seen_pair_df=pd.merge(nci60_seen_both_df,nci60_seen_pair_df,how='inner',on=['CELLNAME','NSC'])\n",
    "\n",
    "print('Total: '+str(len(nci60)))\n",
    "print('Training&Validation: '+str(len(nci60_seen_pair_df))+'('+str(np.around(len(nci60_seen_pair_df)/len(nci60)*100,2))+'%)')\n",
    "print('Unseen Pair: '+str(len(nci60_unseen_pair_df))+'('+str(np.around(len(nci60_unseen_pair_df)/len(nci60)*100,2))+'%)')\n",
    "print('Unseen CellLine: '+str(len(nci60_unseen_cellline_df))+'('+str(np.around(len(nci60_unseen_cellline_df)/len(nci60)*100,2))+'%)')\n",
    "print('Unseen Drug: '+str(len(nci60_unseen_drug_df))+'('+str(np.around(len(nci60_unseen_drug_df)/len(nci60)*100,2))+'%)')\n",
    "print('Both unseen: '+str(len(nci60_unseen_both_df))+'('+str(np.around(len(nci60_unseen_both_df)/len(nci60)*100,2))+'%)')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nci60_seen_pair_df.to_csv(base_directory+'Training/TrainVal.csv')\n",
    "nci60_unseen_pair_df.to_csv(base_directory+'Training/UnseenPair.csv')\n",
    "nci60_unseen_cellline_df.to_csv(base_directory+'Training/UnseenCellLine.csv')\n",
    "nci60_unseen_drug_df.to_csv(base_directory+'Training/UnseenDrug.csv')\n",
    "nci60_unseen_both_df.to_csv(base_directory+'Training/UnseenBoth.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "　"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "　"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NCI-ALMANAC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nci60=pd.read_csv(base_directory+'NCI60/Processed/NCI60_filtered.csv',index_col=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "celline_mapping=nci60[['CELLNAME','depmap_id']].drop_duplicates()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "NCI_ALMANAC=pd.read_csv(base_directory+'Raw/ComboDrugGrowth_Nov2017.csv',index_col=0)\n",
    "NCI_ALMANAC=NCI_ALMANAC[['NSC1','CONC1','NSC2','CONC2','CELLNAME','PERCENTGROWTH']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "NCI_ALMANAC.PERCENTGROWTH=NCI_ALMANAC.PERCENTGROWTH+100\n",
    "NCI_ALMANAC.PERCENTGROWTH=NCI_ALMANAC.PERCENTGROWTH/200"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "NCI_ALMANAC=NCI_ALMANAC[NCI_ALMANAC.PERCENTGROWTH<1.5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "NCI_ALMANAC_mono=NCI_ALMANAC[NCI_ALMANAC.NSC2.isna()]\n",
    "NCI_ALMANAC_mono=NCI_ALMANAC_mono[['NSC1','CONC1','CELLNAME','PERCENTGROWTH']]\n",
    "NCI_ALMANAC_mono.CONC1=[np.log10(x) for x in NCI_ALMANAC_mono.CONC1]\n",
    "NCI_ALMANAC_mono.CONC1=NCI_ALMANAC_mono.CONC1+6\n",
    "NCI_ALMANAC_mono.columns=['NSC','CONC','CELLNAME','PERCENTGROWTH']\n",
    "NCI_ALMANAC_mono_median=NCI_ALMANAC_mono.groupby(by=['NSC','CONC','CELLNAME']).median().reset_index()\n",
    "\n",
    "compound_morgan512=pd.read_csv(base_directory+'Input/Fingerprint_Morgan512.csv',index_col=0)\n",
    "NSC_list=compound_morgan512.index\n",
    "\n",
    "expression_df_zscore=pd.read_csv(base_directory+'Processed/Expression_ZNormalized.csv',index_col=0)\n",
    "cellline_NCI60_valid=list(expression_df_zscore.index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "NCI_ALMANAC_mono_valid=NCI_ALMANAC_mono_median[(NCI_ALMANAC_mono_median.CELLNAME.isin(celline_mapping.CELLNAME))&(NCI_ALMANAC_mono_median.NSC.isin(NSC_list))]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "NCI_ALMANAC_mono_valid.columns=['NSC','CONCENTRATION','CELLNAME','VIABILITY']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "NCI_ALMANAC_mono_valid.to_csv(base_directory+'NCI_ALMANAC_mono/Processed/NCI_ALMANAC_mono.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "NCI_ALMANAC_comb=NCI_ALMANAC[~NCI_ALMANAC.NSC2.isna()]\n",
    "NCI_ALMANAC_comb=NCI_ALMANAC_comb[['NSC1','CONC1','NSC2','CONC2','CELLNAME','PERCENTGROWTH']]\n",
    "NCI_ALMANAC_comb.CONC1=[np.log10(x) for x in NCI_ALMANAC_comb.CONC1]\n",
    "NCI_ALMANAC_comb.CONC1=NCI_ALMANAC_comb.CONC1+6\n",
    "NCI_ALMANAC_comb.CONC2=[np.log10(x) for x in NCI_ALMANAC_comb.CONC2]\n",
    "NCI_ALMANAC_comb.CONC2=NCI_ALMANAC_comb.CONC2+6\n",
    "NCI_ALMANAC_comb_median=NCI_ALMANAC_comb.groupby(by=['NSC1','CONC1','NSC2','CONC2','CELLNAME']).median().reset_index()\n",
    "\n",
    "NCI_ALMANAC_comb_valid=NCI_ALMANAC_comb_median[(NCI_ALMANAC_comb_median.CELLNAME.isin(celline_mapping.CELLNAME))&(NCI_ALMANAC_comb_median.NSC1.isin(NSC_list))&(NCI_ALMANAC_comb_median.NSC2.isin(NSC_list))]\n",
    "NCI_ALMANAC_comb_valid.NSC2=NCI_ALMANAC_comb_valid.NSC2.astype(int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "NCI_ALMANAC_comb_valid.columns=['NSC1','CONCENTRATION1','NSC2','CONCENTRATION2','CELLNAME','VIABILITY']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "NCI_ALMANAC_comb_valid.to_csv(base_directory+'NCI_ALMANAC(combination)/Processed/NCI_ALMANAC_combination.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Split NCI-ALMANAC (mono)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "nci_almanac_mono=pd.read_csv(base_directory+'NCI_ALMANAC_mono/Processed/NCI_ALMANAC_mono.csv',index_col=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cellline_list=list(set(nci_almanac_mono.CELLNAME))\n",
    "drug_list=list(set(nci_almanac_mono.NSC))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ratio_train_val=0.9\n",
    "ratio_test=1-ratio_train_val\n",
    "factor_train_val=(1-ratio_test/2)**0.5\n",
    "factor_test=1-factor_train_val\n",
    "\n",
    "\n",
    "#About the cell line\n",
    "num_cellline=len(cellline_list)\n",
    "num_seen_cellline_for_cycle=int(num_cellline/(factor_test*num_cellline))\n",
    "cellline_test_idx=np.arange(0,num_cellline,num_seen_cellline_for_cycle)\n",
    "cellline_training_idx=[x for x in np.arange(0,num_cellline,1) if x not in cellline_test_idx]\n",
    "cellline_count_df=nci_almanac_mono.groupby(by='CELLNAME').VIABILITY.count().sort_values(ascending=False)\n",
    "unseen_cellline_list=cellline_count_df.iloc[cellline_test_idx].index.values\n",
    "seen_cellline_list=cellline_count_df.iloc[cellline_training_idx].index.values\n",
    "\n",
    "#About the drug\n",
    "num_drug=len(drug_list)\n",
    "num_seen_drug_for_cycle=int(num_drug/(factor_test*num_drug))\n",
    "drug_test_idx=np.arange(0,num_drug,num_seen_drug_for_cycle)\n",
    "drug_training_idx=[x for x in np.arange(0,num_drug,1) if x not in drug_test_idx]\n",
    "drug_count_df=nci_almanac_mono.groupby(by='NSC').VIABILITY.count().sort_values(ascending=False)\n",
    "unseen_drug_list=drug_count_df.iloc[drug_test_idx].index.values\n",
    "seen_drug_list=drug_count_df.iloc[drug_training_idx].index.values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "almanac_unseen_both_df=nci_almanac_mono[(nci_almanac_mono.NSC.isin(unseen_drug_list))&(nci_almanac_mono.CELLNAME.isin(unseen_cellline_list))]\n",
    "almanac_unseen_drug_df=nci_almanac_mono[(nci_almanac_mono.NSC.isin(unseen_drug_list))&(~nci_almanac_mono.CELLNAME.isin(unseen_cellline_list))]\n",
    "almanac_unseen_cellline_df=nci_almanac_mono[(~nci_almanac_mono.NSC.isin(unseen_drug_list))&(nci_almanac_mono.CELLNAME.isin(unseen_cellline_list))]\n",
    "almanac_seen_both_df=nci_almanac_mono[(~nci_almanac_mono.NSC.isin(unseen_drug_list))&(~nci_almanac_mono.CELLNAME.isin(unseen_cellline_list))]\n",
    "\n",
    "#Currently around 90% of whole data are in nci60_seen_both, so 1/18 of nci60_seen_both will be 5% of whole data, like unseen cell line or unseen drug\n",
    "almanac_pair_df=almanac_seen_both_df[['CELLNAME','NSC']].drop_duplicates()\n",
    "almanac_unseen_pair_df=almanac_pair_df.sample(frac=1/18)\n",
    "almanac_seen_pair_df=almanac_pair_df[~almanac_pair_df.index.isin(almanac_unseen_pair_df.index)]\n",
    "almanac_unseen_pair_df=pd.merge(almanac_seen_both_df,almanac_unseen_pair_df,how='inner',on=['CELLNAME','NSC'])\n",
    "almanac_seen_pair_df=pd.merge(almanac_seen_both_df,almanac_seen_pair_df,how='inner',on=['CELLNAME','NSC'])\n",
    "\n",
    "print('Total: '+str(len(nci_almanac_mono)))\n",
    "print('Training&Validation: '+str(len(almanac_seen_pair_df))+'('+str(np.around(len(almanac_seen_pair_df)/len(nci_almanac_mono)*100,2))+'%)')\n",
    "print('Unseen Pair: '+str(len(almanac_unseen_pair_df))+'('+str(np.around(len(almanac_unseen_pair_df)/len(nci_almanac_mono)*100,2))+'%)')\n",
    "print('Unseen CellLine: '+str(len(almanac_unseen_cellline_df))+'('+str(np.around(len(almanac_unseen_cellline_df)/len(nci_almanac_mono)*100,2))+'%)')\n",
    "print('Unseen Drug: '+str(len(almanac_unseen_drug_df))+'('+str(np.around(len(almanac_unseen_drug_df)/len(nci_almanac_mono)*100,2))+'%)')\n",
    "print('Both unseen: '+str(len(almanac_unseen_both_df))+'('+str(np.around(len(almanac_unseen_both_df)/len(nci_almanac_mono)*100,2))+'%)')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "almanac_seen_pair_df.to_csv(base_directory+'NCI_ALMANAC_mono/Training/TrainVal.csv')\n",
    "almanac_unseen_pair_df.to_csv(base_directory+'NCI_ALMANAC_mono/Training/UnseenPair.csv')\n",
    "almanac_unseen_cellline_df.to_csv(base_directory+'NCI_ALMANAC_mono/Training/UnseenCellLine.csv')\n",
    "almanac_unseen_drug_df.to_csv(base_directory+'NCI_ALMANAC_mono/Training/UnseenDrug.csv')\n",
    "almanac_unseen_both_df.to_csv(base_directory+'NCI_ALMANAC_mono/Training/UnseenBoth.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Split NCI-ALMANAC (combination) into TrainVal&Test (9:1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nci_almanac_combination=pd.read_csv(base_directory+'NCI_ALMANAC_combination/Processed/NCI_ALMANAC_combination.csv',index_col=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "monotherapy_unseen_cellline_df=pd.read_csv(base_directory+'NCI_ALMANAC_mono/Training/UnseenCellLine.csv',index_col=0)\n",
    "monotherapy_unseen_drug_df=pd.read_csv(base_directory+'NCI_ALMANAC_mono/Training/UnseenDrug.csv',index_col=0)\n",
    "unseen_cellline_list=list(set(monotherapy_unseen_cellline_df.CELLNAME))\n",
    "unseen_drug_list=list(set(monotherapy_unseen_drug_df.NSC))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nci_almanac_unseen_cellline_df=nci_almanac_combination[(~nci_almanac_combination.NSC1.isin(unseen_drug_list))&(~nci_almanac_combination.NSC2.isin(unseen_drug_list))&(nci_almanac_combination.CELLNAME.isin(unseen_cellline_list))]\n",
    "#About the unseen drug1, cell line could be both seen or unseen\n",
    "nci_almanac_unseen_drug1=nci_almanac_combination[((nci_almanac_combination.NSC1.isin(unseen_drug_list))&(~nci_almanac_combination.NSC2.isin(unseen_drug_list)))|((~nci_almanac_combination.NSC1.isin(unseen_drug_list))&(nci_almanac_combination.NSC2.isin(unseen_drug_list)))]\n",
    "nci_almanac_unseen_drug2=nci_almanac_combination[(nci_almanac_combination.NSC1.isin(unseen_drug_list))&(nci_almanac_combination.NSC2.isin(unseen_drug_list))&(~nci_almanac_combination.CELLNAME.isin(unseen_cellline_list))]\n",
    "nci_almanac_unseen_both=nci_almanac_combination[(nci_almanac_combination.NSC1.isin(unseen_drug_list))&(nci_almanac_combination.NSC2.isin(unseen_drug_list))&(nci_almanac_combination.CELLNAME.isin(unseen_cellline_list))]\n",
    "nci_almanac_seen=nci_almanac_combination[(~nci_almanac_combination.NSC1.isin(unseen_drug_list))&(~nci_almanac_combination.NSC2.isin(unseen_drug_list))&(~nci_almanac_combination.CELLNAME.isin(unseen_cellline_list))]\n",
    "#Here, around 10% of NCI-ALMANAC combination dataset are test set, and 90% are training&validation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#We need Unseen pair (Cell line-Drug1-Drug2 pair) also, so divide 10% of total dataset as a unseen pair test set\n",
    "nci_almanac_seen['min_NSC']=np.minimum(nci_almanac_seen.NSC1,nci_almanac_seen.NSC2)\n",
    "nci_almanac_seen['max_NSC']=np.maximum(nci_almanac_seen.NSC1,nci_almanac_seen.NSC2)\n",
    "\n",
    "nci_almanac_seen_pair=nci_almanac_seen[['CELLNAME','min_NSC','max_NSC']].drop_duplicates()\n",
    "\n",
    "ratio_test=1/9 #10% of total dataset=1/9 of train&val dataset\n",
    "nci_almanac_unseen_pair_df=nci_almanac_seen_pair.sample(frac=ratio_test)\n",
    "nci_almanac_seen_pair_df=nci_almanac_seen_pair[~nci_almanac_seen_pair.index.isin(nci_almanac_unseen_pair_df.index)]\n",
    "\n",
    "nci_almanac_unseen_pair_df=pd.merge(nci_almanac_seen,nci_almanac_unseen_pair_df,how='inner',on=['CELLNAME','min_NSC','max_NSC'])\n",
    "nci_almanac_seen_pair_df=pd.merge(nci_almanac_seen,nci_almanac_seen_pair_df,how='inner',on=['CELLNAME','min_NSC','max_NSC'])\n",
    "\n",
    "nci_almanac_seen=nci_almanac_seen_pair_df.sample(frac=1)\n",
    "nci_almanac_unseen_pair=nci_almanac_unseen_pair_df.sample(frac=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nci_almanac_seen.to_csv(base_directory+'NCI_ALMANAC_combination/Training/UnseenSetting/TrainVal.csv')\n",
    "nci_almanac_unseen_pair.to_csv(base_directory+'NCI_ALMANAC_combination/Training/UnseenSetting/UnseenPair.csv')\n",
    "nci_almanac_unseen_cellline_df.to_csv(base_directory+'NCI_ALMANAC_combination/Training/UnseenSetting/UnseenCellLine.csv')\n",
    "nci_almanac_unseen_drug1.to_csv(base_directory+'NCI_ALMANAC_combination/Training/UnseenSetting/UnseenDrug1.csv')\n",
    "nci_almanac_unseen_drug2.to_csv(base_directory+'NCI_ALMANAC_combination/Training/UnseenSetting/UnseenDrug2.csv')\n",
    "nci_almanac_unseen_both.to_csv(base_directory+'NCI_ALMANAC_combination/Training/UnseenSetting/UnseenBoth.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Total: '+str(len(nci_almanac_combination)))\n",
    "print('Training&Validation: '+str(len(nci_almanac_seen))+'('+str(np.around(len(nci_almanac_seen)/len(nci_almanac_combination)*100,2))+'%)')\n",
    "print('Unseen Pair: '+str(len(nci_almanac_unseen_pair))+'('+str(np.around(len(nci_almanac_unseen_pair)/len(nci_almanac_combination)*100,2))+'%)')\n",
    "print('Unseen CellLine: '+str(len(nci_almanac_unseen_cellline_df))+'('+str(np.around(len(nci_almanac_unseen_cellline_df)/len(nci_almanac_combination)*100,2))+'%)')\n",
    "print('Unseen Drug 1: '+str(len(nci_almanac_unseen_drug1))+'('+str(np.around(len(nci_almanac_unseen_drug1)/len(nci_almanac_combination)*100,2))+'%)')\n",
    "print('Unseen Drug 2: '+str(len(nci_almanac_unseen_drug2))+'('+str(np.around(len(nci_almanac_unseen_drug2)/len(nci_almanac_combination)*100,2))+'%)')\n",
    "print('Both unseen: '+str(len(nci_almanac_unseen_both))+'('+str(np.around(len(nci_almanac_unseen_both)/len(nci_almanac_combination)*100,2))+'%)')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}