step03_EmbeddingModel-02_CV4.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# PyTorch Modules\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "import torch.optim as optim\n",
    "import torch.nn.functional as F\n",
    "\n",
    "import torchvision\n",
    "from torchvision import models\n",
    "from torchvision import transforms\n",
    "import torchvision.transforms as transforms\n",
    "import torchvision.datasets as dsets\n",
    "\n",
    "# Other non-PyTorch Modules\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "from tqdm import tqdm\n",
    "from matplotlib.pyplot import imshow\n",
    "import matplotlib.pylab as plt\n",
    "from PIL import Image\n",
    "import time\n",
    "from datetime import datetime\n",
    "import pickle\n",
    "import json\n",
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.cuda.empty_cache()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20201012_2232\n"
     ]
    }
   ],
   "source": [
    "now = datetime.now()\n",
    "DATESTRING = now.strftime(\"%Y%m%d_%H%M\")\n",
    "print(DATESTRING)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataDF = pd.read_csv('data_fold.csv')\n",
    "dataDF = dataDF.set_index('SOPInstanceUID')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['StudyInstanceUID', 'SeriesInstanceUID', 'pe_present_on_image',\n",
       "       'negative_exam_for_pe', 'qa_motion', 'qa_contrast', 'flow_artifact',\n",
       "       'rv_lv_ratio_gte_1', 'rv_lv_ratio_lt_1', 'leftsided_pe', 'chronic_pe',\n",
       "       'true_filling_defect_not_pe', 'rightsided_pe', 'acute_and_chronic_pe',\n",
       "       'central_pe', 'indeterminate', 'window_center', 'window_width',\n",
       "       'intercept', 'slope', 'slice_thickness', 'kvp', 'ma', 'exposure',\n",
       "       'img_pos', 'conv_kernel', 'patient_position', 'pixel_spacing',\n",
       "       'bits_stored', 'high_bit', 'img_count', 'fold'],\n",
       "      dtype='object')"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataDF.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataDF = dataDF.reindex(columns=['StudyInstanceUID', 'SeriesInstanceUID', 'pe_present_on_image', 'negative_exam_for_pe',\n",
    "                       'indeterminate', 'chronic_pe', 'acute_and_chronic_pe', 'central_pe', 'leftsided_pe',\n",
    "                       'rightsided_pe', 'rv_lv_ratio_gte_1', 'rv_lv_ratio_lt_1','fold','img_pos','patient_position',\n",
    "                       'intercept', 'slope'])                  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": false
   },
   "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>StudyInstanceUID</th>\n",
       "      <th>SeriesInstanceUID</th>\n",
       "      <th>pe_present_on_image</th>\n",
       "      <th>negative_exam_for_pe</th>\n",
       "      <th>indeterminate</th>\n",
       "      <th>chronic_pe</th>\n",
       "      <th>acute_and_chronic_pe</th>\n",
       "      <th>central_pe</th>\n",
       "      <th>leftsided_pe</th>\n",
       "      <th>rightsided_pe</th>\n",
       "      <th>rv_lv_ratio_gte_1</th>\n",
       "      <th>rv_lv_ratio_lt_1</th>\n",
       "      <th>fold</th>\n",
       "      <th>img_pos</th>\n",
       "      <th>patient_position</th>\n",
       "      <th>intercept</th>\n",
       "      <th>slope</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>SOPInstanceUID</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>c0f3cb036d06</th>\n",
       "      <td>6897fa9de148</td>\n",
       "      <td>2bfbb7fd2e8b</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "      <td>-234.5</td>\n",
       "      <td>HFS</td>\n",
       "      <td>-1024</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>f57ffd3883b6</th>\n",
       "      <td>6897fa9de148</td>\n",
       "      <td>2bfbb7fd2e8b</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "      <td>-252.5</td>\n",
       "      <td>HFS</td>\n",
       "      <td>-1024</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>41220fda34a3</th>\n",
       "      <td>6897fa9de148</td>\n",
       "      <td>2bfbb7fd2e8b</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "      <td>-432.5</td>\n",
       "      <td>HFS</td>\n",
       "      <td>-1024</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13b685b4b14f</th>\n",
       "      <td>6897fa9de148</td>\n",
       "      <td>2bfbb7fd2e8b</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "      <td>-434.5</td>\n",
       "      <td>HFS</td>\n",
       "      <td>-1024</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>be0b7524ffb4</th>\n",
       "      <td>6897fa9de148</td>\n",
       "      <td>2bfbb7fd2e8b</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "      <td>-436.5</td>\n",
       "      <td>HFS</td>\n",
       "      <td>-1024</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "               StudyInstanceUID SeriesInstanceUID  pe_present_on_image  \\\n",
       "SOPInstanceUID                                                           \n",
       "c0f3cb036d06       6897fa9de148      2bfbb7fd2e8b                    0   \n",
       "f57ffd3883b6       6897fa9de148      2bfbb7fd2e8b                    0   \n",
       "41220fda34a3       6897fa9de148      2bfbb7fd2e8b                    0   \n",
       "13b685b4b14f       6897fa9de148      2bfbb7fd2e8b                    0   \n",
       "be0b7524ffb4       6897fa9de148      2bfbb7fd2e8b                    0   \n",
       "\n",
       "                negative_exam_for_pe  indeterminate  chronic_pe  \\\n",
       "SOPInstanceUID                                                    \n",
       "c0f3cb036d06                       0              0           0   \n",
       "f57ffd3883b6                       0              0           0   \n",
       "41220fda34a3                       0              0           0   \n",
       "13b685b4b14f                       0              0           0   \n",
       "be0b7524ffb4                       0              0           0   \n",
       "\n",
       "                acute_and_chronic_pe  central_pe  leftsided_pe  rightsided_pe  \\\n",
       "SOPInstanceUID                                                                  \n",
       "c0f3cb036d06                       0           0             1              1   \n",
       "f57ffd3883b6                       0           0             1              1   \n",
       "41220fda34a3                       0           0             1              1   \n",
       "13b685b4b14f                       0           0             1              1   \n",
       "be0b7524ffb4                       0           0             1              1   \n",
       "\n",
       "                rv_lv_ratio_gte_1  rv_lv_ratio_lt_1  fold  img_pos  \\\n",
       "SOPInstanceUID                                                       \n",
       "c0f3cb036d06                    0                 1     3   -234.5   \n",
       "f57ffd3883b6                    0                 1     3   -252.5   \n",
       "41220fda34a3                    0                 1     3   -432.5   \n",
       "13b685b4b14f                    0                 1     3   -434.5   \n",
       "be0b7524ffb4                    0                 1     3   -436.5   \n",
       "\n",
       "               patient_position  intercept  slope  \n",
       "SOPInstanceUID                                     \n",
       "c0f3cb036d06                HFS      -1024      1  \n",
       "f57ffd3883b6                HFS      -1024      1  \n",
       "41220fda34a3                HFS      -1024      1  \n",
       "13b685b4b14f                HFS      -1024      1  \n",
       "be0b7524ffb4                HFS      -1024      1  "
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataDF.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "trainDF = dataDF[dataDF['fold']!=4]\n",
    "valDF = dataDF[dataDF['fold']==4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "class embeddingsDataset(Dataset):\n",
    "    \"\"\"create sample dataset to work with\"\"\"\n",
    "\n",
    "    def __init__(self, dataDF = None, listOfStudies = None, embeddingDirPath = None):\n",
    "        self.dataDF = dataDF\n",
    "        self.listOfStudies = listOfStudies\n",
    "        self.embeddingDirPath = embeddingDirPath\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.listOfStudies)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        embedDict = pickle.load(open(self.embeddingDirPath+self.listOfStudies[idx]+'.p', 'rb'))\n",
    "        embeddingVolume = np.array(embedDict['embeddings'])\n",
    "        listOfImages = embedDict['ids']\n",
    "        imageLevelLabels = [self.dataDF.loc[eachImageID, 'pe_present_on_image']for eachImageID in listOfImages]\n",
    "        imageLevelLabels = np.array(imageLevelLabels).astype(np.float32)\n",
    "        studyLevelLabels = self.dataDF.loc[listOfImages[0]][3:12].values\n",
    "        studyLevelLabels = np.array(studyLevelLabels).astype(np.float32)\n",
    "        return embeddingVolume, (imageLevelLabels, studyLevelLabels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "INPUT_SIZE = 64\n",
    "HIDDEN_SIZE = 32\n",
    "NUM_LAYERS = 1\n",
    "NUM_CLASSES = 1\n",
    "\n",
    "class BiGRU(nn.Module):\n",
    "    def __init__(self, input_size, hidden_size, num_layers, num_classes):\n",
    "        super(BiGRU, self).__init__()\n",
    "        self.hidden_size = hidden_size\n",
    "        self.num_layers = num_layers\n",
    "        self.GRU = nn.GRU(\n",
    "            input_size, hidden_size, num_layers, batch_first=True, bidirectional=True\n",
    "        )\n",
    "        self.linear1 = nn.Linear(hidden_size*2, hidden_size)\n",
    "        self.linear2 = nn.Linear(hidden_size, num_classes)\n",
    "        self.linear3 = nn.Linear(hidden_size*2, hidden_size)\n",
    "        self.linear4 = nn.Linear(hidden_size, 9)\n",
    "\n",
    "    def forward(self, x):\n",
    "        imageLevelOutputs = []\n",
    "        h0 = torch.zeros(self.num_layers * 2, x.size(0), self.hidden_size).cuda()\n",
    "        #c0 = torch.zeros(self.num_layers * 2, x.size(0), self.hidden_size).cuda()\n",
    "\n",
    "        out, h_n = self.GRU(x, h0)\n",
    "        \n",
    "        for i, out_t in enumerate(out.chunk(out.size(1), dim=1)):\n",
    "            out_t = out_t.squeeze(1)\n",
    "            out_t = F.relu(self.linear1(out_t))\n",
    "            out_t = self.linear2(out_t)\n",
    "            imageLevelOutputs += [out_t]\n",
    "        imageLevelOutputs = torch.stack(imageLevelOutputs, 1).squeeze(2)\n",
    "        \n",
    "        h_n = h_n.view(1,-1)\n",
    "        studyLevelOutputs = F.relu(self.linear3(h_n))\n",
    "        studyLevelOutputs = self.linear4(studyLevelOutputs)\n",
    "        \n",
    "        return (imageLevelOutputs, studyLevelOutputs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "seq = BiGRU(INPUT_SIZE, HIDDEN_SIZE, NUM_LAYERS, NUM_CLASSES).cuda()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# batch,seqNum,features\n",
    "sampleInput = torch.rand((1,120,64)).cuda()\n",
    "sampleImgOutput, sampleStdOutput = seq(sampleInput)\n",
    "print(sampleImgOutput.size())\n",
    "print(sampleStdOutput.size())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def customLoss(imageLevelOutputLogits, imageLevelLabels, studyLeveloutputLogits, studyLevelLabels):\n",
    "    imageLevelLoss = F.binary_cross_entropy_with_logits(imageLevelOutputLogits,imageLevelLabels,pos_weight = torch.tensor([3.0]).cuda())\n",
    "    \n",
    "    studyLevelLoss = 0\n",
    "    weightList = [0.0736196319, 0.09202453988, 0.1042944785, 0.1042944785, 0.1877300613, 0.06257668712, 0.06257668712, 0.2346625767, 0.0782208589]\n",
    "    for eachInd in range(9):\n",
    "        studyLevelLoss += weightList[eachInd]*F.binary_cross_entropy_with_logits(studyLeveloutputLogits[:,eachInd],studyLevelLabels[:,eachInd])\n",
    "    \n",
    "    return imageLevelLoss+studyLevelLoss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = optim.Adam(seq.parameters(), lr=1e-4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "valEmbeddingDirPath = 'data/embeddings/CNNmodel_01_epoch1_CV4_20201008_2252/val/'\n",
    "augEmbeddingDirPathBase = 'data/embeddings/CNNmodel_01_epoch1_CV4_20201008_2252/aug'\n",
    "\n",
    "valEmbeddingsDataset = embeddingsDataset(dataDF=dataDF, listOfStudies=valDF['StudyInstanceUID'].unique(), embeddingDirPath=valEmbeddingDirPath)\n",
    "valEmbeddingsDataloader = DataLoader(valEmbeddingsDataset, batch_size=1, shuffle=False, num_workers=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_loop(model, epoch):\n",
    "    train_total = train_correct = train_cost = 0\n",
    "    seq.train()\n",
    "    thisEmbeddingDirPath = augEmbeddingDirPathBase + str(epoch).zfill(2) + '/'\n",
    "    thisEmbeddingsDataset = embeddingsDataset(dataDF=dataDF, listOfStudies=trainDF['StudyInstanceUID'].unique(), embeddingDirPath=thisEmbeddingDirPath)\n",
    "    train_loader = DataLoader(thisEmbeddingsDataset, batch_size=1, shuffle=True, num_workers=1)\n",
    "    for x, (y_img, y_std) in tqdm(train_loader):\n",
    "        x = x.cuda()\n",
    "        y_img = y_img.cuda()\n",
    "        y_std = y_std.cuda()\n",
    "        optimizer.zero_grad()\n",
    "        (o_img, o_std) = seq(x)\n",
    "        train_total += y_img.size(1)\n",
    "        train_correct += ((torch.sigmoid(o_img[0,:])>0.5) == (y_img[0,:]>0.5)).sum().item()\n",
    "        loss = customLoss(o_img, y_img, o_std, y_std)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        train_cost += loss.item()\n",
    "    return train_cost/train_total, train_correct/train_total\n",
    "\n",
    "def valid_loop(model, valid_loader):\n",
    "    # Evaluate on validation  data \n",
    "    val_total = val_correct = val_cost = 0\n",
    "    model.eval()\n",
    "    with torch.no_grad():\n",
    "        for x_val, (y_val_img, y_val_std) in tqdm(valid_loader):\n",
    "            x_val = x_val.cuda()\n",
    "            y_val_img = y_val_img.cuda()\n",
    "            y_val_std = y_val_std.cuda()\n",
    "            (o_val_img, o_val_std) = seq(x_val)\n",
    "            val_total += y_val_img.size(1)\n",
    "            val_correct += ((torch.sigmoid(o_val_img[0,:])>0.5) == (y_val_img[0,:]>0.5)).sum().item()\n",
    "            loss = customLoss(o_val_img, y_val_img, o_val_std, y_val_std)\n",
    "            val_cost += loss.item()\n",
    "    return val_cost/val_total, val_correct/val_total\n",
    "\n",
    "def main_loop(n_epochs):\n",
    "    for epoch in range(n_epochs):\n",
    "        print('epoch ' + str(epoch) + ':')\n",
    "        train_avgCost, train_acc = train_loop(seq, epoch)\n",
    "        val_avgCost, val_acc = valid_loop(seq, valEmbeddingsDataloader)\n",
    "\n",
    "        print('train_cost: %.4f, train_acc: %.4f, val_cost: %.4f, val_acc: %.4f'\\\n",
    "              % (train_avgCost, train_acc, val_avgCost, val_acc))\n",
    "        modelPath = 'models/embedderModel/CNNmodel_01_epoch1_CV4_20201008_2252_sequence' + str(epoch) + '_' + DATESTRING +'.pth'\n",
    "        print('saving: ',modelPath)\n",
    "        torch.save(seq, modelPath)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "  0%|          | 0/5824 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch 0:\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 5824/5824 [06:00<00:00, 16.15it/s]\n",
      "100%|██████████| 1455/1455 [00:36<00:00, 39.86it/s]\n",
      "  0%|          | 0/5824 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train_cost: 0.0017, train_acc: 0.9737, val_cost: 0.0016, val_acc: 0.9694\n",
      "saving:  models/embedderModel/CNNmodel_01_epoch1_CV4_20201008_2252_sequence0_20201012_2232.pth\n",
      "epoch 1:\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 5824/5824 [05:59<00:00, 16.20it/s]\n",
      "100%|██████████| 1455/1455 [00:36<00:00, 39.63it/s]\n",
      "  0%|          | 0/5824 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train_cost: 0.0013, train_acc: 0.9753, val_cost: 0.0016, val_acc: 0.9720\n",
      "saving:  models/embedderModel/CNNmodel_01_epoch1_CV4_20201008_2252_sequence1_20201012_2232.pth\n",
      "epoch 2:\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 5824/5824 [05:58<00:00, 16.24it/s]\n",
      "100%|██████████| 1455/1455 [00:36<00:00, 39.70it/s]\n",
      "  0%|          | 0/5824 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train_cost: 0.0012, train_acc: 0.9760, val_cost: 0.0015, val_acc: 0.9718\n",
      "saving:  models/embedderModel/CNNmodel_01_epoch1_CV4_20201008_2252_sequence2_20201012_2232.pth\n",
      "epoch 3:\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 5824/5824 [05:57<00:00, 16.27it/s]\n",
      "100%|██████████| 1455/1455 [00:36<00:00, 40.08it/s]\n",
      "  0%|          | 0/5824 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train_cost: 0.0012, train_acc: 0.9761, val_cost: 0.0016, val_acc: 0.9742\n",
      "saving:  models/embedderModel/CNNmodel_01_epoch1_CV4_20201008_2252_sequence3_20201012_2232.pth\n",
      "epoch 4:\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 5824/5824 [05:58<00:00, 16.24it/s]\n",
      "100%|██████████| 1455/1455 [00:36<00:00, 39.77it/s]\n",
      "  0%|          | 0/5824 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train_cost: 0.0012, train_acc: 0.9761, val_cost: 0.0015, val_acc: 0.9682\n",
      "saving:  models/embedderModel/CNNmodel_01_epoch1_CV4_20201008_2252_sequence4_20201012_2232.pth\n",
      "epoch 5:\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 62%|██████▏   | 3627/5824 [03:45<02:05, 17.45it/s]"
     ]
    }
   ],
   "source": [
    "main_loop(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "iterVal = iter(valEmbeddingsDataloader)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Sanity Check\n",
    "seq.eval()\n",
    "with torch.no_grad():\n",
    "    x,(y_img, _) = next(iterVal)\n",
    "    x=x.cuda()\n",
    "    o_img, _ = seq(x)\n",
    "    pred = torch.sigmoid(o_img)\n",
    "    for eachIndex in range(pred.size(1)):\n",
    "        print((pred[0,eachIndex]).type(torch.float).item(), y_img[0, eachIndex].item())"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "pyTorchEnv37",
   "language": "python",
   "name": "pytorchenv37"
  },
  "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.7.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}