deeplearn-torch/Chapter_8.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-31T14:53:27.591465Z",
     "start_time": "2021-03-31T14:53:26.280648Z"
    },
    "tags": [
     "remove_cell"
    ]
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torchvision \n",
    "from torchvision.models.detection import FasterRCNN\n",
    "from torchvision.models.detection.rpn import AnchorGenerator\n",
    "from torchvision import transforms\n",
    "\n",
    "\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "\n",
    "from tqdm.autonotebook import tqdm\n",
    "\n",
    "\n",
    "\n",
    "import os\n",
    "from imageio import imread\n",
    "from glob import glob\n",
    "import json\n",
    "\n",
    "import numpy as np\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.pyplot import imshow\n",
    "\n",
    "import pandas as pd\n",
    "\n",
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "import time\n",
    "\n",
    "from idlmam import set_seed\n",
    "from idlmam import train_network, Flatten, View, weight_reset, moveTo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-31T14:53:27.600644Z",
     "start_time": "2021-03-31T14:53:27.594386Z"
    },
    "tags": [
     "remove_cell"
    ]
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "from IPython.display import set_matplotlib_formats\n",
    "set_matplotlib_formats('png', 'pdf')\n",
    "\n",
    "from IPython.display import display_pdf\n",
    "from IPython.display import Latex\n",
    "\n",
    "torch.backends.cudnn.deterministic=True\n",
    "set_seed(42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-31T14:53:27.638334Z",
     "start_time": "2021-03-31T14:53:27.603194Z"
    },
    "tags": [
     "remove_cell"
    ]
   },
   "outputs": [],
   "source": [
    "device = torch.device(\"cuda\") if torch.cuda.is_available() else torch.device(\"cpu\") "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-31T14:53:27.651856Z",
     "start_time": "2021-03-31T14:53:27.646464Z"
    },
    "tags": [
     "remove_cell"
    ]
   },
   "outputs": [],
   "source": [
    "#This URL has a copy of the dataset, make sure you go to Kaggle though and make an account and follow the license rules. \n",
    "data_url_zip = \"https://github.com/kamalkraj/DATA-SCIENCE-BOWL-2018/blob/master/data/stage1_train.zip?raw=true\"\n",
    "from io import BytesIO\n",
    "from zipfile import ZipFile\n",
    "from urllib.request import urlopen\n",
    "import re\n",
    "\n",
    "#Download this dataset if we have not already done so\n",
    "if not os.path.isdir('./data/stage1_train'):\n",
    "    resp = urlopen(data_url_zip)\n",
    "    os.mkdir(\"./data/stage1_train\")\n",
    "    zipfile = ZipFile(BytesIO(resp.read()))\n",
    "    zipfile.extractall(path = './data/stage1_train')\n",
    "#Grab all the paths to the images we just unziped \n",
    "paths = glob(\"./data/stage1_train/*\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-31T14:53:27.660959Z",
     "start_time": "2021-03-31T14:53:27.654191Z"
    }
   },
   "outputs": [],
   "source": [
    "class DSB2018(Dataset):\n",
    "    \"\"\"Dataset class for the 2018 Data Science Bowl.\"\"\"\n",
    "    def __init__(self, paths):\n",
    "        \"\"\"paths: a list of paths to every image folder in the dataset\"\"\"\n",
    "        self.paths = paths\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self.paths)\n",
    "    \n",
    "    def __getitem__(self, idx):   \n",
    "        #There is only one image in each images path. So we will grab the \"first\" thing we find with \"[0]\" at the end\n",
    "        img_path = glob(self.paths[idx] + \"/images/*\")[0]        \n",
    "        #but there are multiple mask images in each mask path\n",
    "        mask_imgs = glob(self.paths[idx] + \"/masks/*\")        \n",
    "        #the image shape is (W, H, 4), the last dimension is an 'alpha' channel that is not used\n",
    "        img = imread(img_path)[:,:,0:3]#trim off the alpha so we get (W, H, 3)\n",
    "        #Now we want this as (3, W, H), which is the normal shape for PyTorch\n",
    "        img = np.moveaxis(img, -1, 0)\n",
    "        #Last step for the image, re-scale it to the range [0, 1]\n",
    "        img = img/255.0\n",
    "       \n",
    "        #Every mask image is going to have a shape of (W, H) which has a value of 1 if the pixel is of a nuclei, and a value of 0 if the image is background/ a  _different_ nuclei\n",
    "        masks = [imread(f)/255.0 for f in mask_imgs]\n",
    "        \n",
    "        #Since we want to do simple segmentation, we will create one final mask that contains _all_ nuclei pixels from _every_ mask\n",
    "        final_mask = np.zeros(masks[0].shape)\n",
    "        for m in masks:\n",
    "            final_mask = np.logical_or(final_mask, m)\n",
    "        final_mask = final_mask.astype(np.float32)\n",
    "        \n",
    "        #Not every image in the dataset is the same size.  To simplify the problem, we are going to re-size  every image to be (256, 256)\n",
    "        img, final_mask = torch.tensor(img), torch.tensor(final_mask).unsqueeze(0) #First we convert to PyTorch tensors\n",
    "        #The interpolate function can be used to re-size a batch of images. So we make each image a \"batch\" of 1\n",
    "        img = F.interpolate(img.unsqueeze(0), (256, 256))\n",
    "        final_mask = F.interpolate(final_mask.unsqueeze(0), (256, 256))\n",
    "        #Now the shapes  are (B=1, C, W, H) We need to convert them back to FloatTensors and grab the first item in the \"batch\". This will return a tuple of: (3, 256, 256), (1, 256, 256)\n",
    "        return img.type(torch.FloatTensor)[0], final_mask.type(torch.FloatTensor)[0]\n",
    "#Caption: Class for the 2018 data science bowl dataset.  Each image has a corresponding folder of masks, one for every object in the image. We aren’t going to do that kind of object detection yet. Instead our DataSet class will go through every mask and “or” them together, so that we get a single mask showing every pixel that contains an object. This is done inside __getitem__ which will return a tuple with the input image, followed by the mask we want to predict (i.e., all pixels that contain nuclei). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-31T14:53:28.149444Z",
     "start_time": "2021-03-31T14:53:27.662613Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7fd24a8a5350>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "application/pdf": "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
      "image/png": "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
      "text/plain": [
       "<Figure size 1152x720 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Create the Dataset class object\n",
    "dsb_data = DSB2018(paths)\n",
    "\n",
    "plt.figure(figsize=(16,10))\n",
    "#Plot the original image\n",
    "plt.subplot(1, 2, 1)\n",
    "plt.imshow(dsb_data[0][0].permute(1,2,0).numpy())\n",
    "#Plot the mask\n",
    "plt.subplot(1, 2, 2)\n",
    "plt.imshow(dsb_data[0][1].numpy()[0,:], cmap='gray')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-31T14:53:28.679856Z",
     "start_time": "2021-03-31T14:53:28.150767Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7fd24a7eb6d0>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "application/pdf": "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
      "image/png": "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
      "text/plain": [
       "<Figure size 1152x720 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Lets plot a second image that is in color\n",
    "plt.figure(figsize=(16,10))\n",
    "plt.subplot(1, 2, 1)\n",
    "plt.imshow(dsb_data[1][0].permute(1,2,0).numpy())\n",
    "plt.subplot(1, 2, 2)\n",
    "plt.imshow(dsb_data[1][1].numpy()[0,:], cmap='gray')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-31T14:53:28.684554Z",
     "start_time": "2021-03-31T14:53:28.681162Z"
    }
   },
   "outputs": [],
   "source": [
    "train_split, test_split = torch.utils.data.random_split(dsb_data, [500, len(dsb_data)-500])\n",
    "train_seg_loader = DataLoader(train_split, batch_size=16, shuffle=True)\n",
    "test_seg_loader = DataLoader(test_split,  batch_size=16)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-31T14:53:28.690784Z",
     "start_time": "2021-03-31T14:53:28.685812Z"
    }
   },
   "outputs": [],
   "source": [
    "C = 3 #How many channels are in the input? \n",
    "n_filters = 32 #Smallest value of filters you should usually consider. If we wanted to try and optimize the architecture we could use Optuna to pick a better number of filters. \n",
    "loss_func = nn.BCEWithLogitsLoss()#BCE loss implicitly assumes a binary problem"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-31T15:04:51.165776Z",
     "start_time": "2021-03-31T14:53:28.692224Z"
    },
    "tags": [
     "remove_output"
    ]
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "877f75f99662433eaff4de2fe89d4483",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Epoch'), FloatProgress(value=0.0, max=10.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Training'), FloatProgress(value=0.0, max=32.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Validating'), FloatProgress(value=0.0, max=11.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Training'), FloatProgress(value=0.0, max=32.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Validating'), FloatProgress(value=0.0, max=11.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Training'), FloatProgress(value=0.0, max=32.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Validating'), FloatProgress(value=0.0, max=11.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Training'), FloatProgress(value=0.0, max=32.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Validating'), FloatProgress(value=0.0, max=11.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Training'), FloatProgress(value=0.0, max=32.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Validating'), FloatProgress(value=0.0, max=11.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Training'), FloatProgress(value=0.0, max=32.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Validating'), FloatProgress(value=0.0, max=11.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Training'), FloatProgress(value=0.0, max=32.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Validating'), FloatProgress(value=0.0, max=11.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Training'), FloatProgress(value=0.0, max=32.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Validating'), FloatProgress(value=0.0, max=11.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Training'), FloatProgress(value=0.0, max=32.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Validating'), FloatProgress(value=0.0, max=11.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Training'), FloatProgress(value=0.0, max=32.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Validating'), FloatProgress(value=0.0, max=11.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "#Define our helper function that creates a hidden layer for a CNN\n",
    "def cnnLayer(in_filters, out_filters, kernel_size=3):\n",
    "    \"\"\"\n",
    "    in_filters: how many channels are in the input to this layer\n",
    "    out_filters: how many channels should this layer output\n",
    "    kernel_size: how large should the filters of this layer be\n",
    "    \"\"\"\n",
    "    padding = kernel_size//2\n",
    "    return nn.Sequential(\n",
    "        nn.Conv2d(in_filters, out_filters, kernel_size, padding=padding), \n",
    "        nn.BatchNorm2d(out_filters),\n",
    "        nn.LeakyReLU(), # I'm not setting the leak value to anything just to make the code shorter. \n",
    "    )\n",
    "#Specifying a model for image segmentation\n",
    "segmentation_model = nn.Sequential(\n",
    "    cnnLayer(C, n_filters), #First layer changes number of channels up to the large numer\n",
    "    *[cnnLayer(n_filters, n_filters) for _ in range(5)], #Create 5 more hidden layers\n",
    "    #Make a prediction for _every_ location. Notice we use 1 channel out, since we have a binary problem and are using BCEWithLogitsLoss as our loss function. \n",
    "    nn.Conv2d(n_filters, 1, (3,3), padding=1), #Shape is now (1, W, H)\n",
    ")\n",
    "#train the segmentation model\n",
    "seg_results = train_network(segmentation_model, loss_func, train_seg_loader, epochs=10, device=device, val_loader=test_seg_loader)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-31T15:04:51.906837Z",
     "start_time": "2021-03-31T15:04:51.167000Z"
    },
    "tags": [
     "remove_input"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(-240, -50, 'Error: Phantom object')"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "application/pdf": "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
      "image/png": "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
      "text/plain": [
       "<Figure size 1152x720 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "index = 6 # Picking a specific example from the dataset that shows a particular result. Change this to look at other entries from the dataset.\n",
    "\n",
    "with torch.no_grad():#We don't want gradients if we aren't training, so no gradients please!\n",
    "    #push a test datapoint through the model. Remember the raw outputs are called the logits\n",
    "    logits = segmentation_model(test_split[index][0].unsqueeze(0).to(device))[0].cpu()\n",
    "    #apply $\\sigma$ to the logits to make predictions and then apply a threshold to get a prediction mask\n",
    "    pred = torch.sigmoid(logits) >= 0.5\n",
    "\n",
    "#Plot the input, ground truth, and prediction\n",
    "plt.figure(figsize=(16,10))\n",
    "plt.subplot(1, 3, 1)\n",
    "plt.imshow(test_split[index][0].permute(1,2,0).numpy(), cmap='gray') #First plot the original input to the network\n",
    "plt.subplot(1, 3, 2)\n",
    "plt.imshow(test_split[index][1].numpy()[0,:], cmap='gray') #Second is ground truth\n",
    "plt.subplot(1, 3, 3) \n",
    "plt.imshow(pred.numpy()[0,:], cmap='gray') #Third is the prediction our network made\n",
    "\n",
    "plt.annotate('Error: Hole', color=\"red\", fontsize=20, xy=(130, 230),\n",
    "            xycoords='data', xytext=(-60, 60),\n",
    "            textcoords='offset points',\n",
    "            arrowprops=dict(arrowstyle=\"->\",\n",
    "                            linewidth = 2.5,\n",
    "                            color = 'red')\n",
    "            )\n",
    "\n",
    "plt.annotate('Error: Hole', color=\"red\", fontsize=20, xy=(210, 75),\n",
    "            xycoords='data', xytext=(-160, -60),\n",
    "            textcoords='offset points',\n",
    "            arrowprops=dict(arrowstyle=\"->\",\n",
    "                            linewidth = 2.5,\n",
    "                            color = 'red')\n",
    "            )\n",
    "plt.annotate('Error: Phantom object', color=\"red\", fontsize=20, xy=(247, 15),\n",
    "            xycoords='data', xytext=(-240, -50),\n",
    "            textcoords='offset points',\n",
    "            arrowprops=dict(arrowstyle=\"->\",\n",
    "                            linewidth = 2.5,\n",
    "                            color = 'red')\n",
    "            )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-31T15:16:22.176581Z",
     "start_time": "2021-03-31T15:04:51.911189Z"
    },
    "tags": [
     "remove_output"
    ]
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7a30e1ea044b4be9a811b4b3b5db0602",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Epoch'), FloatProgress(value=0.0, max=10.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Training'), FloatProgress(value=0.0, max=32.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Validating'), FloatProgress(value=0.0, max=11.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Training'), FloatProgress(value=0.0, max=32.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Validating'), FloatProgress(value=0.0, max=11.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Training'), FloatProgress(value=0.0, max=32.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Validating'), FloatProgress(value=0.0, max=11.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Training'), FloatProgress(value=0.0, max=32.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Validating'), FloatProgress(value=0.0, max=11.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Training'), FloatProgress(value=0.0, max=32.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Validating'), FloatProgress(value=0.0, max=11.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Training'), FloatProgress(value=0.0, max=32.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Validating'), FloatProgress(value=0.0, max=11.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Training'), FloatProgress(value=0.0, max=32.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Validating'), FloatProgress(value=0.0, max=11.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Training'), FloatProgress(value=0.0, max=32.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Validating'), FloatProgress(value=0.0, max=11.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Training'), FloatProgress(value=0.0, max=32.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Validating'), FloatProgress(value=0.0, max=11.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Training'), FloatProgress(value=0.0, max=32.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Validating'), FloatProgress(value=0.0, max=11.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "segmentation_model2 = nn.Sequential(\n",
    "    cnnLayer(C, n_filters), #First layer changes number of channels up to the large numer\n",
    "    cnnLayer(n_filters, n_filters),\n",
    "    nn.MaxPool2d(2), #Shrinks the height and width by 2\n",
    "    cnnLayer(n_filters, 2*n_filters),\n",
    "    cnnLayer(2*n_filters, 2*n_filters),\n",
    "    cnnLayer(2*n_filters, 2*n_filters),\n",
    "    #Double the height and width, countering the effect of the single MaxPool2d before\n",
    "    nn.ConvTranspose2d(2*n_filters, n_filters, (3,3), padding=1, output_padding=1, stride=2),\n",
    "    nn.BatchNorm2d(n_filters),\n",
    "    nn.LeakyReLU(),\n",
    "    #Back to normal convolutions\n",
    "    cnnLayer(n_filters, n_filters),\n",
    "    #Prediction for _every_ location\n",
    "    nn.Conv2d(n_filters, 1, (3,3), padding=1), #Shape is now (B, 1, W, H)\n",
    ")\n",
    "\n",
    "seg_results2 = train_network(segmentation_model2, loss_func, train_seg_loader, epochs=10, device=device, val_loader=test_seg_loader)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-31T15:16:22.745317Z",
     "start_time": "2021-03-31T15:16:22.177892Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7fd24804e1d0>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "application/pdf": "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
      "image/png": "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
      "text/plain": [
       "<Figure size 1152x720 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "index = 6 # Same example from before\n",
    "\n",
    "with torch.no_grad(): #We don't want gradients if we aren't training, so no gradients please!\n",
    "    #push a test datapoint through the model. Remember the raw outputs are called the logits\n",
    "    pred = segmentation_model2(test_split[index][0].unsqueeze(0).to(device))[0].cpu()\n",
    "    #apply $\\sigma$ to the logits to make predictions and then apply a threshold to get a prediction mask\n",
    "    pred = torch.sigmoid(pred) >= 0.5\n",
    "\n",
    "\n",
    "#Plot the input, ground truth, and prediction\n",
    "plt.figure(figsize=(16,10))\n",
    "plt.subplot(1, 3, 1)\n",
    "plt.imshow(test_split[index][0].permute(1,2,0).numpy(), cmap='gray')  #First plot the original input to the network\n",
    "plt.subplot(1, 3, 2)\n",
    "plt.imshow(test_split[index][1].numpy()[0,:], cmap='gray') #Second is ground truth\n",
    "plt.subplot(1, 3, 3)\n",
    "plt.imshow(pred.numpy()[0,:], cmap='gray') #Third is the prediction our network made"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-31T15:16:22.749203Z",
     "start_time": "2021-03-31T15:16:22.746680Z"
    },
    "tags": [
     "remove_cell"
    ]
   },
   "outputs": [],
   "source": [
    "del segmentation_model\n",
    "del segmentation_model2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-31T15:16:22.973715Z",
     "start_time": "2021-03-31T15:16:22.750267Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:xlabel='epoch', ylabel='val loss'>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "application/pdf": "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
      "image/png": "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
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.lineplot(x='epoch', y='val loss', data=seg_results, label='CNN')\n",
    "sns.lineplot(x='epoch', y='val loss', data=seg_results2, label='CNN w/ transposed-conv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-31T15:16:22.981762Z",
     "start_time": "2021-03-31T15:16:22.975242Z"
    },
    "tags": [
     "remove_cell"
    ]
   },
   "outputs": [],
   "source": [
    "class UNetBlock2d(nn.Module): #Our class extends nn.Module, all PyTorch layers must extend this \n",
    "    def __init__(self, in_channels, mid_channels, out_channels=None, layers=1, sub_network=None, filter_size=3):\n",
    "        \"\"\" \n",
    "        in_channels: the number of channels in the input to this block\n",
    "        mid_channels: the number of channels to have as the output for each convolutional filter\n",
    "        out_channels: if not `None`, ends the network with a 1x1 convolution to convert the number of output channels to a specific number. \n",
    "        layers: how many blocks of hidden layers to create on both the input and output side of a U-Net block\n",
    "        sub_network: the network to apply after shrinking the input by a factor of 2 using max pooling. The number of output channels should be equal to `mid_channels`\n",
    "        filter_size: how large the convolutional filters should be\n",
    "        \"\"\"\n",
    "        super().__init__()\n",
    "        \n",
    "        #Start preparing the layers used to process the input\n",
    "        in_layers = [cnnLayer(in_channels, mid_channels, filter_size)]\n",
    "        \n",
    "        #If we have a sub-network, we will double the number of inputs to the output. So lets figure that out now\n",
    "        if sub_network is None:\n",
    "            inputs_to_outputs = 1\n",
    "        else:\n",
    "            inputs_to_outputs = 2\n",
    "\n",
    "        #Preparing the layers used to make the final output, which has extra input channels from any sub-network\n",
    "        out_layers = [ cnnLayer(mid_channels*inputs_to_outputs, mid_channels, filter_size)]\n",
    "        \n",
    "        #Make the additional hidden layers used for the input and output\n",
    "        for _ in range(layers-1):\n",
    "            in_layers.append(cnnLayer(mid_channels, mid_channels, filter_size))\n",
    "            out_layers.append(cnnLayer(mid_channels, mid_channels, filter_size))\n",
    "        #Use 1x1 Convolutions to ensure a specific output size\n",
    "        if out_channels is not None:\n",
    "            out_layers.append(nn.Conv2d(mid_channels, out_channels, 1, padding=0))\n",
    "    \n",
    "        #define our three total sub-networks:\n",
    "        #1) in_model performs the intial rounds of convolution\n",
    "        self.in_model = nn.Sequential(*in_layers)\n",
    "        #2) our subnetwork works on the max-pooled result. We will add the pooling and up-scaling directly into the sub-model\n",
    "        if sub_network is not None:\n",
    "            self.bottleneck = nn.Sequential(\n",
    "                nn.MaxPool2d(2), #Shrink\n",
    "                sub_network, #process the smaller resolution\n",
    "                #expand back up\n",
    "                nn.ConvTranspose2d(mid_channels, mid_channels, filter_size, padding=filter_size//2, output_padding=1, stride=2)\n",
    "            )\n",
    "        else:\n",
    "            self.bottleneck = None\n",
    "        #3) the output model that processes the concatinated result, or just the output from in_model if no sub-network was given\n",
    "        self.out_model = nn.Sequential(*out_layers)\n",
    "        \n",
    "    \n",
    "    #The forward function is the code that takes an input and produce an output. \n",
    "    def forward(self, x):\n",
    "        #compute the convolutions at the current scale\n",
    "        full_scale_result = self.in_model(x) #(B, C, W, H)\n",
    "        #check if we have a bottleneck to apply\n",
    "        if self.bottleneck is not None:\n",
    "            #(B, C, W, H) shape because bottleneck does both the pooling & expansion\n",
    "            bottle_result = self.bottleneck(full_scale_result)\n",
    "            #Now shape (B, 2*C, W, H)\n",
    "            full_scale_result = torch.cat([full_scale_result, bottle_result], dim=1)\n",
    "        #compute the output on the concatenated (or not!) result\n",
    "        return self.out_model(full_scale_result)\n",
    "#Caption: A class implementing a “Block” of the U-Net approach. Each block needs to know how many channels are coming in and out of the block. The block has three components. 1) the input network, what processes the raw input coming into this block. 2) the bottleneck, which is what the block runs after shrinking the current results down by a factor of 2, and then expands the result back up to the original size. 3) the output network, which is run on the results from the prior two sub-networks concatenated together. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-31T15:28:17.548162Z",
     "start_time": "2021-03-31T15:16:22.982896Z"
    },
    "tags": [
     "remove_output"
    ]
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "066e265e7a2b4effa57f6a682ec2533c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Epoch'), FloatProgress(value=0.0, max=10.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Training'), FloatProgress(value=0.0, max=32.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Validating'), FloatProgress(value=0.0, max=11.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Training'), FloatProgress(value=0.0, max=32.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Validating'), FloatProgress(value=0.0, max=11.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Training'), FloatProgress(value=0.0, max=32.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Validating'), FloatProgress(value=0.0, max=11.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Training'), FloatProgress(value=0.0, max=32.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Validating'), FloatProgress(value=0.0, max=11.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Training'), FloatProgress(value=0.0, max=32.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Validating'), FloatProgress(value=0.0, max=11.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Training'), FloatProgress(value=0.0, max=32.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Validating'), FloatProgress(value=0.0, max=11.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Training'), FloatProgress(value=0.0, max=32.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Validating'), FloatProgress(value=0.0, max=11.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Training'), FloatProgress(value=0.0, max=32.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Validating'), FloatProgress(value=0.0, max=11.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Training'), FloatProgress(value=0.0, max=32.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Validating'), FloatProgress(value=0.0, max=11.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Training'), FloatProgress(value=0.0, max=32.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Validating'), FloatProgress(value=0.0, max=11.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "unet_model = nn.Sequential(\n",
    "    UNetBlock2d(3, 32, layers=2, sub_network=\n",
    "        UNetBlock2d(32, 64, out_channels=32, layers=2, sub_network=\n",
    "            UNetBlock2d(64, 128, out_channels=64, layers=2)\n",
    "        ),\n",
    "    ),\n",
    "    #Prediction for _every_ location\n",
    "    nn.Conv2d(32, 1, (3,3), padding=1), #Shape is now (B, 1, W, H)\n",
    ")\n",
    "\n",
    "unet_results = train_network(unet_model, loss_func, train_seg_loader, epochs=10, device=device, val_loader=test_seg_loader)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-31T15:28:17.874024Z",
     "start_time": "2021-03-31T15:28:17.550990Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:xlabel='epoch', ylabel='val loss'>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "application/pdf": "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
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEJCAYAAACZjSCSAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAABFEElEQVR4nO3dd3hUZfbA8e9J7yGVQBJaQDHUQBIFhFWwgAVUQAGx7q6LK7Dqz4KCirruumtHUZZdUREEe0fADogKAUJvoSeUNNJD6vv7YyYhCQmEkMkkmfN5nnkyc+9775wM4Z6573vvecUYg1JKKcflZO8AlFJK2ZcmAqWUcnCaCJRSysFpIlBKKQeniUAppRycJgKllHJwNk0EIjJcRHaKSJKITKtlfYCIfCoim0RkjYj0tGU8SimlTmWzRCAizsBsYAQQDYwXkegazR4FEo0xvYFbgVdsFY9SSqnaudhw3/FAkjFmL4CILAZGAduqtIkG/glgjNkhIp1EpK0x5lhdOw0ODjadOnWyXdRKKdUKrVu3Lt0YE1LbOlsmgnDgUJXXycCFNdpsBG4AVolIPNARiACqJQIRuQu4C6BDhw4kJCTYKmallGqVRORAXetsOUYgtSyrWc/iWSBARBKBKcAGoPSUjYyZa4yJNcbEhoTUmtCUUko1kC3PCJKByCqvI4DDVRsYY3KAOwBERIB91odSSqkmYsszgrVANxHpLCJuwDjgi6oNRKSNdR3An4AV1uSglFKqidjsjMAYUyoik4FlgDMwzxizVUQmWdfPAS4A5otIGZZB5D/aKh6lmlpJSQnJycmcOHHC3qEoB+Lh4UFERASurq713saWXUMYY5YAS2osm1Pl+a9AN1vGoJS9JCcn4+vrS6dOnbD0fCplW8YYMjIySE5OpnPnzvXeTu8sVspGTpw4QVBQkCYB1WREhKCgoLM+C9VEoJQNaRJQTa0hf3MOkwiSjifx3NrnOFGq/bVKKVWVwySCw/mHmb9tPpvSNtk7FKWa1NGjRxk3bhxRUVFER0dz1VVXsWvXLkSEV199tbLd5MmTefvttwG4/fbbCQ8Pp6ioCID09HT0jv7Wy2ESQUxoDE7ixNpja+0dilJNxhjD9ddfzyWXXMKePXvYtm0b//jHPzh27BihoaG88sorFBcX17qts7Mz8+bNa+KIlT04TCLwdfMlOjCaNUfW2DsUpZrMjz/+iKurK5MmTapc1rdvXyIjIwkJCWHYsGG88847tW5777338tJLL1FaesrN/qqVsenlo81NXFgcC7YvoLC0EE8XT3uHoxzIk19uZdvhxr1XMrq9H09c2+O0bbZs2UL//v3rXD9t2jRGjBjBnXfeecq6Dh06cPHFF/Puu+9y7bXXnnO8qvlymDMCsCSCkvISNqZttHcoSjULnTt3Jj4+nvfee6/W9Y8++ijPPfcc5eXlTRyZakoOdUYQExqDsziz9uhaLmp3kb3DUQ7kTN/cbaVHjx589NFHp23z6KOPMmbMGIYMGXLKuq5du9K3b18++OADW4WomgGHOiPwcfMhOiiatUd1wFg5hqFDh1JUVMR///vfymVr167lwIGTFYm7d+9OdHQ0X331Va37mD59Os8//7zNY1X241CJACzdQ5vTN1NQUmDvUJSyORHh008/5dtvvyUqKooePXowc+ZM2rdvX63d9OnTSU5OrnUfPXr0oF+/fk0RrrITMabmFAHNW2xsrDmXiWlWpazi7u/uZu7lcxnQfkAjRqZUddu3b+eCCy6wdxjKAdX2tyci64wxsbW1d7gzgn6h/SrHCZRSSjlgIvBy9aJHcA9NBEopZeVwiQAgrm0cW9K36DiBUkrhoIkgPiyeUlNKYmqivUNRSim7s2kiEJHhIrJTRJJEZFot6/1F5EsR2SgiW0XkDlvGU6FvaF9cxIU1R7XchFJK2SwRiIgzMBsYAUQD40Ukukaze4Btxpg+wCXAC1XmMLYZL1cvegb31AJ0SimFbc8I4oEkY8xeY0wxsBgYVaONAXzFMpOCD5AJNEmFq7iwOLamb9VxAtWq1VWCev/+/U1ahvqf//wnCxcurLbsp59+YvXq1Q3eZ3M0c+bMFnnznS0TQThwqMrrZOuyql7DMoH9YWAz8DdjTJMUNYkLi6PMlLE+dX1TvJ1STe50JaiBJi1DvXz5cq644opqy06XCLTiadOyZSKobb60mnevXQkkAu2BvsBrIuJ3yo5E7hKRBBFJSEtLa5Tg+oT0wcXJRS8jVa1WXSWoBw8eDNAoZaj//e9/M2vWLADuu+8+hg4dCsD333/PxIkTAcjJyaG4uJiQkJDK7fbv38+cOXN46aWX6Nu3LytXruT222/n/vvv59JLL+Xhhx9mzZo1DBw4kJiYGAYOHMjOnTsBePvtt7nhhhsYPnw43bp146GHHgKgrKyM22+/nZ49e9KrVy9eeuklAC655BLuvfdeBg4cSM+ePVmzxjI2mJmZyXXXXUfv3r256KKL2LTJMmnVzz//TN++fenbty8xMTHk5uYC8NxzzxEXF0fv3r154oknKn+XZ555hvPPP5/LLrusMsbazJ8/n969e9OnTx9uueUWAA4cOMCwYcPo3bs3w4YN4+DBg4DljGzq1KkMHDiQLl26VNaLuummm1iyZEnlPm+//XY+/vjjOt+zvmxZdC4ZiKzyOgLLN/+q7gCeNZbbm5NEZB/QHag2imuMmQvMBcudxY0RnJerF72Ce2kiUE3jm2lwdHPj7jOsF4x4ts7VZypBDedehnrIkCG88MILTJ06lYSEBIqKiigpKWHVqlWVCee7775j2LBh1bbr1KkTkyZNwsfHhwceeACAN998k127dvHdd9/h7OxMTk4OK1aswMXFhe+++45HH3208qCXmJjIhg0bcHd35/zzz2fKlCmkpqaSkpLCli1bAMjKyqp8v/z8fFavXs2KFSu488472bJlC0888QQxMTF89tln/PDDD9x6660kJiby/PPPM3v2bAYNGkReXh4eHh4sX76c3bt3s2bNGowxjBw5khUrVuDt7c3ixYvZsGEDpaWl9OvXr9bPfOvWrTzzzDP88ssvBAcHk5mZCVi642699VZuu+025s2bx9SpU/nss88AOHLkCKtWrWLHjh2MHDmSMWPGMG7cON5//32uuuoqiouL+f7773njjTdO+29cH7Y8I1gLdBORztYB4HHAFzXaHASGAYhIW+B8YK8NY6omLiyObRnbyCvOa6q3VKpZOdcy1P3792fdunXk5ubi7u7OgAEDSEhIYOXKlZWJYOnSpYwYMaJe8YwdOxZnZ2cAsrOzGTt2LD179uS+++5j69atle2GDRuGv78/Hh4eREdHc+DAAbp06cLevXuZMmUKS5cuxc/vZOfC+PHjAUviysnJISsri1WrVlV+Mx86dCgZGRlkZ2czaNAg7r//fmbNmkVWVhYuLi4sX76c5cuXExMTQ79+/dixYwe7d+9m5cqVXH/99Xh5eeHn58fIkSNr/b1++OEHxowZQ3BwMACBgYEA/Prrr0yYMAGAW265hVWrVlVuc9111+Hk5ER0dHRld96IESP44YcfKCoq4ptvvmHIkCF4ep773Co2OyMwxpSKyGRgGeAMzDPGbBWRSdb1c4CngbdFZDOWrqSHjTHptoqppriwOOZumsv61PUMiTi1BK9SjeY039xtpT4lqOHcylC7urrSqVMn3nrrLQYOHEjv3r358ccf2bNnT2WtmzVr1tT7W6u3t3fl88cee4xLL72UTz/9lP3793PJJZdUrnN3d6987uzsTGlpKQEBAWzcuJFly5Yxe/ZsPvjgg8oxDsv1KCeJCLXVWRMRpk2bxtVXX82SJUu46KKL+O677zDG8Mgjj/CXv/ylWvuXX375lH0DHDp0qPIsatKkSRhjam1X2/vX9jtWxOrh4cEll1zCsmXLeP/99ysT3Lmy6X0ExpglxpjzjDFRxphnrMvmWJMAxpjDxpgrjDG9jDE9jTELbBlPTX1C+uDq5ErC0YYXsVOquaqrBPXPP/9crd25lqEeMmQIzz//PEOGDGHw4MHMmTOHvn37IiJs3bqV7t27V37Lr8r
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.lineplot(x='epoch', y='val loss', data=seg_results, label='CNN')\n",
    "sns.lineplot(x='epoch', y='val loss', data=seg_results2, label='CNN w/ transposed-conv')\n",
    "sns.lineplot(x='epoch', y='val loss', data=unet_results, label='UNet')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-31T15:28:17.878290Z",
     "start_time": "2021-03-31T15:28:17.875648Z"
    },
    "tags": [
     "remove_cell"
    ]
   },
   "outputs": [],
   "source": [
    "set_seed(42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-31T15:28:17.887461Z",
     "start_time": "2021-03-31T15:28:17.879653Z"
    }
   },
   "outputs": [],
   "source": [
    "class Class2Detect(Dataset):\n",
    "    \"\"\"This class is used to create a simple converstion of a dataset from a classification problem, to a detection problem. \"\"\"\n",
    "\n",
    "    def __init__(self, dataset, toSample=3, canvas_size=100):\n",
    "        \"\"\"\n",
    "        dataset: the source dataset to sample items from as the \"objects\" to detect\n",
    "        toSample: the maximum number of \"objects\" to put into any image\n",
    "        canvas_size: the width and height of the images to place objects inside of. \n",
    "        \"\"\"\n",
    "        self.dataset = dataset\n",
    "        self.toSample = toSample\n",
    "        self.canvas_size = canvas_size\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.dataset)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        \n",
    "        boxes = []\n",
    "        labels = []\n",
    "        \n",
    "        final_size = self.canvas_size\n",
    "        #First, create a larger image that will store all the \"objects\" to detect\n",
    "        img_p = torch.zeros((final_size,final_size), dtype=torch.float32)\n",
    "        #Now we are going to sample up to self.toSample objects to place into the image\n",
    "        for _ in range(np.random.randint(1,self.toSample+1)):\n",
    "            \n",
    "            #Pick an object at random from the original dataset, and its label\n",
    "            img, label = self.dataset[np.random.randint(0,len(self.dataset))]\n",
    "            #Get the height and width of that image\n",
    "            _, img_h, img_w = img.shape\n",
    "            #Pick a random offset of the x and y axis, essentially placing the image at a random location\n",
    "            offsets = np.random.randint(0,final_size-np.max(img.shape),size=(4))\n",
    "            #Change the padding at the end to make sure we come out to a specific 100,100 shape\n",
    "            offsets[1] = final_size - img.shape[1] - offsets[0]\n",
    "            offsets[3] = final_size - img.shape[2] - offsets[2]\n",
    "            \n",
    "            with torch.no_grad():\n",
    "                img_p = img_p + F.pad(img, tuple(offsets))\n",
    "            #Lets craete the values for the \"boxes\"\n",
    "            #all of these are in absolute pixel locations\n",
    "            \n",
    "            #x_min determined by the randomly selected offset\n",
    "            xmin = offsets[0]\n",
    "            #x_max is the offset plus the image's width\n",
    "            xmax = offsets[0]+img_w\n",
    "            #y min/max follows the same pattern\n",
    "            ymin = offsets[2]\n",
    "            ymax = offsets[2]+img_h\n",
    "            #now we add to the box with the right label\n",
    "            boxes.append( [xmin, ymin, xmax, ymax] )\n",
    "            labels.append( label )\n",
    "\n",
    "            \n",
    "        target = {}\n",
    "        target[\"boxes\"] = torch.as_tensor(boxes, dtype=torch.float32)\n",
    "        target[\"labels\"] = torch.as_tensor(labels, dtype=torch.int64)\n",
    "        \n",
    "        return img_p, target\n",
    "#Caption: This class defines a toy MNIST detector. Images from the MNIST dataset are placed at random locations in an image. The object detector will try to learn to predict where digits are, and what digit is at each location. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-31T15:28:17.913258Z",
     "start_time": "2021-03-31T15:28:17.888995Z"
    }
   },
   "outputs": [],
   "source": [
    "train_data = Class2Detect(torchvision.datasets.MNIST(\"./\", train=True, transform=transforms.ToTensor(), download=True))\n",
    "test_data = Class2Detect(torchvision.datasets.MNIST(\"./\", train=False, transform=transforms.ToTensor(), download=True))\n",
    "\n",
    "def collate_fn(batch):\n",
    "    \"\"\"\n",
    "    batch is going to contain a python list of objects. In our case, our data loader returns (Tensor, Dict) pairs\n",
    "    The FasterRCNN algorithm wants a List[Tensors] and a List[Dict]. So we will use this function to convert the \n",
    "    batch of data into the form we want, and then give it to the Dataloader to use\n",
    "    \"\"\"\n",
    "    imgs = []\n",
    "    labels = []\n",
    "    for img, label in batch:\n",
    "        imgs.append(img)\n",
    "        labels.append(label)\n",
    "    return imgs, labels\n",
    "\n",
    "train_loader = DataLoader(train_data, batch_size=128, shuffle=True, collate_fn=collate_fn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-31T15:28:18.076517Z",
     "start_time": "2021-03-31T15:28:17.914692Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7fd248227510>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "application/pdf": "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
      "image/png": "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
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x, y = train_data[0] # Grab an image with its labels\n",
    "imshow(x.numpy()[0,:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-31T15:28:18.088621Z",
     "start_time": "2021-03-31T15:28:18.077976Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'boxes': tensor([[14., 60., 42., 88.],\n",
      "        [23., 21., 51., 49.],\n",
      "        [29.,  1., 57., 29.]]), 'labels': tensor([0, 1, 8])}\n",
      "Boxes:  tensor([[14., 60., 42., 88.],\n",
      "        [23., 21., 51., 49.],\n",
      "        [29.,  1., 57., 29.]])\n",
      "Labels:  tensor([0, 1, 8])\n"
     ]
    }
   ],
   "source": [
    "print(y) #prints out everything\n",
    "print(\"Boxes: \", y['boxes']) #prints a tensor showing the pixel locations of the corners for all 3 objects\n",
    "print(\"Labels: \", y['labels']) #prints a tensor showing the labels for all 3 objects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-31T15:28:18.091836Z",
     "start_time": "2021-03-31T15:28:18.089734Z"
    }
   },
   "outputs": [],
   "source": [
    "#How many channels are in the input?\n",
    "C = 1\n",
    "#How many classes are there?\n",
    "classes = 10\n",
    "#How many filters in our backbone\n",
    "n_filters = 32"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-31T15:28:18.103107Z",
     "start_time": "2021-03-31T15:28:18.093172Z"
    }
   },
   "outputs": [],
   "source": [
    "backbone = nn.Sequential(\n",
    "    cnnLayer(C, n_filters),    \n",
    "    cnnLayer(n_filters, n_filters),\n",
    "    cnnLayer(n_filters, n_filters),\n",
    "    nn.MaxPool2d((2,2)),\n",
    "    cnnLayer(n_filters, 2*n_filters),\n",
    "    cnnLayer(2*n_filters, 2*n_filters),\n",
    "    cnnLayer(2*n_filters, 2*n_filters),\n",
    "    nn.MaxPool2d((2,2)),\n",
    "    cnnLayer(2*n_filters, 4*n_filters),\n",
    "    cnnLayer(4*n_filters, 4*n_filters),\n",
    ")\n",
    "#Let Faster RCNN know exactly how many output channels to expect\n",
    "backbone.out_channels = n_filters*4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-31T15:28:18.149000Z",
     "start_time": "2021-03-31T15:28:18.104290Z"
    }
   },
   "outputs": [],
   "source": [
    "# How many proposals $k$ should be generated? Every aspect ration will be one, and the process will be repeated for multiple image sizes \n",
    "anchor_generator = AnchorGenerator(sizes=((32),), aspect_ratios=((1.0),)) #To make this run faster, we are telling PyTorch to look for only square images that are 32 x 32 in size\n",
    "\n",
    "#Tell PyTorch to use the final output of the backbone as the featuremap (['0']), use adaptive pooling down to a 7x7 grid (output_size=7)\n",
    "roi_pooler = torchvision.ops.MultiScaleRoIAlign(featmap_names=['0'], output_size=7, sampling_ratio=2)\n",
    "#sampling_ratio is poorly named, and controls details on how the RoI grabs slices of the feature map when a fractional pixel location is predicted (e.g., 5.8 instead of 6). We are not going to go into those low level details, 2 is a reasonable default for most work. \n",
    "        \n",
    "#Now we can create the FasterRCNN object. We give it the backbone network, number of classes, min & max size to process images at (we know all our images at 100 pixels), a mean and standard deviation to subtract from the images, and the anchor generation (RPN) and RoI objects\n",
    "model = FasterRCNN(backbone, num_classes=10, image_mean = [0.5], image_std = [0.229], min_size=100, max_size=100, rpn_anchor_generator=anchor_generator, box_roi_pool=roi_pooler)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-31T15:37:42.859956Z",
     "start_time": "2021-03-31T15:28:18.150662Z"
    },
    "tags": [
     "remove_output"
    ]
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "73af7714d1a34004bd2871485d5a5645",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Epoch'), FloatProgress(value=0.0, max=1.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Train Batch'), FloatProgress(value=0.0, max=469.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "model = model.train()\n",
    "model.to(device)\n",
    "optimizer = torch.optim.AdamW(model.parameters())\n",
    "\n",
    "for epoch in tqdm(range(1), desc=\"Epoch\", disable=False):\n",
    "    running_loss = 0.0\n",
    "    for inputs, labels in tqdm(train_loader, desc=\"Train Batch\", leave=False, disable=False):\n",
    "        #Move the batch to the device we are using. \n",
    "        inputs = moveTo(inputs, device)\n",
    "        labels = moveTo(labels, device)\n",
    "\n",
    "        optimizer.zero_grad()\n",
    "        #rcnn wants model(inputs, labels) - not just model(inputs)\n",
    "        losses = model(inputs, labels)\n",
    "        # Compute loss, RCNN gives us a list of losses to add up.\n",
    "        loss = 0\n",
    "        for partial_loss in losses.values():\n",
    "            loss += partial_loss\n",
    "        #now proceed like normal\n",
    "        loss.backward()\n",
    "        \n",
    "        optimizer.step()\n",
    "\n",
    "        running_loss += loss.item()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-31T15:37:42.866460Z",
     "start_time": "2021-03-31T15:37:42.861250Z"
    }
   },
   "outputs": [],
   "source": [
    "model = model.eval()\n",
    "model = model.to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-31T15:37:42.870296Z",
     "start_time": "2021-03-31T15:37:42.867691Z"
    },
    "tags": [
     "remove_cell"
    ]
   },
   "outputs": [],
   "source": [
    "set_seed(161)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-31T15:37:42.877789Z",
     "start_time": "2021-03-31T15:37:42.871737Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'boxes': tensor([[31., 65., 59., 93.],\n",
      "        [10., 36., 38., 64.],\n",
      "        [64., 24., 92., 52.]]), 'labels': tensor([8, 0, 4])}\n"
     ]
    }
   ],
   "source": [
    "x, y = test_data[0]\n",
    "print(y) #this is the ideal truth we want to get back"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-31T15:37:42.891712Z",
     "start_time": "2021-03-31T15:37:42.879296Z"
    }
   },
   "outputs": [],
   "source": [
    "with torch.no_grad():\n",
    "    pred = model([x.to(device)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-31T15:37:42.897062Z",
     "start_time": "2021-03-31T15:37:42.892791Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[{'boxes': tensor([[31.9313, 65.4917, 59.7824, 93.3052],\n",
      "        [64.1321, 23.8941, 92.0808, 51.8841],\n",
      "        [70.3358, 26.2407, 96.2834, 53.7900],\n",
      "        [64.9917, 24.2980, 92.9516, 52.2016],\n",
      "        [30.9127, 65.1308, 58.6978, 93.3224]], device='cuda:0'), 'labels': tensor([8, 4, 1, 9, 5], device='cuda:0'), 'scores': tensor([0.9896, 0.9868, 0.1201, 0.0699, 0.0555], device='cuda:0')}]\n"
     ]
    }
   ],
   "source": [
    "print(pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-31T15:37:42.900668Z",
     "start_time": "2021-03-31T15:37:42.898381Z"
    }
   },
   "outputs": [],
   "source": [
    "import matplotlib.patches as patches"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-31T15:37:42.907776Z",
     "start_time": "2021-03-31T15:37:42.902003Z"
    }
   },
   "outputs": [],
   "source": [
    "def plotDetection(ax, abs_pos, label=None):\n",
    "    \"\"\"\n",
    "    ax: the matpllib axis to add this plot to\n",
    "    abs_pos: the positions of the bounding box\n",
    "    label: the label of the prediction to add\n",
    "    \"\"\"\n",
    "    x1, y1, x2, y2 = abs_pos\n",
    "    #make a rectangle for the bounding box\n",
    "    rect = patches.Rectangle((x1,y1),x2-x1,y2-y1,linewidth=1,edgecolor='r',facecolor='none')\n",
    "    ax.add_patch(rect)\n",
    "    #add the label if given\n",
    "    if label is not None:\n",
    "        plt.text(x1+0.5, y1, label, color='black', bbox=dict(facecolor='white', edgecolor='white', pad=1.0))\n",
    "    \n",
    "    return \n",
    "\n",
    "def showPreds(img, pred):\n",
    "    \"\"\"\n",
    "    img: the image to show the bounding box predictions for\n",
    "    pred: the Faster R-CNN predictions to show ontop of the image\n",
    "    \"\"\"\n",
    "    fig,ax = plt.subplots(1)\n",
    "    #plot the image\n",
    "    ax.imshow(img.cpu().numpy()[0,:])\n",
    "    #grab the predictions\n",
    "    boxes = pred['boxes'].cpu()\n",
    "    labels = pred['labels'].cpu()\n",
    "    scores = pred['scores'].cpu()\n",
    "    \n",
    "    num_preds = labels.shape[0]\n",
    "    #for each prediction, plot if if it has a high enough score\n",
    "    for i in range(num_preds):\n",
    "        plotDetection(ax, boxes[i].cpu().numpy(), label=str(labels[i].item()))\n",
    "    \n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-31T15:37:43.104631Z",
     "start_time": "2021-03-31T15:37:42.908906Z"
    }
   },
   "outputs": [
    {
     "data": {
      "application/pdf": "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
      "image/png": "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
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "showPreds(x, pred[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-31T15:37:43.108447Z",
     "start_time": "2021-03-31T15:37:43.105938Z"
    }
   },
   "outputs": [],
   "source": [
    "from torchvision.ops import nms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-31T15:37:43.116099Z",
     "start_time": "2021-03-31T15:37:43.109882Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[31.9313, 65.4917, 59.7824, 93.3052],\n",
      "        [64.1321, 23.8941, 92.0808, 51.8841],\n",
      "        [70.3358, 26.2407, 96.2834, 53.7900],\n",
      "        [64.9917, 24.2980, 92.9516, 52.2016],\n",
      "        [30.9127, 65.1308, 58.6978, 93.3224]], device='cuda:0')\n"
     ]
    }
   ],
   "source": [
    "print(pred[0]['boxes'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-31T15:37:43.121366Z",
     "start_time": "2021-03-31T15:37:43.117412Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([0.9896, 0.9868, 0.1201, 0.0699, 0.0555], device='cuda:0')\n"
     ]
    }
   ],
   "source": [
    "print(pred[0]['scores'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-31T15:37:43.126997Z",
     "start_time": "2021-03-31T15:37:43.122968Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([0, 1], device='cuda:0')\n"
     ]
    }
   ],
   "source": [
    "print(nms(pred[0]['boxes'], pred[0]['scores'], 0.5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-31T15:37:43.134345Z",
     "start_time": "2021-03-31T15:37:43.128588Z"
    }
   },
   "outputs": [],
   "source": [
    "def showPreds(img, pred, iou_max_overlap=0.5, min_score=0.05, label_names=None):\n",
    "    \"\"\"\n",
    "    img: the original image object detection was performed on\n",
    "    pred: the output dictionary from FasterRCNN for evaluation on img\n",
    "    iou_max_overlap: the iou threshold at which non-maximum suppression will be performed\n",
    "    min_score: the minimum RPN network score to consider an object\n",
    "    \"\"\"\n",
    "    fig,ax = plt.subplots(1)\n",
    "    img = img.cpu().numpy()\n",
    "    if img.shape[0] == 1:\n",
    "        ax.imshow(img[0,:])\n",
    "    else:\n",
    "        ax.imshow(np.moveaxis(img, 0, 2))\n",
    "    boxes = pred['boxes'].cpu()\n",
    "    labels = pred['labels'].cpu()\n",
    "    scores = pred['scores'].cpu()\n",
    "    \n",
    "    selected = nms(boxes, scores, iou_max_overlap).cpu().numpy()\n",
    "    \n",
    "    for i in selected:\n",
    "        if scores[i].item() > min_score:\n",
    "            if label_names is None:\n",
    "                label = str(labels[i].item())\n",
    "            else:\n",
    "                label = label_names[labels[i].item()]\n",
    "            plotDetection(ax, boxes[i].cpu().numpy(), label=label)\n",
    "    \n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-31T15:37:43.310039Z",
     "start_time": "2021-03-31T15:37:43.135729Z"
    }
   },
   "outputs": [
    {
     "data": {
      "application/pdf": "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
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPsAAAD7CAYAAACscuKmAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAAuEklEQVR4nO3deZwb533n+c+vqlCFG2j0fbJ5tERSEinK1G3JNGVZtqKNN47s2BN7vYk92p14EjuJdyzPvOblyWz2FW/WE8eZySQj2/EmVnZkj+KJFDlWJOsYH5KoWyIpimeT3c2+TzTuQtWzfwAmKYsSm2IfAPG89cILBApA/dDqb9dTTz31lCil0DTt4mesdQGapq0OHXZNaxA67JrWIHTYNa1B6LBrWoPQYde0BnFBYReRD4jIQRE5IiJ3L1dRmqYtP3mnx9lFxAQOAbcCI8BzwMeVUq8tX3mapi0X6wLeew1wRCl1DEBE7gM+BLxl2G1xVJDIBaxS07S3UyBLSRXlbMsuJOzdwPAZj0eAa3/xRSJyF3AXQJAw18otF7BKTdPezh712Fsuu5B99rP99XjTPoFS6h6l1E6l1M4AzgWsTtO0C3EhYR8Bes943AOMXlg5mqatlAsJ+3PAgIisFxEb+Bjw4PKUpWnacnvH++xKqbKI/EvgnwAT+Cul1P5lq0zTtGV1IR10KKX+EfjHZapF07QVpEfQaVqD0GHXtAahw65pDUKHXdMahA67pjUIHXZNaxA67JrWIHTYNa1B6LBrWoPQYde0BqHDrmkNQodd0xqEDrumNQgddk1rEDrsmtYgdNg1rUHosGtag9Bh17QGocOuaQ1Ch13TGoQOu6Y1CB12TWsQOuya1iB02DWtQeiwa1qD0GHXtAahw65pDUKHXdMahA67pjUIHXZNaxA67JrWIHTYNa1B6LBrWoPQYde0BqHDrmkN4pxhF5FeEXlCRA6IyH4R+Vz1+ZSIPCoih6v3TStfrqZp79RStuxl4PeVUluA64DPishW4G7gMaXUAPBY9bGmaTXKOtcLlFJjwFj134sicgDoBj4E7Kq+7K+BJ4EvrkiVWsP67ug9pDreutE4Oz7Hr3XdtYoV1a/z2mcXkX5gB7AHaK/+Ifj5H4S2t3jPXSLyvIg871K8wHK1RvN2QV/Kcu20JYddRKLA3wGfV0qll/o+pdQ9SqmdSqmdAZx3UqOmAeB5Hjt27OCOO+5Y61Lq0pLCLiIBKkH/W6XU96tPT4hIZ3V5JzC5MiVqWsXXv/51tmzZstZl1K2l9MYL8C3ggFLqT85Y9CDwqeq/PwU8sPzlaVrFyMgIP/jBD/jMZz6z1qXUraVs2W8EPgnsFpGXq7fbga8At4rIYeDW6mNNWxGf//zn+eM//mMMQw8NeaeW0hv/U0DeYvEty1uOpr3ZQw89RFtbG+9617t48skn17qcuqX/TGo172c/+xkPPvgg/f39fOxjH+Pxxx/nE5/4xFqXVXd02LWa90d/9EeMjIxw/Phx7rvvPnbv3s2999671mXVnXM24zVtrXxH/eOSXveoun+FK1k944T5pNy+Ip+tw67VrA5yb3pu165d7Nq16w3P3Sp3rlJFK28l/3DpZrymNQgddq2mzY7PXdBy7TTdjNdqmj7JZfnoLbumNQgddk1rEDrsmtYgdNg1rUHoDjqtbknARkwDCToQsMEQxDBQhSLeQhqUD0qtdZk1Q4ddq0sSsPF3biHfEWTyKgMuyRIJFWmO5Dj2aj+X/vkEzC3gzS2A7611uTVBh12rS2IaFNod0n0mke0z/JvNP2RjYIrLbItfMe+gHEthZvOIISh/rautDTrsWn0RwQiFMBJxJnaaRLbN8OH+V7jCGcNEMea5pItBIp6H8n2Ur5vxP6fDrtUXMRDHQcUiMJDl9y/9EVc6I6yzbGa9IhNegLwbIOop8HTz/Uw67FpdMUJBylvXke1y6G85yWZ7jJThARYH3Tg/TG9jejxOW2YCP5dHt+FP02HX6oqEw8xcHiLTCx9sPcLltkB11uK9hV5+eGILwWEbNbeAn3vzWXONTB9n1+qLIZSDghdShI3SmxYr9VYzqGk67FpdEcvCjYPXVCZh6i33+dDNeK3uKAOQN/eyO4ZLxCkxZysIWCCyooNqxLIwEnHEtvHbmvAdC/EVKIU5Pkd5bKKmBvbosGsXjf7AFNe0neAfWpqQcBgjX8DP51csbEYiTn7nBnJtAabeV6SzfZ58KYDrmTgPraP1e4uoUglVrI3Lnumwa/XF9zFKQMnAVSbGGXuicaNAtzOPhLzKlt00V7QUCQQoNFvk24T13dO8u/UoC+UQ2bLDM03bEcsCz6M2tus67FqdUYUi8eM+hhdg6JpmYOjUsksDRdrjL/EPbVfgR4NINgTZHKiVOd6umuJMXynQk+OTPc9wU+gYJWXgYvBE+zYkEq68sEaOCuiwa/XF83AWPNyoMF8O4yoPUwQDg6jhEDWgJZQlH45iBR3ENFErNDZeBUzKyTJdqTQD9jh9VggAHx8/6INlglk7feC1U4mmLYGfLxA+NE1qf44nT2zi3sV+DrpvDPNAbJLxa6PMXdeN2dOJ2dRUaVKvEu/nfQRK1UznHOiwa3VGlV3U6ASBoWnyU2GeS69ntJyobE2r/3XaC2TW+Sz2GviJSKU5vYL7774SPIxT668UumKre8d0M16rL0pVerizOZJ7LR4vXoF/nbC162HCIsQMm2vDR3j5+h4OzHQwFGghNJmg7ZkojE7iZ7Io982DcRqBDrtWd1S5jJ/J0vpKjvCUw56+dYy3O7QaRWIG7HQ8dvY9xkvtBp9VH2dmNEHsZJxwroCUyzrsmlZPlOdhTaaJuhFmX03wWfvX2d19iM83/5SgGISNAK1mnt3dhzkQ6+DQzf2EB7pJHmkjNJbFmEnjT02jPP+8w282p/D7O5m/JEZ7zzRXtw7RbOSp9TjVdnWa9lZ8D+/IIGKarFNbSB9I8b1bd/KrtzxHq1HEEUWP5fAHbXtYaClxb8t2Xs908uQzlxM/nKTpYIhgqYTkC3jnGXbV2cbYTQky/T5fXP8U1wQH6TJrcCf9F+iwa/VLKVS5jDmfJTJqEToR4qsnP8CV8RE+0/QiUQIExCRmWFzqjBGUMi+u72HeiVOKO0Q7N2JnfZxZF6PoYS4WkZILc2kol5FwCAIWfjyMH7YphwO4MZPFbov0FpdkxyL9gSkShktAaj9KtV+hpp2DPziEOWSybnEjQ4MDvPCuAd7zoQNssHKkTAdHArwnNIMfnOaOK/eT224yXE5yvNTCS5k+nhntZzEdwjmawl6AlleTWJkS2d4wpZjBwiYodbp0d8/yP3Xvpcee5SpnmIjhkzIsDGxMqf2z7XTYtbqnymUolzHnFomeDJLtDPL38+9ic2iMq0PHiUmRmCEExaTLCmBgkDJm6LXmiZkFSr7FULSJY+U2SmkLs2hj5W1y7UI5onD7inS3zXN92yDvibxOyizQYwZODeb5RR4e1GD2lxx2ETGB54GTSqk7RCQFfBfoB44DH1VK6avsaWvGG53AnlugZ6aLJ2av4wcdQud7R9iSmOCDTa/Qb83RZbpEDYeU6RAzPFrNIa4ODuEqg/kNDlnfYfwDCQrKJm7kCRouKTNDXIokDJeUaeIrIaNcAkoIG4E3Bf7UVr7Gtvbns2X/HHAAiFcf3w08ppT6iojcXX38xWWur6YZwSBi2+A4iGNXRkt5Hsp18RfSKM+rqRFUFzvllvDcEuaYQ+r1IHY2yOClLWRLNslAjqngBAP2OK1m/tR7AijCArbhs94qA2Ugi49/KsRFVcZFUVIw7XlklcW8HyQiJS4NeDjyNmPTaijwSwq7iPQAvwT8X8DvVZ/+ELCr+u+/Bp6kUcIugtg2+d1XML8xwMJlZS7bPMxcIcRMOoJ3LMqm/28Oc3IOb3qm0szUVo0/v4B10KdpJExkpBkvnOSx5hv5p5CQ3gClltPDa814iY5Umq7oArc17ydm5gmKiyk+ASqvezo7wOFsG69NtzM3FkeKBoFFg1JXift3/QXb7Deuv1aHyy51y/6nwL8CYmc8166UGgNQSo2
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "showPreds(x, pred[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-31T15:37:44.134523Z",
     "start_time": "2021-03-31T15:37:43.311416Z"
    },
    "tags": [
     "remove_output"
    ]
   },
   "outputs": [],
   "source": [
    "rcnn = torchvision.models.detection.fasterrcnn_resnet50_fpn(pretrained=True)\n",
    "# This RCNN detector is pre setup for a specific set of classes. You can re-use it for your own problems by setting num_classes=10 and pretrained_backbone=True, and then training it with your own data like we did before with MNIST. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-31T15:37:44.138784Z",
     "start_time": "2021-03-31T15:37:44.136194Z"
    }
   },
   "outputs": [],
   "source": [
    "rcnn = rcnn.eval()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-31T15:37:44.144505Z",
     "start_time": "2021-03-31T15:37:44.140143Z"
    }
   },
   "outputs": [],
   "source": [
    "# COCO_INSTANCE_CATEGORY_NAMES, these come from the PyTorch documentation. https://pytorch.org/docs/stable/torchvision/models.html#object-detection-instance-segmentation-and-person-keypoint-detection\n",
    "NAME = [\n",
    "    '__background__', 'person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus',\n",
    "    'train', 'truck', 'boat', 'traffic light', 'fire hydrant', 'N/A', 'stop sign',\n",
    "    'parking meter', 'bench', 'bird', 'cat', 'dog', 'horse', 'sheep', 'cow',\n",
    "    'elephant', 'bear', 'zebra', 'giraffe', 'N/A', 'backpack', 'umbrella', 'N/A', 'N/A',\n",
    "    'handbag', 'tie', 'suitcase', 'frisbee', 'skis', 'snowboard', 'sports ball',\n",
    "    'kite', 'baseball bat', 'baseball glove', 'skateboard', 'surfboard', 'tennis racket',\n",
    "    'bottle', 'N/A', 'wine glass', 'cup', 'fork', 'knife', 'spoon', 'bowl',\n",
    "    'banana', 'apple', 'sandwich', 'orange', 'broccoli', 'carrot', 'hot dog', 'pizza',\n",
    "    'donut', 'cake', 'chair', 'couch', 'potted plant', 'bed', 'N/A', 'dining table',\n",
    "    'N/A', 'N/A', 'toilet', 'N/A', 'tv', 'laptop', 'mouse', 'remote', 'keyboard', 'cell phone',\n",
    "    'microwave', 'oven', 'toaster', 'sink', 'refrigerator', 'N/A', 'book',\n",
    "    'clock', 'vase', 'scissors', 'teddy bear', 'hair drier', 'toothbrush'\n",
    "]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-31T15:37:44.599282Z",
     "start_time": "2021-03-31T15:37:44.146011Z"
    }
   },
   "outputs": [],
   "source": [
    "from PIL import Image\n",
    "import requests\n",
    "from io import BytesIO\n",
    "\n",
    "urls = [\n",
    "    \"https://hips.hearstapps.com/hmg-prod.s3.amazonaws.com/images/10best-cars-group-cropped-1542126037.jpg\",\n",
    "    \"https://miro.medium.com/max/5686/1*ZqJFvYiS5GmLajfUfyzFQA.jpeg\",\n",
    "    \"https://www.denverpost.com/wp-content/uploads/2018/03/virginia_umbc_001.jpg?w=910\"\n",
    "]\n",
    "\n",
    "response = requests.get(urls[0])\n",
    "img = Image.open(BytesIO(response.content))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-31T15:37:47.766816Z",
     "start_time": "2021-03-31T15:37:44.601635Z"
    }
   },
   "outputs": [],
   "source": [
    "img = np.asarray(img)/256.0\n",
    "img = torch.tensor(img, dtype=torch.float32).permute((2,0,1))\n",
    "\n",
    "with torch.no_grad():\n",
    "    pred = rcnn([img]) # Pass the image to the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-31T15:37:49.660060Z",
     "start_time": "2021-03-31T15:37:47.768107Z"
    }
   },
   "outputs": [
    {
     "data": {
      "application/pdf": "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
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX0AAADvCAYAAAAeoAStAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOz9eaxl237Xi33GmP1c/Vq739Wf/tzeHQY/I56sEKIgPYGMHSIBFlGIUBACxYLkSUj4D/5zXhQhEcVRQEIv5AkpFnkyBCu84Mcz2Pf69veerqpOVe1du1/9WnPNfo6RP+Zczd5Vda4JcHMt15Cq9t6zG/331/+G0Frzurwur8vr8rr84Sjy/98NeF1el9fldXldfnjlNei/Lq/L6/K6/CEqr0H/dXldXpfX5Q9ReQ36r8vr8rq8Ln+IymvQf11el9fldflDVF6D/uvyurwur8sfovJDB30hxJ8SQnwihHgshPjf/rDrf11el9fldfnDXMQP009fCGEAD4H/EXAC/B7w57XWH/7QGvG6vC6vy+vyh7j8sDn9nwIea62faK1T4L8B/osfchtel9fldXld/tAW84dc3yHwfOPvE+CP3HxICPFXgL8C4Hvuj79x7+6NJzalE/GK6y+7v/Gk3nxeVPW+st1cf+DVD25+d/WruHl/9de1Ft8UuvT1/16o97NktNW9z5Dk1nfEiw39fdXzqnn4Qe36jHnSyx+/PwlU/77qXvbtJQMsPqN/n9GEf3/5WF/78dnfEa+4+5I+vLqm8o3fV30vG29x84Hf11u//3dEuTZ/H13SL/nts+t4yeWXvqqrXmqEVqg8A50jtAJdUBTlPyElColhWmS5xrQdDNMu8UC/WMHLV7dCqIwij5AopDTQugCtkVKiVY5hGEgpUAqSNKPIFZ7vk2dJ+ZwhkYZBnqUgJJZlkWUZSinKgRSoQgGgtGY6TwZa6+2bbflhg/7LdueL86P1rwG/BvDF99/V//yf/J83AFmwCVLiByL1RuU3QFsg0bpae1Ii0AhDAxKl1lAhhUTK8g9VzfPyvTzTFIVCa4VSGq0FSikKXYCWFIXCNC2ElGihyZVCK41SqvxHOUFKg9Jlt/SNQdFagL4ulBUbG04IwaaaTmvQy7aq68N77bnVUCwBV6x+Xz6mBCihPwMtNAixel6z/sbyyuqe1qu2qqpatezwtXfExtvlM7qa8pvqyPLvjTq15EVi+u8HlOvnr5MoAdUYsZo3LfSLxPraXLzk92rMlpOtX/LsulR90+XYvhojy3FYfkPz4py9MHZoCr3RR62v9VjrNSHeZBBeaGb13sv6em0sl9/R12dI6817637cfGZz5W62QWu9Gpeyvs01t1FXtXE3x0iikXlMcHlMzYohHhPOpxg6IklTJpMpwnRxWnvs33kXvC6JqJFpgcLYWJPX1/nNn4bM8EWMmQ+wiVFZwHzch3xOs9VC6ACTjHa7TRIXPPzkU6JFitdokGYJvU6DLMuQUhLFAfuH96k1GpydPEUgmE6mdNtb9AdjkjRDmgb/9//2gyNeUn7YoH8C3N74+xZw9plviDXAlkVv4JR+JX8qhFht0NWyU+tvlARj4wWt0UIgFCBBSnn9W0KVbJMUiGrzqUIiZbmIlBIb4CtQhSSOY/I8x7IsNAIlIE1TpDRRqkAYJhhlO68t4mvtktzUwpWAKVaDchPwhRBrfuoGQdi8JgQVYFejWI0peklMNXLZV5ZAdQM8xE0pablpVw+s7onVswJZbWIpynG5/l290edqrqg4sxttEKt31cZCkNdJyLK/ZXPWn63a9wJTWy24FR94rb/luwYgpaAQJTi+COgvlhVgV2Ortdhov34pA7MEFIRArMZiDWJ69V256ivLEROvJnjleAjkRpWr7fHCIF0HVbHkcKufWpTzIwQotRznm30R1zjrFwZdsAH4ZT/Eiohtrs9l7zaYno0vimut3fjsst7VOC7ZE40pIbUNLAlZkZInAcFiwmyRECxSdm9vkeTw/PkZnVseVr2OFHJNFF/SpmtdEyCEgRIWYQhRFlPzXPzWAXkScDUa0Kg7eLaJwmM0ekqtZiOlQRSHaMC0XIIgpNXucn4xINPPqdddgumYmt9ECDAMjWMbeI6H6eYvaUlZftig/3vAW0KI+8Ap8D8D/uef+cYGZV5dqoBpNbFCrP4tuYaSgzRKDmHjX/lJvX6+qmMTkMr1Ja59u1w9ilxXm1xplNKoQpOrgqxgfU0rsrwgTmLSLMNzPQzTJMsVUZTgei6LcIG0LJrN5g8YsheX0XKtbYLEdRDUFWGqiOIGUG72c7VpVpy6Rgi54sYQGqFBaIFeIfdm3S9yuVSbVMjln5WIdLMfQiCWHOIrNsu6wvU836hstfGW7UFcB+wlCL/wrlhv082fq/EQFXRsSCfLMVyqhNQGeK2eqYixWBLlTaJbgeOSyK6apDVyYz7WfXtJn7V6Kb1avr1uQkk4N+fpZetAblZa9WsT3K/1aTkdmzMmxEpiBoGUrLQ2LwX3G0VvjJWQFeBfkz6omJDr4L0kNBskYXmrvC6u35CAFgrQGEoTBXMsQyBEgelYWKZJGhcEs4DRsE8SBxRKIg2T4WhMlM2w/IRJKjm85+C2OkhREW4tV+uC9XBtrBuFIQSLyZR4PMGxwDIdpCkxai3u7L7DZHyM5QQMphOEEDSaTWoNyWw6QSlFnidYlsXRk2MWUU4QjRD7XZSSFAU0mi1Goym242Laktk0euWY/1BBX2udCyH+GvCblMzSP9Raf/CZ7wBFUQA3N4DY+K0EFnGNldu4LwRiuRpZ/rgBgEvCAOhCXWPY1hsAVMXVFUVBnhcopckVKC1Xm00pBVpjGiZRklQqnYI0zUjSmEIpBqMRh7cOV2pBUXFO6w1T1S00gkr8qIpRgZTaeO5lHLBEoDbUD1LKF8XuJRO1sWuE0Ku2LHeQpFSxbBKRa8B1sx1UnDmq5EI3JZlNcbxq7JIAbDzFZ5Wynuorq3eXFKmo1sSaA16/V31drmpfcYigQMkN4HxFvUuCuOS9V8NRrSe9ZFrFSyDvRSC8Joksn3pBYKi44BfeXt+/pqMWG+/oak5X+6TcC2pTutAao1ppFc6uAF8vB6nq27VatQaKjfl4ke9er8lNUnCDEG32cyWtcO2e3JiTFStwQ0JaakENBEIplutZ5xlJNMf1HEzTYrIYEqURruegU5dOp0U0S8l8j2azgdGukyvBYJZweP9dhNNGuh0s20c6DogChUALWar5EGgleWHdihKfhEqZT0dYQJErFmGCRmDXGkS6oNa8Q6FH5GFGva5wzJQo0ogiZ7vXZTSa025uE0c5mgW5LtDKJC8KLNvFsgx6WwazYIrEApW9dJXAD5/TR2v9L4B/8e/xAkWhWepqgQ1OXFSi03oDw3oxfJYud1M62CQYQoA0jNUzCLGqqwT9EvC1BsMQIBVSKaQWKzG/NP6UHIBpmKAUFIJGzUNTkKU5d28d4Lg2qKJUJVXrVt0gREIs720I39pAV7CmN/7d7J/WeiUVXNfIrKUi/UqwrepeicKCgutAdF0dc13qWKuDVwj40lqWqp1NgFyL9OVbBvIa8brZz83+Lj++6pVU1XfWKitNyVkvv79CNb0mVks2U6wr2uDYy+8ZVWXLPqx7uGYAXqa2eUHuuYHwN9/RG+P3okSw8f6KSLOiWqrSaa45/iWVX4LoddCV1fc0pXRXsJR4lo3X6+9vzPvmnJXPGOWoX5PANyXPF0bhJd9brtXlmKxfWTJHSyK8mhoJJjlCZ8xGfdqdNoZpkGYxk4tjPN+l0W6zv7/NxfNnLCZDMtum4e7iez4zBIaUSKEIkwJp11gkcO/ubZIcXMdlsQi4PH6C3+pS72xTFAIMEymXGLDZ0HLOTGnQ625Rs0DqjPk8IFcKpSSW1SBVJkoUFMYCyxPsdmpcXJ7RajVotDukKcznc4SwyLMEw3QJ5iFZltNsFPS22oSLAffv32I8GCBatZurZFV+6KD/71u0hjwt0BRIvV4mAlFR9Re5zerNlcj5KvBfA75gqccWAoQUSFn9jQCx1GwDgsrKbqAqdY+lSsk
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "showPreds(img, pred[0], iou_max_overlap=0.15, min_score=0.15, label_names=NAME)"
   ]
  }
 ],
 "metadata": {
  "author": "mes$",
  "celltoolbar": "Tags",
  "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.7.9"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  },
  "latex_metadata": {
   "title": "Object Detection"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}