6. BioNet-Nor.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "da103003-0a84-4cc7-a129-d17c7246df8f",
   "metadata": {},
   "outputs": [],
   "source": [
    "### General analysis package\n",
    "import os\n",
    "import time\n",
    "import random\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import scipy.stats as stats\n",
    "from scipy.stats import norm, pearsonr, spearmanr\n",
    "from scipy.spatial import distance\n",
    "### Drawing package\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib import gridspec\n",
    "import matplotlib.lines as mlines\n",
    "from matplotlib.font_manager import FontProperties\n",
    "#import seaborn as sns\n",
    "import matplotlib as mpl\n",
    "mpl.rcParams['pdf.fonttype'] = 42 # Output editable PDF text\n",
    "### else\n",
    "#import cloudpickle as pickle\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\") # Error alert\n",
    "from IPython.core.interactiveshell import InteractiveShell\n",
    "InteractiveShell.ast_node_interactivity = 'all' #last_expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "eab2c8ba-7db6-41f4-ae78-e99b43fe03c1",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Global seed set to 42\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "42"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using torch 1.10.1\n"
     ]
    }
   ],
   "source": [
    "from sklearn import model_selection\n",
    "from sklearn.preprocessing import StandardScaler, Normalizer\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.metrics import roc_auc_score, accuracy_score\n",
    "from sklearn.model_selection import train_test_split, StratifiedShuffleSplit\n",
    "from sklearn.metrics import accuracy_score, balanced_accuracy_score, recall_score, precision_score, roc_auc_score, average_precision_score\n",
    "\n",
    "import math\n",
    "import torch\n",
    "from torch import nn\n",
    "import torch.nn.functional as F\n",
    "import torch.utils.data as TorchData\n",
    "from torchmetrics import Accuracy\n",
    "from pytorch_lightning import LightningModule, Trainer, seed_everything\n",
    "from pytorch_lightning.callbacks.early_stopping import EarlyStopping\n",
    "from pytorch_lightning.loggers import TensorBoardLogger\n",
    "\n",
    "from imblearn.over_sampling import RandomOverSampler, SMOTE\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "\n",
    "SEED = 42\n",
    "seed_everything(SEED, workers=True)\n",
    "\n",
    "print(\"Using torch\", torch.__version__)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c53c835-571c-4c48-aa66-08316fc9fa1a",
   "metadata": {},
   "source": [
    "# 1. Knowledge network information（Mask）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "5a6cdccd-ebb5-485e-89af-d5f4b01c4d80",
   "metadata": {},
   "outputs": [],
   "source": [
    "microRNA = pd.read_csv('20220610_Results/1. diff_microRNA(FC2_FDR0.05).csv', index_col=0)['ID']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "a4ed85fd-5294-4528-8b16-c85b077c4465",
   "metadata": {},
   "outputs": [],
   "source": [
    "path = 'Breast cancer/'\n",
    "### Target Gene\n",
    "tar_data = pd.read_csv(path+'Target/hsa_MTI.csv')\n",
    "mir2gene = {}\n",
    "for i in tar_data.index:\n",
    "    mir = str(tar_data.loc[i, 'miRNA']).strip()\n",
    "    gene = str(tar_data.loc[i, 'Target Gene (Entrez Gene ID)']).strip()\n",
    "    mir2gene[mir] = mir2gene.get(mir, set())\n",
    "    mir2gene[mir].add(gene)\n",
    "gene_set = set()\n",
    "for mir in microRNA:\n",
    "    gene_set.update(mir2gene.get(mir, set()))\n",
    "GENE_LIST = list(gene_set)\n",
    "GENE_MASK = []\n",
    "for mir in microRNA:\n",
    "    genes = mir2gene.get(mir, set())\n",
    "    GENE_MASK.append([1 if g in genes else 0 for g in GENE_LIST])\n",
    "GENE_MASK = torch.tensor(np.array(GENE_MASK).T, dtype=torch.float)\n",
    "### Module\n",
    "module_data = pd.read_csv(path+'KEGG/gene2module.txt', sep='\\t')\n",
    "gene2module = {}\n",
    "for i in module_data.index:\n",
    "    mid = str(module_data.loc[i, 'Module']).split('hsa_')[1].strip()\n",
    "    gene = str(module_data.loc[i, 'gene']).split('hsa:')[1].strip()\n",
    "    gene2module[gene] = gene2module.get(gene, set())\n",
    "    gene2module[gene].add(mid)\n",
    "module_set = set()\n",
    "for gene in GENE_LIST:\n",
    "    module_set.update(gene2module.get(gene, set()))\n",
    "MODULE_LIST = list(module_set)\n",
    "MODULE_MASK = []\n",
    "for gene in GENE_LIST:\n",
    "    modules = gene2module.get(gene, set())\n",
    "    MODULE_MASK.append([1 if m in modules else 0 for m in MODULE_LIST])\n",
    "MODULE_MASK = torch.tensor(np.array(MODULE_MASK).T, dtype=torch.float)\n",
    "### Pathway\n",
    "pathway_data = pd.read_csv(path+'KEGG/module2pathway.txt', sep='\\t')\n",
    "module2pathway = {}\n",
    "for i in pathway_data.index:\n",
    "    pathway = str(pathway_data.loc[i, 'Pathway']).split('path:')[1].strip()\n",
    "    module = str(pathway_data.loc[i, 'Module']).split('md:')[1].strip()\n",
    "    module2pathway[module] = module2pathway.get(module, set())\n",
    "    module2pathway[module].add(pathway)\n",
    "pathway_set = set()\n",
    "for module in MODULE_LIST:\n",
    "    pathway_set.update(module2pathway.get(module, set()))\n",
    "PATHWAY_LIST = list(pathway_set)\n",
    "\n",
    "PATHWAY_MASK = []\n",
    "for module in MODULE_LIST:\n",
    "    pathways = module2pathway.get(module, set())\n",
    "    PATHWAY_MASK.append([1 if p in pathways else 0 for p in PATHWAY_LIST])\n",
    "PATHWAY_MASK = torch.tensor(np.array(PATHWAY_MASK).T, dtype=torch.float)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "218eae86-e3ae-455d-83cd-30d675865eed",
   "metadata": {},
   "source": [
    "Constructing neural network model based on knowledge information"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "cef0c244-533e-42ea-a3ae-6595a998fa1a",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "class MaskedModel(LightningModule):\n",
    "    def __init__(self, mirN, geneN, gene_mask, moduleN, module_mask, pathwayN, pathway_mask, learning_rate):\n",
    "        super(MaskedModel, self).__init__()\n",
    "        self.save_hyperparameters()\n",
    "        self.learning_rate = learning_rate\n",
    "        # microRNA 2 Gene\n",
    "        self.mir2gene = nn.Linear(mirN, geneN)\n",
    "        self.mir2gene.weight.data = self.mir2gene.weight * gene_mask\n",
    "        self.gene_mask = gene_mask\n",
    "        self.gene_active = nn.ReLU() # ReLU Tanh\n",
    "        self.gene_bn = nn.BatchNorm1d(geneN, eps=1e-05, momentum=0.5, affine=True)\n",
    "        self.gene_dropout = nn.Dropout(p=0.8)\n",
    "        \n",
    "        ## Gene 2 Module\n",
    "        self.gene2module = nn.Linear(geneN, moduleN)\n",
    "        self.gene2module.weight.data = self.gene2module.weight * module_mask\n",
    "        self.module_mask = module_mask\n",
    "        self.module_active = nn.ReLU()\n",
    "        self.module_bn = nn.BatchNorm1d(moduleN, eps=1e-05, momentum=0.5, affine=True)\n",
    "        self.module_dropout = nn.Dropout(p=0.5)\n",
    "        \n",
    "        ## Module 2 Pathway\n",
    "        self.module2pathway = nn.Linear(moduleN, pathwayN)\n",
    "        self.module2pathway.weight.data = self.module2pathway.weight * pathway_mask\n",
    "        self.pathway_mask = pathway_mask\n",
    "        self.pathway_active = nn.ReLU()\n",
    "        self.pathway_bn = nn.BatchNorm1d(pathwayN, eps=1e-05, momentum=0.5, affine=True)\n",
    "        self.pathway_dropout = nn.Dropout(p=0.2)\n",
    "        \n",
    "        ## Output\n",
    "        self.pathway2out = nn.Linear(pathwayN, 2)\n",
    "        self.out_bn = nn.BatchNorm1d(2, eps=1e-05, momentum=0.5, affine=True)\n",
    "        #self.sigmoid = nn.Sigmoid()\n",
    "        \n",
    "        # Result save\n",
    "        self.gene_result = None\n",
    "        self.module_result = None\n",
    "        self.pathway_result = None\n",
    "    \n",
    "    def forward(self, x):\n",
    "        ## microRNA 2 Gene\n",
    "        #print(self.mir2gene.weight.data.shape, self.mir2gene.weight.shape, self.gene_mask.shape)\n",
    "        self.mir2gene.weight.data = self.mir2gene.weight * self.gene_mask\n",
    "        #print(self.mir2gene.weight.data.shape)\n",
    "        gene_x = self.mir2gene(x)\n",
    "        gene_x = self.gene_active(gene_x)\n",
    "        gene_x = self.gene_bn(gene_x)\n",
    "        gene_x = self.gene_dropout(gene_x)\n",
    "        self.gene_result = gene_x # save result\n",
    "        \n",
    "        ## Gene 2 Module\n",
    "        self.gene2module.weight.data = self.gene2module.weight * self.module_mask\n",
    "        module_x = self.gene2module(gene_x)\n",
    "        module_x = self.module_active(module_x)\n",
    "        module_x = self.module_bn(module_x)\n",
    "        module_x = self.module_dropout(module_x)\n",
    "        self.module_result = module_x # save result\n",
    "        \n",
    "        ## Module 2 Pathway\n",
    "        self.module2pathway.weight.data = self.module2pathway.weight * self.pathway_mask\n",
    "        pathway_x = self.module2pathway(module_x)\n",
    "        pathway_x = self.pathway_active(pathway_x)\n",
    "        pathway_x = self.pathway_bn(pathway_x)\n",
    "        pathway_x = self.pathway_dropout(pathway_x)\n",
    "        self.pathway_result = pathway_x # save result\n",
    "        \n",
    "        ## Output\n",
    "        out_x = self.pathway2out(pathway_x)\n",
    "        out_x = self.out_bn(out_x)\n",
    "        #out_x = self.sigmoid(out_x)\n",
    "        return out_x\n",
    "    \n",
    "    def training_step(self, batch, batch_nb):\n",
    "        x, y = batch\n",
    "        loss = F.cross_entropy(self.forward(x), y)\n",
    "        self.log(\"train_loss\", loss, prog_bar=True)\n",
    "        return loss\n",
    "    \n",
    "    def configure_optimizers(self):\n",
    "        return torch.optim.Adam(self.parameters(), lr=self.learning_rate)\n",
    "    \n",
    "    def validation_step(self, batch, batch_idx):\n",
    "        x, y = batch\n",
    "        logits = F.softmax(self(x))\n",
    "        loss = F.cross_entropy(logits, y)\n",
    "        preds = torch.argmax(logits, dim=1)\n",
    "        probs = logits[:, 1]\n",
    "        auc = roc_auc_score(y, probs)\n",
    "        bac = balanced_accuracy_score(y, preds)\n",
    "        aps = average_precision_score(y, probs)\n",
    "        recall = recall_score(y, preds)\n",
    "        precision = precision_score(y, preds)\n",
    "        #self.auc(probs, y)\n",
    "\n",
    "        # Calling self.log will surface up scalars for you in TensorBoard\n",
    "        self.log(\"val_loss\", loss, prog_bar=True)\n",
    "        self.log(\"val_bac\", bac, prog_bar=True)\n",
    "        self.log(\"val_auc\", auc, prog_bar=True)\n",
    "        self.log(\"val_aps\", aps, prog_bar=True)\n",
    "        self.log(\"val_rec\", recall, prog_bar=True)\n",
    "        self.log(\"val_pre\", precision, prog_bar=True)\n",
    "        return loss\n",
    "    \n",
    "    def validation_epoch_end(self, validation_step_outputs):\n",
    "        avg_loss = torch.stack(validation_step_outputs).mean()\n",
    "        #avg_loss = torch.stack([x[\"val_loss\"] for x in outputs]).mean() # Outputs are the values of return for validation\n",
    "        self.logger.experiment.add_scalar('loss', avg_loss, self.current_epoch)\n",
    "    \n",
    "    def test_step(self, batch, batch_idx):\n",
    "        # Here we just reuse the validation_step for testing\n",
    "        return self.validation_step(batch, batch_idx)\n",
    "    \n",
    "    def predict_step(self, batch, batch_idx):\n",
    "        x, y = batch\n",
    "        logits = F.softmax(self(x))\n",
    "        loss = F.cross_entropy(logits, y)\n",
    "        preds = torch.argmax(logits, dim=1)\n",
    "        probs = logits[:, 1]\n",
    "        return preds, probs\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8cdd7c5f-c72f-43f7-98cd-2b5751bc005f",
   "metadata": {},
   "source": [
    "# 3. Model Initialization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "479d1b3b-4f91-4ecb-8179-69394e1b8aa0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "710 11418 116 70\n"
     ]
    }
   ],
   "source": [
    "mirN = len(microRNA)\n",
    "geneN = len(GENE_LIST)\n",
    "moduleN = len(MODULE_LIST)\n",
    "pathwayN = len(PATHWAY_LIST)\n",
    "print(mirN, geneN, moduleN, pathwayN)\n",
    "GENE_No_MASK = torch.ones_like(GENE_MASK)\n",
    "MODULE_No_MASK = torch.ones_like(MODULE_MASK)\n",
    "PATHWAY_No_MASK = torch.ones_like(PATHWAY_MASK)\n",
    "model = MaskedModel(mirN, geneN, GENE_MASK, moduleN, MODULE_MASK, pathwayN, PATHWAY_MASK, 0.01)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "8e90412d-a3b3-4ee9-a6ab-1760780eba14",
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MaskedModel(\n",
      "  (mir2gene): Linear(in_features=710, out_features=11418, bias=True)\n",
      "  (gene_active): ReLU()\n",
      "  (gene_bn): BatchNorm1d(11418, eps=1e-05, momentum=0.5, affine=True, track_running_stats=True)\n",
      "  (gene_dropout): Dropout(p=0.8, inplace=False)\n",
      "  (gene2module): Linear(in_features=11418, out_features=116, bias=True)\n",
      "  (module_active): ReLU()\n",
      "  (module_bn): BatchNorm1d(116, eps=1e-05, momentum=0.5, affine=True, track_running_stats=True)\n",
      "  (module_dropout): Dropout(p=0.5, inplace=False)\n",
      "  (module2pathway): Linear(in_features=116, out_features=70, bias=True)\n",
      "  (pathway_active): ReLU()\n",
      "  (pathway_bn): BatchNorm1d(70, eps=1e-05, momentum=0.5, affine=True, track_running_stats=True)\n",
      "  (pathway_dropout): Dropout(p=0.2, inplace=False)\n",
      "  (pathway2out): Linear(in_features=70, out_features=2, bias=True)\n",
      "  (out_bn): BatchNorm1d(2, eps=1e-05, momentum=0.5, affine=True, track_running_stats=True)\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "print(model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "e44b5f2d-bee5-452a-86d4-b55960ddc47b",
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Parameter mir2gene.weight, shape torch.Size([11418, 710])\n",
      "Parameter mir2gene.bias, shape torch.Size([11418])\n",
      "Parameter gene_bn.weight, shape torch.Size([11418])\n",
      "Parameter gene_bn.bias, shape torch.Size([11418])\n",
      "Parameter gene2module.weight, shape torch.Size([116, 11418])\n",
      "Parameter gene2module.bias, shape torch.Size([116])\n",
      "Parameter module_bn.weight, shape torch.Size([116])\n",
      "Parameter module_bn.bias, shape torch.Size([116])\n",
      "Parameter module2pathway.weight, shape torch.Size([70, 116])\n",
      "Parameter module2pathway.bias, shape torch.Size([70])\n",
      "Parameter pathway_bn.weight, shape torch.Size([70])\n",
      "Parameter pathway_bn.bias, shape torch.Size([70])\n",
      "Parameter pathway2out.weight, shape torch.Size([2, 70])\n",
      "Parameter pathway2out.bias, shape torch.Size([2])\n",
      "Parameter out_bn.weight, shape torch.Size([2])\n",
      "Parameter out_bn.bias, shape torch.Size([2])\n"
     ]
    }
   ],
   "source": [
    "for name, param in model.named_parameters():\n",
    "    print(f\"Parameter {name}, shape {param.shape}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51a24536-38cb-45c8-a7df-107d758e414e",
   "metadata": {},
   "source": [
    "# 4. Data import¶"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "ad87cac9-9616-4b17-8014-2a205ca0c635",
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train = pd.read_csv('20220610_Results/1. X_train.csv', index_col=0)\n",
    "X_test = pd.read_csv('20220610_Results/1. X_test.csv', index_col=0)\n",
    "y_train = pd.read_csv('20220610_Results/1. y_train.csv', index_col=0)\n",
    "y_test = pd.read_csv('20220610_Results/1. y_test.csv', index_col=0)\n",
    "\n",
    "cv = model_selection.StratifiedShuffleSplit(n_splits=2, test_size=.4, random_state=SEED)\n",
    "X = X_train.copy()\n",
    "y = y_train.copy()\n",
    "for train_index, val_index in cv.split(X, y):pass\n",
    "X_train, X_valid = X.iloc[train_index, :], X.iloc[val_index, :]\n",
    "y_train, y_valid = y.iloc[train_index], y.iloc[val_index]\n",
    "\n",
    "# Normalize ?\n",
    "scaler = Normalizer() # Normalizer StandardScaler\n",
    "X_train = pd.DataFrame(scaler.fit_transform(X_train[microRNA]), index=X_train.index, columns=microRNA)\n",
    "X_valid = pd.DataFrame(scaler.fit_transform(X_valid[microRNA]), index=X_valid.index, columns=microRNA)\n",
    "X_test = pd.DataFrame(scaler.fit_transform(X_test[microRNA]), index=X_test.index, columns=microRNA)\n",
    "############\n",
    "\n",
    "X_train = torch.from_numpy(X_train.values).type(torch.FloatTensor)\n",
    "y_train = torch.from_numpy(y_train['Label'].values).type(torch.LongTensor)\n",
    "X_valid = torch.from_numpy(X_valid.values).type(torch.FloatTensor)\n",
    "y_valid = torch.from_numpy(y_valid['Label'].values).type(torch.LongTensor)\n",
    "X_test = torch.from_numpy(X_test.values).type(torch.FloatTensor)\n",
    "y_test = torch.from_numpy(y_test['Label'].values).type(torch.LongTensor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "b3efade8-0b8c-4c6f-bace-4c7048b3f2fd",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_data_loader = TorchData.DataLoader(dataset=TorchData.TensorDataset(X_train, y_train), \n",
    "                                         batch_size=64, shuffle=True)\n",
    "\n",
    "valid_data_loader = TorchData.DataLoader(dataset=TorchData.TensorDataset(X_valid, y_valid), \n",
    "                                         batch_size=64, shuffle=True)\n",
    "\n",
    "test_data_loader = TorchData.DataLoader(dataset=TorchData.TensorDataset(X_test, y_test), \n",
    "                                        batch_size=X_test.shape[0], shuffle=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c66f126f-56de-401f-b50c-c87416b86fbd",
   "metadata": {},
   "source": [
    "# 5. Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "5d3532df-b8e4-438e-b6c2-097847e38dc4",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "GPU available: False, used: False\n",
      "TPU available: False, using: 0 TPU cores\n",
      "IPU available: False, using: 0 IPUs\n",
      "HPU available: False, using: 0 HPUs\n"
     ]
    }
   ],
   "source": [
    "logger = TensorBoardLogger(\"tb_logs\", name=\"BioNet_nor\")\n",
    "# Initialize a trainer\n",
    "trainer = Trainer(\n",
    "    accelerator=\"cpu\",\n",
    "    #gpus=AVAIL_GPUS,\n",
    "    num_processes=1,\n",
    "    min_epochs=10,\n",
    "    max_epochs=500,\n",
    "    #progress_bar_refresh_rate=20,\n",
    "    callbacks=[EarlyStopping(monitor=\"val_auc\", mode='max')], # validate Stops when the AUC in the data is highest\n",
    "    auto_lr_find=True,\n",
    "    stochastic_weight_avg=False,\n",
    "    #deterministic=False, # GPU repeatable\n",
    "    #val_check_interval=100,\n",
    "    logger=logger,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "55f98644-6955-48f8-9260-c0bf777ba1cf",
   "metadata": {},
   "outputs": [],
   "source": [
    "# tune the model (batch_size, lr_find)\n",
    "#trainer.tune(model, train_data_loader, valid_data_loader)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "408e769d-ccee-461b-a05f-c40f5b126ff1",
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "   | Name            | Type        | Params\n",
      "-------------------------------------------------\n",
      "0  | mir2gene        | Linear      | 8.1 M \n",
      "1  | gene_active     | ReLU        | 0     \n",
      "2  | gene_bn         | BatchNorm1d | 22.8 K\n",
      "3  | gene_dropout    | Dropout     | 0     \n",
      "4  | gene2module     | Linear      | 1.3 M \n",
      "5  | module_active   | ReLU        | 0     \n",
      "6  | module_bn       | BatchNorm1d | 232   \n",
      "7  | module_dropout  | Dropout     | 0     \n",
      "8  | module2pathway  | Linear      | 8.2 K \n",
      "9  | pathway_active  | ReLU        | 0     \n",
      "10 | pathway_bn      | BatchNorm1d | 140   \n",
      "11 | pathway_dropout | Dropout     | 0     \n",
      "12 | pathway2out     | Linear      | 142   \n",
      "13 | out_bn          | BatchNorm1d | 4     \n",
      "-------------------------------------------------\n",
      "9.5 M     Trainable params\n",
      "0         Non-trainable params\n",
      "9.5 M     Total params\n",
      "37.897    Total estimated model params size (MB)\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Sanity Checking: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e06df364e5f24f69bbaca6ceabdf79c9",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validation: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validation: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validation: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validation: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validation: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validation: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validation: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validation: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validation: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validation: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validation: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validation: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Train the model\n",
    "trainer.fit(model, train_data_loader, valid_data_loader)\n",
    "trainer.save_checkpoint(\"Temp/BioNet_nor.ckpt\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d0979f3-7ace-47f5-b50e-3c9f1c3f5d75",
   "metadata": {},
   "source": [
    "# 6. Model evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "fe384690-d5a2-4ca2-b855-533b3103b7f3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "adfd80009f374875992bf38bc671f521",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Testing: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n",
      "       Test metric             DataLoader 0\n",
      "────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n",
      "         val_aps            0.9546261634744474\n",
      "         val_auc            0.9789379339918536\n",
      "         val_bac            0.9303844927249523\n",
      "        val_loss            0.38233035802841187\n",
      "         val_pre            0.9286368549529922\n",
      "         val_rec             0.891633885396414\n",
      "────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[{'val_loss': 0.38233035802841187,\n",
       "  'val_bac': 0.9303844927249523,\n",
       "  'val_auc': 0.9789379339918536,\n",
       "  'val_aps': 0.9546261634744474,\n",
       "  'val_rec': 0.891633885396414,\n",
       "  'val_pre': 0.9286368549529922}]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "trainer.test(model, valid_data_loader)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "d4f9e3a0-d2ab-4f7a-bf9e-5d29fe0dfa76",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c9b7af81933a41e3a015bbf4e01d69fd",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Testing: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n",
      "       Test metric             DataLoader 0\n",
      "────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n",
      "         val_aps            0.9572682644262971\n",
      "         val_auc            0.9782986111111109\n",
      "         val_bac            0.9415664269179894\n",
      "        val_loss            0.3778093159198761\n",
      "         val_pre            0.9507186858316222\n",
      "         val_rec                0.904296875\n",
      "────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[{'val_loss': 0.3778093159198761,\n",
       "  'val_bac': 0.9415664269179894,\n",
       "  'val_auc': 0.9782986111111109,\n",
       "  'val_aps': 0.9572682644262971,\n",
       "  'val_rec': 0.904296875,\n",
       "  'val_pre': 0.9507186858316222}]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "trainer.test(model, test_data_loader)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d6d88f24-14f7-4166-a0ad-70fbf7383ff4",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "b9b7fb29-674c-4f36-980b-3b50d4128269",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "17996ddb43ee44f2be2eb1b0af2cb66a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Predicting: 24it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 2400x1800 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 2400x1800 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn import metrics\n",
    "pred, probs = trainer.predict(model, test_data_loader)[0]\n",
    "#auc = roc_auc_score(y_test, probs.numpy())\n",
    "\n",
    "fpr, tpr, thresholds = metrics.roc_curve(y_test, probs.numpy(), pos_label=1)\n",
    "auc = metrics.auc(fpr, tpr)\n",
    "fig = plt.figure(figsize=(8, 6), dpi=300)\n",
    "_ = plt.plot(fpr, tpr, color=\"darkorange\", lw=2, label=\"ROC curve (area = %0.3f)\" % auc)\n",
    "_ = plt.plot([0, 1], [0, 1], color=\"navy\", lw=2, linestyle=\"--\")\n",
    "_ = plt.xlim([-0.01, 1.01])\n",
    "_ = plt.ylim([-0.01, 1.01])\n",
    "_ = plt.xlabel(\"False Positive Rate\")\n",
    "_ = plt.ylabel(\"True Positive Rate\")\n",
    "_ = plt.legend(loc=\"lower right\")\n",
    "_ = plt.show()\n",
    "#fig.savefig('20220610_Results/6. ROC.pdf', dpi=300)\n",
    "\n",
    "precision, recall, _ = metrics.precision_recall_curve(y_test, pred.numpy())\n",
    "disp = metrics.PrecisionRecallDisplay(precision=precision, recall=recall)\n",
    "fig = plt.figure(figsize=(8, 6), dpi=300)\n",
    "_ = disp.plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "efbafd71-4dac-41b8-9a4f-7c4262bf24b7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 480x480 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay\n",
    "fig = plt.figure(1, (6, 6), dpi=80)\n",
    "ax = fig.add_subplot(1,1,1)\n",
    "cm = confusion_matrix(y_test, pred.numpy(), labels=[0, 1])\n",
    "disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=[0, 1])\n",
    "_ = disp.plot(ax=ax, cmap='Blues') #, ax=ax, cmap='Blues'\n",
    "#_ = plot_confusion_matrix(model, X_test[select_microRNA], y_test, ax=ax, cmap='Blues')\n",
    "#fig.savefig('20220610_Results/6. plot_confusion_matrix.pdf', dpi=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ffef46f2-9fa2-4f1c-bad4-662b6e21d7e7",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "36d9c848-d96e-48c6-b293-e1c527a62956",
   "metadata": {},
   "source": [
    "# 7. Model predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "d010d585-4d2e-443c-bdbb-a2dba64d3a7e",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "GPU available: False, used: False\n",
      "TPU available: False, using: 0 TPU cores\n",
      "IPU available: False, using: 0 IPUs\n",
      "HPU available: False, using: 0 HPUs\n"
     ]
    }
   ],
   "source": [
    "model = MaskedModel.load_from_checkpoint(checkpoint_path=\"Temp/BioNet_nor.ckpt\")\n",
    "trainer = Trainer()\n",
    "#trainer.test(model, dataloaders=test_data_loader)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "8a841710-c016-49a3-890c-6e9cd1dfc7c7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6e8b26fe8404470898fc60d585fe54ef",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Predicting: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "[(tensor([0, 0, 0,  ..., 0, 0, 1]),\n",
       "  tensor([0.0013, 0.0015, 0.0017,  ..., 0.0298, 0.0137, 0.8717]))]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#trainer.predict(model, test_data_loader)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2d807452-325b-43e4-9235-a4ee4ed97d8a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "acf81991-ddb0-43e3-891b-4ff8a0cb5eed",
   "metadata": {},
   "source": [
    "# 8. External data validation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "9d9054b7-0e13-4407-8dcc-d200dde7e63e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(710, 523)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>hsa-miR-9-5p</th>\n",
       "      <th>hsa-miR-126-3p</th>\n",
       "      <th>hsa-miR-140-5p</th>\n",
       "      <th>hsa-miR-105-5p</th>\n",
       "      <th>hsa-miR-297</th>\n",
       "      <th>hsa-let-7i-5p</th>\n",
       "      <th>hsa-miR-130a-3p</th>\n",
       "      <th>hsa-miR-146b-5p</th>\n",
       "      <th>hsa_negative_control_6</th>\n",
       "      <th>hsa_negative_control_7</th>\n",
       "      <th>...</th>\n",
       "      <th>hsa-miR-205-3p</th>\n",
       "      <th>hsa-miR-1260a</th>\n",
       "      <th>hsa-miR-525-5p</th>\n",
       "      <th>hsa-miR-187-5p</th>\n",
       "      <th>hsa-miRPlus-A1086</th>\n",
       "      <th>hsa-miR-551b-5p</th>\n",
       "      <th>hsa-miR-300</th>\n",
       "      <th>hsa-miR-193b-5p</th>\n",
       "      <th>Label</th>\n",
       "      <th>Disease</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>6.877643</td>\n",
       "      <td>8.080215</td>\n",
       "      <td>6.245265</td>\n",
       "      <td>6.304782</td>\n",
       "      <td>6.686064</td>\n",
       "      <td>7.805950</td>\n",
       "      <td>6.814781</td>\n",
       "      <td>7.146955</td>\n",
       "      <td>6.170680</td>\n",
       "      <td>6.129586</td>\n",
       "      <td>...</td>\n",
       "      <td>7.176684</td>\n",
       "      <td>7.724408</td>\n",
       "      <td>6.035476</td>\n",
       "      <td>6.255048</td>\n",
       "      <td>6.572019</td>\n",
       "      <td>6.251777</td>\n",
       "      <td>5.873303</td>\n",
       "      <td>6.362097</td>\n",
       "      <td>1</td>\n",
       "      <td>primary breast cancer</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>6.544287</td>\n",
       "      <td>6.882722</td>\n",
       "      <td>5.874236</td>\n",
       "      <td>6.324987</td>\n",
       "      <td>6.638048</td>\n",
       "      <td>6.946567</td>\n",
       "      <td>6.488574</td>\n",
       "      <td>6.690773</td>\n",
       "      <td>6.160272</td>\n",
       "      <td>6.104929</td>\n",
       "      <td>...</td>\n",
       "      <td>7.249094</td>\n",
       "      <td>7.308890</td>\n",
       "      <td>6.021796</td>\n",
       "      <td>6.902473</td>\n",
       "      <td>6.347183</td>\n",
       "      <td>6.625569</td>\n",
       "      <td>6.004899</td>\n",
       "      <td>6.560329</td>\n",
       "      <td>1</td>\n",
       "      <td>primary breast cancer</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>2 rows × 1928 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "   hsa-miR-9-5p  hsa-miR-126-3p  hsa-miR-140-5p  hsa-miR-105-5p  hsa-miR-297  \\\n",
       "0      6.877643        8.080215        6.245265        6.304782     6.686064   \n",
       "1      6.544287        6.882722        5.874236        6.324987     6.638048   \n",
       "\n",
       "   hsa-let-7i-5p  hsa-miR-130a-3p  hsa-miR-146b-5p  hsa_negative_control_6  \\\n",
       "0       7.805950         6.814781         7.146955                6.170680   \n",
       "1       6.946567         6.488574         6.690773                6.160272   \n",
       "\n",
       "   hsa_negative_control_7  ...  hsa-miR-205-3p  hsa-miR-1260a  hsa-miR-525-5p  \\\n",
       "0                6.129586  ...        7.176684       7.724408        6.035476   \n",
       "1                6.104929  ...        7.249094       7.308890        6.021796   \n",
       "\n",
       "   hsa-miR-187-5p  hsa-miRPlus-A1086  hsa-miR-551b-5p  hsa-miR-300  \\\n",
       "0        6.255048           6.572019         6.251777     5.873303   \n",
       "1        6.902473           6.347183         6.625569     6.004899   \n",
       "\n",
       "   hsa-miR-193b-5p  Label                Disease  \n",
       "0         6.362097      1  primary breast cancer  \n",
       "1         6.560329      1  primary breast cancer  \n",
       "\n",
       "[2 rows x 1928 columns]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>hsa-miR-875-5p</th>\n",
       "      <th>hsa-miR-99a-3p</th>\n",
       "      <th>hsa-miR-196b-5p</th>\n",
       "      <th>hsa-miR-4456</th>\n",
       "      <th>hsa-miR-5004-5p</th>\n",
       "      <th>hsa-miR-526b-5p</th>\n",
       "      <th>hsa-miR-122-5p</th>\n",
       "      <th>hsa-miR-708-3p</th>\n",
       "      <th>hsa-miR-4510</th>\n",
       "      <th>hsa-miR-616-5p</th>\n",
       "      <th>...</th>\n",
       "      <th>hsa-miR-1288-5p</th>\n",
       "      <th>hsa-miR-6772-3p</th>\n",
       "      <th>hsa-miR-504-5p</th>\n",
       "      <th>hsa-miR-6826-5p</th>\n",
       "      <th>hsa-miR-7160-3p</th>\n",
       "      <th>hsa-miR-8064</th>\n",
       "      <th>hsa-miR-376a-2-5p</th>\n",
       "      <th>hsa-miR-6818-5p</th>\n",
       "      <th>hsa-miR-8063</th>\n",
       "      <th>hsa-miR-8059</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>6.097826</td>\n",
       "      <td>6.454512</td>\n",
       "      <td>6.527494</td>\n",
       "      <td>10.28918</td>\n",
       "      <td>6.896914</td>\n",
       "      <td>6.374826</td>\n",
       "      <td>6.323629</td>\n",
       "      <td>6.332212</td>\n",
       "      <td>6.353440</td>\n",
       "      <td>6.391591</td>\n",
       "      <td>...</td>\n",
       "      <td>2.403726</td>\n",
       "      <td>3.414851</td>\n",
       "      <td>2.501417</td>\n",
       "      <td>6.348159</td>\n",
       "      <td>2.389214</td>\n",
       "      <td>3.867423</td>\n",
       "      <td>2.359387</td>\n",
       "      <td>2.45412</td>\n",
       "      <td>7.677084</td>\n",
       "      <td>8.266604</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>6.073248</td>\n",
       "      <td>6.361881</td>\n",
       "      <td>6.369383</td>\n",
       "      <td>10.73224</td>\n",
       "      <td>7.435074</td>\n",
       "      <td>6.320196</td>\n",
       "      <td>6.310753</td>\n",
       "      <td>6.310753</td>\n",
       "      <td>6.758494</td>\n",
       "      <td>6.439965</td>\n",
       "      <td>...</td>\n",
       "      <td>2.403726</td>\n",
       "      <td>3.414851</td>\n",
       "      <td>2.501417</td>\n",
       "      <td>6.348159</td>\n",
       "      <td>2.389214</td>\n",
       "      <td>3.867423</td>\n",
       "      <td>2.359387</td>\n",
       "      <td>2.45412</td>\n",
       "      <td>7.677084</td>\n",
       "      <td>8.266604</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>2 rows × 711 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "   hsa-miR-875-5p  hsa-miR-99a-3p  hsa-miR-196b-5p  hsa-miR-4456  \\\n",
       "0        6.097826        6.454512         6.527494      10.28918   \n",
       "1        6.073248        6.361881         6.369383      10.73224   \n",
       "\n",
       "   hsa-miR-5004-5p  hsa-miR-526b-5p  hsa-miR-122-5p  hsa-miR-708-3p  \\\n",
       "0         6.896914         6.374826        6.323629        6.332212   \n",
       "1         7.435074         6.320196        6.310753        6.310753   \n",
       "\n",
       "   hsa-miR-4510  hsa-miR-616-5p  ...  hsa-miR-1288-5p  hsa-miR-6772-3p  \\\n",
       "0      6.353440        6.391591  ...         2.403726         3.414851   \n",
       "1      6.758494        6.439965  ...         2.403726         3.414851   \n",
       "\n",
       "   hsa-miR-504-5p  hsa-miR-6826-5p  hsa-miR-7160-3p  hsa-miR-8064  \\\n",
       "0        2.501417         6.348159         2.389214      3.867423   \n",
       "1        2.501417         6.348159         2.389214      3.867423   \n",
       "\n",
       "   hsa-miR-376a-2-5p  hsa-miR-6818-5p  hsa-miR-8063  hsa-miR-8059  \n",
       "0           2.359387          2.45412      7.677084      8.266604  \n",
       "1           2.359387          2.45412      7.677084      8.266604  \n",
       "\n",
       "[2 rows x 711 columns]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "extenal = pd.read_csv('20220610_Results/1. GSE58606.csv', index_col=0)\n",
    "X_train_ = pd.read_csv('20220610_Results/1. X_train.csv', index_col=0)\n",
    "len(microRNA), len(set(microRNA)&set(extenal.columns))\n",
    "extenal.head(2)\n",
    "temp = extenal[list(set(microRNA)&set(extenal.columns))+['Label']]\n",
    "for i in set(microRNA)-set(extenal.columns):\n",
    "    temp[i] = X_train_[i].median()\n",
    "extenal = temp\n",
    "extenal.head(2)\n",
    "\n",
    "scaler = Normalizer() # Normalizer StandardScaler\n",
    "X_extenal = pd.DataFrame(scaler.fit_transform(extenal[microRNA]), index=extenal.index, columns=microRNA)\n",
    "y_extenal = extenal['Label'].values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "528d060b-5862-4b18-8374-a20203b37694",
   "metadata": {},
   "outputs": [],
   "source": [
    "X_extenal = torch.from_numpy(X_extenal.values).type(torch.FloatTensor)\n",
    "y_extenal = torch.from_numpy(y_extenal).type(torch.LongTensor)\n",
    "extenal_data_loader = TorchData.DataLoader(dataset=TorchData.TensorDataset(X_extenal, y_extenal), \n",
    "                                           batch_size=X_extenal.shape[0], shuffle=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "bf722d9c-e97b-4ac3-b088-44b69588fa3a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d588217ba02c4a97a2f01a8a82574b38",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Testing: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n",
      "       Test metric             DataLoader 0\n",
      "────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n",
      "         val_aps             0.859599039165206\n",
      "         val_auc            0.19597615499254845\n",
      "         val_bac                    0.5\n",
      "        val_loss            0.40964600443840027\n",
      "         val_pre            0.9172932330827067\n",
      "         val_rec                    1.0\n",
      "────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[{'val_loss': 0.40964600443840027,\n",
       "  'val_bac': 0.5,\n",
       "  'val_auc': 0.19597615499254845,\n",
       "  'val_aps': 0.859599039165206,\n",
       "  'val_rec': 1.0,\n",
       "  'val_pre': 0.9172932330827067}]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "trainer.test(model, extenal_data_loader)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "0f2de48f-4b49-4d48-8033-adcde3085cbc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "45ae97adb14a46c59b4d8a09c958f8ba",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Predicting: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "[(tensor([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "          1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "          1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "          1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "          1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "          1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       "  tensor([0.9642, 0.9543, 0.9511, 0.9670, 0.9823, 0.9789, 0.9857, 0.9737, 0.9791,\n",
       "          0.9666, 0.9684, 0.9644, 0.9640, 0.9684, 0.9746, 0.9664, 0.9562, 0.9557,\n",
       "          0.9524, 0.9511, 0.9500, 0.9529, 0.9512, 0.9617, 0.9494, 0.9586, 0.9589,\n",
       "          0.9629, 0.9551, 0.9487, 0.9592, 0.9612, 0.9625, 0.9533, 0.9638, 0.9621,\n",
       "          0.9643, 0.9538, 0.9642, 0.9607, 0.9597, 0.9667, 0.9696, 0.9606, 0.9629,\n",
       "          0.9567, 0.9643, 0.9659, 0.9662, 0.9674, 0.9666, 0.9790, 0.9772, 0.9768,\n",
       "          0.9799, 0.9831, 0.9652, 0.9734, 0.9844, 0.9742, 0.9752, 0.9831, 0.9748,\n",
       "          0.9828, 0.9744, 0.9720, 0.9741, 0.9658, 0.9672, 0.9627, 0.9749, 0.9666,\n",
       "          0.9682, 0.9719, 0.9695, 0.9719, 0.9755, 0.9723, 0.9729, 0.9698, 0.9690,\n",
       "          0.9709, 0.9689, 0.9749, 0.9705, 0.9765, 0.9686, 0.9773, 0.9730, 0.9785,\n",
       "          0.9752, 0.9636, 0.9690, 0.9697, 0.9669, 0.9714, 0.9618, 0.9738, 0.9683,\n",
       "          0.9746, 0.9695, 0.9723, 0.9717, 0.9718, 0.9698, 0.9705, 0.9667, 0.9669,\n",
       "          0.9660, 0.9650, 0.9704, 0.9555, 0.9712, 0.9716, 0.9640, 0.9614, 0.9710,\n",
       "          0.9676, 0.9689, 0.9647, 0.9627, 0.9665, 0.9693, 0.9728, 0.9644, 0.9684,\n",
       "          0.9617, 0.9626, 0.9661, 0.9613, 0.9645, 0.9660, 0.9730]))]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "trainer.predict(model, extenal_data_loader)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d1083b6b-0600-4fa8-9a5c-09c28e191d4c",
   "metadata": {},
   "outputs": [],
   "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.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}