test_step1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "from torch import nn\n",
    "from torch.utils.data import DataLoader\n",
    "import torch.optim as optim\n",
    "from torch.optim import lr_scheduler\n",
    "from torchvision import transforms, models\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import roc_curve, auc, roc_auc_score, confusion_matrix\n",
    "from sklearn.manifold import TSNE\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.colors import ListedColormap\n",
    "import pickle\n",
    "import os\n",
    "import math\n",
    "import random\n",
    "from torchsummary import summary\n",
    "\n",
    "from dataset import PEDataset\n",
    "from utils import Timer, AverageMeter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Hyperparameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "load_model = 'new/r3d_18_chunk10_batch16_new_splits/epoch9.pth'\n",
    "feature_dir = 'test/features/new/r3d_18_chunk10_batch16_epoch10_new_splits'\n",
    "gpu = 5\n",
    "pos_weight = 1.\n",
    "batch_size = 1\n",
    "chunk_size = 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Splits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test 1000\n"
     ]
    }
   ],
   "source": [
    "with open('data/data_splits.pkl', 'rb') as f:\n",
    "    data_splits = pickle.load(f)\n",
    "\n",
    "test_paths = data_splits['test_paths']\n",
    "print(\"test {}\".format(len(test_paths)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1000/1000 [00:00<00:00, 1196.47it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step 1 test exams: 1000\n",
      "step 1 test chunks: 26836\n",
      "step 1 test loader iters: 26836\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "transform_test = transforms.Compose([\n",
    "        transforms.ToTensor(),\n",
    "        transforms.Resize((192, 192)),\n",
    "    ])\n",
    "\n",
    "test_set_s1 = PEDataset(paths=test_paths, mode='test', chunk_size=chunk_size,\n",
    "                        transform=transform_test)\n",
    "\n",
    "print(\"step 1 test exams: {}\".format(test_set_s1.get_num_exams()))\n",
    "print(\"step 1 test chunks: {}\".format(len(test_set_s1)))\n",
    "\n",
    "test_loader_s1 = DataLoader(test_set_s1, batch_size=1, shuffle=False)\n",
    "print(\"step 1 test loader iters: {}\".format(len(test_loader_s1)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Use cuda 5\n",
      "\n",
      "model:\n",
      "----------------------------------------------------------------\n",
      "        Layer (type)               Output Shape         Param #\n",
      "================================================================\n",
      "            Conv3d-1        [1, 64, 10, 96, 96]          28,224\n",
      "       BatchNorm3d-2        [1, 64, 10, 96, 96]             128\n",
      "              ReLU-3        [1, 64, 10, 96, 96]               0\n",
      "      Conv3DSimple-4        [1, 64, 10, 96, 96]         110,592\n",
      "       BatchNorm3d-5        [1, 64, 10, 96, 96]             128\n",
      "              ReLU-6        [1, 64, 10, 96, 96]               0\n",
      "      Conv3DSimple-7        [1, 64, 10, 96, 96]         110,592\n",
      "       BatchNorm3d-8        [1, 64, 10, 96, 96]             128\n",
      "              ReLU-9        [1, 64, 10, 96, 96]               0\n",
      "       BasicBlock-10        [1, 64, 10, 96, 96]               0\n",
      "     Conv3DSimple-11        [1, 64, 10, 96, 96]         110,592\n",
      "      BatchNorm3d-12        [1, 64, 10, 96, 96]             128\n",
      "             ReLU-13        [1, 64, 10, 96, 96]               0\n",
      "     Conv3DSimple-14        [1, 64, 10, 96, 96]         110,592\n",
      "      BatchNorm3d-15        [1, 64, 10, 96, 96]             128\n",
      "             ReLU-16        [1, 64, 10, 96, 96]               0\n",
      "       BasicBlock-17        [1, 64, 10, 96, 96]               0\n",
      "     Conv3DSimple-18        [1, 128, 5, 48, 48]         221,184\n",
      "      BatchNorm3d-19        [1, 128, 5, 48, 48]             256\n",
      "             ReLU-20        [1, 128, 5, 48, 48]               0\n",
      "     Conv3DSimple-21        [1, 128, 5, 48, 48]         442,368\n",
      "      BatchNorm3d-22        [1, 128, 5, 48, 48]             256\n",
      "           Conv3d-23        [1, 128, 5, 48, 48]           8,192\n",
      "      BatchNorm3d-24        [1, 128, 5, 48, 48]             256\n",
      "             ReLU-25        [1, 128, 5, 48, 48]               0\n",
      "       BasicBlock-26        [1, 128, 5, 48, 48]               0\n",
      "     Conv3DSimple-27        [1, 128, 5, 48, 48]         442,368\n",
      "      BatchNorm3d-28        [1, 128, 5, 48, 48]             256\n",
      "             ReLU-29        [1, 128, 5, 48, 48]               0\n",
      "     Conv3DSimple-30        [1, 128, 5, 48, 48]         442,368\n",
      "      BatchNorm3d-31        [1, 128, 5, 48, 48]             256\n",
      "             ReLU-32        [1, 128, 5, 48, 48]               0\n",
      "       BasicBlock-33        [1, 128, 5, 48, 48]               0\n",
      "     Conv3DSimple-34        [1, 256, 3, 24, 24]         884,736\n",
      "      BatchNorm3d-35        [1, 256, 3, 24, 24]             512\n",
      "             ReLU-36        [1, 256, 3, 24, 24]               0\n",
      "     Conv3DSimple-37        [1, 256, 3, 24, 24]       1,769,472\n",
      "      BatchNorm3d-38        [1, 256, 3, 24, 24]             512\n",
      "           Conv3d-39        [1, 256, 3, 24, 24]          32,768\n",
      "      BatchNorm3d-40        [1, 256, 3, 24, 24]             512\n",
      "             ReLU-41        [1, 256, 3, 24, 24]               0\n",
      "       BasicBlock-42        [1, 256, 3, 24, 24]               0\n",
      "     Conv3DSimple-43        [1, 256, 3, 24, 24]       1,769,472\n",
      "      BatchNorm3d-44        [1, 256, 3, 24, 24]             512\n",
      "             ReLU-45        [1, 256, 3, 24, 24]               0\n",
      "     Conv3DSimple-46        [1, 256, 3, 24, 24]       1,769,472\n",
      "      BatchNorm3d-47        [1, 256, 3, 24, 24]             512\n",
      "             ReLU-48        [1, 256, 3, 24, 24]               0\n",
      "       BasicBlock-49        [1, 256, 3, 24, 24]               0\n",
      "     Conv3DSimple-50        [1, 512, 2, 12, 12]       3,538,944\n",
      "      BatchNorm3d-51        [1, 512, 2, 12, 12]           1,024\n",
      "             ReLU-52        [1, 512, 2, 12, 12]               0\n",
      "     Conv3DSimple-53        [1, 512, 2, 12, 12]       7,077,888\n",
      "      BatchNorm3d-54        [1, 512, 2, 12, 12]           1,024\n",
      "           Conv3d-55        [1, 512, 2, 12, 12]         131,072\n",
      "      BatchNorm3d-56        [1, 512, 2, 12, 12]           1,024\n",
      "             ReLU-57        [1, 512, 2, 12, 12]               0\n",
      "       BasicBlock-58        [1, 512, 2, 12, 12]               0\n",
      "     Conv3DSimple-59        [1, 512, 2, 12, 12]       7,077,888\n",
      "      BatchNorm3d-60        [1, 512, 2, 12, 12]           1,024\n",
      "             ReLU-61        [1, 512, 2, 12, 12]               0\n",
      "     Conv3DSimple-62        [1, 512, 2, 12, 12]       7,077,888\n",
      "      BatchNorm3d-63        [1, 512, 2, 12, 12]           1,024\n",
      "             ReLU-64        [1, 512, 2, 12, 12]               0\n",
      "       BasicBlock-65        [1, 512, 2, 12, 12]               0\n",
      "AdaptiveAvgPool3d-66          [1, 512, 1, 1, 1]               0\n",
      "           Linear-67                     [1, 1]             513\n",
      "      VideoResNet-68                     [1, 1]               0\n",
      "================================================================\n",
      "Total params: 33,166,785\n",
      "Trainable params: 33,166,785\n",
      "Non-trainable params: 0\n",
      "----------------------------------------------------------------\n",
      "Input size (MB): 4.22\n",
      "Forward/backward pass size (MB): 1017.00\n",
      "Params size (MB): 126.52\n",
      "Estimated Total Size (MB): 1147.74\n",
      "----------------------------------------------------------------\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "if load_model == '':\n",
    "    model = models.video.r3d_18(pretrained=True)\n",
    "    num_features = model.fc.in_features\n",
    "    model.fc = nn.Linear(num_features, 1)\n",
    "else:\n",
    "    model = models.video.r3d_18(pretrained=False)\n",
    "    num_features = model.fc.in_features\n",
    "    model.fc = nn.Linear(num_features, 1)\n",
    "    model.load_state_dict(torch.load(\"weights/\"+load_model))\n",
    "\n",
    "criterion = nn.BCEWithLogitsLoss(pos_weight=torch.tensor([pos_weight]))\n",
    "\n",
    "print('')\n",
    "print(\"Use cuda \" + str(gpu))\n",
    "print('')\n",
    "device = torch.device(\"cuda:\"+str(gpu) if torch.cuda.is_available() else \"cpu\")\n",
    "torch.cuda.empty_cache()\n",
    "model.to(device)\n",
    "criterion.to(device)\n",
    "print(\"model:\")\n",
    "summary(model, input_size=(3, 10, 192, 192), batch_size=batch_size, device=device)\n",
    "print('')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100 iters evaluated | time: 36.83\n",
      "200 iters evaluated | time: 34.15\n",
      "300 iters evaluated | time: 42.79\n",
      "400 iters evaluated | time: 47.26\n",
      "500 iters evaluated | time: 51.01\n",
      "600 iters evaluated | time: 56.37\n",
      "700 iters evaluated | time: 52.95\n",
      "800 iters evaluated | time: 56.61\n",
      "900 iters evaluated | time: 49.64\n",
      "1000 iters evaluated | time: 60.15\n",
      "1100 iters evaluated | time: 62.38\n",
      "1200 iters evaluated | time: 66.60\n",
      "1300 iters evaluated | time: 64.20\n",
      "1400 iters evaluated | time: 65.34\n",
      "1500 iters evaluated | time: 64.12\n",
      "1600 iters evaluated | time: 65.80\n",
      "1700 iters evaluated | time: 67.69\n",
      "1800 iters evaluated | time: 68.10\n",
      "1900 iters evaluated | time: 68.69\n",
      "2000 iters evaluated | time: 69.31\n",
      "2100 iters evaluated | time: 68.97\n",
      "2200 iters evaluated | time: 66.82\n",
      "2300 iters evaluated | time: 64.80\n",
      "2400 iters evaluated | time: 66.33\n",
      "2500 iters evaluated | time: 63.55\n",
      "2600 iters evaluated | time: 64.20\n",
      "2700 iters evaluated | time: 68.92\n",
      "2800 iters evaluated | time: 66.62\n",
      "2900 iters evaluated | time: 65.39\n",
      "3000 iters evaluated | time: 62.04\n",
      "3100 iters evaluated | time: 60.65\n",
      "3200 iters evaluated | time: 65.75\n",
      "3300 iters evaluated | time: 61.42\n",
      "3400 iters evaluated | time: 68.64\n",
      "3500 iters evaluated | time: 67.24\n",
      "3600 iters evaluated | time: 67.66\n",
      "3700 iters evaluated | time: 67.39\n",
      "3800 iters evaluated | time: 66.96\n",
      "3900 iters evaluated | time: 67.68\n",
      "4000 iters evaluated | time: 34.95\n",
      "4100 iters evaluated | time: 5.48\n",
      "4200 iters evaluated | time: 3.89\n",
      "4300 iters evaluated | time: 4.20\n",
      "4400 iters evaluated | time: 3.51\n",
      "4500 iters evaluated | time: 3.58\n",
      "4600 iters evaluated | time: 3.45\n",
      "4700 iters evaluated | time: 3.43\n",
      "4800 iters evaluated | time: 3.33\n",
      "4900 iters evaluated | time: 3.38\n",
      "5000 iters evaluated | time: 2.92\n",
      "5100 iters evaluated | time: 3.29\n",
      "5200 iters evaluated | time: 3.07\n",
      "5300 iters evaluated | time: 3.83\n",
      "5400 iters evaluated | time: 3.40\n",
      "5500 iters evaluated | time: 3.06\n",
      "5600 iters evaluated | time: 3.20\n",
      "5700 iters evaluated | time: 3.24\n",
      "5800 iters evaluated | time: 3.13\n",
      "5900 iters evaluated | time: 2.82\n",
      "6000 iters evaluated | time: 3.25\n",
      "6100 iters evaluated | time: 5.61\n",
      "6200 iters evaluated | time: 3.66\n",
      "6300 iters evaluated | time: 3.55\n",
      "6400 iters evaluated | time: 3.62\n",
      "6500 iters evaluated | time: 3.28\n",
      "6600 iters evaluated | time: 4.97\n",
      "6700 iters evaluated | time: 3.97\n",
      "6800 iters evaluated | time: 4.29\n",
      "6900 iters evaluated | time: 5.04\n",
      "7000 iters evaluated | time: 3.58\n",
      "7100 iters evaluated | time: 3.82\n",
      "7200 iters evaluated | time: 2.93\n",
      "7300 iters evaluated | time: 4.95\n",
      "7400 iters evaluated | time: 7.92\n",
      "7500 iters evaluated | time: 62.71\n",
      "7600 iters evaluated | time: 63.28\n",
      "7700 iters evaluated | time: 65.52\n",
      "7800 iters evaluated | time: 68.66\n",
      "7900 iters evaluated | time: 66.77\n",
      "8000 iters evaluated | time: 21.01\n",
      "8100 iters evaluated | time: 4.49\n",
      "8200 iters evaluated | time: 52.77\n",
      "8300 iters evaluated | time: 64.82\n",
      "8400 iters evaluated | time: 66.43\n",
      "8500 iters evaluated | time: 68.24\n",
      "8600 iters evaluated | time: 56.58\n",
      "8700 iters evaluated | time: 65.93\n",
      "8800 iters evaluated | time: 67.60\n",
      "8900 iters evaluated | time: 68.77\n",
      "9000 iters evaluated | time: 65.10\n",
      "9100 iters evaluated | time: 66.60\n",
      "9200 iters evaluated | time: 65.90\n",
      "9300 iters evaluated | time: 66.14\n",
      "9400 iters evaluated | time: 63.91\n",
      "9500 iters evaluated | time: 67.80\n",
      "9600 iters evaluated | time: 67.38\n",
      "9700 iters evaluated | time: 68.09\n",
      "9800 iters evaluated | time: 69.15\n",
      "9900 iters evaluated | time: 67.48\n",
      "10000 iters evaluated | time: 65.03\n",
      "10100 iters evaluated | time: 68.13\n",
      "10200 iters evaluated | time: 69.33\n",
      "10300 iters evaluated | time: 62.11\n",
      "10400 iters evaluated | time: 64.97\n",
      "10500 iters evaluated | time: 67.72\n",
      "10600 iters evaluated | time: 66.89\n",
      "10700 iters evaluated | time: 69.78\n",
      "10800 iters evaluated | time: 67.72\n",
      "10900 iters evaluated | time: 67.34\n",
      "11000 iters evaluated | time: 64.49\n",
      "11100 iters evaluated | time: 63.96\n",
      "11200 iters evaluated | time: 63.26\n",
      "11300 iters evaluated | time: 8.93\n",
      "11400 iters evaluated | time: 2.97\n",
      "11500 iters evaluated | time: 3.04\n",
      "11600 iters evaluated | time: 2.81\n",
      "11700 iters evaluated | time: 3.05\n",
      "11800 iters evaluated | time: 2.82\n",
      "11900 iters evaluated | time: 2.94\n",
      "12000 iters evaluated | time: 2.71\n",
      "12100 iters evaluated | time: 2.92\n",
      "12200 iters evaluated | time: 2.73\n",
      "12300 iters evaluated | time: 2.94\n",
      "12400 iters evaluated | time: 2.83\n",
      "12500 iters evaluated | time: 2.62\n",
      "12600 iters evaluated | time: 2.53\n",
      "12700 iters evaluated | time: 2.59\n",
      "12800 iters evaluated | time: 3.09\n",
      "12900 iters evaluated | time: 2.48\n",
      "13000 iters evaluated | time: 2.67\n",
      "13100 iters evaluated | time: 3.02\n",
      "13200 iters evaluated | time: 2.92\n",
      "13300 iters evaluated | time: 2.89\n",
      "13400 iters evaluated | time: 2.96\n",
      "13500 iters evaluated | time: 2.95\n",
      "13600 iters evaluated | time: 3.26\n",
      "13700 iters evaluated | time: 2.85\n",
      "13800 iters evaluated | time: 2.64\n",
      "13900 iters evaluated | time: 2.73\n",
      "14000 iters evaluated | time: 2.94\n",
      "14100 iters evaluated | time: 2.70\n",
      "14200 iters evaluated | time: 2.98\n",
      "14300 iters evaluated | time: 3.04\n",
      "14400 iters evaluated | time: 2.69\n",
      "14500 iters evaluated | time: 3.25\n",
      "14600 iters evaluated | time: 3.19\n",
      "14700 iters evaluated | time: 2.87\n",
      "14800 iters evaluated | time: 2.99\n",
      "14900 iters evaluated | time: 2.94\n",
      "15000 iters evaluated | time: 2.68\n",
      "15100 iters evaluated | time: 3.12\n",
      "15200 iters evaluated | time: 3.21\n",
      "15300 iters evaluated | time: 3.01\n",
      "15400 iters evaluated | time: 3.17\n",
      "15500 iters evaluated | time: 3.22\n",
      "15600 iters evaluated | time: 2.74\n",
      "15700 iters evaluated | time: 2.66\n",
      "15800 iters evaluated | time: 2.77\n",
      "15900 iters evaluated | time: 3.04\n",
      "16000 iters evaluated | time: 2.74\n",
      "16100 iters evaluated | time: 2.70\n",
      "16200 iters evaluated | time: 2.71\n",
      "16300 iters evaluated | time: 3.03\n",
      "16400 iters evaluated | time: 2.97\n",
      "16500 iters evaluated | time: 3.16\n",
      "16600 iters evaluated | time: 2.89\n",
      "16700 iters evaluated | time: 3.04\n",
      "16800 iters evaluated | time: 3.20\n",
      "16900 iters evaluated | time: 2.72\n",
      "17000 iters evaluated | time: 2.75\n",
      "17100 iters evaluated | time: 2.97\n",
      "17200 iters evaluated | time: 2.95\n",
      "17300 iters evaluated | time: 2.91\n",
      "17400 iters evaluated | time: 2.76\n",
      "17500 iters evaluated | time: 3.06\n",
      "17600 iters evaluated | time: 2.85\n",
      "17700 iters evaluated | time: 2.83\n",
      "17800 iters evaluated | time: 2.84\n",
      "17900 iters evaluated | time: 2.78\n",
      "18000 iters evaluated | time: 2.77\n",
      "18100 iters evaluated | time: 2.90\n",
      "18200 iters evaluated | time: 3.06\n",
      "18300 iters evaluated | time: 2.58\n",
      "18400 iters evaluated | time: 2.49\n",
      "18500 iters evaluated | time: 2.79\n",
      "18600 iters evaluated | time: 2.75\n",
      "18700 iters evaluated | time: 2.72\n",
      "18800 iters evaluated | time: 2.86\n",
      "18900 iters evaluated | time: 2.98\n",
      "19000 iters evaluated | time: 2.84\n",
      "19100 iters evaluated | time: 2.76\n",
      "19200 iters evaluated | time: 2.85\n",
      "19300 iters evaluated | time: 2.81\n",
      "19400 iters evaluated | time: 2.87\n",
      "19500 iters evaluated | time: 2.87\n",
      "19600 iters evaluated | time: 2.68\n",
      "19700 iters evaluated | time: 2.69\n",
      "19800 iters evaluated | time: 3.01\n",
      "19900 iters evaluated | time: 2.73\n",
      "20000 iters evaluated | time: 2.88\n",
      "20100 iters evaluated | time: 3.13\n",
      "20200 iters evaluated | time: 3.19\n",
      "20300 iters evaluated | time: 3.26\n",
      "20400 iters evaluated | time: 4.36\n",
      "20500 iters evaluated | time: 5.28\n",
      "20600 iters evaluated | time: 5.51\n",
      "20700 iters evaluated | time: 4.20\n",
      "20800 iters evaluated | time: 4.38\n",
      "20900 iters evaluated | time: 5.00\n",
      "21000 iters evaluated | time: 5.09\n",
      "21100 iters evaluated | time: 5.21\n",
      "21200 iters evaluated | time: 5.27\n",
      "21300 iters evaluated | time: 4.31\n",
      "21400 iters evaluated | time: 4.64\n",
      "21500 iters evaluated | time: 4.66\n",
      "21600 iters evaluated | time: 5.69\n",
      "21700 iters evaluated | time: 4.42\n",
      "21800 iters evaluated | time: 4.65\n",
      "21900 iters evaluated | time: 5.42\n",
      "22000 iters evaluated | time: 5.02\n",
      "22100 iters evaluated | time: 5.22\n",
      "22200 iters evaluated | time: 6.88\n",
      "22300 iters evaluated | time: 8.53\n",
      "22400 iters evaluated | time: 6.18\n",
      "22500 iters evaluated | time: 4.10\n",
      "22600 iters evaluated | time: 5.25\n",
      "22700 iters evaluated | time: 5.45\n",
      "22800 iters evaluated | time: 6.54\n",
      "22900 iters evaluated | time: 4.69\n",
      "23000 iters evaluated | time: 4.68\n",
      "23100 iters evaluated | time: 4.75\n",
      "23200 iters evaluated | time: 4.22\n",
      "23300 iters evaluated | time: 4.76\n",
      "23400 iters evaluated | time: 4.55\n",
      "23500 iters evaluated | time: 5.25\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "23600 iters evaluated | time: 4.10\n",
      "23700 iters evaluated | time: 4.84\n",
      "23800 iters evaluated | time: 5.07\n",
      "23900 iters evaluated | time: 4.35\n",
      "24000 iters evaluated | time: 5.98\n",
      "24100 iters evaluated | time: 5.62\n",
      "24200 iters evaluated | time: 3.65\n",
      "24300 iters evaluated | time: 4.66\n",
      "24400 iters evaluated | time: 5.16\n",
      "24500 iters evaluated | time: 4.42\n",
      "24600 iters evaluated | time: 4.29\n",
      "24700 iters evaluated | time: 4.31\n",
      "24800 iters evaluated | time: 6.86\n",
      "24900 iters evaluated | time: 4.12\n",
      "25000 iters evaluated | time: 3.65\n",
      "25100 iters evaluated | time: 4.84\n",
      "25200 iters evaluated | time: 6.38\n",
      "25300 iters evaluated | time: 5.34\n",
      "25400 iters evaluated | time: 5.15\n",
      "25500 iters evaluated | time: 5.80\n",
      "25600 iters evaluated | time: 3.46\n",
      "25700 iters evaluated | time: 5.40\n",
      "25800 iters evaluated | time: 5.77\n",
      "25900 iters evaluated | time: 6.92\n",
      "26000 iters evaluated | time: 4.72\n",
      "26100 iters evaluated | time: 5.14\n",
      "26200 iters evaluated | time: 4.71\n",
      "26300 iters evaluated | time: 4.52\n",
      "26400 iters evaluated | time: 4.82\n",
      "26500 iters evaluated | time: 7.23\n",
      "26600 iters evaluated | time: 4.91\n",
      "26700 iters evaluated | time: 4.74\n",
      "26800 iters evaluated | time: 4.72\n",
      "Loss 0.1502 | Acc 0.9528 | AUC 0.9134\n"
     ]
    }
   ],
   "source": [
    "timer = Timer()\n",
    "\n",
    "model.eval()\n",
    "\n",
    "running_loss = 0.0\n",
    "running_corrects = 0\n",
    "total_samples = 0\n",
    "y_trues = []\n",
    "y_scores = []\n",
    "\n",
    "timer.start()\n",
    "\n",
    "for batch, (inputs, labels) in enumerate(test_loader_s1):\n",
    "    inputs = inputs.to(device)\n",
    "    labels = labels.to(device)\n",
    "\n",
    "    with torch.no_grad():\n",
    "        logit = model(inputs)\n",
    "        loss = criterion(logit.squeeze(-1), labels)\n",
    "\n",
    "        pred_probs = logit.detach().squeeze(-1).sigmoid().cpu().numpy()\n",
    "        running_loss += loss.item() * inputs.size(0)\n",
    "        running_corrects += sum((pred_probs >= 0.5) == labels.cpu().numpy())\n",
    "        total_samples += inputs.size(0)\n",
    "        y_trues.extend(labels.cpu().numpy())\n",
    "        y_scores.extend(pred_probs)\n",
    "\n",
    "    # report loss, accuracy, and AUC every 100 iterations\n",
    "    if batch % 100 == 99:\n",
    "        print('{} iters evaluated | time: {:.2f}'.format(batch+1, timer.stop()))\n",
    "        timer.start()\n",
    "\n",
    "timer.stop()\n",
    "\n",
    "# report epoch loss, accuracy, and AUC\n",
    "test_loss = running_loss / total_samples\n",
    "test_acc = running_corrects / total_samples\n",
    "test_auc = roc_auc_score(y_trues, y_scores)\n",
    "print('Loss {:.4f} | Acc {:.4f} | AUC {:.4f}'.format(test_loss, test_acc, test_auc))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Select thresholds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "sensitivity = []\n",
    "specificity = []\n",
    "\n",
    "for threshold in np.linspace(0.0, 1.0, 21):\n",
    "    y_preds = (y_scores >= threshold) * 1.\n",
    "    tn, fp, fn, tp = confusion_matrix(y_trues, y_preds).ravel()\n",
    "    sensitivity.append(tp/(tp+fn))\n",
    "    specificity.append(tn/(tn+fp))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10,6))\n",
    "x = np.round(np.linspace(0.0, 1.0, 21), decimals=2)\n",
    "width = 0.4\n",
    "plt.bar(np.arange(len(x))-width/2, sensitivity, width=width, label='sensitivity')\n",
    "plt.bar(np.arange(len(x))+width/2, specificity, width=width, label='specificity')\n",
    "plt.xlabel('Probability threshold')\n",
    "plt.xticks(ticks=np.arange(len(x)), labels=x)\n",
    "plt.yticks(ticks=np.linspace(0., 1., 11))\n",
    "plt.legend(bbox_to_anchor=(0.23, 0.88))\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Draw ROC Plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Compute ROC curve and ROC area for each class\n",
    "fpr, tpr, _ = roc_curve(y_trues, y_scores)\n",
    "roc_auc = auc(fpr, tpr)\n",
    "\n",
    "plt.figure(figsize=(8, 6))\n",
    "lw = 2\n",
    "plt.plot(fpr, tpr, lw=lw, \n",
    "         label='area = {:0.2f}'.format(roc_auc))\n",
    "plt.plot([0, 1], [0, 1], lw=lw, linestyle='--')\n",
    "plt.xlim([0.0, 1.0])\n",
    "plt.ylim([0.0, 1.05])\n",
    "plt.xlabel('False Positive Rate')\n",
    "plt.ylabel('True Positive Rate')\n",
    "plt.title('Receiver operating characteristic')\n",
    "plt.legend(loc=\"lower right\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Draw t-SNE Plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(26836, 512)\n",
      "(26836,)\n"
     ]
    }
   ],
   "source": [
    "test_features = np.load(feature_dir+'/test_features.npy')\n",
    "print(test_features.shape)\n",
    "test_labels = np.load(feature_dir+'/test_labels.npy')\n",
    "print(test_labels.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "tsne = TSNE(n_components=2, perplexity=50, learning_rate=500, init='pca', verbose=1, random_state=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[t-SNE] Computing 151 nearest neighbors...\n",
      "[t-SNE] Indexed 26836 samples in 0.006s...\n",
      "[t-SNE] Computed neighbors for 26836 samples in 12.802s...\n",
      "[t-SNE] Computed conditional probabilities for sample 1000 / 26836\n",
      "[t-SNE] Computed conditional probabilities for sample 2000 / 26836\n",
      "[t-SNE] Computed conditional probabilities for sample 3000 / 26836\n",
      "[t-SNE] Computed conditional probabilities for sample 4000 / 26836\n",
      "[t-SNE] Computed conditional probabilities for sample 5000 / 26836\n",
      "[t-SNE] Computed conditional probabilities for sample 6000 / 26836\n",
      "[t-SNE] Computed conditional probabilities for sample 7000 / 26836\n",
      "[t-SNE] Computed conditional probabilities for sample 8000 / 26836\n",
      "[t-SNE] Computed conditional probabilities for sample 9000 / 26836\n",
      "[t-SNE] Computed conditional probabilities for sample 10000 / 26836\n",
      "[t-SNE] Computed conditional probabilities for sample 11000 / 26836\n",
      "[t-SNE] Computed conditional probabilities for sample 12000 / 26836\n",
      "[t-SNE] Computed conditional probabilities for sample 13000 / 26836\n",
      "[t-SNE] Computed conditional probabilities for sample 14000 / 26836\n",
      "[t-SNE] Computed conditional probabilities for sample 15000 / 26836\n",
      "[t-SNE] Computed conditional probabilities for sample 16000 / 26836\n",
      "[t-SNE] Computed conditional probabilities for sample 17000 / 26836\n",
      "[t-SNE] Computed conditional probabilities for sample 18000 / 26836\n",
      "[t-SNE] Computed conditional probabilities for sample 19000 / 26836\n",
      "[t-SNE] Computed conditional probabilities for sample 20000 / 26836\n",
      "[t-SNE] Computed conditional probabilities for sample 21000 / 26836\n",
      "[t-SNE] Computed conditional probabilities for sample 22000 / 26836\n",
      "[t-SNE] Computed conditional probabilities for sample 23000 / 26836\n",
      "[t-SNE] Computed conditional probabilities for sample 24000 / 26836\n",
      "[t-SNE] Computed conditional probabilities for sample 25000 / 26836\n",
      "[t-SNE] Computed conditional probabilities for sample 26000 / 26836\n",
      "[t-SNE] Computed conditional probabilities for sample 26836 / 26836\n",
      "[t-SNE] Mean sigma: 0.402564\n",
      "[t-SNE] KL divergence after 250 iterations with early exaggeration: 82.133652\n",
      "[t-SNE] KL divergence after 1000 iterations: 1.852433\n"
     ]
    }
   ],
   "source": [
    "test_features_embedded = tsne.fit_transform(test_features)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(26836, 2)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_features_embedded.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x324 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(6, 4.5))\n",
    "plt.scatter(test_features_embedded[test_labels==0][:, 0], \n",
    "            test_features_embedded[test_labels==0][:, 1], \n",
    "            s=3, alpha=0.5, label='Negative PE')\n",
    "plt.scatter(test_features_embedded[test_labels==1][:, 0], \n",
    "            test_features_embedded[test_labels==1][:, 1], \n",
    "            s=3, alpha=0.5, label='Positive PE')\n",
    "plt.xticks(ticks=[])\n",
    "plt.yticks(ticks=[])\n",
    "plt.legend(markerscale=4, loc='lower right')\n",
    "# plt.title('TSNE of Extracted Features', fontsize=12)\n",
    "plt.savefig('plot_tsne.jpg', dpi=300)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Calculate Manhattan distance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_features_tensor = torch.from_numpy(test_features).float().to('cuda:5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_features_embedded_tensor = torch.from_numpy(test_features_embedded).float().to('cuda:5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_labels_tensor = torch.from_numpy(test_labels).bool().to('cuda:5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "center_pos = test_features_tensor[test_labels_tensor].mean(dim=0, keepdim=True)\n",
    "distance_pos = torch.cdist(test_features_tensor[test_labels_tensor], center_pos, p=1).mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(70.1536, device='cuda:5')"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "distance_pos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "center_neg = test_features_tensor[~test_labels_tensor].mean(dim=0, keepdim=True)\n",
    "distance_neg = torch.cdist(test_features_tensor[~test_labels_tensor], center_neg, p=1).mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(75.7024, device='cuda:5')"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "distance_neg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "distance = torch.cdist(center_pos, center_neg, p=1).mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(97.2102, device='cuda:5')"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "distance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}