select_core_genes_for_classification.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "valid-theta",
   "metadata": {},
   "source": [
    "# import packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "popular-bleeding",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-03T16:58:30.413596Z",
     "start_time": "2021-11-03T16:58:28.144347Z"
    }
   },
   "outputs": [],
   "source": [
    "\n",
    "import json\n",
    "import csv\n",
    "import numpy as np\n",
    "import os\n",
    "import sys\n",
    "import pandas as pd\n",
    "import random\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from itertools import product\n",
    "import pickle\n",
    "import copy\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import confusion_matrix\n",
    "\n",
    "import torch\n",
    "import torch.nn.functional as F\n",
    "from torch.nn.functional import relu,tanh\n",
    "from torch import nn\n",
    "from torch.autograd import Variable\n",
    "from torch.optim import Adam\n",
    "import torch.optim as optim\n",
    "from torch.utils.data import TensorDataset, DataLoader\n",
    "\n",
    "from livelossplot import PlotLosses\n",
    "from torchsummary import summary\n",
    "\n",
    "from tensorflow.keras.utils import plot_model\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "chubby-corporation",
   "metadata": {},
   "source": [
    "# define models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "spanish-isolation",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-03T16:58:30.529647Z",
     "start_time": "2021-11-03T16:58:30.415682Z"
    }
   },
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n",
    "class ConvCaps2D(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(ConvCaps2D, self).__init__()\n",
    "        # The paper suggests having 32 8D capsules\n",
    "        self.capsules = nn.ModuleList([nn.Conv2d(in_channels=1, out_channels = primary_capslen,\n",
    "                                                 kernel_size=(1,ks), stride=stride) for _ in range(filters)])\n",
    "\n",
    "    def squash(self, tensor, dim=-1):\n",
    "        norm = (tensor**2).sum(dim=dim, keepdim = True) # norm.size() is (None, 1152, 1)\n",
    "        scale = norm / (1 + norm) # scale.size()  is (None, 1152, 1)\n",
    "        return scale*tensor / torch.sqrt(norm)\n",
    "\n",
    "    def forward(self, x):\n",
    "        outputs = [capsule(x).view(x.size(0), primary_capslen, -1) for capsule in self.capsules] # 32 list of (None, 1, 8, 36)\n",
    "        outputs = torch.cat(outputs, dim = 2).permute(0, 2, 1)  # outputs.size() is (None, 1152, 8)\n",
    "        return self.squash(outputs)\n",
    "\n",
    "\n",
    "class Caps1D(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Caps1D, self).__init__()\n",
    "        self.num_iterations = num_iterations\n",
    "        self.num_caps = 2 # equals to class number\n",
    "        self.num_routes= (int((neurons-ks)/stride)+1)*filters\n",
    "        print('num_routes:{}'.format(self.num_routes))\n",
    "        self.in_channels=primary_capslen\n",
    "        self.out_channels=digital_capslen\n",
    "\n",
    "        self.W = nn.Parameter(torch.randn(self.num_caps,self.num_routes, self.in_channels, self.out_channels)) # class,weight,len_capsule,capsule_layer\n",
    "#         self.W = nn.Parameter(torch.randn(3, 3136, 8, 32)) # num_caps, num_routes, in_channels, out_channels\n",
    "    \n",
    "    \n",
    "    def softmax2(self, x, axis=-1):\n",
    "        ex = K.exp(x - K.max(x, axis=axis, keepdims=True))\n",
    "        return ex/K.sum(ex, axis=axis, keepdims=True)\n",
    "\n",
    "    def softmax(self, x, dim = 1):\n",
    "        transposed_input = x.transpose(dim, len(x.size()) - 1)\n",
    "        softmaxed_output = F.softmax(transposed_input.contiguous().view(-1, transposed_input.size(-1)))\n",
    "        return softmaxed_output.view(*transposed_input.size()).transpose(dim, len(x.size()) - 1)\n",
    "\n",
    "    def squash(self, tensor, dim=-1):\n",
    "        norm = (tensor**2).sum(dim=dim, keepdim = True) # norm.size() is (None, 1152, 1)\n",
    "        scale = norm / (1 + norm)\n",
    "        return scale*tensor / torch.sqrt(norm)\n",
    "\n",
    "    # Routing algorithm\n",
    "    def forward(self, u):\n",
    "        # u.size() is (None, 1152, 8)\n",
    "        '''\n",
    "        From documentation\n",
    "        For example, if tensor1 is a j x 1 x n x m Tensor and tensor2 is a k x m x p Tensor,\n",
    "        out will be an j x k x n x p Tensor.\n",
    "\n",
    "        We need j = None, 1, n = 1152, k = 10, m = 8, p = 16\n",
    "        '''\n",
    "\n",
    "        u_ji = torch.matmul(u[:, None, :, None, :], self.W) # u_ji.size() is (None, 10, 1152, 1, 16)\n",
    "\n",
    "        b = Variable(torch.zeros(u_ji.size())) # b.size() is (None, 10, 1152, 1, 16)\n",
    "        b = b.to(device) # using gpu\n",
    "\n",
    "        for i in range(self.num_iterations):\n",
    "            c = self.softmax(b, dim=2)\n",
    "            v = self.squash((c * u_ji).sum(dim=2, keepdim=True)) # v.size() is (None, 10, 1, 1, 16)\n",
    "\n",
    "            if i != self.num_iterations - 1:\n",
    "                delta_b = (u_ji * v).sum(dim=-1, keepdim=True)\n",
    "                b = b + delta_b\n",
    "\n",
    "        # Now we simply compute the length of the vectors and take the softmax to get probability.\n",
    "        v = v.squeeze()\n",
    "        classes = (v ** 2).sum(dim=-1) ** 0.5\n",
    "        classes = F.softmax(classes) # This is not done in the paper, but I've done this to use CrossEntropyLoss.\n",
    "        \n",
    "        #save C_ij\n",
    "        c_ij=c.data.cpu().numpy()\n",
    "#         print('c_ij shape:{}'.format(c_ij.shape)) #shape:(1040, 2, 2336, 1, 16)\n",
    "        c_ij=c_ij[:,:,:,-1,-1] #the value in '16' dim is the same\n",
    "        np.save('C_ij.npy',c_ij) #shape:(1040, 2, 2336)\n",
    "        \n",
    "        return classes\n",
    "\n",
    "\n",
    "# for name, param in model.named_parameters():\n",
    "#     if param.device.type != 'cuda:0':\n",
    "#         print('param {}, not on GPU'.format(name))\n",
    "\n",
    "class CapsNet(nn.Module):\n",
    "    def __init__(self):\n",
    "#         super().__init__() #py3\n",
    "        super(CapsNet, self).__init__() #py2\n",
    "        self.fc1 = nn.Linear(top_k,neurons)\n",
    "        self.dropout1 = nn.Dropout(p=dropout)\n",
    "#         self.fc2 = nn.Linear(256,64)\n",
    "#         self.out_channel=16\n",
    "#         self.conv1 = nn.Conv2d(in_channels = 1, out_channels = self.out_channel, kernel_size = (1,3), stride = 1)\n",
    "#         self.conv1_bn = nn.BatchNorm2d(self.out_channel)\n",
    "\n",
    "#         self.conv2 = nn.Conv2d(in_channels = self.out_channel, out_channels = 2*self.out_channel, kernel_size = (3,3), stride = 2)\n",
    "#         self.conv2_bn = nn.BatchNorm2d(2*self.out_channel)\n",
    "\n",
    "#         self.conv3 = nn.Conv2d(in_channels = 2*self.out_channel, out_channels = 2*2*self.out_channel, kernel_size = (3,3), stride = 1)\n",
    "#         self.conv3_bn = nn.BatchNorm2d(2*2*self.out_channel)\n",
    "\n",
    "        self.primaryCaps = ConvCaps2D()\n",
    "        self.digitCaps = Caps1D()\n",
    "\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = act(self.dropout1(self.fc1(x)))\n",
    "#         x = F.relu(self.fc1(x))\n",
    "#         x = F.relu(self.fc2(x))\n",
    "#         x = F.relu(self.conv1_bn(self.conv1(x)))\n",
    "#         x = F.relu(self.conv2_bn(self.conv2(x)))\n",
    "#         x = F.relu(self.conv3_bn(self.conv3(x)))\n",
    "        x = self.primaryCaps(x)\n",
    "        x = self.digitCaps(x)\n",
    "\n",
    "        return x\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "apparent-homeless",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-03T16:58:30.566107Z",
     "start_time": "2021-11-03T16:58:30.562151Z"
    }
   },
   "outputs": [],
   "source": [
    "top_k=75584\n",
    "\n",
    "#use the best param, id:89\n",
    "neurons=150\n",
    "dropout=0.5\n",
    "primary_capslen=4\n",
    "digital_capslen=16\n",
    "ks=5\n",
    "stride=2\n",
    "filters=32\n",
    "num_iterations=3 #danymic routing iterations\n",
    "\n",
    "##\n",
    "initial_lr=0.0001\n",
    "batch_size=128\n",
    "epochs=30\n",
    "act=relu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "clean-tattoo",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-03T16:58:31.097783Z",
     "start_time": "2021-11-03T16:58:31.083691Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "73"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "2336"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "928"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "1152"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(int((neurons-ks)/stride)+1)\n",
    "73*32\n",
    "29*32\n",
    "36*32"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "indoor-hypothesis",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-03T16:58:36.232546Z",
     "start_time": "2021-11-03T16:58:32.169531Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "num_routes:2336\n"
     ]
    }
   ],
   "source": [
    "device = torch.device('cuda:0')\n",
    "model = CapsNet()\n",
    "model.load_state_dict(torch.load(\"./capsule_pca.best_model.pt\")) #recommended officically\n",
    "model.eval()\n",
    "model.to(device);\n",
    "# model.fc1.weight.data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "attempted-spray",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-03T16:58:40.759237Z",
     "start_time": "2021-11-03T16:58:36.234498Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10405, 75584)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(10405, 75584)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "(10405, 2)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "# read once a time\n",
    "dataset_X,_=pickle.load(open('sigSNPs_pca.features.pkl','rb'))\n",
    "print(dataset_X.shape)\n",
    "\n",
    "dataset_X=np.array(dataset_X) # extract selected features\n",
    "\n",
    "_,dataset_Y=pickle.load(open('../chr1/genes/A3GALT2.pkl','rb'))\n",
    "\n",
    "dataset_X.shape\n",
    "dataset_Y.shape\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "scheduled-daniel",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-03T16:58:40.763496Z",
     "start_time": "2021-11-03T16:58:40.761404Z"
    }
   },
   "outputs": [],
   "source": [
    "\n",
    "# # train dataset\n",
    "# train_idx = [int(line.strip()) for line in open(\"../train_val.unique.idx\", 'r')]\n",
    "# x_train=dataset_X[train_idx]\n",
    "\n",
    "# # test dataset\n",
    "# te_idx = [int(line.strip()) for line in open(\"../test.idx\", 'r')]\n",
    "# x_test=dataset_X[te_idx]\n",
    "# x_train.shape\n",
    "# x_test.shape\n",
    "\n",
    "\n",
    "# x_train=x_train.reshape(x_train.shape[0],1,1,x_train.shape[1])\n",
    "\n",
    "# x_test=x_test.reshape(x_test.shape[0],1,1,x_test.shape[1])\n",
    "\n",
    "# y_train =dataset_Y[train_idx]\n",
    "\n",
    "# y_train = np.argmax(y_train, axis=1)\n",
    "\n",
    "# y_test =dataset_Y[te_idx]\n",
    "\n",
    "# y_test = np.argmax(y_test, axis=1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "determined-kidney",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-03T16:58:40.766961Z",
     "start_time": "2021-11-03T16:58:40.765164Z"
    }
   },
   "outputs": [],
   "source": [
    "# in_train=Variable(torch.tensor(x_train[:500]).to(device))\n",
    "# y_pred = model(in_train).detach().cpu().numpy()\n",
    "# y_pred = np.argmax(y_pred, axis=1)\n",
    "# y_true = y_train[:500]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ranking-roller",
   "metadata": {},
   "source": [
    "# Compute C_ij for training data (need to split dataset then merge)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "complicated-panic",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-03T16:58:40.774486Z",
     "start_time": "2021-11-03T16:58:40.768396Z"
    }
   },
   "outputs": [],
   "source": [
    "def compute_average_cij_for_testdata(x_test,y_test):\n",
    "    in_test=Variable(torch.tensor(x_test).to(device))\n",
    "    y_pred = model(in_test).detach().cpu().numpy()\n",
    "    y_pred = np.argmax(y_pred, axis=1)\n",
    "    y_true = y_test\n",
    "    \n",
    "    c=np.load('C_ij.npy')\n",
    "    c=c.reshape(c.shape[0],c.shape[1],32,73)\n",
    "    c=np.sum(c,axis=-1)\n",
    "\n",
    "    num_classes=2\n",
    "    phenotype = ['Healthy','ALS']\n",
    "    pheno2coefficients={}\n",
    "    count = {}\n",
    "    for i in range(len(c)):\n",
    "        ind = int(y_test[i])     #phenotype\n",
    "        if ind in pheno2coefficients.keys():\n",
    "            pheno2coefficients[ind] = pheno2coefficients[ind] + c[i]   #sum of coupling coefficients for each phenotype\n",
    "            count[ind] = count[ind] + 1   #sample counts for each type   \n",
    "        else:\n",
    "            pheno2coefficients[ind] = c[i]\n",
    "            count[ind] = 1\n",
    "\n",
    "    total = np.zeros((c.shape[1],c.shape[-1]))\n",
    "\n",
    "    #type average coupling coefficients\n",
    "    for i in range(num_classes):\n",
    "        average = pheno2coefficients[i]/count[i]   #sum/count = average\n",
    "        total[i] = average[i]\n",
    "#     print(total)\n",
    "    Cij=total\n",
    "    return Cij\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "fatty-spending",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-03T16:58:40.783454Z",
     "start_time": "2021-11-03T16:58:40.775932Z"
    }
   },
   "outputs": [],
   "source": [
    "def compute_average_cij_for_traindata(x_train,y_train):\n",
    "    k=int(x_train.shape[0]/1000)+1\n",
    "    y_pred=np.array([])\n",
    "    for i in range(k):\n",
    "        upper = min(x_train.shape[0],(i+1)*1000)\n",
    "    #     print(i,upper)\n",
    "        in_train=Variable(torch.tensor(x_train[(i*1000):upper]).to(device))\n",
    "        y_pred0 = model(in_train).detach().cpu().numpy()\n",
    "        y_pred0 = np.argmax(y_pred0, axis=1)\n",
    "        y_pred = np.concatenate([y_pred,y_pred0])\n",
    "        o=os.system('mv C_ij.npy C_ij.{}.npy'.format(i))\n",
    "    y_true = y_train\n",
    "    y_pred.shape\n",
    "    #merge all Cij\n",
    "    c=np.array([])\n",
    "    for i in range(k):\n",
    "        c0=np.load('C_ij.{}.npy'.format(i))\n",
    "        if i==0:\n",
    "            c=c0\n",
    "        else:\n",
    "            c=np.vstack([c,c0])\n",
    "     \n",
    "    c=c.reshape(c.shape[0],c.shape[1],32,73)\n",
    "    c=np.sum(c,axis=-1)\n",
    "\n",
    "    num_classes=2\n",
    "    phenotype = ['Healthy','ALS']\n",
    "    pheno2coefficients={}\n",
    "    count = {}\n",
    "    for i in range(len(c)):\n",
    "        ind = int(y_train[i])     #phenotype\n",
    "        if ind in pheno2coefficients.keys():\n",
    "            pheno2coefficients[ind] = pheno2coefficients[ind] + c[i]   #sum of coupling coefficients for each phenotype\n",
    "            count[ind] = count[ind] + 1   #sample counts for each type   \n",
    "        else:\n",
    "            pheno2coefficients[ind] = c[i]\n",
    "            count[ind] = 1\n",
    "\n",
    "    total = np.zeros((c.shape[1],c.shape[-1]))\n",
    "\n",
    "    #type average coupling coefficients\n",
    "    for i in range(num_classes):\n",
    "        average = pheno2coefficients[i]/count[i]   #sum/count = average\n",
    "        total[i] = average[i]\n",
    "    Cij=total\n",
    "    Cij.shape\n",
    "    return Cij\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "apparent-piano",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "distinguished-county",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-03T16:58:42.644319Z",
     "start_time": "2021-11-03T16:58:42.585587Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "18265"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gene2Cij_train_list=[]\n",
    "for i in range(1,5):\n",
    "    t=pickle.load(open('{}/Cij_for_single_gene.{}.pkl'.format(i,i),'rb')) #based on training data\n",
    "    gene2Cij_train_list.extend(t)\n",
    "len(gene2Cij_train_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "boxed-statistics",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-03T16:58:43.358937Z",
     "start_time": "2021-11-03T16:58:43.320068Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(18265, 2, 32)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "genes=[]\n",
    "Cij_train_tensor=[]\n",
    "for item in gene2Cij_train_list:\n",
    "    gene,Cij_train=item\n",
    "    genes.append(gene)\n",
    "    Cij_train_tensor.append(Cij_train)\n",
    "#     print(gene,Cij_train.shape)\n",
    "Cij_train_tensor=np.array(Cij_train_tensor)\n",
    "Cij_train_tensor.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "expressed-radical",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-03T16:58:44.124369Z",
     "start_time": "2021-11-03T16:58:44.118654Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "18265"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(genes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "informative-crown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-03T16:58:54.560701Z",
     "start_time": "2021-11-03T16:58:48.547153Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "18265"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7feb0b905850>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.lines.Line2D at 0x7feb0b947090>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "Text(0.5, 0, 'Coupling coefficient')"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Density')"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "369"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "922"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "183"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "6846"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "922"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "503345"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "#for primary capsule i\n",
    "pc=5\n",
    "# pc=28\n",
    "# pc=4\n",
    "# pc=17\n",
    "# v=Cij_train_tensor[:,0,pc-1]\n",
    "v=Cij_train_tensor[:,1,pc-1]\n",
    "len(v)\n",
    "# gene2pc5cij={genes[k]:v_ for k,v_ in enumerate(v)}\n",
    "sns.distplot(v)\n",
    "plt.axvline(x=np.quantile(v,0.95),color='red', linestyle='dashed')\n",
    "# plt.axvline(x=np.quantile(v,0.98),color='green', linestyle='dashed')\n",
    "# plt.axvline(x=np.quantile(v,0.99),color='yellow', linestyle='dashed')\n",
    "plt.xlabel('Coupling coefficient',fontsize=12)\n",
    "plt.ylabel('Density',fontsize=12)\n",
    "sum(v>=np.quantile(v,0.98))\n",
    "sum(v>=np.quantile(v,0.95))\n",
    "sum(v>=np.quantile(v,0.99))\n",
    "\n",
    "target_genes={genes[k]:1 for k,v_ in enumerate(v) if v_>=np.quantile(v,0.95)}\n",
    "# target_genes={genes[k]:1 for k,v_ in enumerate(v) if v_>=np.quantile(v,0.99)}\n",
    "# target_genes={genes[k]:1 for k,v_ in enumerate(v) if v_>=np.quantile(v,0.98)}\n",
    "\n",
    "with open('target_genes.95th_percentile.pc{}'.format(pc),'w') as fw:\n",
    "    fw.write('\\n'.join(list(target_genes.keys())))\n",
    "len(target_genes)\n",
    "\n",
    "with open('sorted_genes2cij.95th_percentile.pc{}'.format(pc),'w') as fw:\n",
    "    g2cij_={genes[k]:v_ for k,v_ in enumerate(v)}\n",
    "    fw.write('\\n'.join(['{}\\t{}'.format(a,b) for a,b in sorted(g2cij_.items(),key=lambda d:d[1],reverse=True)]))\n",
    "    \n",
    "plt.savefig('target_genes.95th_percentile.pc5.dist.png',dpi=400,bbox_inches='tight') #bbox_inches='tight' ,keep all elements in fig\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "annoying-graduation",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-03T16:58:54.566930Z",
     "start_time": "2021-11-03T16:58:54.562519Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "922"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "target_genes_pc5={line.strip():1 for line in open(\"target_genes.95th_percentile.pc5\", 'r')}\n",
    "# target_genes_pc4={line.strip():1 for line in open(\"target_genes.pc4\", 'r')}\n",
    "# target_genes_pc28={line.strip():1 for line in open(\"target_genes.pc28\", 'r')}\n",
    "\n",
    "# target_genes={g:1 for g in target_genes_pc5 if (g not in target_genes_pc28 and g not in target_genes_pc4)}\n",
    "len(target_genes)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "prescribed-knitting",
   "metadata": {},
   "source": [
    "# plot coefficient using all genes on training / test data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "present-rochester",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-03T17:07:58.864779Z",
     "start_time": "2021-11-03T17:07:56.627307Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(9365, 75584)"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "(1040, 75584)"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/export/scratch1/home/vincent/software/miniconda3/envs/gpu/lib/python3.7/site-packages/ipykernel_launcher.py:39: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
      "/export/scratch1/home/vincent/software/miniconda3/envs/gpu/lib/python3.7/site-packages/ipykernel_launcher.py:74: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.837\t0.98\t0.903\t0.938\n",
      "\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "# train dataset\n",
    "train_idx = [int(line.strip()) for line in open(\"../train_val.unique.idx\", 'r')]\n",
    "x_train=dataset_X[train_idx]\n",
    "\n",
    "# test dataset\n",
    "te_idx = [int(line.strip()) for line in open(\"../test.idx\", 'r')]\n",
    "x_test=dataset_X[te_idx]\n",
    "x_train.shape\n",
    "x_test.shape\n",
    "\n",
    "\n",
    "x_train=x_train.reshape(x_train.shape[0],1,1,x_train.shape[1])\n",
    "\n",
    "x_test=x_test.reshape(x_test.shape[0],1,1,x_test.shape[1])\n",
    "\n",
    "y_train =dataset_Y[train_idx]\n",
    "\n",
    "y_train = np.argmax(y_train, axis=1)\n",
    "\n",
    "y_test =dataset_Y[te_idx]\n",
    "\n",
    "y_test = np.argmax(y_test, axis=1)\n",
    "\n",
    "\n",
    "in_test=Variable(torch.tensor(x_train[:1000]).to(device))\n",
    "# in_test=Variable(torch.tensor(x_test).to(device))\n",
    "y_pred = model(in_test).detach().cpu().numpy()\n",
    "\n",
    "y_pred = np.argmax(y_pred, axis=1)\n",
    "y_true = y_train[:1000]\n",
    "\n",
    "tn, fp, fn, tp = confusion_matrix(y_true, y_pred).ravel()\n",
    "acc = round((tp + tn) * 1. / (tp + fp + tn + fn),3)\n",
    "precision = round(tp*1./(tp+fp),3)\n",
    "recall = round(tp*1./(tp+fn),3)\n",
    "f1=round(2*(precision*recall)/(precision+recall),3)\n",
    "\n",
    "print('\\t'.join(list(map(str,[precision,recall,f1,acc])))+'\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "selected-thursday",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-03T16:52:18.718613Z",
     "start_time": "2021-11-03T16:52:18.707364Z"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "quick-continent",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-03T17:08:06.672516Z",
     "start_time": "2021-11-03T17:07:59.930140Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/export/scratch1/home/vincent/software/miniconda3/envs/gpu/lib/python3.7/site-packages/ipykernel_launcher.py:39: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
      "/export/scratch1/home/vincent/software/miniconda3/envs/gpu/lib/python3.7/site-packages/ipykernel_launcher.py:74: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x72 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "cmap='YlOrBr'\n",
    "phenotype = ['Healthy','ALS']\n",
    "c=compute_average_cij_for_traindata(x_train,y_train)\n",
    "c.shape\n",
    "fs=12\n",
    "\n",
    "#overall heatmap\n",
    "plt.figure(figsize=(8,1))\n",
    "df = pd.DataFrame(np.asmatrix(c),index=phenotype,columns=list(range(1,c.shape[-1]+1)))\n",
    "vmax=np.max(np.asmatrix(df))\n",
    "vmin=np.min(np.asmatrix(df))\n",
    "\n",
    "# ax = sns.heatmap(df,linewidths=.1,cmap=cmap,vmax=vmax,vmin=vmin)\n",
    "ax = sns.heatmap(df,linewidths=.1,cmap=cmap)\n",
    "plt.title('Training data (all genes)',fontsize=fs+1) #Overall(health+ALS)\n",
    "plt.ylabel('PhenoCaps', fontsize=fs)\n",
    "plt.xlabel('PrimaryCaps', fontsize=fs)\n",
    "\n",
    "plt.savefig('capsule_train.all_genes.cc_heatmap.png',dpi=400,bbox_inches='tight') \n",
    "plt.show()\n",
    "print();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "divine-directive",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-03T16:59:05.021628Z",
     "start_time": "2021-11-03T16:59:03.742321Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/export/scratch1/home/vincent/software/miniconda3/envs/gpu/lib/python3.7/site-packages/ipykernel_launcher.py:39: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
      "/export/scratch1/home/vincent/software/miniconda3/envs/gpu/lib/python3.7/site-packages/ipykernel_launcher.py:74: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x72 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "cmap='YlOrBr'\n",
    "phenotype = ['Healthy','ALS']\n",
    "c=compute_average_cij_for_testdata(x_test,y_test)\n",
    "c.shape\n",
    "fs=12\n",
    "\n",
    "#overall heatmap\n",
    "plt.figure(figsize=(8,1))\n",
    "df = pd.DataFrame(np.asmatrix(c),index=phenotype,columns=list(range(1,c.shape[-1]+1)))\n",
    "ax = sns.heatmap(df,linewidths=.1,cmap=cmap)\n",
    "plt.title('Test data (all genes)',fontsize=fs+1)\n",
    "plt.ylabel('PhenoCaps', fontsize=fs)\n",
    "plt.xlabel('PrimaryCaps', fontsize=fs)\n",
    "plt.savefig('capsule_test.all_genes.cc_heatmap.png',dpi=400,bbox_inches='tight') \n",
    "plt.show()\n",
    "\n",
    "print();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "surgical-credits",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-03T16:59:12.701125Z",
     "start_time": "2021-11-03T16:59:05.023540Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/export/scratch1/home/vincent/software/miniconda3/envs/gpu/lib/python3.7/site-packages/ipykernel_launcher.py:39: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
      "/export/scratch1/home/vincent/software/miniconda3/envs/gpu/lib/python3.7/site-packages/ipykernel_launcher.py:74: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAegAAAB5CAYAAADyHbJeAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nO2deZxe0/3H35/MTDaRkFgrdiG2CiL2okgtVbS0lpbQVlXRav1Ki9raolpbCVVLFmtDaZRYY2sbkSAV2ZAIghIJIpLY8v39cc6TubmeZ+beZJ6ZOzPf9+t1XnPuOZ97zvfeuc/53nPuvefIzHAcx3Ecp1h0aGkDHMdxHMf5Iu6gHcdxHKeAuIN2HMdxnALiDtpxHMdxCog7aMdxHMcpIO6gHcdxHKeAuIN22gWSjpT035a2wyk+kgZJejmxPUTSdS1pk9M+cQftFBJJ8xPh0xiWpOUtz8xuNrOtltOmFSQNlzQ3hsck9WxAv2vqOBZLWpTYHrWMdizlQBrQmaQFkj6U9IGk5yX9SdKaOepaL5bTe1lsbaTsHSXdH237SNIzko5u6nocp7XiDtopJGbWrRSAocDNqbQlSKprJrNOAbYFNgFWA84CPqskNrMnUzbPAI5PpO3bDDYPNLMVgZWBo4ANgP9K2rAZ6q6IpIHAo8CYaNOqwEXAZZLOrWK9zXWtOM5y4w7aaXXEnutlku6WNA/4haTesTc2O/bInpS0bWKf9LDlY7E3eWfsYU6XdGAjVX8KfGBms83ss+iA5y3Hcewq6V+xNz5d0i8kKeatLGmEpDnxeCZF/Y7ANcAGiZ747o3VZWaLzWwC8B3gXeC8hB03Sno9nofJko5I7Fp6LDAt1nVW3Of3kmbEtOmSfpbz8K8CbjWzc81sjpktMLO/EW6Czog9980lfSJp1YStivUeHbe7SvqjpFfiebxf0kYJfe5rxXGKgjtop7VyLHAF0CP+7QAMBtYF1gCeBf7eSI/paOBPsYwrgaGSujagfxzYXtKVJUe6rEjaDLgPuJjQe9wfOBH4XpT8H9CVcDwrAQcDs8xsDHA8MCPRE38sa71m9glwF7BnIvlfQL9Yz3nAkGgfQOmxwCaxrvPj9mRgF2BF4IfABZK+lvHYNwY2Am4qk30LIGBvM5sETACOTOTvDqwCjIjbfwX6AjsQ/u9jgX+m/u9Nca04TrPjDtpprdxhZqMtsMDMXjOzkTG+EDgTWAfo00AZt5vZf8xsMXAtoQEvq5e0LnAPsC+wIXBzqUGX9EtJD+e0/wRghJn9w8w+N7OphJuEo2L+J0AvwnC6zOxFM3slZx2VmBXLBsDMro+92M/N7DbgeYIjrIiZ3WRmb8bzPxq4l6WdfkOUesRvlCn3E0IPf7WYdCNwTEJyDOH/tkDSKsARwAlm9nbc91xgTWD7xD5Nca04TrPjDtpprcxMbkhaRdIwSa/FoczXY9aqX9iznrdKETP7KEZXrKA9DnjKzB4ADiI483skrUBwZiNz2r8+cLik90sBOJvgXCD0rB8hPH+fLWmopNVz1lGJ3sAcAEkdJJ0naVoc7n2f0Gtu6Lwh6WRJEyW9F/c5oLF9EsyOf9cqU25HQg+5pLkV2FjSNpJWBL4F3BDz1o9/n0+cw7lAHbB2otiZqTqW5VpxnGbHHbTTWlmc2r6A2HMys+7UN9DLNRSdoC4GzOxj4JuEZ9LjCEOseT/DeRW4wcxWSoTuZrZ5rOMjMzvDzLYANic4s4vjvuljz0x0gAcDo2PS4cAPCI5vZTNbifDcuXTevlCXpJ0JL3T9CFgl7nMP2c/1S4QX5o4ok3cYYMBDAGb2PnA3MAj4NvBaHOaHcA4B+qTOY1czuzVRZnNfK47TJLiDdtoK3YEFwHuSuhEcSFNyO7C7pBMldSY461EE5/wBUJOzvMHAYZIOkFQnqVbSZpJ2A4jpm0qqAeYDi4DP477/A1aT1D1rZbGn/GXCM97VCL11COftM0KPtYOkY6l/7kxMX8zSw7/doy2zAZO0P2HoP1nfY5KGlLPFwhq3JwLflXSmpJ6Sukg6BLgMuCg1nH8jwZkfF+Olct6JxzNY0lqx3pUkHRyvgUpU+1pxnCbBHbTTVvgNwfHMITxD/Q/1Dm25MbNnCE7oOwQH+RrhmWt/4D3Ci0ldcpT3AvB14GeEofZ3gCHUD7NuSOiVziMM0S4ETot5jxJ6mK/Eod3dGqjqQUkfRhtvIQznbmVmL8X8oYQXq14mPBPeDHgyYedCwudkt8a6zgAeAIYBTxOeFx9CePEsyTrAYw0c/yjC+ftKPL53gTOAU83sjJT8YYJD3TbWm+SHwDTgsXicE4FDCb3wSlT1WnGcpkLhZtZxHKdpkLQBYVi6X3wBz3GcZcAdtOM4juMUEB/idhzHcZwCsswOWtIGktZrOlMcx3EcxymR2UFLulXSTjF+DDAJmCTp+9UyznEcx3HaK5mfQUt6B+htZp9ImkiYbvB94G4z8xl4HMdxHKcJqc2h7Rid81pATzP7N0ATzm5UKOz1SzO/Pae1T8Ge/UE27TbXwfx7shXc7QDsqUOzlbvDCGxa+uuUCtpNfgcLH8pmQ5e9sVl/zqYF1PskbMppjQsBbXoR9uDAbNqBD2IjG/qaKKH9xuPYc8dl0259LTbr8mza3j/F/ntCNu1Wg0Nk4YOZ9HQZiD1xQLayv3IP9ubV2bRf+jH2952zab/5b2zC8dm0/a7BZvwum3aDcF3a9PMbUUb9hmdhc27Opu11ZL5yx5abG6WMdvtbsPGDsmn7D8FG7JhNe+gYbOqvMmkB1PcC7IVs65Boi8uwcUc1LgS03bDMdqjvBdhN2dYS0XefyWdDxvYNQDuMqMpEMj/euNOStv7qFz8u1GQ1eRz0BEm/Ikwwfy9AdNbLvJqP4ziO47QknfNOMdSM5HlJ7PvAlkAXwsQFADsC2W51HcdxHKdgdOxgS0LRyNyDNrPppObONbM7gDua2ijHcRzHaQ46F/hj41ymSTpW0kMKi8c/JOn7y7suruM4juO0FJ071IeikbkHLekPwIGEyexfJcy1eyphvdpfVsU6x3Ecx6kinWuKN7RdIs9LYoOAbcxsVilB0r3As7iDdhzHcVohHQvYcy6Rx0F/GEM6zd/idhzHcVolbeUt7suAv0vaO65TOxAYAVwap/3cIK5i4ziO4zitgs419SELkvaRNE3Sy5JOL5PfSdLtMX9sekpsSetImi/p1MbqytODLs3msEcqfU/gihg38i9c7ziO4zgtQqccz6Al1QBXAXsDs4Bxkkaa2eSE7PvAe2a2kaTDgIsI68iXuAQYlaW+zD1oM+uQIZR1zpLmp7YHSboya92pfXeX9M9EfKdE3hBJhyxLuY7jOE77o3NtfcjAAOBlM5thZp8AtxFenk5yIDA0xu8A9ix97STpIOAVwloWjVLgx+OZ2B3YqTGR4ziO45Qj6aAlHSdpfCKk5wxeC3g9sT0rppXVmNlnwAdAL0ndgNOAc7Palmc1q1pJJ0u6U9Ljkp4ohaxlVCh31VjmuBh2jukDJI2R9Jyk/0jaJLXfeoQFO06RNEHSrjHrK1E/o9SbljQs3rmU9r1ZUvqux3Ecx2lndKyxJcHMrjWz/olwbRNWdQ5wqZnNb0xYIk8P+lLgR8ATwLbAncBqwOgM+3aJTnSCpAnAeYm8ywlGbwd8C7gupk8FdjWzrYHfAL9PFmhmM4Fr4r79zOzJmLUmsAvwdeDCmHY94TMxJPUg9LrvTRuZvHu69uYxGQ7LcRzHac3kHOJ+A1g7sd07ppXVSKoFegBzgO2BP0iaCfwM+LWkExuqLM9LYt8EdjSz1ySda2aXS3oA+AvhzqAhFppZv9KGpEFA/7i5F7BZYkKy7nEooAcwVFIfwstndRntvNvMFgOTSyttmdnjkgZLWpVwE3BnHHpYini3dC3kW83KcRzHaZ10rMv1pHcc0EfS+gRHfBipKbCBkcDRwBjgEGC0hXWdS6O8SDoHmG9mDb6LlcdBd6V+7H2hpK5mNlXS1jnKKEcHYAczW5RMjC+RPWpmB8fh7McylvdxsphEfBjwXcIJPWZZjXUcx3HaDnV12T88MrPPYq/3AcIXSzeY2SRJ5wHjzWwkYcR2uKSXgbkEn7NM5HHQU4DtgKeB8cA5kubxxe59Xh4ETgIuBpDUz8wmEHrQpbIHVdj3Q6B7xnqGEGz/X+qVeMdxHKedUpuvB42Z3Qfcl0r7TSK+CGhwoWszOydLXXks+ylQGhb+ObANcACQfsstLycD/SU9L2ky4cUvgD8AF0h6jso3EvcAB6deEiuLmb1NuMm4cTntdRzHcdoIdXU1S0LRyLPc5LhE/CXCs+Os+3ZLbQ8h9Ggxs3dZ+iPukmYMsHEi6cyY/hhxuNvMXgS+nNA8mYgvVa+krkAf4NasdjuO4zhtm7qOxXPMJRrtQUvaWdJFFfIulLRD05vVtEjai9B7/rOZfdDS9jiO4zjFoLauw5JQNLL0oH8NDK6Q9zhwBmGou7CY2cPAui1th+M4jlMsiji0XSLLLUM/4P4KeQ8Rvol2HMdxnFZHTaeaJaFoZOlBdwc6AgvL5NUBKzapRY7jOI7TTNS05mfQhBm9BlbIGxjzHcdxHKfVUVNXsyQUjSw96EuBv8Rltu42s8WSOgAHEZbd+nk1DXQcx3GcatGhgEPbJRp10GZ2i6Q1CMtndZL0LrAKYcaus83MP1tyHMdxWiVFHuJWmCI0g1DqTlhkoidh4u8xZjavira1ND4Xt+M4TnFQ45L8fHblJkva+toTp1WljmUlz0Ql8yQ9THDSawFbSRpTbtGJtoD9ZbPMWv1oMvb6pdm0a5+CzfpzNm3vk7Dbts+mPWws/7dZx0zaiyd/gs0elq3cVY/C3romkxZAax4Pn47PJq7rD/ZqxoLXxd6s9LVfSvqlE7Cb+zcuBHTkeGzOLdm0vY7I9f8A8l0Xf8s2pYC+/RT29nWNCwGt/gNsbrZBLvU8HHv6u9m0A26CeXdl0tL94PB30aPZ9J33wJ45Npsd296A3f2VbNqDnsBG7JhNe+gY7MFKr96ktAMfxKafn0274VnYxJMzaQG05RXw0ahs4hX2Zd5Z6aWJy9P9/Dfgo/saFwKssB82fJtMUn3v2Xz/54ztEIS2qBrUdMoz43XzktkySX0JU2t2JixSvTawSNIBZjalSvY5juM4TvXomK1j0xLkmTplMGEpxnXMbEcz601Yjzlbt8ZxHMdxikanjvWhYORx0P2AS2zph9aXxXTHcRzHaX10rK0PBSOPg34T2C2VtmtMdxzHcZzWR8eO9aFg5Lll+DUwUtI/gVcJc1vvD2R7q8RxHMdxikYBh7ZLZO5Bm9lIwhrQLxCm93wB2NbM/lEl2xzHcRynutTV1YeCkWvQPa6//Nsq2eI4juM4zUunTi1tQUXyfGbVEziV8FJYt2SemWX7ENFxHMdxikTtCi1tQUXy9KBvAToBfwMWVMccx3Ecx2lG6rq2tAUVyeOgdwJWNbOPq2VMHiQdBNwFbGpmUyWtB/zTzLZI6XYALifcXHQCbjezc5rXWsdxHKeQ1HbOJZe0D8Gn1ADXmdmFqfxOwDBgW8K02N8xs5mSBhDmEoEwbek5ZtbgdHx5PrN6HuidQ19tDgf+Ff82xFDgODPrB2xBGAFwHMdxHKhboT40QlzV8SpgX2Az4HBJ6Xmhvw+8Z2YbEVaDvCimvwD0j75oH8IqkQ12kvP0oEcD90u6EfhfMsPMbshRznIjqRuwC7AHYfrRsxuQrwa8BWBmnwOTq26g4ziO0zrIN8Q9AHjZzGYASLoNOJCl/cqBwDkxfgdwpSSZWfLRcGcyLMiUpwe9K2EO7r2B7yVCS3wHfSBwf3yrfI6kbRvQXgpMk3SXpB9JqjieIek4SeMljb/2yfea2mbHcRynaNR2rg+NsxbwemJ7Vkwrq4mLSX0A9AKQtL2kScBE4PjGFpvKs5rVHlm1zcDhhGcAALfF7SvLCc3sPEk3AwOBI6J29wraa4nPCOwvm/lyk47jOG2d2i5LopKOA45L5F4b/UKTYGZjgc0lbQoMlTTKzBZVNC1P4ZJ6AfsBa5jZxZK+BHQws1nLZXU+G3oCXwW2lGSEB/VGeC5QFjObDlwt6a/AbEm9zGxOsxjsOI7jFJea+pnEkp20CrxBWMmxRO+YVk4zKz5j7kF4WSxZzxRJ8wnvRVVcnzfzELek3YBpwJHAb2JyH+DqrGU0EYcAw81sXTNbz8zWBl5h6ZO2BEn7Syotwt0H+Bx4v3lMdRzHcQpNh471oXHGAX0krS+pI3AYMDKlGQkcHeOHAKPNzOI+tQCS1gX6AjMbqixPD/oywuvij0gqPaAdS3ho3pwcTv1bcSXuBH4FbCIp2Zs/BfgWcKmkBcBnwJHxZTHHcRynnaPa7DOJmdlnkk4EHiCM3t5gZpMknQeMj1NiXw8Ml/QyMJfgxCG82Hy6pE+BxcAJZvZuQ/XlcdDrmdkjJTvj309ylrHclHsWbmZXAFdU2GVEdS1yHMdxWi01+RbLMLP7gPtSab9JxBcBh5bZbzgwPE9ded7inizpa6m0vQhvozmO4zhO66OmU30oGHl6v78A/inpXqCLpL8ABxA+eXIcx3Gc1keH4q1iVSLPcpNPAVsBk4AbCC9mDTCzcVWyzXEcx3GqS4dO9aFg5F1u8g3gD1WyxXEcx3GaF+V7Bt2c+HKTjuM4TvulLThofLlJx3Ecp63RRhx0oZabdBzHcZzlJtsEJS1Ca15u0nEcx3GWD3WqD0XDzCoG4NhEOA94Cfh1Kv3Yhspoa4GwtrRrc2iLYkcRtEWxowjaothRBG1R7Ght2rYeGjtRjybC6NT2kvSWPohmPWFhOjfX5tAWxY4iaItiRxG0RbGjCNqi2NHatG09NPgM2sz2kLQCcCZh1Y1ngd+bP4d2HMdxnKqS5Rn0n4H9gSmEhSf+WFWLHMdxHMfJ5KD3Bb5mZr+M8a9X16TCk2fxbtcWy44iaItiRxG0RbGjCNqi2NHatG0axTH/ygJpnpl1T2zPNbOeVbfMcRzHcdoxWb6DrpW0B6AK25jZ6GoY5ziO4zjtlSw96JnUr/9cDjOzDZrSKMdxHMdp7zTqoB3HcRzHaX7yzCTmNICkvpL2lNQtlb5PBf0ASdvF+GaSfi5pvwz1DMth0y6x3IFl8raX1D3Gu0g6V9I9ki6S1COlPVnS2hnr7CjpKEl7xe0jJF0p6SeSvrDwqqQNJJ0q6XJJl0g6vmSX4xQNSatVqdxe1SjXad24g15GJB2TiJ8M/AM4CXhB0oEJ6e/L7Hs2cAVwtaQLgCuBFYDTJZ2R0I1MhXuAb5a2y5T7dCL+w1juisDZkk5PyW+gftGTy4EewEUx7caU9nxgrKQnJZ0gadXKZ4YbCZ/l/VTScOBQYCywHXBdyt6TgWuAzjG/E7A28JSk3Ruoo1XTHht5ST0kXShpqqS5kuZImhLTVspRzqgyad0lXSBpuKQjUnmDU9trSLpa0lWSekk6R9JESX+TtGZK2zMVegFPS1o5ru6X1O6TiPeQdL2k5yXdImn1lPZCSavEeH9JMwi/r1cl7ZbSPivpTEkbZjw//SU9KukmSWtLekjSB5LGSdo6pe0m6TxJk6JmtqSnJA0qU26tpB9Juj8e1/OSRsUb6i/ceDdg37Wp7ZpY7vmSdk7lnZm13DZLS8+U0loD8FoiPhHoFuPrAeOBn8bt58rsOxGoAboC84DuMb0L8HxC9yxwE7A7sFv8+1aM71am3OcS8XGExU0gOP+JKe2UZD2pvAnpcgk3cwOB64HZwP3A0cCKKe3z8W8t8DZQE7eVPLbkeYjxrsBjMb5OhfPWA7gQmArMBeYQvs+/EFgpx/9uVGq7O3ABMBw4IpU3uMz+awBXA1cBvYBz4rH8DVgzpe2ZCr2AmcDKQM+Udp/UsV5PmAP/FmD1lPZCYJUY7w/MAF4GXk1fG/E6OhPYMMO56U+YIfAmws3SQ8AH8Xrauoy+G2Ea4ElRNxt4ChiU0j0AnAaskTqPpwEPprTbVAjbAm+VseHOeD4OAkbG7U4Vru37CTfSp8dze1o8zpOAf6S0i4FXUuHT+HdG+hwn4tcBvwXWBU4B7k5f94n4o8B2Mb4xqVm0Yl1/BF4Dno7lfamB/9/ThM9hDwdeBw6J6XsCY1LafwCDCGss/Bw4C+gDDCVMSJXU3kq45neI+t4xfjVweyPXfPLan5XSXke4vn8GPANcUqldao+hxQ0ocog/4HJhIvBxQjcptV+32BBcQsrZxfznysXj9oREvEP8QT4E9ItpMxqw97+Ehr9XmR96up4RwDExfiPQP8Y3BsaltOlGrg74RvzRzk7lvQB0jHZ8SHRChF7ylJR2IvUN6cpJm4EXyhxfVRp5cjTwMa3NNvLkaOBjeqZGHpjWwHU7LbX9OZWnFl5YZv/0DeUZwL8Jv4P0tZv87b3WSDm/iP/rLZPnssIxPNtAOentKUBtjD9V6f9aptxdgcHA/+K5+MKc1Y0cX7oN+G9qe1z82wGYmsp7sYH/34up7c8JN4zJa760/UlKm+yQ1BK+gf47YTTtCzfp7S20uAFFDoQeYL/YSCbDesCbCd1oogNNpNUCw4DPy5Q7Fuga4x0S6T3SDUpM701wqFemf3Qp3czED2EGsTdHuGFINxI9gCHA9GjPp3Gfx4GtUtqKP5TScSS2T4nlvAqcDDwC/JXgjM9OaX9KcHB/JfSKSzcMqwJPlKmrKo18mXNTsYFPn48yjWCrbuQbObZyoxqZGnngQeCXJEYCgNUJNzcPp8p4AehT4Ry9XiZtConfUUwbROjVv1rJXuC3DZ03W/q3dwnhcVHZG2RgFuEG5Rfx+lciLz1ydFI8H18ljL5cThgVOxcYXul/l0irAfYBbiyTN4Yw0nUo4Td4UEzfjS/euP0H2CXGvwE80MDv6alYZrK96gB8Bxib0r4ErJPl/0fqRiCmnU34/b1Uroz2FFrcgCIHwhDjLhXybknEe5Po1aV0O5dJ61RBuwqJhrxM/v6khp4yHkdXYP0Ked2BrQg9y9UraDbOWd+XiD00YCXgEGBABe3mMb9vhnKr0siTo4GPeW22kSdHAx/TMzXyhBGSiwg3Yu8RHlFMiWnpof5DgE0qnKODyqT9AdirTPo+pBp5wnB8tzLajYA7Grj2vkFwUv+rkH92KpQeL60BDCuj3x24nfD4aCJwH3AcUJfS3Zbzt7cVYaRpFNA3Xhfvx2t5pzLap+P/41+lc064QT45pV0v2vsO8GIM78S09VPan5C6yU9et6ntm0g82kmk/wD4NM+xt8XQ4gZ48JA1pBr5ualGfuWUNnMjn6eBj+lFb+RrU7rMjXyeBj7qv5xq5DeO6eUa+b7AXulzV6GB7ksYVm9U24h+3+UpO6klvCOyRVPYXC1tTN80R9mb5vifbA8MIIws7QycCuxXwYYB1D922Yxw47nc2vYWWtwADx6aIhCHx1tSm0WfauRb3ObmOheExx3TgLsJj2IOTOSlnxNn1sa0k3KUnUebx+YWLzdR9tQcdmTVnk24uRxPeKHyEcL7Bk8AZzSiHd0U2vYYWtwADx6aItDAs/nm0hbFjiJo03pyfOmQR1vNslubthnsaPTLk2pq22PIMhe34xQCSc9XyiI8i666tih2FEGbU9/BzOYDmNnM+J37HZLWJTGv/zJoq1l2a9NWs+zPzOxzYIGk6WY2L+63UNLiZtK2O9xBO62J1YGvEZ53JhHhZaXm0BbFjiJo8+jfltTPzCYAmNl8SV8nTJizZWrfPNpqlt3atNUs+xNJXc1sAeGFUiBMykL4lLA5tO2Plu7Ce/CQNZDxrfpqaotiRxG0efTk+NIhj7aaZbc2bZXtyPzlSbW07TH4YhmO4ziOU0B8Lm7HcRzHKSDuoB3HcRyngLiDdpwWQNJ8SRu0tB2O4xQXd9CO00RImilpYXS+b0saotT64CXMrJuZzWhuG8uhsFzjZZJei7ZPj9urtLRtjtOecQftOE3LAWbWjbByVn/CMo9LkNSsnzY2Vp+kjoRZoTYnTG3aHdiRsJTngKob6DhORdxBO04VMLM3CPNZbyHJJP1E0kuElX6IaRvF+BBJgyWNij3Yf0taI/Zi35M0VdLWpbIlnR57uR9Kmizp4ETeoLj/pZLmAOdJmitpy4RmNUkLJK0KHEVYf/tgM5tsZovN7B0zO9/M7stR35WSPoi27pnKnxH3fUXSkVU65Y7T5nAH7ThVQNLawH6EhSwgrDW9PWExgHJ8m9DbXgX4mLCq1LNx+w7CSlglphOWjexBWL3qJklrJvK3J6yGtTpwPnAb8N1E/uHAI2Y2m7BQwv0WZ5SqQJb6pkdbzwb+LqmnpBWAKwgLVqwI7ARMaKAex3ESuIN2nKblbknvE1Z2ehz4fUy/wMzmmtnCCvvdZWbPmNki4C5gkZkNszAN4u3Akh60mY0wszdjb/d2Qq88ORz9ppn92cw+i/UNBQ6XVJq+8XvA8BjvBbzV0AFlqO8d4DIz+zTmTyMsjQphNqgtJHUxs7fMbFJDdTmOU487aMdpWg4ys5XMbF0zOyHhkF9vZL+3E/GFZbaXvGwm6ShJEyS9H28GtiD0XkssVZeZjQUWALtL6ktYFnNkzJ4DJHvDXyBDfW/Y0jMevUpYD/wj4DvA8cBbku6N9TuOkwF30I7TPDTJlH1xIYO/AicCvcxsJeAFll7coFxdQwnD3N8jrFm9KKY/DHwtDkcva31rJXrnEJ5pvwlgZg+Y2d6Em4CpsSzHcTLgDtpxWhcrEBzwbABJxxB6tI1xE3AwwUkPS6QPJ/S475TUV1IHSb0k/VrSfhnrWw04WVKdpEOBTYH7JK0u6cDo/D8G5uMLIDhOZtxBO04rwswmA38ivET2NmHVoX9n2O91wktnBjyZSP+Y8KLYVOAhwpq8TxOGsMdmrG8s0Ad4F/gdcIiZzSG0Lz8n9KbnArsBP16Gw3acdokvluE47QRJNxBeIDuzUXH2MgcBPzCzXZqqTMdxAr4etOO0AyStB3yTxNvgjuMUGx/idpw2jqTzCS92XWxmr7S0PY7jZMOHuB3HcRyngHgP2nEcx3EKiDtox3Ecxykg7qAdx3Ecp4C4g3Ycx3GcAmj34J8AAAAXSURBVOIO2nEcx3EKiDtox3Ecxykg/w+TYJgk78sbZgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 576x72 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "cmap='YlOrBr'\n",
    "phenotype = ['Healthy','ALS']\n",
    "#For both train and test data\n",
    "c=compute_average_cij_for_traindata(np.concatenate([x_train,x_test]),np.concatenate([y_train,y_test])) \n",
    "c.shape\n",
    "fs=12\n",
    "\n",
    "#overall heatmap\n",
    "plt.figure(figsize=(8,1))\n",
    "df = pd.DataFrame(np.asmatrix(c),index=phenotype,columns=list(range(1,c.shape[-1]+1)))\n",
    "ax = sns.heatmap(df,linewidths=.1,cmap=cmap,vmax=vmax,vmin=vmin)\n",
    "plt.title('Train & Test Data, Overall',fontsize=fs+1)\n",
    "plt.ylabel('PhenoCaps', fontsize=fs)\n",
    "plt.xlabel('PrimaryCaps', fontsize=fs)\n",
    "plt.show()\n",
    "\n",
    "print();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "basic-delta",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "pressing-schedule",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "organic-alberta",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cross-mother",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "wireless-designer",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "average-things",
   "metadata": {},
   "source": [
    "# only feed target genes into capsule network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "limited-armenia",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-03T16:59:34.523178Z",
     "start_time": "2021-11-03T16:59:12.703363Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10405, 75584)\n",
      "(10405,)\n"
     ]
    }
   ],
   "source": [
    "X,Y=pickle.load(open('sigSNPs_pca.features.pkl','rb'))\n",
    "print(X.shape)\n",
    "print(Y.shape)\n",
    "X2=np.array(copy.deepcopy(X))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "spoken-bouquet",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-03T16:59:34.529073Z",
     "start_time": "2021-11-03T16:59:34.525320Z"
    }
   },
   "outputs": [],
   "source": [
    "# test dataset\n",
    "te_idx = [int(line.strip()) for line in open(\"../test.idx\", 'r')]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "mineral-master",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-03T16:59:34.534221Z",
     "start_time": "2021-11-03T16:59:34.530618Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "922"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(target_genes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "productive-colombia",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-03T16:59:35.674667Z",
     "start_time": "2021-11-03T16:59:34.535682Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1040, 75584)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "x_test=X.iloc[te_idx]\n",
    "x_test=np.array(x_test)\n",
    "\n",
    "x_test.shape\n",
    "\n",
    "for i in range(X.shape[1]):\n",
    "    if X.columns[i].split(':')[1] not in target_genes: #there are some duplicated genes located on different chrs\n",
    "#         x_test.iloc[:,i]=0. #replace in dataframe is very slow\n",
    "        x_test[:,i]=0.\n",
    "        X2[:,i]=0.\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "seventh-annex",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-03T16:59:36.246700Z",
     "start_time": "2021-11-03T16:59:35.676831Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/export/scratch1/home/vincent/software/miniconda3/envs/gpu/lib/python3.7/site-packages/ipykernel_launcher.py:39: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
      "/export/scratch1/home/vincent/software/miniconda3/envs/gpu/lib/python3.7/site-packages/ipykernel_launcher.py:74: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.763\t0.754\t0.758\t0.76\n",
      "\n"
     ]
    }
   ],
   "source": [
    "x_test=x_test.reshape(x_test.shape[0],1,1,x_test.shape[1])\n",
    "\n",
    "in_test=Variable(torch.tensor(x_test).to(device))\n",
    "y_pred = model(in_test).detach().cpu().numpy()\n",
    "\n",
    "y_pred = np.argmax(y_pred, axis=1)\n",
    "y_true = y_test\n",
    "\n",
    "\n",
    "tn, fp, fn, tp = confusion_matrix(y_true, y_pred).ravel()\n",
    "acc = round((tp + tn) * 1. / (tp + fp + tn + fn),3)\n",
    "precision = round(tp*1./(tp+fp),3)\n",
    "recall = round(tp*1./(tp+fn),3)\n",
    "f1=round(2*(precision*recall)/(precision+recall),3)\n",
    "\n",
    "print('\\t'.join(list(map(str,[precision,recall,f1,acc])))+'\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "id": "strange-glance",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-03T16:54:55.877347Z",
     "start_time": "2021-11-03T16:54:55.875442Z"
    }
   },
   "outputs": [],
   "source": [
    "#quantile98: 0.719\t0.675\t0.696\t0.706\n",
    "#quantile95: 0.763\t0.754\t0.758\t0.760\n",
    "#quantile99: 0.657\t0.585\t0.619\t0.639\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "dominant-masters",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-03T16:59:44.579563Z",
     "start_time": "2021-11-03T16:59:43.269808Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x72 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x72 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x72 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "only use target genes, test data\n"
     ]
    }
   ],
   "source": [
    "c=np.load('C_ij.npy')\n",
    "c=c.reshape(c.shape[0],c.shape[1],32,73)\n",
    "c=np.sum(c,axis=-1)\n",
    "c.shape\n",
    "\n",
    "num_classes=2\n",
    "phenotype = ['Healthy','ALS']\n",
    "pheno2coefficients={}\n",
    "count = {}\n",
    "for i in range(len(c)):\n",
    "    ind = int(y_test[i])     #phenotype\n",
    "    if ind in pheno2coefficients.keys():\n",
    "        pheno2coefficients[ind] = pheno2coefficients[ind] + c[i]   #sum of coupling coefficients for each phenotype\n",
    "        count[ind] = count[ind] + 1   #sample counts for each type   \n",
    "    else:\n",
    "        pheno2coefficients[ind] = c[i]\n",
    "        count[ind] = 1\n",
    "\n",
    "total = np.zeros((c.shape[1],c.shape[-1]))\n",
    "\n",
    "#type average coupling coefficients\n",
    "fs=12\n",
    "for i in range(num_classes):\n",
    "    average = pheno2coefficients[i]/count[i]   #sum/count = average\n",
    "    k = i + 1\n",
    "    plt.figure(figsize=(8,1))\n",
    "    plt.title(phenotype[i],fontsize=fs+1)\n",
    "    total[i] = average[i]\n",
    "    df = pd.DataFrame(np.asmatrix(average),columns=list(range(1,c.shape[-1]+1)))\n",
    "    heatmap = sns.heatmap(df,yticklabels=phenotype,linewidths=.1,cmap=cmap)\n",
    "    plt.ylabel('PhenoCaps', fontsize=fs)\n",
    "    plt.xlabel('PrimaryCaps', fontsize=fs)\n",
    "plt.show()\n",
    "\n",
    "#overall heatmap\n",
    "plt.figure(figsize=(8,1))\n",
    "df = pd.DataFrame(np.asmatrix(total),index=phenotype,columns=list(range(1,c.shape[-1]+1)))\n",
    "ax = sns.heatmap(df,linewidths=.1,cmap=cmap)\n",
    "plt.title('Test data (core genes)',fontsize=fs+1)#for both healthy and ALS\n",
    "plt.ylabel('PhenoCaps', fontsize=fs)\n",
    "plt.xlabel('PrimaryCaps', fontsize=fs)\n",
    "plt.savefig('capsule_test.core_genes.cc_heatmap.png',dpi=400,bbox_inches='tight') \n",
    "plt.show()\n",
    "\n",
    "print(\"only use target genes, test data\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "exciting-extension",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-03T16:59:44.584573Z",
     "start_time": "2021-11-03T16:59:44.581235Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.03125"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1/32"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "jewish-memorabilia",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-03T16:59:57.714507Z",
     "start_time": "2021-11-03T16:59:49.560684Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/export/scratch1/home/vincent/software/miniconda3/envs/gpu/lib/python3.7/site-packages/ipykernel_launcher.py:39: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
      "/export/scratch1/home/vincent/software/miniconda3/envs/gpu/lib/python3.7/site-packages/ipykernel_launcher.py:74: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x72 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "X2=X2.reshape(X2.shape[0],1,1,X2.shape[1])\n",
    "X2.shape\n",
    "\n",
    "cmap='YlOrBr'\n",
    "phenotype = ['Healthy','ALS']\n",
    "#For both train and test data\n",
    "c=compute_average_cij_for_traindata(X2,Y) \n",
    "c.shape\n",
    "fs=12\n",
    "\n",
    "#overall heatmap\n",
    "plt.figure(figsize=(8,1))\n",
    "df = pd.DataFrame(np.asmatrix(c),index=phenotype,columns=list(range(1,c.shape[-1]+1)))\n",
    "ax = sns.heatmap(df,linewidths=.1,cmap=cmap)\n",
    "plt.title('Train & Test Data, Overall',fontsize=fs+1)\n",
    "plt.ylabel('PhenoCaps', fontsize=fs)\n",
    "plt.xlabel('PrimaryCaps', fontsize=fs)\n",
    "plt.show()\n",
    "\n",
    "print();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "amazing-norman",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "universal-plate",
   "metadata": {},
   "source": [
    "# only feed randomly chosen k genes into capsule network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "cosmetic-taylor",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-03T13:36:17.575684Z",
     "start_time": "2021-11-03T13:17:29.135192Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/export/scratch1/home/vincent/software/miniconda3/envs/gpu/lib/python3.7/site-packages/ipykernel_launcher.py:39: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
      "/export/scratch1/home/vincent/software/miniconda3/envs/gpu/lib/python3.7/site-packages/ipykernel_launcher.py:74: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
     ]
    }
   ],
   "source": [
    "res_rand_kgenes=[]\n",
    "# num_genes=[50,69,100,118,300,500] #69,118 for acc>0.5 recall>0 genes\n",
    "# num_genes=[69,118] #69,118 for acc>0.5 recall>0 genes\n",
    "num_genes=[922] #95th percentile\n",
    "for k in num_genes:\n",
    "    # k=100 #number of randomly chosen genes\n",
    "    for _ in range(1000):\n",
    "        target_genes={}\n",
    "        all_input_genes=[]\n",
    "        with open('all_input.genes') as fr:\n",
    "            for line in fr:\n",
    "                all_input_genes.append(line.strip())\n",
    "\n",
    "        random.shuffle(all_input_genes)\n",
    "        target_genes={gene:1 for gene in random.sample(all_input_genes,k)}\n",
    "        # len(target_genes)\n",
    "\n",
    "        # test dataset\n",
    "        te_idx = [int(line.strip()) for line in open(\"../test.idx\", 'r')]\n",
    "\n",
    "        x_test=X.iloc[te_idx]\n",
    "        x_test=np.array(x_test)\n",
    "\n",
    "        for i in range(X.shape[1]):\n",
    "            if X.columns[i].split(':')[1] not in target_genes: #there are some duplicated genes located on different chrs\n",
    "        #         x_test.iloc[:,i]=0. #replace in dataframe is very slow\n",
    "                x_test[:,i]=0.\n",
    "\n",
    "        x_test=x_test.reshape(x_test.shape[0],1,1,x_test.shape[1])\n",
    "\n",
    "        in_test=Variable(torch.tensor(x_test).to(device))\n",
    "        y_pred = model(in_test).detach().cpu().numpy()\n",
    "\n",
    "        y_pred = np.argmax(y_pred, axis=1)\n",
    "        y_true = y_test\n",
    "\n",
    "\n",
    "        tn, fp, fn, tp = confusion_matrix(y_true, y_pred).ravel()\n",
    "        acc = round((tp + tn) * 1. / (tp + fp + tn + fn),3)\n",
    "        precision = round(tp*1./(tp+fp),3)\n",
    "        recall = round(tp*1./(tp+fn),3)\n",
    "        f1=round(2*(precision*recall)/(precision+recall),3)\n",
    "\n",
    "    #     print('\\t'.join(list(map(str,[precision,recall,f1,acc])))+'\\n')\n",
    "        res_rand_kgenes.append([k,precision,recall,f1,acc])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "equipped-cancer",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-03T13:36:17.628968Z",
     "start_time": "2021-11-03T13:36:17.577592Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>numOfGenes</th>\n",
       "      <th>precision</th>\n",
       "      <th>recall</th>\n",
       "      <th>f1</th>\n",
       "      <th>accuracy</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>922</td>\n",
       "      <td>0.766</td>\n",
       "      <td>0.604</td>\n",
       "      <td>0.675</td>\n",
       "      <td>0.710</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>922</td>\n",
       "      <td>0.766</td>\n",
       "      <td>0.579</td>\n",
       "      <td>0.660</td>\n",
       "      <td>0.701</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>922</td>\n",
       "      <td>0.771</td>\n",
       "      <td>0.660</td>\n",
       "      <td>0.711</td>\n",
       "      <td>0.732</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>922</td>\n",
       "      <td>0.758</td>\n",
       "      <td>0.585</td>\n",
       "      <td>0.660</td>\n",
       "      <td>0.699</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   numOfGenes  precision  recall     f1  accuracy\n",
       "0         922      0.766   0.604  0.675     0.710\n",
       "1         922      0.766   0.579  0.660     0.701\n",
       "2         922      0.771   0.660  0.711     0.732\n",
       "3         922      0.758   0.585  0.660     0.699"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res_rand_kgenes=pd.DataFrame(res_rand_kgenes,columns=['numOfGenes','precision','recall','f1','accuracy'])\n",
    "res_rand_kgenes[:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "every-interaction",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-03T15:25:23.696422Z",
     "start_time": "2021-11-03T15:25:22.735505Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7f567d375e90>"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.lines.Line2D at 0x7f567d2c8c50>"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "Text(0.5, 0, 'Test accuracy (random genes)')"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Density')"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "sns.distplot(res_rand_kgenes['accuracy'])\n",
    "plt.axvline(x=0.76,color='red', linestyle='dashed')\n",
    "plt.xlabel('Test accuracy (random genes)',fontsize=12)\n",
    "plt.ylabel('Density',fontsize=12)\n",
    "\n",
    "plt.savefig('random_genes.accuray_dist.png',dpi=400,bbox_inches='tight') #bbox_inches='tight' ,keep all elements in fig\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "religious-boulder",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-03T14:23:10.042382Z",
     "start_time": "2021-11-03T14:23:09.770759Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>precision</th>\n",
       "      <th>recall</th>\n",
       "      <th>f1</th>\n",
       "      <th>accuracy</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>numOfGenes</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>922</th>\n",
       "      <td>0.74708</td>\n",
       "      <td>0.6119</td>\n",
       "      <td>0.67259</td>\n",
       "      <td>0.702284</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            precision  recall       f1  accuracy\n",
       "numOfGenes                                      \n",
       "922           0.74708  0.6119  0.67259  0.702284"
      ]
     },
     "execution_count": 41,
     "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>precision</th>\n",
       "      <th>recall</th>\n",
       "      <th>f1</th>\n",
       "      <th>accuracy</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>numOfGenes</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>922</th>\n",
       "      <td>0.799</td>\n",
       "      <td>0.679</td>\n",
       "      <td>0.719</td>\n",
       "      <td>0.741</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            precision  recall     f1  accuracy\n",
       "numOfGenes                                    \n",
       "922             0.799   0.679  0.719     0.741"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res_rand_kgenes.groupby('numOfGenes').mean()\n",
    "res_rand_kgenes.groupby('numOfGenes').max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "cardiac-statistics",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-03T14:23:26.960361Z",
     "start_time": "2021-11-03T14:23:26.934355Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>precision</th>\n",
       "      <th>recall</th>\n",
       "      <th>f1</th>\n",
       "      <th>accuracy</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>numOfGenes</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>922</th>\n",
       "      <td>0.74708</td>\n",
       "      <td>0.6119</td>\n",
       "      <td>0.67259</td>\n",
       "      <td>0.702284</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            precision  recall       f1  accuracy\n",
       "numOfGenes                                      \n",
       "922           0.74708  0.6119  0.67259  0.702284"
      ]
     },
     "execution_count": 42,
     "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>precision</th>\n",
       "      <th>recall</th>\n",
       "      <th>f1</th>\n",
       "      <th>accuracy</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>numOfGenes</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>922</th>\n",
       "      <td>0.016167</td>\n",
       "      <td>0.019846</td>\n",
       "      <td>0.0156</td>\n",
       "      <td>0.012743</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            precision    recall      f1  accuracy\n",
       "numOfGenes                                       \n",
       "922          0.016167  0.019846  0.0156  0.012743"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res_rand_kgenes.groupby('numOfGenes').mean()\n",
    "res_rand_kgenes.groupby('numOfGenes').std()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dressed-marketing",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "328.675px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}