{

 "cells": [

  {

   "cell_type": "code",

   "execution_count": 1,

   "metadata": {},

   "outputs": [

    {

     "name": "stderr",

     "output_type": "stream",

     "text": [

      "/home/hnoghabi/anaconda3/lib/python3.6/site-packages/sklearn/utils/validation.py:475: DataConversionWarning: Data with input dtype object was converted to float64 by StandardScaler.\n",

      "  warnings.warn(msg, DataConversionWarning)\n",

      "/home/hnoghabi/anaconda3/lib/python3.6/site-packages/sklearn/utils/validation.py:475: DataConversionWarning: Data with input dtype object was converted to float64 by StandardScaler.\n",

      "  warnings.warn(msg, DataConversionWarning)\n"

     ]

    },

    {

     "name": "stdout",

     "output_type": "stream",

     "text": [

      "0.9440567436313729\n",

      "0.7222222222222222\n",

      "0.8\n"

     ]

    }

   ],

   "source": [

    "import torch \n",

    "import torch.nn as nn\n",

    "import torch.nn.functional as F\n",

    "import torch.optim as optim\n",

    "import numpy as np\n",

    "import matplotlib.pyplot as plt\n",

    "import pandas as pd\n",

    "import math\n",

    "import sklearn.preprocessing as sk\n",

    "import seaborn as sns\n",

    "from sklearn import metrics\n",

    "from sklearn.feature_selection import VarianceThreshold\n",

    "from sklearn.model_selection import train_test_split\n",

    "from utils import AllTripletSelector,HardestNegativeTripletSelector, RandomNegativeTripletSelector, SemihardNegativeTripletSelector # Strategies for selecting triplets within a minibatch\n",

    "from metrics import AverageNonzeroTripletsMetric\n",

    "from torch.utils.data.sampler import WeightedRandomSampler\n",

    "from sklearn.metrics import roc_auc_score\n",

    "from sklearn.metrics import average_precision_score\n",

    "import random\n",

    "from random import randint\n",

    "from sklearn.model_selection import StratifiedKFold\n",

    "\n",

    "save_results_to = '/home/hnoghabi/EGFR/'\n",

    "torch.manual_seed(42)\n",

    "random.seed(42)\n",

    "\n",

    "GDSCE = pd.read_csv(\"GDSC_exprs.z.EGFRi.tsv\", \n",

    "                    sep = \"\\t\", index_col=0, decimal = \",\")\n",

    "GDSCE = pd.DataFrame.transpose(GDSCE)\n",

    "\n",

    "GDSCM = pd.read_csv(\"GDSC_mutations.EGFRi.tsv\", \n",

    "                    sep = \"\\t\", index_col=0, decimal = \".\")\n",

    "GDSCM = pd.DataFrame.transpose(GDSCM)\n",

    "GDSCM = GDSCM.loc[:,~GDSCM.columns.duplicated()]\n",

    "\n",

    "GDSCC = pd.read_csv(\"GDSC_CNA.EGFRi.tsv\", \n",

    "                    sep = \"\\t\", index_col=0, decimal = \".\")\n",

    "GDSCC.drop_duplicates(keep='last')\n",

    "GDSCC = pd.DataFrame.transpose(GDSCC)\n",

    "GDSCC = GDSCC.loc[:,~GDSCC.columns.duplicated()]\n",

    "\n",

    "PDXEerlo = pd.read_csv(\"PDX_exprs.Erlotinib.eb_with.GDSC_exprs.Erlotinib.tsv\", \n",

    "                   sep = \"\\t\", index_col=0, decimal = \",\")\n",

    "PDXEerlo = pd.DataFrame.transpose(PDXEerlo)\n",

    "PDXMerlo = pd.read_csv(\"PDX_mutations.Erlotinib.tsv\", \n",

    "                   sep = \"\\t\", index_col=0, decimal = \",\")\n",

    "PDXMerlo = pd.DataFrame.transpose(PDXMerlo)\n",

    "PDXCerlo = pd.read_csv(\"PDX_CNA.Erlotinib.tsv\", \n",

    "                   sep = \"\\t\", index_col=0, decimal = \",\")\n",

    "PDXCerlo.drop_duplicates(keep='last')\n",

    "PDXCerlo = pd.DataFrame.transpose(PDXCerlo)\n",

    "PDXCerlo = PDXCerlo.loc[:,~PDXCerlo.columns.duplicated()]\n",

    "\n",

    "PDXEcet = pd.read_csv(\"PDX_exprs.Cetuximab.eb_with.GDSC_exprs.Cetuximab.tsv\", \n",

    "                   sep = \"\\t\", index_col=0, decimal = \",\")\n",

    "PDXEcet = pd.DataFrame.transpose(PDXEcet)\n",

    "PDXMcet = pd.read_csv(\"PDX_mutations.Cetuximab.tsv\", \n",

    "                   sep = \"\\t\", index_col=0, decimal = \",\")\n",

    "PDXMcet = pd.DataFrame.transpose(PDXMcet)\n",

    "PDXCcet = pd.read_csv(\"PDX_CNA.Cetuximab.tsv\", \n",

    "                   sep = \"\\t\", index_col=0, decimal = \",\")\n",

    "PDXCcet.drop_duplicates(keep='last')\n",

    "PDXCcet = pd.DataFrame.transpose(PDXCcet)\n",

    "PDXCcet = PDXCcet.loc[:,~PDXCcet.columns.duplicated()]\n",

    "\n",

    "selector = VarianceThreshold(0.05)\n",

    "selector.fit_transform(GDSCE)\n",

    "GDSCE = GDSCE[GDSCE.columns[selector.get_support(indices=True)]]\n",

    "\n",

    "GDSCM = GDSCM.fillna(0)\n",

    "GDSCM[GDSCM != 0.0] = 1\n",

    "GDSCC = GDSCC.fillna(0)\n",

    "GDSCC[GDSCC != 0.0] = 1\n",

    "\n",

    "ls = GDSCE.columns.intersection(GDSCM.columns)\n",

    "ls = ls.intersection(GDSCC.columns)\n",

    "ls = ls.intersection(PDXEerlo.columns)\n",

    "ls = ls.intersection(PDXMerlo.columns)\n",

    "ls = ls.intersection(PDXCerlo.columns)\n",

    "ls = ls.intersection(PDXEcet.columns)\n",

    "ls = ls.intersection(PDXMcet.columns)\n",

    "ls = ls.intersection(PDXCcet.columns)\n",

    "ls2 = GDSCE.index.intersection(GDSCM.index)\n",

    "ls2 = ls2.intersection(GDSCC.index)\n",

    "ls3 = PDXEerlo.index.intersection(PDXMerlo.index)\n",

    "ls3 = ls3.intersection(PDXCerlo.index)\n",

    "ls4 = PDXEcet.index.intersection(PDXMcet.index)\n",

    "ls4 = ls4.intersection(PDXCcet.index)\n",

    "ls = pd.unique(ls)\n",

    "\n",

    "PDXEerlo = PDXEerlo.loc[ls3,ls]\n",

    "PDXMerlo = PDXMerlo.loc[ls3,ls]\n",

    "PDXCerlo = PDXCerlo.loc[ls3,ls]\n",

    "PDXEcet = PDXEcet.loc[ls4,ls]\n",

    "PDXMcet = PDXMcet.loc[ls4,ls]\n",

    "PDXCcet = PDXCcet.loc[ls4,ls]\n",

    "GDSCE = GDSCE.loc[:,ls]\n",

    "GDSCM = GDSCM.loc[:,ls]\n",

    "GDSCC = GDSCC.loc[:,ls]\n",

    "\n",

    "GDSCR = pd.read_csv(\"GDSC_response.EGFRi.tsv\", \n",

    "                    sep = \"\\t\", index_col=0, decimal = \",\")\n",

    "\n",

    "GDSCR.rename(mapper = str, axis = 'index', inplace = True)\n",

    "\n",

    "d = {\"R\":0,\"S\":1}\n",

    "GDSCR[\"response\"] = GDSCR.loc[:,\"response\"].apply(lambda x: d[x])\n",

    "\n",

    "responses = GDSCR\n",

    "drugs = set(responses[\"drug\"].values)\n",

    "exprs_z = GDSCE\n",

    "cna = GDSCC\n",

    "mut = GDSCM\n",

    "expression_zscores = []\n",

    "CNA=[]\n",

    "mutations = []\n",

    "for drug in drugs:\n",

    "    samples = responses.loc[responses[\"drug\"]==drug,:].index.values\n",

    "    e_z = exprs_z.loc[samples,:]\n",

    "    c = cna.loc[samples,:]\n",

    "    m = mut.loc[samples,:]\n",

    "    m = mut.loc[samples,:]\n",

    "    # next 3 rows if you want non-unique sample names\n",

    "    e_z.rename(lambda x : str(x)+\"_\"+drug, axis = \"index\", inplace=True)\n",

    "    c.rename(lambda x : str(x)+\"_\"+drug, axis = \"index\", inplace=True)\n",

    "    m.rename(lambda x : str(x)+\"_\"+drug, axis = \"index\", inplace=True)\n",

    "    expression_zscores.append(e_z)\n",

    "    CNA.append(c)\n",

    "    mutations.append(m)\n",

    "responses.index = responses.index.values +\"_\"+responses[\"drug\"].values\n",

    "GDSCEv2 = pd.concat(expression_zscores, axis =0 )\n",

    "GDSCCv2 = pd.concat(CNA, axis =0 )\n",

    "GDSCMv2 = pd.concat(mutations, axis =0 )\n",

    "GDSCRv2 = responses\n",

    "\n",

    "ls2 = GDSCEv2.index.intersection(GDSCMv2.index)\n",

    "ls2 = ls2.intersection(GDSCCv2.index)\n",

    "GDSCEv2 = GDSCEv2.loc[ls2,:]\n",

    "GDSCMv2 = GDSCMv2.loc[ls2,:]\n",

    "GDSCCv2 = GDSCCv2.loc[ls2,:]\n",

    "GDSCRv2 = GDSCRv2.loc[ls2,:]\n",

    "\n",

    "Y = GDSCRv2['response'].values\n",

    "\n",

    "PDXRcet = pd.read_csv(\"PDX_response.Cetuximab.tsv\", \n",

    "                       sep = \"\\t\", index_col=0, decimal = \",\")\n",

    "PDXRcet.loc[PDXRcet.iloc[:,0] == 'R'] = 0\n",

    "PDXRcet.loc[PDXRcet.iloc[:,0] == 'S'] = 1\n",

    "PDXRcet = PDXRcet.loc[ls4,:]\n",

    "Ytscet = PDXRcet['response'].values    \n",

    "\n",

    "PDXRerlo = pd.read_csv(\"PDX_response.Erlotinib.tsv\", \n",

    "                       sep = \"\\t\", index_col=0, decimal = \",\")\n",

    "PDXRerlo.loc[PDXRerlo.iloc[:,0] == 'R'] = 0\n",

    "PDXRerlo.loc[PDXRerlo.iloc[:,0] == 'S'] = 1\n",

    "PDXRerlo = PDXRerlo.loc[ls3,:]\n",

    "Ytserlo = PDXRerlo['response'].values  \n",

    "\n",

    "hdm1 = 32\n",

    "hdm2 = 16\n",

    "hdm3 = 256\n",

    "rate1 = 0.5\n",

    "rate2 = 0.8\n",

    "rate3 = 0.5\n",

    "rate4 = 0.3\n",

    "\n",

    "scalerGDSC = sk.StandardScaler()\n",

    "scalerGDSC.fit(GDSCEv2.values)\n",

    "X_trainE = scalerGDSC.transform(GDSCEv2.values)\n",

    "X_testEerlo = scalerGDSC.transform(PDXEerlo.values)    \n",

    "X_testEcet = scalerGDSC.transform(PDXEcet.values)    \n",

    "\n",

    "X_trainM = np.nan_to_num(GDSCMv2.values)\n",

    "X_trainC = np.nan_to_num(GDSCCv2.values)\n",

    "X_testMerlo = np.nan_to_num(PDXMerlo.values)\n",

    "X_testCerlo = np.nan_to_num(PDXCerlo.values)\n",

    "X_testMcet = np.nan_to_num(PDXMcet.values)\n",

    "X_testCcet = np.nan_to_num(PDXCcet.values)\n",

    "\n",

    "TX_testEerlo = torch.FloatTensor(X_testEerlo)\n",

    "TX_testMerlo = torch.FloatTensor(X_testMerlo)\n",

    "TX_testCerlo = torch.FloatTensor(X_testCerlo)\n",

    "ty_testEerlo = torch.FloatTensor(Ytserlo.astype(int))\n",

    "\n",

    "TX_testEcet = torch.FloatTensor(X_testEcet)\n",

    "TX_testMcet = torch.FloatTensor(X_testMcet)\n",

    "TX_testCcet = torch.FloatTensor(X_testCcet)\n",

    "ty_testEcet = torch.FloatTensor(Ytscet.astype(int))\n",

    "\n",

    "n_sampE, IE_dim = X_trainE.shape\n",

    "n_sampM, IM_dim = X_trainM.shape\n",

    "n_sampC, IC_dim = X_trainC.shape\n",

    "\n",

    "h_dim1 = hdm1\n",

    "h_dim2 = hdm2\n",

    "h_dim3 = hdm3        \n",

    "Z_in = h_dim1 + h_dim2 + h_dim3\n",

    "\n",

    "costtr = []\n",

    "auctr = []\n",

    "costts = []\n",

    "aucts = []\n",

    "\n",

    "class AEE(nn.Module):\n",

    "    def __init__(self):\n",

    "        super(AEE, self).__init__()\n",

    "        self.EnE = torch.nn.Sequential(\n",

    "            nn.Linear(IE_dim, h_dim1),\n",

    "            nn.BatchNorm1d(h_dim1),\n",

    "            nn.ReLU(),\n",

    "            nn.Dropout(rate1))\n",

    "    def forward(self, x):\n",

    "        output = self.EnE(x)\n",

    "        return output\n",

    "\n",

    "class AEM(nn.Module):\n",

    "    def __init__(self):\n",

    "        super(AEM, self).__init__()\n",

    "        self.EnM = torch.nn.Sequential(\n",

    "            nn.Linear(IM_dim, h_dim2),\n",

    "            nn.BatchNorm1d(h_dim2),\n",

    "            nn.ReLU(),\n",

    "            nn.Dropout(rate2))\n",

    "    def forward(self, x):\n",

    "        output = self.EnM(x)\n",

    "        return output    \n",

    "\n",

    "\n",

    "class AEC(nn.Module):\n",

    "    def __init__(self):\n",

    "        super(AEC, self).__init__()\n",

    "        self.EnC = torch.nn.Sequential(\n",

    "            nn.Linear(IM_dim, h_dim3),\n",

    "            nn.BatchNorm1d(h_dim3),\n",

    "            nn.ReLU(),\n",

    "            nn.Dropout(rate3))\n",

    "    def forward(self, x):\n",

    "        output = self.EnC(x)\n",

    "        return output       \n",

    "\n",

    "class Classifier(nn.Module):\n",

    "    def __init__(self):\n",

    "        super(Classifier, self).__init__()\n",

    "        self.FC = torch.nn.Sequential(\n",

    "            nn.Linear(Z_in, 1),\n",

    "            nn.Dropout(rate4),\n",

    "            nn.Sigmoid())\n",

    "    def forward(self, x):\n",

    "        return self.FC(x)\n",

    "\n",

    "torch.cuda.manual_seed_all(42)\n",

    "\n",

    "AutoencoderE = torch.load('EGFRv2Exprs.pt')\n",

    "AutoencoderM = torch.load('EGFRv2Mut.pt')\n",

    "AutoencoderC = torch.load('EGFRv2CNA.pt')\n",

    "\n",

    "Clas = torch.load('EGFRv2Class.pt')\n",

    "\n",

    "AutoencoderE.eval()\n",

    "AutoencoderM.eval()\n",

    "AutoencoderC.eval()\n",

    "Clas.eval()\n",

    "\n",

    "ZEX = AutoencoderE(torch.FloatTensor(X_trainE))\n",

    "ZMX = AutoencoderM(torch.FloatTensor(X_trainM))\n",

    "ZCX = AutoencoderC(torch.FloatTensor(X_trainC))\n",

    "ZTX = torch.cat((ZEX, ZMX, ZCX), 1)\n",

    "ZTX = F.normalize(ZTX, p=2, dim=0)\n",

    "PredX = Clas(ZTX)\n",

    "AUCt = roc_auc_score(Y, PredX.detach().numpy())\n",

    "print(AUCt)\n",

    "\n",

    "ZETerlo = AutoencoderE(TX_testEerlo)\n",

    "ZMTerlo = AutoencoderM(TX_testMerlo)\n",

    "ZCTerlo = AutoencoderC(TX_testCerlo)\n",

    "ZTTerlo = torch.cat((ZETerlo, ZMTerlo, ZCTerlo), 1)\n",

    "ZTTerlo = F.normalize(ZTTerlo, p=2, dim=0)\n",

    "PredTerlo = Clas(ZTTerlo)\n",

    "AUCterlo = roc_auc_score(Ytserlo, PredTerlo.detach().numpy())\n",

    "print(AUCterlo)\n",

    "\n",

    "ZETcet = AutoencoderE(TX_testEcet)\n",

    "ZMTcet = AutoencoderM(TX_testMcet)\n",

    "ZCTcet = AutoencoderC(TX_testCcet)\n",

    "ZTTcet = torch.cat((ZETcet, ZMTcet, ZCTcet), 1)\n",

    "ZTTcet = F.normalize(ZTTcet, p=2, dim=0)\n",

    "PredTcet = Clas(ZTTcet)\n",

    "AUCtcet = roc_auc_score(Ytscet, PredTcet.detach().numpy())\n",

    "print(AUCtcet)"

   ]

  },

  {

   "cell_type": "code",

   "execution_count": 2,

   "metadata": {},

   "outputs": [

    {

     "name": "stderr",

     "output_type": "stream",

     "text": [

      "/home/hnoghabi/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:28: FutureWarning: \n",

      "Passing list-likes to .loc or [] with any missing label will raise\n",

      "KeyError in the future, you can use .reindex() as an alternative.\n",

      "\n",

      "See the documentation here:\n",

      "https://pandas.pydata.org/pandas-docs/stable/indexing.html#deprecate-loc-reindex-listlike\n",

      "/home/hnoghabi/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:29: FutureWarning: \n",

      "Passing list-likes to .loc or [] with any missing label will raise\n",

      "KeyError in the future, you can use .reindex() as an alternative.\n",

      "\n",

      "See the documentation here:\n",

      "https://pandas.pydata.org/pandas-docs/stable/indexing.html#deprecate-loc-reindex-listlike\n",

      "/home/hnoghabi/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:30: FutureWarning: \n",

      "Passing list-likes to .loc or [] with any missing label will raise\n",

      "KeyError in the future, you can use .reindex() as an alternative.\n",

      "\n",

      "See the documentation here:\n",

      "https://pandas.pydata.org/pandas-docs/stable/indexing.html#deprecate-loc-reindex-listlike\n"

     ]

    },

    {

     "name": "stdout",

     "output_type": "stream",

     "text": [

      "(492, 13081)\n",

      "(492, 13081)\n",

      "(492, 13081)\n"

     ]

    }

   ],

   "source": [

    "PRADE = pd.read_csv(\"TCGA-PRAD_exprs.tsv\", \n",

    "                   sep = \"\\t\", index_col=0, decimal = \".\")\n",

    "PRADE = pd.DataFrame.transpose(PRADE)\n",

    "\n",

    "PRADM = pd.read_csv(\"TCGA-PRAD_mutations.tsv\", \n",

    "                   sep = \"\\t\", index_col=0, decimal = \".\")\n",

    "PRADM = pd.DataFrame.transpose(PRADM)\n",

    "PRADM = PRADM.loc[:,~PRADM.columns.duplicated()]\n",

    "\n",

    "PRADC = pd.read_csv(\"TCGA-PRAD_CNA.tsv\", \n",

    "                   sep = \"\\t\", index_col=0, decimal = \".\")\n",

    "PRADC = pd.DataFrame.transpose(PRADC)\n",

    "PRADC = PRADC.loc[:,~PRADC.columns.duplicated()]\n",

    "\n",

    "PRADM = PRADM.fillna(0)\n",

    "PRADM[PRADM != 0.0] = 1\n",

    "PRADC = PRADC.fillna(0)\n",

    "PRADC[PRADC != 0.0] = 1\n",

    "\n",

    "#PRADE.rename(lambda x : x[0:11], axis = \"index\", inplace=True)  \n",

    "#PRADM.rename(lambda x : x[0:11], axis = \"index\", inplace=True)   \n",

    "#PRADC.rename(lambda x : x[0:11], axis = \"index\", inplace=True)   \n",

    "\n",

    "lsPRAD = PRADE.index.intersection(PRADM.index)\n",

    "lsPRAD = lsPRAD.intersection(PRADC.index)\n",

    "lsPRAD = pd.unique(lsPRAD)\n",

    "\n",

    "PRADE = PRADE.loc[lsPRAD,ls]\n",

    "PRADM = PRADM.loc[lsPRAD,ls]\n",

    "PRADC = PRADC.loc[lsPRAD,ls]\n",

    "\n",

    "print(PRADE.shape)\n",

    "print(PRADM.shape)\n",

    "print(PRADC.shape)\n",

    "\n",

    "AutoencoderE.eval()\n",

    "AutoencoderM.eval()\n",

    "AutoencoderC.eval()\n",

    "Clas.eval()\n",

    "\n",

    "PRADE2 = np.nan_to_num(PRADE.values)\n",

    "PRADM2 = np.nan_to_num(PRADM.values)\n",

    "PRADC2 = np.nan_to_num(PRADC.values)\n",

    "\n",

    "NPRADE2 = scalerGDSC.transform(PRADE2)    \n",

    "\n",

    "PRADexprs = torch.FloatTensor(NPRADE2)\n",

    "PRADmut = torch.FloatTensor(PRADM2)\n",

    "PRADcna = torch.FloatTensor(PRADC2)\n",

    "\n",

    "PRADZE = AutoencoderE(PRADexprs)\n",

    "PRADZM = AutoencoderM(PRADmut)\n",

    "PRADZC = AutoencoderC(PRADcna)\n",

    "\n",

    "PRADZT = torch.cat((PRADZE, PRADZM, PRADZC), 1)\n",

    "PRADZTX = F.normalize(PRADZT, p=2, dim=0)\n",

    "PredPRAD = Clas(PRADZTX)\n",

    "\n",

    "#print(PredPRAD.detach().numpy())"

   ]

  },

  {

   "cell_type": "code",

   "execution_count": 3,

   "metadata": {},

   "outputs": [

    {

     "name": "stderr",

     "output_type": "stream",

     "text": [

      "/home/hnoghabi/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:28: FutureWarning: \n",

      "Passing list-likes to .loc or [] with any missing label will raise\n",

      "KeyError in the future, you can use .reindex() as an alternative.\n",

      "\n",

      "See the documentation here:\n",

      "https://pandas.pydata.org/pandas-docs/stable/indexing.html#deprecate-loc-reindex-listlike\n",

      "/home/hnoghabi/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:29: FutureWarning: \n",

      "Passing list-likes to .loc or [] with any missing label will raise\n",

      "KeyError in the future, you can use .reindex() as an alternative.\n",

      "\n",

      "See the documentation here:\n",

      "https://pandas.pydata.org/pandas-docs/stable/indexing.html#deprecate-loc-reindex-listlike\n",

      "/home/hnoghabi/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:30: FutureWarning: \n",

      "Passing list-likes to .loc or [] with any missing label will raise\n",

      "KeyError in the future, you can use .reindex() as an alternative.\n",

      "\n",

      "See the documentation here:\n",

      "https://pandas.pydata.org/pandas-docs/stable/indexing.html#deprecate-loc-reindex-listlike\n"

     ]

    },

    {

     "name": "stdout",

     "output_type": "stream",

     "text": [

      "(161, 13081)\n",

      "(161, 13081)\n",

      "(161, 13081)\n"

     ]

    }

   ],

   "source": [

    "KIRPE = pd.read_csv(\"TCGA-KIRP_exprs.tsv\", \n",

    "                   sep = \"\\t\", index_col=0, decimal = \".\")\n",

    "KIRPE = pd.DataFrame.transpose(KIRPE)\n",

    "\n",

    "KIRPM = pd.read_csv(\"TCGA-KIRP_mutations.tsv\", \n",

    "                   sep = \"\\t\", index_col=0, decimal = \".\")\n",

    "KIRPM = pd.DataFrame.transpose(KIRPM)\n",

    "KIRPM = KIRPM.loc[:,~KIRPM.columns.duplicated()]\n",

    "\n",

    "KIRPC = pd.read_csv(\"TCGA-KIRP_CNA.tsv\", \n",

    "                   sep = \"\\t\", index_col=0, decimal = \".\")\n",

    "KIRPC = pd.DataFrame.transpose(KIRPC)\n",

    "KIRPC = KIRPC.loc[:,~KIRPC.columns.duplicated()]\n",

    "\n",

    "KIRPM = KIRPM.fillna(0)\n",

    "KIRPM[KIRPM != 0.0] = 1\n",

    "KIRPC = KIRPC.fillna(0)\n",

    "KIRPC[KIRPC != 0.0] = 1\n",

    "\n",

    "#KIRPE.rename(lambda x : x[0:11], axis = \"index\", inplace=True)  \n",

    "#KIRPM.rename(lambda x : x[0:11], axis = \"index\", inplace=True)   \n",

    "#KIRPC.rename(lambda x : x[0:11], axis = \"index\", inplace=True)   \n",

    "\n",

    "lsKIRP = KIRPE.index.intersection(KIRPM.index)\n",

    "lsKIRP = lsKIRP.intersection(KIRPC.index)\n",

    "lsKIRP = pd.unique(lsKIRP)\n",

    "\n",

    "KIRPE = KIRPE.loc[lsKIRP,ls]\n",

    "KIRPM = KIRPM.loc[lsKIRP,ls]\n",

    "KIRPC = KIRPC.loc[lsKIRP,ls]\n",

    "\n",

    "print(KIRPE.shape)\n",

    "print(KIRPM.shape)\n",

    "print(KIRPC.shape)\n",

    "\n",

    "AutoencoderE.eval()\n",

    "AutoencoderM.eval()\n",

    "AutoencoderC.eval()\n",

    "Clas.eval()\n",

    "\n",

    "KIRPE2 = np.nan_to_num(KIRPE.values)\n",

    "KIRPM2 = np.nan_to_num(KIRPM.values)\n",

    "KIRPC2 = np.nan_to_num(KIRPC.values)\n",

    "\n",

    "NKIRPE2 = scalerGDSC.transform(KIRPE2)    \n",

    "\n",

    "KIRPexprs = torch.FloatTensor(NKIRPE2)\n",

    "KIRPmut = torch.FloatTensor(KIRPM2)\n",

    "KIRPcna = torch.FloatTensor(KIRPC2)\n",

    "\n",

    "KIRPZE = AutoencoderE(KIRPexprs)\n",

    "KIRPZM = AutoencoderM(KIRPmut)\n",

    "KIRPZC = AutoencoderC(KIRPcna)\n",

    "\n",

    "KIRPZT = torch.cat((KIRPZE, KIRPZM, KIRPZC), 1)\n",

    "KIRPZTX = F.normalize(KIRPZT, p=2, dim=0)\n",

    "PredKIRP = Clas(KIRPZTX)\n",

    "\n",

    "#print(PredKIRP.detach().numpy())"

   ]

  },

  {

   "cell_type": "code",

   "execution_count": 4,

   "metadata": {},

   "outputs": [

    {

     "name": "stderr",

     "output_type": "stream",

     "text": [

      "/home/hnoghabi/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:28: FutureWarning: \n",

      "Passing list-likes to .loc or [] with any missing label will raise\n",

      "KeyError in the future, you can use .reindex() as an alternative.\n",

      "\n",

      "See the documentation here:\n",

      "https://pandas.pydata.org/pandas-docs/stable/indexing.html#deprecate-loc-reindex-listlike\n",

      "/home/hnoghabi/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:29: FutureWarning: \n",

      "Passing list-likes to .loc or [] with any missing label will raise\n",

      "KeyError in the future, you can use .reindex() as an alternative.\n",

      "\n",

      "See the documentation here:\n",

      "https://pandas.pydata.org/pandas-docs/stable/indexing.html#deprecate-loc-reindex-listlike\n",

      "/home/hnoghabi/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:30: FutureWarning: \n",

      "Passing list-likes to .loc or [] with any missing label will raise\n",

      "KeyError in the future, you can use .reindex() as an alternative.\n",

      "\n",

      "See the documentation here:\n",

      "https://pandas.pydata.org/pandas-docs/stable/indexing.html#deprecate-loc-reindex-listlike\n"

     ]

    },

    {

     "name": "stdout",

     "output_type": "stream",

     "text": [

      "(123, 13081)\n",

      "(123, 13081)\n",

      "(123, 13081)\n"

     ]

    }

   ],

   "source": [

    "BLCAE = pd.read_csv(\"TCGA-BLCA_exprs.tsv\", \n",

    "                   sep = \"\\t\", index_col=0, decimal = \".\")\n",

    "BLCAE = pd.DataFrame.transpose(BLCAE)\n",

    "\n",

    "BLCAM = pd.read_csv(\"TCGA-BLCA_mutations.tsv\", \n",

    "                   sep = \"\\t\", index_col=0, decimal = \".\")\n",

    "BLCAM = pd.DataFrame.transpose(BLCAM)\n",

    "BLCAM = BLCAM.loc[:,~BLCAM.columns.duplicated()]\n",

    "\n",

    "BLCAC = pd.read_csv(\"TCGA-BLCA_CNA.tsv\", \n",

    "                   sep = \"\\t\", index_col=0, decimal = \".\")\n",

    "BLCAC = pd.DataFrame.transpose(BLCAC)\n",

    "BLCAC = BLCAC.loc[:,~BLCAC.columns.duplicated()]\n",

    "\n",

    "BLCAM = BLCAM.fillna(0)\n",

    "BLCAM[BLCAM != 0.0] = 1\n",

    "BLCAC = BLCAC.fillna(0)\n",

    "BLCAC[BLCAC != 0.0] = 1\n",

    "\n",

    "#BLCAE.rename(lambda x : x[0:11], axis = \"index\", inplace=True)  \n",

    "#BLCAM.rename(lambda x : x[0:11], axis = \"index\", inplace=True)   \n",

    "#BLCAC.rename(lambda x : x[0:11], axis = \"index\", inplace=True)   \n",

    "\n",

    "lsBLCA = BLCAE.index.intersection(BLCAM.index)\n",

    "lsBLCA = lsBLCA.intersection(BLCAC.index)\n",

    "lsBLCA = pd.unique(lsBLCA)\n",

    "\n",

    "BLCAE = BLCAE.loc[lsBLCA,ls]\n",

    "BLCAM = BLCAM.loc[lsBLCA,ls]\n",

    "BLCAC = BLCAC.loc[lsBLCA,ls]\n",

    "\n",

    "print(BLCAE.shape)\n",

    "print(BLCAM.shape)\n",

    "print(BLCAC.shape)\n",

    "\n",

    "AutoencoderE.eval()\n",

    "AutoencoderM.eval()\n",

    "AutoencoderC.eval()\n",

    "Clas.eval()\n",

    "\n",

    "BLCAE2 = np.nan_to_num(BLCAE.values)\n",

    "BLCAM2 = np.nan_to_num(BLCAM.values)\n",

    "BLCAC2 = np.nan_to_num(BLCAC.values)\n",

    "\n",

    "NBLCAE2 = scalerGDSC.transform(BLCAE2)    \n",

    "\n",

    "BLCAexprs = torch.FloatTensor(NBLCAE2)\n",

    "BLCAmut = torch.FloatTensor(BLCAM2)\n",

    "BLCAcna = torch.FloatTensor(BLCAC2)\n",

    "\n",

    "BLCAZE = AutoencoderE(BLCAexprs)\n",

    "BLCAZM = AutoencoderM(BLCAmut)\n",

    "BLCAZC = AutoencoderC(BLCAcna)\n",

    "\n",

    "BLCAZT = torch.cat((BLCAZE, BLCAZM, BLCAZC), 1)\n",

    "BLCAZTX = F.normalize(BLCAZT, p=2, dim=0)\n",

    "PredBLCA = Clas(BLCAZTX)\n",

    "\n",

    "#print(PredBLCA.detach().numpy())"

   ]

  },

  {

   "cell_type": "code",

   "execution_count": 5,

   "metadata": {},

   "outputs": [

    {

     "name": "stderr",

     "output_type": "stream",

     "text": [

      "/home/hnoghabi/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:28: FutureWarning: \n",

      "Passing list-likes to .loc or [] with any missing label will raise\n",

      "KeyError in the future, you can use .reindex() as an alternative.\n",

      "\n",

      "See the documentation here:\n",

      "https://pandas.pydata.org/pandas-docs/stable/indexing.html#deprecate-loc-reindex-listlike\n",

      "/home/hnoghabi/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:29: FutureWarning: \n",

      "Passing list-likes to .loc or [] with any missing label will raise\n",

      "KeyError in the future, you can use .reindex() as an alternative.\n",

      "\n",

      "See the documentation here:\n",

      "https://pandas.pydata.org/pandas-docs/stable/indexing.html#deprecate-loc-reindex-listlike\n",

      "/home/hnoghabi/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:30: FutureWarning: \n",

      "Passing list-likes to .loc or [] with any missing label will raise\n",

      "KeyError in the future, you can use .reindex() as an alternative.\n",

      "\n",

      "See the documentation here:\n",

      "https://pandas.pydata.org/pandas-docs/stable/indexing.html#deprecate-loc-reindex-listlike\n"

     ]

    },

    {

     "name": "stdout",

     "output_type": "stream",

     "text": [

      "(921, 13081)\n",

      "(921, 13081)\n",

      "(921, 13081)\n"

     ]

    }

   ],

   "source": [

    "BRCAE = pd.read_csv(\"TCGA-BRCA_exprs.tsv\", \n",

    "                   sep = \"\\t\", index_col=0, decimal = \".\")\n",

    "BRCAE = pd.DataFrame.transpose(BRCAE)\n",

    "\n",

    "BRCAM = pd.read_csv(\"TCGA-BRCA_mutations.tsv\", \n",

    "                   sep = \"\\t\", index_col=0, decimal = \".\")\n",

    "BRCAM = pd.DataFrame.transpose(BRCAM)\n",

    "BRCAM = BRCAM.loc[:,~BRCAM.columns.duplicated()]\n",

    "\n",

    "BRCAC = pd.read_csv(\"TCGA-BRCA_CNA.tsv\", \n",

    "                   sep = \"\\t\", index_col=0, decimal = \".\")\n",

    "BRCAC = pd.DataFrame.transpose(BRCAC)\n",

    "BRCAC = BRCAC.loc[:,~BRCAC.columns.duplicated()]\n",

    "\n",

    "BRCAM = BRCAM.fillna(0)\n",

    "BRCAM[BRCAM != 0.0] = 1\n",

    "BRCAC = BRCAC.fillna(0)\n",

    "BRCAC[BRCAC != 0.0] = 1\n",

    "\n",

    "#BRCAE.rename(lambda x : x[0:11], axis = \"index\", inplace=True)  \n",

    "#BRCAM.rename(lambda x : x[0:11], axis = \"index\", inplace=True)   \n",

    "#BRCAC.rename(lambda x : x[0:11], axis = \"index\", inplace=True)   \n",

    "\n",

    "lsBRCA = BRCAE.index.intersection(BRCAM.index)\n",

    "lsBRCA = lsBRCA.intersection(BRCAC.index)\n",

    "lsBRCA = pd.unique(lsBRCA)\n",

    "\n",

    "BRCAE = BRCAE.loc[lsBRCA,ls]\n",

    "BRCAM = BRCAM.loc[lsBRCA,ls]\n",

    "BRCAC = BRCAC.loc[lsBRCA,ls]\n",

    "\n",

    "print(BRCAE.shape)\n",

    "print(BRCAM.shape)\n",

    "print(BRCAC.shape)\n",

    "\n",

    "AutoencoderE.eval()\n",

    "AutoencoderM.eval()\n",

    "AutoencoderC.eval()\n",

    "Clas.eval()\n",

    "\n",

    "BRCAE2 = np.nan_to_num(BRCAE.values)\n",

    "BRCAM2 = np.nan_to_num(BRCAM.values)\n",

    "BRCAC2 = np.nan_to_num(BRCAC.values)\n",

    "\n",

    "NBRCAE2 = scalerGDSC.transform(BRCAE2)    \n",

    "\n",

    "BRCAexprs = torch.FloatTensor(NBRCAE2)\n",

    "BRCAmut = torch.FloatTensor(BRCAM2)\n",

    "BRCAcna = torch.FloatTensor(BRCAC2)\n",

    "\n",

    "BRCAZE = AutoencoderE(BRCAexprs)\n",

    "BRCAZM = AutoencoderM(BRCAmut)\n",

    "BRCAZC = AutoencoderC(BRCAcna)\n",

    "\n",

    "BRCAZT = torch.cat((BRCAZE, BRCAZM, BRCAZC), 1)\n",

    "BRCAZTX = F.normalize(BRCAZT, p=2, dim=0)\n",

    "PredBRCA = Clas(BRCAZTX)\n",

    "\n",

    "#print(PredBRCA.detach().numpy())"

   ]

  },

  {

   "cell_type": "code",

   "execution_count": 6,

   "metadata": {},

   "outputs": [

    {

     "name": "stdout",

     "output_type": "stream",

     "text": [

      "(130, 13081)\n",

      "(130, 13081)\n",

      "(130, 13081)\n"

     ]

    },

    {

     "name": "stderr",

     "output_type": "stream",

     "text": [

      "/home/hnoghabi/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:28: FutureWarning: \n",

      "Passing list-likes to .loc or [] with any missing label will raise\n",

      "KeyError in the future, you can use .reindex() as an alternative.\n",

      "\n",

      "See the documentation here:\n",

      "https://pandas.pydata.org/pandas-docs/stable/indexing.html#deprecate-loc-reindex-listlike\n",

      "/home/hnoghabi/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:29: FutureWarning: \n",

      "Passing list-likes to .loc or [] with any missing label will raise\n",

      "KeyError in the future, you can use .reindex() as an alternative.\n",

      "\n",

      "See the documentation here:\n",

      "https://pandas.pydata.org/pandas-docs/stable/indexing.html#deprecate-loc-reindex-listlike\n",

      "/home/hnoghabi/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:30: FutureWarning: \n",

      "Passing list-likes to .loc or [] with any missing label will raise\n",

      "KeyError in the future, you can use .reindex() as an alternative.\n",

      "\n",

      "See the documentation here:\n",

      "https://pandas.pydata.org/pandas-docs/stable/indexing.html#deprecate-loc-reindex-listlike\n"

     ]

    }

   ],

   "source": [

    "PAADE = pd.read_csv(\"TCGA-PAAD_exprs.tsv\", \n",

    "                   sep = \"\\t\", index_col=0, decimal = \".\")\n",

    "PAADE = pd.DataFrame.transpose(PAADE)\n",

    "\n",

    "PAADM = pd.read_csv(\"TCGA-PAAD_mutations.tsv\", \n",

    "                   sep = \"\\t\", index_col=0, decimal = \".\")\n",

    "PAADM = pd.DataFrame.transpose(PAADM)\n",

    "PAADM = PAADM.loc[:,~PAADM.columns.duplicated()]\n",

    "\n",

    "PAADC = pd.read_csv(\"TCGA-PAAD_CNA.tsv\", \n",

    "                   sep = \"\\t\", index_col=0, decimal = \".\")\n",

    "PAADC = pd.DataFrame.transpose(PAADC)\n",

    "PAADC = PAADC.loc[:,~PAADC.columns.duplicated()]\n",

    "\n",

    "PAADM = PAADM.fillna(0)\n",

    "PAADM[PAADM != 0.0] = 1\n",

    "PAADC = PAADC.fillna(0)\n",

    "PAADC[PAADC != 0.0] = 1\n",

    "\n",

    "#PAADE.rename(lambda x : x[0:11], axis = \"index\", inplace=True)  \n",

    "#PAADM.rename(lambda x : x[0:11], axis = \"index\", inplace=True)   \n",

    "#PAADC.rename(lambda x : x[0:11], axis = \"index\", inplace=True)   \n",

    "\n",

    "lsPAAD = PAADE.index.intersection(PAADM.index)\n",

    "lsPAAD = lsPAAD.intersection(PAADC.index)\n",

    "lsPAAD = pd.unique(lsPAAD)\n",

    "\n",

    "PAADE = PAADE.loc[lsPAAD,ls]\n",

    "PAADM = PAADM.loc[lsPAAD,ls]\n",

    "PAADC = PAADC.loc[lsPAAD,ls]\n",

    "\n",

    "print(PAADE.shape)\n",

    "print(PAADM.shape)\n",

    "print(PAADC.shape)\n",

    "\n",

    "AutoencoderE.eval()\n",

    "AutoencoderM.eval()\n",

    "AutoencoderC.eval()\n",

    "Clas.eval()\n",

    "\n",

    "PAADE2 = np.nan_to_num(PAADE.values)\n",

    "PAADM2 = np.nan_to_num(PAADM.values)\n",

    "PAADC2 = np.nan_to_num(PAADC.values)\n",

    "\n",

    "NPAADE2 = scalerGDSC.transform(PAADE2)    \n",

    "\n",

    "PAADexprs = torch.FloatTensor(NPAADE2)\n",

    "PAADmut = torch.FloatTensor(PAADM2)\n",

    "PAADcna = torch.FloatTensor(PAADC2)\n",

    "\n",

    "PAADZE = AutoencoderE(PAADexprs)\n",

    "PAADZM = AutoencoderM(PAADmut)\n",

    "PAADZC = AutoencoderC(PAADcna)\n",

    "\n",

    "PAADZT = torch.cat((PAADZE, PAADZM, PAADZC), 1)\n",

    "PAADZTX = F.normalize(PAADZT, p=2, dim=0)\n",

    "PredPAAD = Clas(PAADZTX)\n",

    "\n",

    "#print(PredPAAD.detach().numpy())"

   ]

  },

  {

   "cell_type": "code",

   "execution_count": 7,

   "metadata": {},

   "outputs": [

    {

     "name": "stderr",

     "output_type": "stream",

     "text": [

      "/home/hnoghabi/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:28: FutureWarning: \n",

      "Passing list-likes to .loc or [] with any missing label will raise\n",

      "KeyError in the future, you can use .reindex() as an alternative.\n",

      "\n",

      "See the documentation here:\n",

      "https://pandas.pydata.org/pandas-docs/stable/indexing.html#deprecate-loc-reindex-listlike\n",

      "/home/hnoghabi/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:29: FutureWarning: \n",

      "Passing list-likes to .loc or [] with any missing label will raise\n",

      "KeyError in the future, you can use .reindex() as an alternative.\n",

      "\n",

      "See the documentation here:\n",

      "https://pandas.pydata.org/pandas-docs/stable/indexing.html#deprecate-loc-reindex-listlike\n",

      "/home/hnoghabi/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:30: FutureWarning: \n",

      "Passing list-likes to .loc or [] with any missing label will raise\n",

      "KeyError in the future, you can use .reindex() as an alternative.\n",

      "\n",

      "See the documentation here:\n",

      "https://pandas.pydata.org/pandas-docs/stable/indexing.html#deprecate-loc-reindex-listlike\n"

     ]

    },

    {

     "name": "stdout",

     "output_type": "stream",

     "text": [

      "(475, 13081)\n",

      "(475, 13081)\n",

      "(475, 13081)\n"

     ]

    }

   ],

   "source": [

    "LUADE = pd.read_csv(\"TCGA-LUAD_exprs.tsv\", \n",

    "                   sep = \"\\t\", index_col=0, decimal = \".\")\n",

    "LUADE = pd.DataFrame.transpose(LUADE)\n",

    "\n",

    "LUADM = pd.read_csv(\"TCGA-LUAD_mutations.tsv\", \n",

    "                   sep = \"\\t\", index_col=0, decimal = \".\")\n",

    "LUADM = pd.DataFrame.transpose(LUADM)\n",

    "LUADM = LUADM.loc[:,~LUADM.columns.duplicated()]\n",

    "\n",

    "LUADC = pd.read_csv(\"TCGA-LUAD_CNA.tsv\", \n",

    "                   sep = \"\\t\", index_col=0, decimal = \".\")\n",

    "LUADC = pd.DataFrame.transpose(LUADC)\n",

    "LUADC = LUADC.loc[:,~LUADC.columns.duplicated()]\n",

    "\n",

    "LUADM = LUADM.fillna(0)\n",

    "LUADM[LUADM != 0.0] = 1\n",

    "LUADC = LUADC.fillna(0)\n",

    "LUADC[LUADC != 0.0] = 1\n",

    "\n",

    "#LUADE.rename(lambda x : x[0:11], axis = \"index\", inplace=True)  \n",

    "#LUADM.rename(lambda x : x[0:11], axis = \"index\", inplace=True)   \n",

    "#LUADC.rename(lambda x : x[0:11], axis = \"index\", inplace=True)   \n",

    "\n",

    "lsLUAD = LUADE.index.intersection(LUADM.index)\n",

    "lsLUAD = lsLUAD.intersection(LUADC.index)\n",

    "lsLUAD = pd.unique(lsLUAD)\n",

    "\n",

    "LUADE = LUADE.loc[lsLUAD,ls]\n",

    "LUADM = LUADM.loc[lsLUAD,ls]\n",

    "LUADC = LUADC.loc[lsLUAD,ls]\n",

    "\n",

    "print(LUADE.shape)\n",

    "print(LUADM.shape)\n",

    "print(LUADC.shape)\n",

    "\n",

    "AutoencoderE.eval()\n",

    "AutoencoderM.eval()\n",

    "AutoencoderC.eval()\n",

    "Clas.eval()\n",

    "\n",

    "LUADE2 = np.nan_to_num(LUADE.values)\n",

    "LUADM2 = np.nan_to_num(LUADM.values)\n",

    "LUADC2 = np.nan_to_num(LUADC.values)\n",

    "\n",

    "NLUADE2 = scalerGDSC.transform(LUADE2)    \n",

    "\n",

    "LUADexprs = torch.FloatTensor(NLUADE2)\n",

    "LUADmut = torch.FloatTensor(LUADM2)\n",

    "LUADcna = torch.FloatTensor(LUADC2)\n",

    "\n",

    "LUADZE = AutoencoderE(LUADexprs)\n",

    "LUADZM = AutoencoderM(LUADmut)\n",

    "LUADZC = AutoencoderC(LUADcna)\n",

    "\n",

    "LUADZT = torch.cat((LUADZE, LUADZM, LUADZC), 1)\n",

    "LUADZTX = F.normalize(LUADZT, p=2, dim=0)\n",

    "PredLUAD = Clas(LUADZTX)\n",

    "\n",

    "#print(PredLUAD.detach().numpy())"

   ]

  },

  {

   "cell_type": "code",

   "execution_count": 8,

   "metadata": {},

   "outputs": [],

   "source": [

    "from scipy.stats.stats import pearsonr\n",

    "from scipy.stats import spearmanr\n",

    "import statsmodels.api as sm\n",

    "from mne.stats import bonferroni_correction\n",

    "\n",

    "lsEGFR = [10000, 102, 10252, 10253,10254,1026,1027,107,108,109,111,11140,112,113,114,1147,115,117145,1173,1175,1211,1213,1385,1445,156,160,161,163,1950,1956,196883,2060,207,208,2308,2309,23239,2475,253260,2549,26018,2885,2931,29924,30011,3164,3265,3320,3709,3710,3845,4193,4303,4893,5136,5153,5170,5290,5295,5335,5566,5567,5568,5573,5575,5576,5577,5578,5580,5581,5582,55824,5594,5595,5604,5605,572,5728,57761,58513,5894,6199,6233,64223,6456,6464,6654,6714,6868,7249,728590,729120,730418,7311,731292,7529,79109,801,8027,8038,805,808,814,842,84335,867,9146,983,998]\n",

    "\n",

    "#lsEGFR = [10000,1026,1027,10298,10718,1398,1399,145957,1839,1950,1956,1978,2002,2064,2065,2066,2069,207,208,23533,23642,2475,25,2549,25759,27,2885,2932,3084,3265,369,3725,374,3845,399694,4609,4690,4893,5058,5062,5063,5290,5291,5293,5294,5295,5296,5335,53358,5336,5578,5579,5582,5594,5595,5599,5601,5602,5604,5605,5609,56924,57144,572,5747,5894,6198,6199,6416,6464,6654,6655,6714,673,6776,6777,685,7039,815,816,817,818,8440,8503,867,868,9542]"

   ]

  },

  {

   "cell_type": "code",

   "execution_count": 12,

   "metadata": {},

   "outputs": [],

   "source": [

    "listEGFR = PRADE.columns.intersection(lsEGFR)\n",

    "PRADEEGFR = PRADE[listEGFR]\n",

    "PRADMEGFR = PRADM[listEGFR]\n",

    "PRADCEGFR = PRADC[listEGFR]"

   ]

  },

  {

   "cell_type": "code",

   "execution_count": 13,

   "metadata": {},

   "outputs": [

    {

     "data": {

      "text/html": [

       "<table class=\"simpletable\">\n",

       "<caption>OLS Regression Results</caption>\n",

       "<tr>\n",

       "  <th>Dep. Variable:</th>            <td>y</td>        <th>  R-squared:         </th> <td>   0.999</td>\n",

       "</tr>\n",

       "<tr>\n",

       "  <th>Model:</th>                   <td>OLS</td>       <th>  Adj. R-squared:    </th> <td>   0.999</td>\n",

       "</tr>\n",

       "<tr>\n",

       "  <th>Method:</th>             <td>Least Squares</td>  <th>  F-statistic:       </th> <td>   3331.</td>\n",

       "</tr>\n",

       "<tr>\n",

       "  <th>Date:</th>             <td>Sat, 12 Jan 2019</td> <th>  Prob (F-statistic):</th>  <td>  0.00</td> \n",

       "</tr>\n",

       "<tr>\n",

       "  <th>Time:</th>                 <td>18:16:35</td>     <th>  Log-Likelihood:    </th> <td>  1340.8</td>\n",

       "</tr>\n",

       "<tr>\n",

       "  <th>No. Observations:</th>      <td>   492</td>      <th>  AIC:               </th> <td>  -2480.</td>\n",

       "</tr>\n",

       "<tr>\n",

       "  <th>Df Residuals:</th>          <td>   391</td>      <th>  BIC:               </th> <td>  -2056.</td>\n",

       "</tr>\n",

       "<tr>\n",

       "  <th>Df Model:</th>              <td>   101</td>      <th>                     </th>     <td> </td>   \n",

       "</tr>\n",

       "<tr>\n",

       "  <th>Covariance Type:</th>      <td>nonrobust</td>    <th>                     </th>     <td> </td>   \n",

       "</tr>\n",

       "</table>\n",

       "<table class=\"simpletable\">\n",

       "<tr>\n",

       "     <td></td>       <th>coef</th>     <th>std err</th>      <th>t</th>      <th>P>|t|</th>  <th>[0.025</th>    <th>0.975]</th>  \n",

       "</tr>\n",

       "<tr>\n",

       "  <th>102</th>    <td>    0.0038</td> <td>    0.003</td> <td>    1.171</td> <td> 0.242</td> <td>   -0.003</td> <td>    0.010</td>\n",

       "</tr>\n",

       "<tr>\n",

       "  <th>107</th>    <td>   -0.0015</td> <td>    0.001</td> <td>   -0.982</td> <td> 0.327</td> <td>   -0.004</td> <td>    0.001</td>\n",

       "</tr>\n",

       "<tr>\n",

       "  <th>108</th>    <td>   -0.0006</td> <td>    0.002</td> <td>   -0.377</td> <td> 0.706</td> <td>   -0.004</td> <td>    0.003</td>\n",

       "</tr>\n",

       "<tr>\n",

       "  <th>109</th>    <td>   -0.0021</td> <td>    0.004</td> <td>   -0.585</td> <td> 0.559</td> <td>   -0.009</td> <td>    0.005</td>\n",

       "</tr>\n",

       "<tr>\n",

       "  <th>111</th>    <td>   -0.0038</td> <td>    0.003</td> <td>   -1.432</td> <td> 0.153</td> <td>   -0.009</td> <td>    0.001</td>\n",

       "</tr>\n",

       "<tr>\n",

       "  <th>112</th>    <td>   -0.0092</td> <td>    0.004</td> <td>   -2.553</td> <td> 0.011</td> <td>   -0.016</td> <td>   -0.002</td>\n",

       "</tr>\n",

       "<tr>\n",

       "  <th>113</th>    <td>    0.0046</td> <td>    0.003</td> <td>    1.325</td> <td> 0.186</td> <td>   -0.002</td> <td>    0.011</td>\n",

       "</tr>\n",

       "<tr>\n",

       "  <th>114</th>    <td>    0.0184</td> <td>    0.021</td> <td>    0.868</td> <td> 0.386</td> <td>   -0.023</td> <td>    0.060</td>\n",

       "</tr>\n",

       "<tr>\n",

       "  <th>115</th>    <td>   -0.0002</td> <td>    0.004</td> <td>   -0.047</td> <td> 0.963</td> <td>   -0.007</td> <td>    0.007</td>\n",

       "</tr>\n",

       "<tr>\n",

       "  <th>160</th>    <td>    0.0020</td> <td>    0.004</td> <td>    0.564</td> <td> 0.573</td> <td>   -0.005</td> <td>    0.009</td>\n",

       "</tr>\n",

       "<tr>\n",

       "  <th>161</th>    <td>    0.0081</td> <td>    0.006</td> <td>    1.424</td> <td> 0.155</td> <td>   -0.003</td> <td>    0.019</td>\n",

       "</tr>\n",

       "<tr>\n",

       "  <th>163</th>    <td>    0.0006</td> <td>    0.004</td> <td>    0.142</td> <td> 0.887</td> <td>   -0.008</td> <td>    0.009</td>\n",

       "</tr>\n",

       "<tr>\n",

       "  <th>207</th>    <td>    0.0157</td> <td>    0.004</td> <td>    3.698</td> <td> 0.000</td> <td>    0.007</td> <td>    0.024</td>\n",

       "</tr>\n",

       "<tr>\n",

       "  <th>208</th>    <td>    0.0044</td> <td>    0.006</td> <td>    0.792</td> <td> 0.429</td> <td>   -0.007</td> <td>    0.015</td>\n",

       "</tr>\n",

       "<tr>\n",

       "  <th>572</th>    <td>    0.0089</td> <td>    0.004</td> <td>    1.975</td> <td> 0.049</td> <td> 3.82e-05</td> <td>    0.018</td>\n",

       "</tr>\n",

       "<tr>\n",

       "  <th>801</th>    <td>   -0.0057</td> <td>    0.003</td> <td>   -1.772</td> <td> 0.077</td> <td>   -0.012</td> <td>    0.001</td>\n",

       "</tr>\n",

       "<tr>\n",

       "  <th>805</th>    <td>    0.0053</td> <td>    0.004</td> <td>    1.280</td> <td> 0.201</td> <td>   -0.003</td> <td>    0.013</td>\n",

       "</tr>\n",

       "<tr>\n",

       "  <th>808</th>    <td>    0.0055</td> <td>    0.005</td> <td>    1.141</td> <td> 0.255</td> <td>   -0.004</td> <td>    0.015</td>\n",

       "</tr>\n",

       "<tr>\n",

       "  <th>814</th>    <td>   -0.0012</td> <td>    0.003</td> <td>   -0.477</td> <td> 0.633</td> <td>   -0.006</td> <td>    0.004</td>\n",

       "</tr>\n",

       "<tr>\n",

       "  <th>842</th>    <td>   -0.0072</td> <td>    0.004</td> <td>   -1.804</td> <td> 0.072</td> <td>   -0.015</td> <td>    0.001</td>\n",

       "</tr>\n",

       "<tr>\n",

       "  <th>867</th>    <td>    0.0034</td> <td>    0.005</td> <td>    0.666</td> <td> 0.506</td> <td>   -0.007</td> <td>    0.014</td>\n",

       "</tr>\n",

       "<tr>\n",

       "  <th>983</th>    <td>    0.0062</td> <td>    0.002</td> <td>    3.919</td> <td> 0.000</td> <td>    0.003</td> <td>    0.009</td>\n",

       "</tr>\n",

       "<tr>\n",

       "  <th>998</th>    <td>   -0.0097</td> <td>    0.005</td> <td>   -1.854</td> <td> 0.064</td> <td>   -0.020</td> <td>    0.001</td>\n",

       "</tr>\n",

       "<tr>\n",

       "  <th>1026</th>   <td>    0.0025</td> <td>    0.001</td> <td>    1.717</td> <td> 0.087</td> <td>   -0.000</td> <td>    0.005</td>\n",

       "</tr>\n",

       "<tr>\n",

       "  <th>1027</th>   <td>   -0.0033</td> <td>    0.003</td> <td>   -1.224</td> <td> 0.222</td> <td>   -0.009</td> <td>    0.002</td>\n",

       "</tr>\n",

       "<tr>\n",

       "  <th>1147</th>   <td>   -0.0025</td> <td>    0.004</td> <td>   -0.635</td> <td> 0.526</td> <td>   -0.010</td> <td>    0.005</td>\n",

       "</tr>\n",

       "<tr>\n",

       "  <th>1173</th>   <td>    0.0166</td> <td>    0.005</td> <td>    3.472</td> <td> 0.001</td> <td>    0.007</td> <td>    0.026</td>\n",

       "</tr>\n",

       "<tr>\n",

       "  <th>1175</th>   <td>   -0.0029</td> <td>    0.003</td> <td>   -0.927</td> <td> 0.355</td> <td>   -0.009</td> <td>    0.003</td>\n",

       "</tr>\n",

       "<tr>\n",

       "  <th>1211</th>   <td>    0.0137</td> <td>    0.004</td> <td>    3.271</td> <td> 0.001</td> <td>    0.005</td> <td>    0.022</td>\n",

       "</tr>\n",

       "<tr>\n",

       "  <th>1213</th>   <td>   -0.0176</td> <td>    0.005</td> <td>   -3.238</td> <td> 0.001</td> <td>   -0.028</td> <td>   -0.007</td>\n",

       "</tr>\n",

       "<tr>\n",

       "  <th>1385</th>   <td>   -0.0272</td> <td>    0.006</td> <td>   -4.807</td> <td> 0.000</td> <td>   -0.038</td> <td>   -0.016</td>\n",

       "</tr>\n",

       "<tr>\n",

       "  <th>1445</th>   <td>   -0.0190</td> <td>    0.005</td> <td>   -3.692</td> <td> 0.000</td> <td>   -0.029</td> <td>   -0.009</td>\n",

       "</tr>\n",

       "<tr>\n",

       "  <th>1950</th>   <td>    0.0015</td> <td>    0.001</td> <td>    1.262</td> <td> 0.208</td> <td>   -0.001</td> <td>    0.004</td>\n",

       "</tr>\n",

       "<tr>\n",

       "  <th>1956</th>   <td>    0.0091</td> <td>    0.003</td> <td>    3.223</td> <td> 0.001</td> <td>    0.004</td> <td>    0.015</td>\n",

       "</tr>\n",

       "<tr>\n",

       "  <th>2060</th>   <td>   -0.0084</td> <td>    0.005</td> <td>   -1.800</td> <td> 0.073</td> <td>   -0.018</td> <td>    0.001</td>\n",

       "</tr>\n",

       "<tr>\n",

       "  <th>2308</th>   <td>   -0.0026</td> <td>    0.004</td> <td>   -0.730</td> <td> 0.466</td> <td>   -0.010</td> <td>    0.004</td>\n",

       "</tr>\n",

       "<tr>\n",

       "  <th>2309</th>   <td>    0.0015</td> <td>    0.002</td> <td>    0.613</td> <td> 0.540</td> <td>   -0.003</td> <td>    0.006</td>\n",

       "</tr>\n",

       "<tr>\n",

       "  <th>2475</th>   <td>    0.0009</td> <td>    0.003</td> <td>    0.326</td> <td> 0.744</td> <td>   -0.005</td> <td>    0.007</td>\n",

       "</tr>\n",

       "<tr>\n",

       "  <th>2549</th>   <td>    0.0126</td> <td>    0.004</td> <td>    2.997</td> <td> 0.003</td> <td>    0.004</td> <td>    0.021</td>\n",

       "</tr>\n",

       "<tr>\n",

       "  <th>2885</th>   <td>    0.0143</td> <td>    0.006</td> <td>    2.293</td> <td> 0.022</td> <td>    0.002</td> <td>    0.027</td>\n",

       "</tr>\n",

       "<tr>\n",

       "  <th>2931</th>   <td>    0.0105</td> <td>    0.003</td> <td>    3.025</td> <td> 0.003</td> <td>    0.004</td> <td>    0.017</td>\n",

       "</tr>\n",

       "<tr>\n",

       "  <th>3164</th>   <td>    0.0011</td> <td>    0.001</td> <td>    0.984</td> <td> 0.325</td> <td>   -0.001</td> <td>    0.003</td>\n",

       "</tr>\n",

       "<tr>\n",

       "  <th>3265</th>   <td>    0.0007</td> <td>    0.004</td> <td>    0.162</td> <td> 0.872</td> <td>   -0.008</td> <td>    0.009</td>\n",

       "</tr>\n",