model.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "view-in-github"
   },
   "source": [
    "<a href=\"https://colab.research.google.com/github/alongstar518/kaggle-steal_defect_classficiation_segementation/blob/master/221_final_model.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "jrE-XVcM44qr"
   },
   "source": [
    "### CS221 Final Project: Steel Defect Detection \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "1qR0J8qbWRTz"
   },
   "source": [
    "# To do:\n",
    "1. Add Data argumentation.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "LMGIQZgjpMO9"
   },
   "source": [
    "# Routine"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "w-EvsLVbSHCZ"
   },
   "source": [
    "### install packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "OC82MEAsSMyt"
   },
   "outputs": [],
   "source": [
    "# No"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "E88AO-Gw44qu"
   },
   "source": [
    "### Import necessary libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_cell_guid": "79c7e3d0-c299-4dcb-8224-4455121ee9b0",
    "_uuid": "d629ff2d2480ee46fbb7e2d37f6b5fab8052498a",
    "colab": {},
    "colab_type": "code",
    "id": "goMfOUNL44qv"
   },
   "outputs": [],
   "source": [
    "import math\n",
    "import numbers\n",
    "import io\n",
    "import os\n",
    "import pdb\n",
    "import re\n",
    "import random\n",
    "import shutil\n",
    "\n",
    "from collections import OrderedDict\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import pandas as pd\n",
    "import cv2\n",
    "\n",
    "from PIL import Image\n",
    "from tqdm import tqdm_notebook\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.init\n",
    "import torch.optim as optim \n",
    "import torchvision\n",
    "import torch.utils.data as utils\n",
    "import torch.utils.model_zoo as model_zoo\n",
    "import torch.nn.functional as F\n",
    "import torchvision.transforms.functional as vF\n",
    "from torch.nn import NLLLoss, MultiLabelSoftMarginLoss\n",
    "import torch.jit\n",
    "import tensorboard\n",
    "import torchvision.models as models\n",
    "\n",
    "from torch import Tensor\n",
    "from torchvision import models\n",
    "from torch.utils.data import DataLoader, Dataset\n",
    "from tensorboard import notebook\n",
    "from torch.utils.tensorboard import SummaryWriter\n",
    "from torchsummary import summary\n",
    "from torch.autograd import Variable\n",
    "from torchvision import transforms\n",
    "from torch.optim.lr_scheduler import ReduceLROnPlateau\n",
    "\n",
    "try:\n",
    "    from torch.hub import load_state_dict_from_url\n",
    "except ImportError:\n",
    "    from torch.utils.model_zoo import load_url as load_state_dict_from_url"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "xZEX96Lh7xEg"
   },
   "source": [
    "### Print torch and cuda information"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 136
    },
    "colab_type": "code",
    "id": "o6yTwds977TR",
    "outputId": "b9d14333-d425-4b14-9240-a7de7acfe366"
   },
   "outputs": [],
   "source": [
    "print(\"torch version: {}\".format(torch.__version__))\n",
    "print(\"Cuda device avaliablity: {}\".format(torch.cuda.is_available()))\n",
    "cuda_device_count = torch.cuda.device_count()\n",
    "if cuda_device_count == 0:\n",
    "  raise Exception(\"ERROR: No Cuda Device Avaliable!! Stop!!!!\")\n",
    "print(\"cuda device count = {}\".format(cuda_device_count))\n",
    "for device_id in range(cuda_device_count):\n",
    "  print(\"Cuda device name: {}\".format(torch.cuda.get_device_name(device_id)))\n",
    "  print(\"Cuda device Capilibility for {}:{}\".format(\n",
    "      device_id,\n",
    "      torch.cuda.get_device_capability(device=device_id)\n",
    "    )\n",
    "  )\n",
    "  gpu_ram = (\n",
    "      torch.cuda.get_device_properties(device=device_id).total_memory / (1024) **3\n",
    "  )\n",
    "  print(f\"GPU{device_id} RAM: {gpu_ram} GB\")\n",
    "  print(\"===\")\n",
    "#!nvidia-smi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "602qzAwtTEjx"
   },
   "source": [
    "# Configs\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "C5LQpbyYxsBK"
   },
   "source": [
    "## basic config:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "DEoG4ebyTG3i"
   },
   "outputs": [],
   "source": [
    "reload_data = True\n",
    "clear_tensor_board_history = False\n",
    "reload_last_model = True\n",
    "pretrained_backbone = True\n",
    "data_argumentation = True\n",
    "ping_pong_argumentation = False\n",
    "#must_argument = True\n",
    "\n",
    "inference_mode = True\n",
    "\n",
    "print_model_summary = False\n",
    "leave_progress_bar = False\n",
    "debug = False\n",
    "multi_gpu = False\n",
    "device = 0\n",
    "\n",
    "pic_resize = False\n",
    "pic_size = (256, 1600)\n",
    "rand_crop_size = (256, 256)\n",
    "\n",
    "backbone_type = \"densenet\" # or \"resnet\" or \"effnet_b0\" or densenet\n",
    "model_file_name = f\"best_{backbone_type}.pth\"\n",
    "# path to local project folder contains the data\n",
    "path = \"/home/zheng/git/cs221_finalproject\"\n",
    "data_path = os.path.join(path, \"data\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "IbTMFt80pr_d"
   },
   "source": [
    "## data split config"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "dOhTSyqEpwCz"
   },
   "outputs": [],
   "source": [
    "train_data_percent = 0.8\n",
    "eval_data_percent = 0.1\n",
    "test_data_percent = 0.1 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "0_XzUBIC5U-s"
   },
   "source": [
    "##hyperparamters:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "bEzjFzXJ5YDb"
   },
   "outputs": [],
   "source": [
    "batch_size = 2\n",
    "n_classes = 5\n",
    "total_epochs = 300\n",
    "weight_decay=1e-4\n",
    "lr = 0.001\n",
    "momentum=0.9\n",
    "eval_interval = 200"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "rr577pHYMaH1"
   },
   "source": [
    "### adjust config"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "-BWNie3_MZCY"
   },
   "outputs": [],
   "source": [
    "if inference_mode:\n",
    "  reload_last_model = True\n",
    "\n",
    "device = torch.device(f\"cuda:{device}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "YxwD-ek_vr1d"
   },
   "source": [
    "# Data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "nNrvGJrZ44qx"
   },
   "source": [
    "### download data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 241
    },
    "colab_type": "code",
    "id": "YirRY6xP44qx",
    "outputId": "95d9e046-5081-44ad-a37a-af2ebfaabeeb"
   },
   "outputs": [],
   "source": [
    "_run_on_local = False\n",
    "try:\n",
    "  # delay import so we can run on local machine\n",
    "  # this also check if run it on google drive or not . if it is not, it will \n",
    "  # avoiding runing from google colab, but running from local.\n",
    "  from google.colab import drive\n",
    "  path = \"/content/drive/My Drive/share/\"\n",
    "  remote_data_path = os.path.join(path, \"data\")\n",
    "  data_path = \"/content/data\"\n",
    "  data_zip_path = os.path.join(\n",
    "        remote_data_path, \"severstal-steel-defect-detection.zip\"\n",
    "      )\n",
    "  model_save_path = path\n",
    "  data_zip_path_dst = \"/content/severstal-steel-defect-detection.zip\"\n",
    "  os.makedirs(data_path, exist_ok=True)\n",
    "\n",
    "  if reload_data:\n",
    "    print(\"login to google drive\")\n",
    "    drive.mount('/content/drive')\n",
    "    print(\"Copy raw data from {} to {}\".format(\n",
    "        data_zip_path, data_zip_path_dst)\n",
    "    )\n",
    "    shutil.copy(data_zip_path, \"/content\")\n",
    "\n",
    "    print(\"unzip raw data...\")\n",
    "    os.system(\"unzip {} -d {}\".format(data_zip_path_dst, data_path))\n",
    "    \n",
    "    print(\"give back missing permissions for unzipping\")\n",
    "    os.system(\n",
    "      \"chmod +wrx /content/data/train_images.zip /content/data/test_images.zip\"\n",
    "    )\n",
    "    \n",
    "    print(\"unzipping data...\")\n",
    "    os.system(\"unzip {} -d {}\".format(\n",
    "        os.path.join(data_path,\"train_images.zip\"), \n",
    "        os.path.join(data_path,\"train_images\")\n",
    "        )\n",
    "    )\n",
    "    os.system(\"unzip {} -d {}\".format(\n",
    "        os.path.join(data_path,\"test_images.zip\"), \n",
    "        os.path.join(data_path,\"test_images\")\n",
    "      )\n",
    "    )\n",
    "    !ls /content/data\n",
    "except Exception as e:\n",
    "  print(e)\n",
    "  print(\"Running on local machine.\")\n",
    "  _run_on_local = True\n",
    "finally:\n",
    "  model_save_path = os.path.join(path, model_file_name)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### show same sample data frame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 221
    },
    "colab_type": "code",
    "id": "laZ_V0oy44q2",
    "outputId": "e7de5ca2-41fe-4798-c801-df0127a1c4f2"
   },
   "outputs": [],
   "source": [
    "tr = pd.read_csv(os.path.join(data_path, 'train.csv'))\n",
    "print(len(tr))\n",
    "tr.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 221
    },
    "colab_type": "code",
    "id": "eDJzvU5e44q4",
    "outputId": "ce5c25a6-e029-4c54-9ebe-38f0f43ecc33"
   },
   "outputs": [],
   "source": [
    "df_train = tr[tr['EncodedPixels'].notnull()].reset_index(drop=True)\n",
    "if debug:\n",
    "  df_train = df_train[:100]\n",
    "#df_train = df_train[df_train['ImageId_ClassId'].apply(lambda x: x.split('_')[1] == '4')].reset_index(drop=True)\n",
    "print(len(df_train))\n",
    "df_train.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### prepare data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def prepare_data(data_frame):\n",
    "    ret = {}\n",
    "    for index in range(len(data_frame)):\n",
    "      fn_array = data_frame['ImageId_ClassId'].iloc[index].split('_')\n",
    "      fn = fn_array[0]\n",
    "      category = fn_array[1]\n",
    "      tmp = ret.get(fn, {})\n",
    "      tmp.update({category: data_frame['EncodedPixels'].iloc[index]})\n",
    "      ret[fn] = tmp\n",
    "    return [{k:v} for k, v in ret.items()]\n",
    "\n",
    "data_all = prepare_data(df_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "18qvJkxP44q6"
   },
   "source": [
    "### data preprocessing function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "o0Q2nyma44q7"
   },
   "outputs": [],
   "source": [
    "def rle2mask(rle, imgshape):\n",
    "    width = imgshape[0]\n",
    "    height= imgshape[1]\n",
    "    \n",
    "    mask= np.zeros( width*height ).astype(np.uint8)\n",
    "    \n",
    "    array = np.asarray([int(x) for x in rle.split()])\n",
    "    starts = array[0::2]\n",
    "    lengths = array[1::2]\n",
    "\n",
    "    current_position = 0\n",
    "    for index, start in enumerate(starts):\n",
    "        mask[int(start):int(start+lengths[index])] = 1\n",
    "        current_position += lengths[index]\n",
    "        \n",
    "    return np.flipud( np.rot90( mask.reshape(height, width), k=1 ) )\n",
    "\n",
    "\n",
    "def mask2rle(img):\n",
    "    tmp = np.rot90( np.flipud( img ), k=3 )\n",
    "    rle = []\n",
    "    lastColor = 0;\n",
    "    startpos = 0\n",
    "    endpos = 0\n",
    "\n",
    "    tmp = tmp.reshape(-1,1)   \n",
    "    for i in range( len(tmp) ):\n",
    "        if (lastColor==0) and tmp[i]>0:\n",
    "            startpos = i\n",
    "            lastColor = 1\n",
    "        elif (lastColor==1)and(tmp[i]==0):\n",
    "            endpos = i-1\n",
    "            lastColor = 0\n",
    "            rle.append( str(startpos)+' '+str(endpos-startpos+1) )\n",
    "    return \" \".join(rle)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "aXX07J1x44q8"
   },
   "source": [
    "### Display some sample images"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 608
    },
    "colab_type": "code",
    "id": "xxlfGPZ_44q9",
    "outputId": "b3f81bd3-6aa4-42da-d18c-1789f2d321b3"
   },
   "outputs": [],
   "source": [
    "columns = 1\n",
    "rows = 4\n",
    "fig = plt.figure(figsize=(20,columns*rows+6))\n",
    "for i in range(1,columns*rows+1):\n",
    "    fn = df_train['ImageId_ClassId'].str[:-2].iloc[i]\n",
    "    fig.add_subplot(rows, columns, i).set_title(fn)\n",
    "    img = cv2.imread(data_path + '/train_images/'+fn)\n",
    "    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n",
    "    mask = rle2mask(df_train['EncodedPixels'].iloc[i], (256, 1600))\n",
    "    img[mask==1, 0] = 255\n",
    "    plt.imshow(img)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "kGKrDeJ5th4G"
   },
   "source": [
    "### Weighted Random argumentation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "4EPPry4xt_nT"
   },
   "outputs": [],
   "source": [
    "\n",
    "def _get_image_size(img):\n",
    "    if vF._is_pil_image(img):\n",
    "        return img.size\n",
    "    elif isinstance(img, torch.Tensor) and img.dim() > 2:\n",
    "        return img.shape[-2:][::-1]\n",
    "    else:\n",
    "        raise TypeError(\"Unexpected type {}\".format(type(img)))\n",
    "\n",
    "class NoTransform(object):\n",
    "    def __call__(self, img_x, img_y):\n",
    "        return img_x, img_y\n",
    "\n",
    "class RandomCrop(object):\n",
    "    def __init__(self, size=pic_size[0], padding=None, pad_if_needed=False, fill=0, padding_mode='constant'):\n",
    "        if isinstance(size, numbers.Number):\n",
    "            self.size = rand_crop_size#(int(size), int(size))\n",
    "        else:\n",
    "            self.size = rand_crop_size#size\n",
    "        self.padding = padding\n",
    "        self.pad_if_needed = pad_if_needed\n",
    "        self.fill = fill\n",
    "        self.padding_mode = padding_mode\n",
    "\n",
    "    @staticmethod\n",
    "    def get_params(img, output_size):\n",
    "        w, h = _get_image_size(img)\n",
    "        th, tw = output_size\n",
    "        if w == tw and h == th:\n",
    "            return 0, 0, h, w\n",
    "\n",
    "        i = random.randint(0, h - th)\n",
    "        j = random.randint(0, w - tw)\n",
    "        return i, j, th, tw\n",
    "\n",
    "    def __call__(self, img_x, img_y):\n",
    "        if self.padding is not None:\n",
    "            for i, v in enumerate(img_x):\n",
    "                img_x[i] = vF.pad(v, self.padding, self.fill, self.padding_mode)\n",
    "            for i, v in enumerate(img_y):\n",
    "                img_y[i] = vF.pad(v, self.padding, self.fill, self.padding_mode)\n",
    "        # pad the width if needed\n",
    "        if self.pad_if_needed and img_x.size[0] < self.size[1]:\n",
    "            for i, v in enumerate(img_x):\n",
    "                img_x[i] = vF.pad(v, (self.size[1] - img.size[0], 0), self.fill, self.padding_mode)\n",
    "            for i, v in enumerate(img_y):\n",
    "                img_y[i] = vF.pad(v, (self.size[1] - img.size[0], 0), self.fill, self.padding_mode)\n",
    "        # pad the height if needed\n",
    "        if self.pad_if_needed and img_x.size[1] < self.size[0]:\n",
    "            for i, v in enumerate(img_x):\n",
    "                img_x = vF.pad(img_x, (0, self.size[0] - img.size[1]), self.fill, self.padding_mode)\n",
    "            for i, v in enumerate(img_y):\n",
    "                img_y = vF.pad(img_y, (0, self.size[0] - img.size[1]), self.fill, self.padding_mode)\n",
    "        i, j, h, w = self.get_params(img_x[0], self.size)\n",
    "\n",
    "        return [vF.crop(x, i, j, h, w) for x in img_x], [vF.crop(y, i, j, h, w) for y in img_y]\n",
    "\n",
    "\n",
    "class VerticalFlip(object):\n",
    "    def __call__(self, img_x, img_y):\n",
    "      if pic_resize:\n",
    "        for i, v in enumerate(img_x):\n",
    "            img_x[i] = vF.resize(v, pic_size, interpolation=Image.BILINEAR)\n",
    "        for i, v in enumerate(img_y):\n",
    "            img_y[i] = vF.resize(v, pic_size, interpolation=Image.BILINEAR)\n",
    "      return [vF.vflip(x) for x in img_x], [vF.vflip(y) for y in img_y]\n",
    "\n",
    "\n",
    "class RandomRotation(object):\n",
    "    def __init__(self, degrees=\"rand\", resample=False, expand=False, center=None, fill=0):\n",
    "        if degrees == \"rand\":\n",
    "          degrees = random.randint(1, 179)\n",
    "        if isinstance(degrees, numbers.Number):\n",
    "            if degrees < 0:\n",
    "                raise ValueError(\"If degrees is a single number, it must be positive.\")\n",
    "            self.degrees = (-degrees, degrees)\n",
    "        else:\n",
    "            if len(degrees) != 2:\n",
    "                raise ValueError(\"If degrees is a sequence, it must be of len 2.\")\n",
    "            self.degrees = degrees\n",
    "\n",
    "        self.resample = resample\n",
    "        self.expand = expand\n",
    "        self.center = center\n",
    "        self.fill = fill\n",
    "\n",
    "    @staticmethod\n",
    "    def get_params(degrees):\n",
    "        angle = random.uniform(degrees[0], degrees[1])\n",
    "\n",
    "        return angle\n",
    "\n",
    "    def __call__(self, img_x, img_y):\n",
    "        if pic_resize:\n",
    "          for i, v in enumerate(img_x):\n",
    "              img_x[i] = vF.resize(v, pic_size, interpolation=Image.BILINEAR)\n",
    "          for i, v in enumerate(img_y):\n",
    "              img_y[i] = vF.resize(v, pic_size, interpolation=Image.BILINEAR)\n",
    "        angle = self.get_params(self.degrees)\n",
    "        return (\n",
    "            [vF.rotate(\n",
    "                x, \n",
    "                angle, \n",
    "                self.resample, \n",
    "                self.expand, \n",
    "                self.center, \n",
    "            ) for x in img_x],\n",
    "            [vF.rotate(\n",
    "                y, \n",
    "                angle, \n",
    "                self.resample, \n",
    "                self.expand, \n",
    "                self.center, \n",
    "            ) for y in img_y]\n",
    "        )\n",
    "\n",
    "\n",
    "argu_transforms = [NoTransform, VerticalFlip, RandomRotation]\n",
    "argu_transforms_weight = [0.5, 0.20, 0.30]\n",
    "\n",
    "def get_transform(defect_type=None):\n",
    "#     will_trans = True\n",
    "#     if not must_argument:\n",
    "#         will_trans = np.random.choice(\n",
    "#             2, 1, data_transform_on_off_weight.get(defect_type)\n",
    "#         )[0]\n",
    "  \n",
    "#     if will_trans:\n",
    "    #return [RandomCrop]#, VerticalFlip, RandomRotation]\n",
    "    return np.random.choice(argu_transforms, 1, argu_transforms_weight)\n",
    "    #return []\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "matrix = []\n",
    "for i in range(1, 5):\n",
    "  d = df_train[\n",
    "           df_train[\n",
    "                    'ImageId_ClassId'\n",
    "            ].apply(lambda x: x.split('_')[1] == str(i))\n",
    "  ]\n",
    "  matrix.append(len(d))\n",
    "\n",
    "s = sum(matrix)\n",
    "matrix = list(map(lambda x: x / s, matrix))\n",
    "print(\"Data distribute:(defect)[1, 2, 3, 4]\")\n",
    "print(matrix)\n",
    "\n",
    "data_transform_on_off_weight = {}\n",
    "for i, v in enumerate(matrix):\n",
    "  data_transform_on_off_weight[i + 1 ] = [v] + [1 - v]\n",
    "\n",
    "print(\"Data transform weight:\")\n",
    "print(data_transform_on_off_weight)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "79LOZzCp44q_"
   },
   "source": [
    "### Perform train Dataset argumentation and DataLoader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "iulfSvdjts79"
   },
   "outputs": [],
   "source": [
    "data_trans = [\n",
    "      transforms.ToTensor()\n",
    "    ]\n",
    "if pic_resize:\n",
    "  data_trans = [transforms.Resize(pic_size)] + data_trans\n",
    "\n",
    "data_trans_eval = [transforms.ToTensor()]\n",
    "\n",
    "data_transf_train = transforms.Compose(data_trans)\n",
    "data_transf_eval = transforms.Compose(data_trans_eval)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "7jPfKaHI44q_"
   },
   "outputs": [],
   "source": [
    "label_color = np.asarray([\n",
    "                          [0, 0, 0],  #background\n",
    "                          [128, 0, 0], \n",
    "                          [0, 128, 0],\n",
    "                          [128, 128, 0],\n",
    "                          [0, 0, 128]\n",
    "                        ])\n",
    "\n",
    "def encode_segmap(mask, category):\n",
    "    label_mask = np.zeros((mask.shape[1], mask.shape[2]), dtype=np.int16)\n",
    "    label_mask[np.where(np.all(mask > 0, axis=-1))[1:]] = category\n",
    "    return label_mask\n",
    "\n",
    "class ImageData(Dataset):\n",
    "    def __init__(self, data, transform, subset=\"train\"):\n",
    "        super().__init__()\n",
    "        self.data = data\n",
    "        self.transform = transform\n",
    "        self.subset = subset\n",
    "        \n",
    "        if self.subset == \"train\":\n",
    "          self.data_path = data_path + \"/train_images/\"\n",
    "        elif self.subset == \"_test\":\n",
    "          self.data_path = data_path + \"/test_images/\"\n",
    "        else:\n",
    "          self.data_path = data_path + \"/train_images/\"\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.data)\n",
    "    \n",
    "    def __getitem__(self, index):\n",
    "        for key, value in self.data[index].items():\n",
    "            fn = key\n",
    "            enc = value\n",
    "        img = Image.open(self.data_path + fn)\n",
    "        argu_trans = []\n",
    "        if self.subset == 'train':\n",
    "          if data_argumentation:\n",
    "            argu_trans_class = get_transform(None)\n",
    "            for argu_class in argu_trans_class:\n",
    "                argu_trans.append(argu_class())\n",
    "        \n",
    "        indexes = []\n",
    "        masks = []\n",
    "        for k, v in enc.items():\n",
    "          tmp_mask = rle2mask(v, (256, 1600))\n",
    "          tmp_mask = transforms.ToPILImage()(tmp_mask)\n",
    "          indexes.append(k)\n",
    "          masks.append(tmp_mask)\n",
    "        \n",
    "        img = [img]\n",
    "        \n",
    "        for argu in argu_trans:\n",
    "            img, masks = argu(img, masks)\n",
    "        \n",
    "        img = self.transform(img[0])\n",
    "        \n",
    "        mask = self.transform(masks[0]).numpy()\n",
    "        mask[mask > 0] = int(indexes[0])\n",
    "        \n",
    "        for i in range(1, len(masks)):\n",
    "            tmp_mask = self.transform(masks[i]).numpy()\n",
    "            tmp_mask[tmp_mask > 0] = int(indexes[i])\n",
    "            mask += tmp_mask\n",
    "        mask = torch.from_numpy(mask)\n",
    "        return img, mask"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "WOmNaEtU44rB"
   },
   "outputs": [],
   "source": [
    "train_indx = int(len(data_all) * train_data_percent)\n",
    "data_train = data_all[0: train_indx]\n",
    "eval_indx = int(len(data_all) * eval_data_percent) + train_indx\n",
    "data_eval = data_all[train_indx: eval_indx]\n",
    "\n",
    "data_test = data_all[eval_indx:]\n",
    "\n",
    "train_data = ImageData(data=data_train, transform=data_transf_train, subset=\"train\")\n",
    "train_loader = DataLoader(\n",
    "    dataset = train_data, batch_size=batch_size, shuffle=True,\n",
    "  )\n",
    "\n",
    "eval_data = ImageData(data=data_eval, transform=data_transf_eval, subset=\"eval\")\n",
    "eval_loader = DataLoader(dataset = eval_data)\n",
    "\n",
    "test_data = ImageData(data=data_test, transform=data_transf_eval, subset=\"test\")\n",
    "test_loader = DataLoader(dataset = test_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "LUGHi1Cg44rD"
   },
   "source": [
    "### Show some image and ground truth (masks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 286
    },
    "colab_type": "code",
    "id": "sHHMacAX44rD",
    "outputId": "9a830200-c8e0-439d-a5a2-32638ece691a"
   },
   "outputs": [],
   "source": [
    "sample_data = test_data[9]\n",
    "plt.imshow(sample_data[0].permute(1, 2, 0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 286
    },
    "colab_type": "code",
    "id": "gjbltWGm44rF",
    "outputId": "6b217fb4-5bfd-4a41-c4e6-1ecd1457c4b4"
   },
   "outputs": [],
   "source": [
    "plt.imshow(np.squeeze(sample_data[1].permute(1, 2, 0)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "05aAuTsJ44rH"
   },
   "source": [
    "# Models"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## pretrained model urls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_urls = {\n",
    "    'efficientnet_b0':\n",
    "    'https://www.dropbox.com/s/9wigibun8n260qm/efficientnet-b0-4cfa50.pth?dl=1',\n",
    "    'efficientnet_b1':\n",
    "    'https://www.dropbox.com/s/6745ear79b1ltkh/efficientnet-b1-ef6aa7.pth?dl=1',\n",
    "    'efficientnet_b2':\n",
    "    'https://www.dropbox.com/s/0dhtv1t5wkjg0iy/efficientnet-b2-7c98aa.pth?dl=1',\n",
    "    'efficientnet_b3':\n",
    "    'https://www.dropbox.com/s/5uqok5gd33fom5p/efficientnet-b3-bdc7f4.pth?dl=1',\n",
    "    'efficientnet_b4':\n",
    "    'https://www.dropbox.com/s/y2nqt750lixs8kc/efficientnet-b4-3e4967.pth?dl=1',\n",
    "    'efficientnet_b5':\n",
    "    'https://www.dropbox.com/s/qxonlu3q02v9i47/efficientnet-b5-4c7978.pth?dl=1',\n",
    "    'efficientnet_b6': None,\n",
    "    'efficientnet_b7': None,\n",
    "    'densenet121': 'https://download.pytorch.org/models/densenet121-a639ec97.pth',\n",
    "    'densenet169': 'https://download.pytorch.org/models/densenet169-b2777c0a.pth',\n",
    "    'densenet201': 'https://download.pytorch.org/models/densenet201-c1103571.pth',\n",
    "    'densenet161': 'https://download.pytorch.org/models/densenet161-8d451a50.pth'\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "NRPEBKHbV31h"
   },
   "source": [
    "## DeeplabV3+"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "TxC6A_K7naOq"
   },
   "source": [
    "\n",
    "![image.png](data:image/png;base64,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)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "32o6F52OT0E0"
   },
   "source": [
    "### backbone:  resnet101"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "KFx57U6YT146"
   },
   "outputs": [],
   "source": [
    "class Bottleneck(nn.Module):\n",
    "    expansion = 4\n",
    "\n",
    "    def __init__(self, inplanes, planes, stride=1, dilation=1, downsample=None, BatchNorm=None):\n",
    "        super(Bottleneck, self).__init__()\n",
    "        self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False)\n",
    "        self.bn1 = BatchNorm(planes)\n",
    "        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=stride,\n",
    "                               dilation=dilation, padding=dilation, bias=False)\n",
    "        self.bn2 = BatchNorm(planes)\n",
    "        self.conv3 = nn.Conv2d(planes, planes * 4, kernel_size=1, bias=False)\n",
    "        self.bn3 = BatchNorm(planes * 4)\n",
    "        self.relu = nn.ReLU(inplace=True)\n",
    "        self.downsample = downsample\n",
    "        self.stride = stride\n",
    "        self.dilation = dilation\n",
    "\n",
    "    def forward(self, x):\n",
    "        residual = x\n",
    "\n",
    "        out = self.conv1(x)\n",
    "        out = self.bn1(out)\n",
    "        out = self.relu(out)\n",
    "\n",
    "        out = self.conv2(out)\n",
    "        out = self.bn2(out)\n",
    "        out = self.relu(out)\n",
    "\n",
    "        out = self.conv3(out)\n",
    "        out = self.bn3(out)\n",
    "\n",
    "        if self.downsample is not None:\n",
    "            residual = self.downsample(x)\n",
    "\n",
    "        out += residual\n",
    "        out = self.relu(out)\n",
    "\n",
    "        return out\n",
    "\n",
    "class ResNet(nn.Module):\n",
    "\n",
    "    def __init__(self, block, layers, output_stride, BatchNorm, pretrained=True):\n",
    "        self.inplanes = 64\n",
    "        super(ResNet, self).__init__()\n",
    "        blocks = [1, 2, 4]\n",
    "        if output_stride == 16:\n",
    "            strides = [1, 2, 2, 1]\n",
    "            dilations = [1, 1, 1, 2]\n",
    "        elif output_stride == 8:\n",
    "            strides = [1, 2, 1, 1]\n",
    "            dilations = [1, 1, 2, 4]\n",
    "        else:\n",
    "            raise NotImplementedError\n",
    "\n",
    "        self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3,\n",
    "                                bias=False)\n",
    "        self.bn1 = BatchNorm(64)\n",
    "        self.relu = nn.ReLU(inplace=True)\n",
    "        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)\n",
    "\n",
    "        self.layer1 = self._make_layer(block, 64, layers[0], stride=strides[0], dilation=dilations[0], BatchNorm=BatchNorm)\n",
    "        self.layer2 = self._make_layer(block, 128, layers[1], stride=strides[1], dilation=dilations[1], BatchNorm=BatchNorm)\n",
    "        self.layer3 = self._make_layer(block, 256, layers[2], stride=strides[2], dilation=dilations[2], BatchNorm=BatchNorm)\n",
    "        self.layer4 = self._make_MG_unit(block, 512, blocks=blocks, stride=strides[3], dilation=dilations[3], BatchNorm=BatchNorm)\n",
    "        self._init_weight()\n",
    "\n",
    "        if pretrained:\n",
    "            self._load_pretrained_model()\n",
    "\n",
    "    def _make_layer(self, block, planes, blocks, stride=1, dilation=1, BatchNorm=None):\n",
    "        downsample = None\n",
    "        if stride != 1 or self.inplanes != planes * block.expansion:\n",
    "            downsample = nn.Sequential(\n",
    "                nn.Conv2d(self.inplanes, planes * block.expansion,\n",
    "                          kernel_size=1, stride=stride, bias=False),\n",
    "                BatchNorm(planes * block.expansion),\n",
    "            )\n",
    "\n",
    "        layers = []\n",
    "        layers.append(block(self.inplanes, planes, stride, dilation, downsample, BatchNorm))\n",
    "        self.inplanes = planes * block.expansion\n",
    "        for i in range(1, blocks):\n",
    "            layers.append(block(self.inplanes, planes, dilation=dilation, BatchNorm=BatchNorm))\n",
    "\n",
    "        return nn.Sequential(*layers)\n",
    "\n",
    "    def _make_MG_unit(self, block, planes, blocks, stride=1, dilation=1, BatchNorm=None):\n",
    "        downsample = None\n",
    "        if stride != 1 or self.inplanes != planes * block.expansion:\n",
    "            downsample = nn.Sequential(\n",
    "                nn.Conv2d(self.inplanes, planes * block.expansion,\n",
    "                          kernel_size=1, stride=stride, bias=False),\n",
    "                BatchNorm(planes * block.expansion),\n",
    "            )\n",
    "\n",
    "        layers = []\n",
    "        layers.append(block(self.inplanes, planes, stride, dilation=blocks[0]*dilation,\n",
    "                            downsample=downsample, BatchNorm=BatchNorm))\n",
    "        self.inplanes = planes * block.expansion\n",
    "        for i in range(1, len(blocks)):\n",
    "            layers.append(block(self.inplanes, planes, stride=1,\n",
    "                                dilation=blocks[i]*dilation, BatchNorm=BatchNorm))\n",
    "\n",
    "        return nn.Sequential(*layers)\n",
    "\n",
    "    def forward(self, input):\n",
    "        x = self.conv1(input)\n",
    "        x = self.bn1(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.maxpool(x)\n",
    "\n",
    "        x = self.layer1(x)\n",
    "        low_level_feat = x\n",
    "        x = self.layer2(x)\n",
    "        x = self.layer3(x)\n",
    "        x = self.layer4(x)\n",
    "        return x, low_level_feat\n",
    "\n",
    "    def _init_weight(self):\n",
    "        for m in self.modules():\n",
    "            if isinstance(m, nn.Conv2d):\n",
    "                n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels\n",
    "                m.weight.data.normal_(0, math.sqrt(2. / n))\n",
    "            elif isinstance(m, nn.BatchNorm2d):\n",
    "                m.weight.data.fill_(1)\n",
    "                m.bias.data.zero_()\n",
    "\n",
    "    def _load_pretrained_model(self):\n",
    "        pretrain_dict = model_zoo.load_url('https://download.pytorch.org/models/resnet101-5d3b4d8f.pth')\n",
    "        model_dict = {}\n",
    "        state_dict = self.state_dict()\n",
    "        for k, v in pretrain_dict.items():\n",
    "            if k in state_dict:\n",
    "                model_dict[k] = v\n",
    "        state_dict.update(model_dict)\n",
    "        self.load_state_dict(state_dict)\n",
    "\n",
    "def ResNet101(output_stride, BatchNorm, pretrained=True):\n",
    "    \"\"\"Constructs a ResNet-101 model.\n",
    "    Args:\n",
    "        pretrained (bool): If True, returns a model pre-trained on ImageNet\n",
    "    \"\"\"\n",
    "    model = ResNet(Bottleneck, [3, 4, 23, 3], output_stride, BatchNorm, pretrained=pretrained)\n",
    "    return model\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "gKL4rdvv2RP-"
   },
   "source": [
    "### backbone: Densenet 201"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "1ngs8jr22QpI"
   },
   "outputs": [],
   "source": [
    "class _DenseLayer(nn.Module):\n",
    "    def __init__(self, num_input_features, growth_rate, bn_size, drop_rate, memory_efficient=False):\n",
    "        super(_DenseLayer, self).__init__()\n",
    "        self.add_module('norm1', nn.BatchNorm2d(num_input_features)),\n",
    "        self.add_module('relu1', nn.ReLU(inplace=True)),\n",
    "        self.add_module('conv1', nn.Conv2d(num_input_features, bn_size *\n",
    "                                           growth_rate, kernel_size=1, stride=1,\n",
    "                                           bias=False)),\n",
    "        self.add_module('norm2', nn.BatchNorm2d(bn_size * growth_rate)),\n",
    "        self.add_module('relu2', nn.ReLU(inplace=True)),\n",
    "        self.add_module('conv2', nn.Conv2d(bn_size * growth_rate, growth_rate,\n",
    "                                           kernel_size=3, stride=1, padding=1,\n",
    "                                           bias=False)),\n",
    "        self.drop_rate = float(drop_rate)\n",
    "        self.memory_efficient = memory_efficient\n",
    "\n",
    "    def bn_function(self, inputs):\n",
    "        # type: (List[Tensor]) -> Tensor\n",
    "        concated_features = torch.cat(inputs, 1)\n",
    "        bottleneck_output = self.conv1(self.relu1(self.norm1(concated_features)))\n",
    "        return bottleneck_output\n",
    "\n",
    "    # todo: rewrite when torchscript supports any\n",
    "    def any_requires_grad(self, input):\n",
    "        # type: (List[Tensor]) -> bool\n",
    "        for tensor in input:\n",
    "            if tensor.requires_grad:\n",
    "                return True\n",
    "        return False\n",
    "\n",
    "    @torch.jit.unused  # noqa: T484\n",
    "    def call_checkpoint_bottleneck(self, input):\n",
    "        # type: (List[Tensor]) -> Tensor\n",
    "        def closure(*inputs):\n",
    "            return self.bn_function(*inputs)\n",
    "\n",
    "        return cp.checkpoint(closure, input)\n",
    "\n",
    "    @torch.jit._overload_method  # noqa: F811\n",
    "    def forward(self, input):\n",
    "        # type: (List[Tensor]) -> (Tensor)\n",
    "        pass\n",
    "\n",
    "    @torch.jit._overload_method  # noqa: F811\n",
    "    def forward(self, input):\n",
    "        # type: (Tensor) -> (Tensor)\n",
    "        pass\n",
    "\n",
    "    # torchscript does not yet support *args, so we overload method\n",
    "    # allowing it to take either a List[Tensor] or single Tensor\n",
    "    def forward(self, input):  # noqa: F811\n",
    "        if isinstance(input, Tensor):\n",
    "            prev_features = [input]\n",
    "        else:\n",
    "            prev_features = input\n",
    "\n",
    "        if self.memory_efficient and self.any_requires_grad(prev_features):\n",
    "            if torch.jit.is_scripting():\n",
    "                raise Exception(\"Memory Efficient not supported in JIT\")\n",
    "\n",
    "            bottleneck_output = self.call_checkpoint_bottleneck(prev_features)\n",
    "        else:\n",
    "            bottleneck_output = self.bn_function(prev_features)\n",
    "\n",
    "        new_features = self.conv2(self.relu2(self.norm2(bottleneck_output)))\n",
    "        if self.drop_rate > 0:\n",
    "            new_features = F.dropout(new_features, p=self.drop_rate,\n",
    "                                     training=self.training)\n",
    "        return new_features\n",
    "\n",
    "\n",
    "class _DenseBlock(nn.Module):\n",
    "    _version = 2\n",
    "    __constants__ = ['layers']\n",
    "\n",
    "    def __init__(self, num_layers, num_input_features, bn_size, growth_rate, drop_rate, memory_efficient=False):\n",
    "        super(_DenseBlock, self).__init__()\n",
    "        self.layers = nn.ModuleDict()\n",
    "        for i in range(num_layers):\n",
    "            layer = _DenseLayer(\n",
    "                num_input_features + i * growth_rate,\n",
    "                growth_rate=growth_rate,\n",
    "                bn_size=bn_size,\n",
    "                drop_rate=drop_rate,\n",
    "                memory_efficient=memory_efficient,\n",
    "            )\n",
    "            self.layers['denselayer%d' % (i + 1)] = layer\n",
    "\n",
    "    def forward(self, init_features):\n",
    "        features = [init_features]\n",
    "        for name, layer in self.layers.items():\n",
    "            new_features = layer(features)\n",
    "            features.append(new_features)\n",
    "        return torch.cat(features, 1)\n",
    "\n",
    "    @torch.jit.ignore\n",
    "    def _load_from_state_dict(self, state_dict, prefix, local_metadata, strict,\n",
    "                              missing_keys, unexpected_keys, error_msgs):\n",
    "        version = local_metadata.get('version', None)\n",
    "        if (version is None or version < 2):\n",
    "            # now we have a new nesting level for torchscript support\n",
    "            for new_key in self.state_dict().keys():\n",
    "                # remove prefix \"layers.\"\n",
    "                old_key = new_key[len(\"layers.\"):]\n",
    "                old_key = prefix + old_key\n",
    "                new_key = prefix + new_key\n",
    "                if old_key in state_dict:\n",
    "                    value = state_dict[old_key]\n",
    "                    del state_dict[old_key]\n",
    "                    state_dict[new_key] = value\n",
    "        super(_DenseBlock, self)._load_from_state_dict(\n",
    "            state_dict, prefix, local_metadata, strict,\n",
    "            missing_keys, unexpected_keys, error_msgs)\n",
    "\n",
    "\n",
    "class _Transition(nn.Sequential):\n",
    "    def __init__(self, num_input_features, num_output_features):\n",
    "        super(_Transition, self).__init__()\n",
    "        self.add_module('norm', nn.BatchNorm2d(num_input_features))\n",
    "        self.add_module('relu', nn.ReLU(inplace=True))\n",
    "        self.add_module('conv', nn.Conv2d(num_input_features, num_output_features,\n",
    "                                          kernel_size=1, stride=1, bias=False))\n",
    "        self.add_module('pool', nn.AvgPool2d(kernel_size=2, stride=2))\n",
    "\n",
    "\n",
    "class DenseNet(nn.Module):\n",
    "    def __init__(self, growth_rate=32, block_config=(6, 12, 24, 16),\n",
    "                 num_init_features=64, bn_size=4, drop_rate=0, num_classes=1000, memory_efficient=False):\n",
    "\n",
    "        super(DenseNet, self).__init__()\n",
    "\n",
    "        # First convolution\n",
    "        self.features = nn.Sequential(OrderedDict([\n",
    "            ('conv0', nn.Conv2d(3, num_init_features, kernel_size=7, stride=2,\n",
    "                                padding=3, bias=False)),\n",
    "            ('norm0', nn.BatchNorm2d(num_init_features)),\n",
    "            ('relu0', nn.ReLU(inplace=True)),\n",
    "            ('pool0', nn.MaxPool2d(kernel_size=3, stride=2, padding=1)),\n",
    "        ]))\n",
    "\n",
    "        # Each denseblock\n",
    "        num_features = num_init_features\n",
    "        for i, num_layers in enumerate(block_config):\n",
    "            block = _DenseBlock(\n",
    "                num_layers=num_layers,\n",
    "                num_input_features=num_features,\n",
    "                bn_size=bn_size,\n",
    "                growth_rate=growth_rate,\n",
    "                drop_rate=drop_rate,\n",
    "                memory_efficient=memory_efficient\n",
    "            )\n",
    "            self.features.add_module('denseblock%d' % (i + 1), block)\n",
    "            num_features = num_features + num_layers * growth_rate\n",
    "            if i != len(block_config) - 1:\n",
    "                trans = _Transition(num_input_features=num_features,\n",
    "                                    num_output_features=num_features // 2)\n",
    "                self.features.add_module('transition%d' % (i + 1), trans)\n",
    "                num_features = num_features // 2\n",
    "\n",
    "        # Final batch norm\n",
    "        self.features.add_module('norm5', nn.BatchNorm2d(num_features))\n",
    "\n",
    "        # Linear layer\n",
    "        self.classifier = nn.Linear(num_features, num_classes)\n",
    "\n",
    "        # Official init from torch repo.\n",
    "        for m in self.modules():\n",
    "            if isinstance(m, nn.Conv2d):\n",
    "                nn.init.kaiming_normal_(m.weight)\n",
    "            elif isinstance(m, nn.BatchNorm2d):\n",
    "                nn.init.constant_(m.weight, 1)\n",
    "                nn.init.constant_(m.bias, 0)\n",
    "            elif isinstance(m, nn.Linear):\n",
    "                nn.init.constant_(m.bias, 0)\n",
    "\n",
    "    def forward(self, x):\n",
    "        low_level_feature = self.features[0](x)\n",
    "        x = self.features(x)\n",
    "        return x, low_level_feature\n",
    "\n",
    "\n",
    "def load_state_dict_from_url(model, model_url):\n",
    "    pretrain_dict = model_zoo.load_url(model_url)\n",
    "    return pretrain_dict\n",
    "\n",
    "\n",
    "def _load_state_dict(model, model_url, progress):\n",
    "    pattern = re.compile(\n",
    "        r'^(.*denselayer\\d+\\.(?:norm|relu|conv))\\.((?:[12])\\.(?:weight|bias|running_mean|running_var))$')\n",
    "\n",
    "    state_dict = load_state_dict_from_url(model, model_url)\n",
    "    for key in list(state_dict.keys()):\n",
    "        res = pattern.match(key)\n",
    "        if res:\n",
    "            new_key = res.group(1) + res.group(2)\n",
    "            state_dict[new_key] = state_dict[key]\n",
    "            del state_dict[key]\n",
    "    model.load_state_dict(state_dict)\n",
    "\n",
    "\n",
    "def _densenet(arch, growth_rate, block_config, num_init_features, pretrained, progress,\n",
    "              **kwargs):\n",
    "    model = DenseNet(growth_rate, block_config, num_init_features, **kwargs)\n",
    "    if pretrained:\n",
    "        _load_state_dict(model, model_urls[arch], progress)\n",
    "    return model\n",
    "\n",
    "\n",
    "def densenet121(pretrained=False, progress=True, **kwargs):\n",
    "    return _densenet('densenet121', 32, (6, 12, 24, 16), 64, pretrained, progress,\n",
    "                     **kwargs)\n",
    "\n",
    "\n",
    "def densenet161(pretrained=False, progress=True, **kwargs):\n",
    "    return _densenet('densenet161', 48, (6, 12, 36, 24), 96, pretrained, progress,\n",
    "                     **kwargs)\n",
    "\n",
    "\n",
    "def densenet169(pretrained=False, progress=True, **kwargs):\n",
    "    return _densenet('densenet169', 32, (6, 12, 32, 32), 64, pretrained, progress,\n",
    "                     **kwargs)\n",
    "\n",
    "\n",
    "def densenet201(pretrained=False, progress=True, **kwargs):\n",
    "    return _densenet('densenet201', 32, (6, 12, 48, 32), 64, pretrained, progress,\n",
    "                     **kwargs)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "M-RJdMSvowvI"
   },
   "source": [
    "### backbone: Efficiency Net(prefered model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "LBcbLc6eowCm"
   },
   "outputs": [],
   "source": [
    "params = {\n",
    "    'efficientnet_b0': (1.0, 1.0, 224, 0.2),\n",
    "    'efficientnet_b1': (1.0, 1.1, 240, 0.2),\n",
    "    'efficientnet_b2': (1.1, 1.2, 260, 0.3),\n",
    "    'efficientnet_b3': (1.2, 1.4, 300, 0.3),\n",
    "    'efficientnet_b4': (1.4, 1.8, 380, 0.4),\n",
    "    'efficientnet_b5': (1.6, 2.2, 456, 0.4),\n",
    "    'efficientnet_b6': (1.8, 2.6, 528, 0.5),\n",
    "    'efficientnet_b7': (2.0, 3.1, 600, 0.5),\n",
    "}\n",
    "\n",
    "\n",
    "class Swish(nn.Module):\n",
    "\n",
    "    def __init__(self, *args, **kwargs):\n",
    "        super(Swish, self).__init__()\n",
    "\n",
    "    def forward(self, x):\n",
    "        return x * torch.sigmoid(x)\n",
    "\n",
    "\n",
    "class ConvBNReLU(nn.Sequential):\n",
    "\n",
    "    def __init__(self, in_planes, out_planes, kernel_size, stride=1, groups=1):\n",
    "        padding = self._get_padding(kernel_size, stride)\n",
    "        super(ConvBNReLU, self).__init__(\n",
    "            nn.ZeroPad2d(padding),\n",
    "            nn.Conv2d(in_planes,\n",
    "                      out_planes,\n",
    "                      kernel_size,\n",
    "                      stride,\n",
    "                      padding=0,\n",
    "                      groups=groups,\n",
    "                      bias=False),\n",
    "            nn.BatchNorm2d(out_planes, eps=1e-3, momentum=0.01),\n",
    "            Swish(),\n",
    "        )\n",
    "\n",
    "    def _get_padding(self, kernel_size, stride):\n",
    "        p = max(kernel_size - stride, 0)\n",
    "        return [p // 2, p - p // 2, p // 2, p - p // 2]\n",
    "\n",
    "\n",
    "class SqueezeExcitation(nn.Module):\n",
    "\n",
    "    def __init__(self, in_planes, reduced_dim):\n",
    "        super(SqueezeExcitation, self).__init__()\n",
    "        self.se = nn.Sequential(\n",
    "            nn.AdaptiveAvgPool2d(1),\n",
    "            nn.Conv2d(in_planes, reduced_dim, 1),\n",
    "            Swish(),\n",
    "            nn.Conv2d(reduced_dim, in_planes, 1),\n",
    "            nn.Sigmoid(),\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        return x * self.se(x)\n",
    "\n",
    "\n",
    "class MBConvBlock(nn.Module):\n",
    "\n",
    "    def __init__(self,\n",
    "                 in_planes,\n",
    "                 out_planes,\n",
    "                 expand_ratio,\n",
    "                 kernel_size,\n",
    "                 stride,\n",
    "                 reduction_ratio=4,\n",
    "                 drop_connect_rate=0.2,\n",
    "                 BatchNorm=nn.BatchNorm2d):\n",
    "        super(MBConvBlock, self).__init__()\n",
    "        self.drop_connect_rate = drop_connect_rate\n",
    "        self.use_residual = in_planes == out_planes and stride == 1\n",
    "        assert stride in [1, 2]\n",
    "        assert kernel_size in [3, 5]\n",
    "\n",
    "        hidden_dim = in_planes * expand_ratio\n",
    "        reduced_dim = max(1, int(in_planes / reduction_ratio))\n",
    "\n",
    "        layers = []\n",
    "        # pw\n",
    "        if in_planes != hidden_dim:\n",
    "            layers += [ConvBNReLU(in_planes, hidden_dim, 1)]\n",
    "\n",
    "        layers += [\n",
    "            # dw\n",
    "            ConvBNReLU(hidden_dim,\n",
    "                       hidden_dim,\n",
    "                       kernel_size,\n",
    "                       stride=stride,\n",
    "                       groups=hidden_dim),\n",
    "            # se\n",
    "            SqueezeExcitation(hidden_dim, reduced_dim),\n",
    "            # pw-linear\n",
    "            nn.Conv2d(hidden_dim, out_planes, 1, bias=False),\n",
    "            BatchNorm(out_planes, eps=1e-3, momentum=0.01),\n",
    "        ]\n",
    "\n",
    "        self.conv = nn.Sequential(*layers)\n",
    "\n",
    "    def _drop_connect(self, x):\n",
    "        if not self.training:\n",
    "            return x\n",
    "        keep_prob = 1.0 - self.drop_connect_rate\n",
    "        batch_size = x.size(0)\n",
    "        random_tensor = keep_prob\n",
    "        random_tensor += torch.rand(batch_size, 1, 1, 1, device=x.device)\n",
    "        binary_tensor = random_tensor.floor()\n",
    "        return x.div(keep_prob) * binary_tensor\n",
    "\n",
    "    def forward(self, x):\n",
    "        if self.use_residual:\n",
    "            return x + self._drop_connect(self.conv(x))\n",
    "        else:\n",
    "            return self.conv(x)\n",
    "\n",
    "\n",
    "def _make_divisible(value, divisor=8):\n",
    "    new_value = max(divisor, int(value + divisor / 2) // divisor * divisor)\n",
    "    if new_value < 0.9 * value:\n",
    "        new_value += divisor\n",
    "    return new_value\n",
    "\n",
    "\n",
    "def _round_filters(filters, width_mult):\n",
    "    if width_mult == 1.0:\n",
    "        return filters\n",
    "    return int(_make_divisible(filters * width_mult))\n",
    "\n",
    "\n",
    "def _round_repeats(repeats, depth_mult):\n",
    "    if depth_mult == 1.0:\n",
    "        return repeats\n",
    "    return int(math.ceil(depth_mult * repeats))\n",
    "\n",
    "\n",
    "class EfficientNet(nn.Module):\n",
    "\n",
    "    def __init__(self,\n",
    "                 width_mult=1.0,\n",
    "                 depth_mult=1.0,\n",
    "                 dropout_rate=0.2,\n",
    "                 num_classes=1000,\n",
    "                 pooling_mode='mean',\n",
    "                 classifier='linear',\n",
    "                 BatchNorm=nn.BatchNorm2d):\n",
    "        super(EfficientNet, self).__init__()\n",
    "\n",
    "        # yapf: disable\n",
    "        settings = [\n",
    "            # t,  c, n, s, k\n",
    "            [1, 16, 1, 1, 3],  # MBConv1_3x3, SE, 112 -> 112\n",
    "            [6, 24, 2, 2, 3],  # MBConv6_3x3, SE, 112 ->  56\n",
    "            [6, 40, 2, 2, 5],  # MBConv6_5x5, SE,  56 ->  28\n",
    "            [6, 80, 3, 2, 3],  # MBConv6_3x3, SE,  28 ->  14\n",
    "            [6, 112, 3, 1, 5],  # MBConv6_5x5, SE,  14 ->  14\n",
    "            [6, 192, 4, 2, 5],  # MBConv6_5x5, SE,  14 ->   7\n",
    "            [6, 320, 1, 1, 3]   # MBConv6_3x3, SE,   7 ->   7\n",
    "        ]\n",
    "        # yapf: enable\n",
    "\n",
    "        out_channels = _round_filters(32, width_mult)\n",
    "        features = [ConvBNReLU(3, out_channels, 3, stride=2)]\n",
    "\n",
    "        in_channels = out_channels\n",
    "        for t, c, n, s, k in settings:\n",
    "            out_channels = _round_filters(c, width_mult)\n",
    "            repeats = _round_repeats(n, depth_mult)\n",
    "            for i in range(repeats):\n",
    "                stride = s if i == 0 else 1\n",
    "                features += [MBConvBlock(in_channels,\n",
    "                                         out_channels,\n",
    "                                         expand_ratio=t,\n",
    "                                         stride=stride,\n",
    "                                         kernel_size=k,\n",
    "                                         BatchNorm=BatchNorm)]\n",
    "                in_channels = out_channels\n",
    "\n",
    "        last_channels = _round_filters(1280, width_mult)\n",
    "        features += [ConvBNReLU(in_channels, last_channels, 1)]\n",
    "        self.features = nn.Sequential(*features)\n",
    "\n",
    "        # weight initialization\n",
    "        for m in self.modules():\n",
    "            if isinstance(m, nn.Conv2d):\n",
    "                nn.init.kaiming_normal_(m.weight, mode='fan_out')\n",
    "                if m.bias is not None:\n",
    "                    nn.init.zeros_(m.bias)\n",
    "            elif isinstance(m, nn.BatchNorm2d):\n",
    "                nn.init.ones_(m.weight)\n",
    "                nn.init.zeros_(m.bias)\n",
    "            elif isinstance(m, nn.Linear):\n",
    "                fan_out = m.weight.size(0)\n",
    "                init_range = 1.0 / math.sqrt(fan_out)\n",
    "                nn.init.uniform_(m.weight, -init_range, init_range)\n",
    "                if m.bias is not None:\n",
    "                    nn.init.zeros_(m.bias)\n",
    "\n",
    "    def forward(self, x):\n",
    "        low_level_layer = 6\n",
    "        low_level_feat = self.features[:low_level_layer](x)\n",
    "        x = self.features[low_level_layer:](low_level_feat)\n",
    "        return x, low_level_feat\n",
    "\n",
    "\n",
    "def _efficientnet(arch, pretrained, progress, **kwargs):\n",
    "    width_mult, depth_mult, _, dropout_rate = params[arch]\n",
    "    model = EfficientNet(width_mult, depth_mult, dropout_rate, **kwargs)\n",
    "    if pretrained:\n",
    "        state_dict = load_state_dict_from_url(model, model_urls[arch])\n",
    "\n",
    "        if 'num_classes' in kwargs and kwargs['num_classes'] != 1000:\n",
    "            del state_dict['classifier.1.weight']\n",
    "            del state_dict['classifier.1.bias']\n",
    "\n",
    "        model.load_state_dict(state_dict, strict=False)\n",
    "    return model\n",
    "\n",
    "\n",
    "def efficientnet_b0(pretrained=False, progress=True, **kwargs):\n",
    "    return _efficientnet('efficientnet_b0', pretrained, progress, **kwargs)\n",
    "\n",
    "\n",
    "def efficientnet_b1(pretrained=False, progress=True, **kwargs):\n",
    "    return _efficientnet('efficientnet_b1', pretrained, progress, **kwargs)\n",
    "\n",
    "\n",
    "def efficientnet_b2(pretrained=False, progress=True, **kwargs):\n",
    "    return _efficientnet('efficientnet_b2', pretrained, progress, **kwargs)\n",
    "\n",
    "\n",
    "def efficientnet_b3(pretrained=False, progress=True, **kwargs):\n",
    "    return _efficientnet('efficientnet_b3', pretrained, progress, **kwargs)\n",
    "\n",
    "\n",
    "def efficientnet_b4(pretrained=False, progress=True, **kwargs):\n",
    "    return _efficientnet('efficientnet_b4', pretrained, progress, **kwargs)\n",
    "\n",
    "\n",
    "def efficientnet_b5(pretrained=False, progress=True, **kwargs):\n",
    "    return _efficientnet('efficientnet_b5', pretrained, progress, **kwargs)\n",
    "\n",
    "\n",
    "def efficientnet_b6(pretrained=False, progress=True, **kwargs):\n",
    "    return _efficientnet('efficientnet_b6', pretrained, progress, **kwargs)\n",
    "\n",
    "\n",
    "def efficientnet_b7(pretrained=False, progress=True, **kwargs):\n",
    "    return _efficientnet('efficientnet_b7', pretrained, progress, **kwargs)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "CMYRYkmArA-_"
   },
   "outputs": [],
   "source": [
    "def build_backbone(backbone, output_stride, BatchNorm, model_type=\"resnet\"):\n",
    "  if model_type == \"resnet\":\n",
    "    return ResNet101(output_stride, BatchNorm, pretrained=pretrained_backbone)\n",
    "  elif model_type == \"densenet\":\n",
    "    return densenet201(pretrained=pretrained_backbone)\n",
    "  elif model_type == \"effnet_b0\":\n",
    "    return efficientnet_b0(pretrained=pretrained_backbone)\n",
    "  elif model_type == \"effnet_b1\":\n",
    "    return efficientnet_b1(pretrained=pretrained_backbone)\n",
    "  elif model_type == \"effnet_b5\":\n",
    "    return efficientnet_b5(pretrained=pretrained_backbone)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "zvQz4-xPuWVp"
   },
   "source": [
    "### ASPP"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "RJfgwqekV7FP"
   },
   "outputs": [],
   "source": [
    "class _ASPPModule(nn.Module):\n",
    "    def __init__(self, inplanes, planes, kernel_size, padding, dilation, BatchNorm):\n",
    "        super(_ASPPModule, self).__init__()\n",
    "        self.atrous_conv = nn.Conv2d(inplanes, planes, kernel_size=kernel_size,\n",
    "                                            stride=1, padding=padding, dilation=dilation, bias=False)\n",
    "        self.bn = BatchNorm(planes)\n",
    "        self.relu = nn.ReLU()\n",
    "\n",
    "        self._init_weight()\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.atrous_conv(x)\n",
    "        x = self.bn(x)\n",
    "\n",
    "        return self.relu(x)\n",
    "\n",
    "    def _init_weight(self):\n",
    "        for m in self.modules():\n",
    "            if isinstance(m, nn.Conv2d):\n",
    "                torch.nn.init.kaiming_normal_(m.weight)\n",
    "            elif isinstance(m, nn.BatchNorm2d):\n",
    "                m.weight.data.fill_(1)\n",
    "                m.bias.data.zero_()\n",
    "\n",
    "class ASPP(nn.Module):\n",
    "    def __init__(self, backbone, output_stride, BatchNorm):\n",
    "        super(ASPP, self).__init__()\n",
    "        if backbone_type == \"resnet\":\n",
    "          inplanes = 2048\n",
    "        elif backbone_type == \"densenet\":\n",
    "          inplanes = 1920\n",
    "        elif backbone_type == \"effnet_b0\":\n",
    "          inplanes = 1280\n",
    "        elif backbone_type == \"effnet_b1\":\n",
    "          inplanes = 1280\n",
    "        elif backbone_type == \"effnet_b5\":\n",
    "          inplanes = 2048\n",
    "        if output_stride == 16:\n",
    "            dilations = [1, 6, 12, 18]\n",
    "        elif output_stride == 8:\n",
    "            dilations = [1, 12, 24, 36]\n",
    "        else:\n",
    "            raise NotImplementedError\n",
    "\n",
    "        self.aspp1 = _ASPPModule(inplanes, 256, 1, padding=0, dilation=dilations[0], BatchNorm=BatchNorm)\n",
    "        self.aspp2 = _ASPPModule(inplanes, 256, 3, padding=dilations[1], dilation=dilations[1], BatchNorm=BatchNorm)\n",
    "        self.aspp3 = _ASPPModule(inplanes, 256, 3, padding=dilations[2], dilation=dilations[2], BatchNorm=BatchNorm)\n",
    "        self.aspp4 = _ASPPModule(inplanes, 256, 3, padding=dilations[3], dilation=dilations[3], BatchNorm=BatchNorm)\n",
    "\n",
    "        self.global_avg_pool = nn.Sequential(nn.AdaptiveAvgPool2d((1, 1)),\n",
    "                                             nn.Conv2d(inplanes, 256, 1, stride=1, bias=False),\n",
    "                                             BatchNorm(256),\n",
    "                                             nn.ReLU())\n",
    "        self.conv1 = nn.Conv2d(1280, 256, 1, bias=False)\n",
    "        self.bn1 = BatchNorm(256)\n",
    "        self.relu = nn.ReLU()\n",
    "        self.dropout = nn.Dropout(0.5)\n",
    "        self._init_weight()\n",
    "\n",
    "    def forward(self, x):\n",
    "        x1 = self.aspp1(x)\n",
    "        x2 = self.aspp2(x)\n",
    "        x3 = self.aspp3(x)\n",
    "        x4 = self.aspp4(x)\n",
    "        x5 = self.global_avg_pool(x)\n",
    "        x5 = F.interpolate(x5, size=x4.size()[2:], mode='bilinear', align_corners=True)\n",
    "        x = torch.cat((x1, x2, x3, x4, x5), dim=1)\n",
    "\n",
    "        x = self.conv1(x)\n",
    "        x = self.bn1(x)\n",
    "        x = self.relu(x)\n",
    "\n",
    "        return self.dropout(x)\n",
    "\n",
    "    def _init_weight(self):\n",
    "        for m in self.modules():\n",
    "            if isinstance(m, nn.Conv2d):\n",
    "                torch.nn.init.kaiming_normal_(m.weight)\n",
    "            elif isinstance(m, nn.BatchNorm2d):\n",
    "                m.weight.data.fill_(1)\n",
    "                m.bias.data.zero_()\n",
    "def build_aspp(backbone, output_stride, BatchNorm):\n",
    "    return ASPP(backbone, output_stride, BatchNorm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "SkqPQTTx7pL_"
   },
   "source": [
    "### Decoder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Hu350ILA7t5O"
   },
   "outputs": [],
   "source": [
    "class Decoder(nn.Module):\n",
    "    def __init__(self, num_classes, backbone, BatchNorm):\n",
    "        super(Decoder, self).__init__()\n",
    "        bn1_norm = 48\n",
    "        last_conv_inplanes = 304\n",
    "        if backbone_type == \"resnet\":\n",
    "          low_level_inplanes = 256\n",
    "          low_level_out = 48\n",
    "        elif backbone_type == \"densenet\":\n",
    "          low_level_inplanes = 64\n",
    "          low_level_out = 48\n",
    "        elif backbone_type == \"effnet_b0\":\n",
    "          low_level_inplanes = 40\n",
    "          low_level_out = 40\n",
    "          bn1_norm = 40\n",
    "          last_conv_inplanes = 296\n",
    "        elif backbone_type == \"effnet_b1\":\n",
    "          low_level_inplanes = 24\n",
    "          low_level_out = 24\n",
    "          bn1_norm = 24\n",
    "          last_conv_inplanes = 280\n",
    "        elif backbone_type == \"effnet_b5\":\n",
    "          low_level_inplanes = 24\n",
    "          low_level_out = 40\n",
    "          bn1_norm = 40\n",
    "          last_conv_inplanes = 296\n",
    "        self.conv1 = nn.Conv2d(low_level_inplanes, low_level_out, 1, bias=False)\n",
    "        self.bn1 = BatchNorm(bn1_norm)\n",
    "        self.relu = nn.ReLU()\n",
    "        self.last_conv = nn.Sequential(nn.Conv2d(last_conv_inplanes, 256, kernel_size=3, stride=1, padding=1, bias=False),\n",
    "                                       BatchNorm(256),\n",
    "                                       nn.ReLU(),\n",
    "                                       nn.Dropout(0.5),\n",
    "                                       nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1, bias=False),\n",
    "                                       BatchNorm(256),\n",
    "                                       nn.ReLU(),\n",
    "                                       nn.Dropout(0.1),\n",
    "                                       nn.Conv2d(256, num_classes, kernel_size=1, stride=1))\n",
    "        self._init_weight()\n",
    "        \n",
    "\n",
    "    def forward(self, x, low_level_feat):\n",
    "        low_level_feat = self.conv1(low_level_feat)\n",
    "        low_level_feat = self.bn1(low_level_feat)\n",
    "        low_level_feat = self.relu(low_level_feat)\n",
    "        x = F.interpolate(x, size=low_level_feat.size()[2:], mode='bilinear', align_corners=True) \n",
    "        x = torch.cat((x, low_level_feat), dim=1)\n",
    "        x = self.last_conv(x)\n",
    "\n",
    "        return x\n",
    "\n",
    "    def _init_weight(self):\n",
    "        for m in self.modules():\n",
    "            if isinstance(m, nn.Conv2d):\n",
    "                torch.nn.init.kaiming_normal_(m.weight)\n",
    "            elif isinstance(m, nn.BatchNorm2d):\n",
    "                m.weight.data.fill_(1)\n",
    "                m.bias.data.zero_()\n",
    "\n",
    "\n",
    "def build_decoder(num_classes, backbone, BatchNorm):\n",
    "    return Decoder(num_classes, backbone, BatchNorm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Yp7XcyQ9Tpnl"
   },
   "source": [
    "### deeplab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "nyrYJ2ecTwZG"
   },
   "outputs": [],
   "source": [
    "class DeepLab(nn.Module):\n",
    "    def __init__(self, backbone='resnet', output_stride=16, num_classes=n_classes,\n",
    "                 sync_bn=True, freeze_bn=False):\n",
    "        super(DeepLab, self).__init__()\n",
    "        BatchNorm = nn.BatchNorm2d\n",
    "\n",
    "        self.backbone = build_backbone(backbone, output_stride, BatchNorm, model_type=backbone_type)\n",
    "        self.aspp = build_aspp(backbone, output_stride, BatchNorm)\n",
    "        self.decoder = build_decoder(num_classes, backbone, BatchNorm)\n",
    "        self.upchannel = nn.Conv2d(256, 2048, 3)\n",
    "        self.bn = BatchNorm(2048)\n",
    "        self.relu = nn.ReLU()\n",
    "        \n",
    "        # self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3,\n",
    "        #                         bias=False)\n",
    "        # self.bn1 = BatchNorm(64)\n",
    "        # self.relu1 = nn.ReLU(inplace=True)\n",
    "        # self.maxpool1 = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)\n",
    "        if freeze_bn:\n",
    "            self.freeze_bn()\n",
    "\n",
    "    def forward(self, input):\n",
    "        # low_level_feat = self.conv1(input)\n",
    "        # low_level_feat = self.bn1(low_level_feat)\n",
    "        # low_level_feat = self.relu1(low_level_feat)\n",
    "        # low_level_feat = self.maxpool1(low_level_feat)\n",
    "        x, low_level_feat = self.backbone(input)\n",
    "        x = self.aspp(x)\n",
    "        x = self.decoder(x, low_level_feat)\n",
    "        x = F.interpolate(x, size=input.size()[2:], mode='bilinear', align_corners=True)\n",
    "\n",
    "        return x\n",
    "\n",
    "    def freeze_bn(self):\n",
    "        for m in self.modules():\n",
    "            if isinstance(m, SynchronizedBatchNorm2d):\n",
    "                m.eval()\n",
    "            elif isinstance(m, nn.BatchNorm2d):\n",
    "                m.eval()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "QTBghQVhyYwn"
   },
   "source": [
    "# Train"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "69if1gn7D_Eh"
   },
   "source": [
    "## Define loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "5krcDfofD-CN"
   },
   "outputs": [],
   "source": [
    "class SegmentationLosses(object):\n",
    "    def __init__(self, \n",
    "                 weight=None, \n",
    "                 size_average=True, \n",
    "                 batch_average=True, \n",
    "                 ignore_index=255, \n",
    "                 cuda=False):\n",
    "        self.ignore_index = ignore_index\n",
    "        self.weight = weight\n",
    "        self.size_average = size_average\n",
    "        self.batch_average = batch_average\n",
    "        self.cuda = cuda\n",
    "\n",
    "    def build_loss(self):\n",
    "        return self.CrossEntropyLoss\n",
    "\n",
    "    def CrossEntropyLoss(self, logit, target):\n",
    "        n, c, h, w = logit.size()\n",
    "        criterion = nn.CrossEntropyLoss(weight=self.weight, \n",
    "                                        ignore_index=self.ignore_index,\n",
    "                                        reduction='mean')\n",
    "        if self.cuda:\n",
    "            criterion = criterion.to(device)\n",
    "\n",
    "        loss = criterion(logit, target.long())\n",
    "\n",
    "        if self.batch_average:\n",
    "            loss /= n\n",
    "\n",
    "        return loss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "aC8tTvmgGLGM"
   },
   "source": [
    "## Init for training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 88
    },
    "colab_type": "code",
    "id": "ShbS55vH44rJ",
    "outputId": "a092f3cb-168d-46df-a0f6-d4a23c268a66"
   },
   "outputs": [],
   "source": [
    "last_result = 0\n",
    "last_result_acc = 0\n",
    "starting_epoch = 0\n",
    "total_it = 0\n",
    "model = DeepLab().to(device)\n",
    "if cuda_device_count > 1 and multi_gpu:\n",
    "  model = nn.DataParallel(model)\n",
    "if print_model_summary:\n",
    "  summary(model, (3, 256, 256))\n",
    "optimizer = torch.optim.SGD(\n",
    "    model.parameters(), weight_decay=weight_decay, lr = lr, momentum=momentum\n",
    ")\n",
    "scheduler = ReduceLROnPlateau(optimizer, \"min\")\n",
    "if reload_last_model and os.path.exists(model_save_path):\n",
    "  print(\"Loading model from {}\".format(model_save_path))\n",
    "  state = torch.load(model_save_path)\n",
    "  last_result = state.get(\"last_best\", 0)\n",
    "  last_result_acc = state.get(\"last_best_acc\", 0)\n",
    "  starting_epoch = state.get(\"epoch\", 0)\n",
    "  model.load_state_dict(state.get(\"model_state_dict\"))\n",
    "#   if \"optimizer_state_dict\" in state:\n",
    "#     optimizer.load_state_dict(state.get(\"optimizer_state_dict\"))\n",
    "  \n",
    "  if \"total_iterations\" in state:\n",
    "    total_it = state.get(\"total_iterations\")\n",
    "else:\n",
    "  print(\"Not load model, train from scrath\")\n",
    "criterion = SegmentationLosses(batch_average=False).build_loss()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "TCb_jX1vnjOr"
   },
   "source": [
    "## define training eval and test functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "GF_n3mWEirMi"
   },
   "source": [
    "Get LR value if we use lr decay"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "fcFWxz0HnmWs"
   },
   "outputs": [],
   "source": [
    "def get_lr(optimizer):\n",
    "    for param_group in optimizer.param_groups:\n",
    "        return param_group['lr']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "dGrxNrusiuyG"
   },
   "source": [
    "Eval Matrics:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "zzCGiMk8i0ed"
   },
   "outputs": [],
   "source": [
    "SMOOTH = 0\n",
    "\n",
    "def dice_coefficient(x, y):\n",
    "  \"\"\"\n",
    "  :param X: numpy array\n",
    "  :param y: numpy array\n",
    "  :return: float, dice coefficient for one x, y pair\n",
    "  x, y is mask the preidiction values (mask)\n",
    "  \"\"\"\n",
    "  x = x.squeeze()\n",
    "  #y = y.squeeze()\n",
    "  return 2. * np.count_nonzero((x > 0) & (y > 0)) / (np.count_nonzero(x > 0) + np.count_nonzero(y > 0))\n",
    "\n",
    "\n",
    "def iou_numpy(outputs, labels: np.array):\n",
    "    outputs = outputs.squeeze()\n",
    "    if isinstance(outputs, torch.Tensor):\n",
    "      outputs = outputs.numpy()\n",
    "    intersection = ((outputs > 0) & (labels > 0)).sum()\n",
    "    union = ((outputs > 0) | (labels > 0)).sum()\n",
    "    \n",
    "    iou = (intersection) / (union + SMOOTH)\n",
    "  \n",
    "    return iou\n",
    "\n",
    "def accuracy_numpy(outputs, labels):\n",
    "    acc = accuracy_with_margin_numpy(outputs, labels, 0)\n",
    "    return acc\n",
    "\n",
    "def accuracy_with_margin_numpy(outputs, labels, margin=0):\n",
    "    correct = 0\n",
    "    for i, mask in enumerate(outputs):\n",
    "      out_label = []\n",
    "      true_label = []\n",
    "      label = labels[i]\n",
    "      if isinstance(mask, torch.Tensor):\n",
    "        mask = mask.numpy()\n",
    "      if isinstance(label, torch.Tensor):\n",
    "        label = label.numpy()\n",
    "        \n",
    "      for i in range(1, 5):\n",
    "        if np.sum(mask == i) > margin:\n",
    "            out_label.append(i)\n",
    "        \n",
    "        if np.sum(label == i) > 0:\n",
    "            true_label.append(i)\n",
    "      \n",
    "      true_label.sort()\n",
    "      out_label.sort()\n",
    "      \n",
    "      if true_label == out_label:\n",
    "        correct += 1\n",
    "    acc = correct / len(labels)\n",
    "    return acc\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "n61_D7-VqTI8"
   },
   "source": [
    "Inference:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "9JMFfq4DqWY1"
   },
   "outputs": [],
   "source": [
    "def decode_seg_map_sequence(label_masks):\n",
    "    rgb_masks = []\n",
    "    for label_mask in label_masks:\n",
    "        rgb_mask = decode_segmap(label_mask)\n",
    "        rgb_masks.append(rgb_mask)\n",
    "    rgb_masks = torch.from_numpy(np.array(rgb_masks).transpose([0, 3, 1, 2]))\n",
    "    return rgb_masks\n",
    "\n",
    "\n",
    "def decode_segmap(label_mask, plot=False):    \n",
    "    r = label_mask.copy()\n",
    "    g = label_mask.copy()\n",
    "    b = label_mask.copy()\n",
    "    t = label_mask.copy()\n",
    "    for c in range(n_classes):\n",
    "      r[t == c] = label_color[c, 0]\n",
    "      g[t == c] = label_color[c, 1]\n",
    "      b[t == c] = label_color[c, 2]\n",
    "    rgb = np.zeros((label_mask.shape[0], label_mask.shape[1], 3))\n",
    "    rgb[:, :, 0] = r / 255.0\n",
    "    rgb[:, :, 1] = g / 255.0\n",
    "    rgb[:, :, 2] = b / 255.0\n",
    "    if plot:\n",
    "        plt.imshow(rgb)\n",
    "        plt.show()\n",
    "    \n",
    "    return rgb\n",
    "\n",
    "\n",
    "def predict(model, data_loader, resize=False, out_mask=True):\n",
    "    predict = []\n",
    "    Y = []\n",
    "    raw = []\n",
    "    model.eval() \n",
    "    print(\"Predicting...\")\n",
    "    total = 0\n",
    "    losses = []\n",
    "    print_out = False\n",
    "    torch.set_printoptions(profile=\"full\")\n",
    "    with tqdm_notebook(total=len(data_loader.dataset), leave=leave_progress_bar) as pbar:\n",
    "      for data, y in data_loader:\n",
    "        with torch.no_grad():\n",
    "          o = model(data.to(device))  \n",
    "        o = o.cpu().detach()\n",
    "        loss = criterion(o, y.squeeze(1))\n",
    "        losses.append(loss)\n",
    "        pred = o.numpy()\n",
    "        pred = np.argmax(pred, axis=1)\n",
    "        \n",
    "        if print_out:\n",
    "          print(pred)\n",
    "          print_out = False\n",
    "\n",
    "        predict.append(pred.squeeze(0))\n",
    "        raw.append(data)\n",
    "        Y.append(y)\n",
    "\n",
    "        pbar.update(1)\n",
    "    predict_loss = np.average(losses)\n",
    "    print(f\"Predict Loss = {predict_loss}\")\n",
    "    return predict, Y, raw, predict_loss\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "hhEZZeDoyuc4"
   },
   "source": [
    "## Eval Data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "u-fQt2Fzs741"
   },
   "outputs": [],
   "source": [
    "def eval_data_set(model, data_loader, matrics):\n",
    "  corr = []\n",
    "  predictions, Y, raw, loss = predict(model, data_loader)\n",
    "  for i, mask in enumerate(predictions):\n",
    "    corr.append(matrics(mask, Y[i].numpy()))\n",
    "  \n",
    "  acc = accuracy_numpy(predictions, Y)\n",
    "  acc_adj = accuracy_with_margin_numpy(predictions, Y)\n",
    "  #print(f\"mIou = {np.mean(corr)}\")\n",
    "  #print(f\"acc_EM = {acc}\")\n",
    "  #print(f\"acc= {acc_adj}\")\n",
    "  print(f\"max iou={np.max(corr)}\")\n",
    "  print(f\"min iou={np.min(corr)}\")\n",
    "  \n",
    "  plt.hist(corr, bins=\"auto\")\n",
    "  plt.xlabel(\"iou\")\n",
    "  plt.ylabel(\"data count\")\n",
    "  plt.title(\"iou distribution\")\n",
    "\n",
    "  buf = io.BytesIO()\n",
    "\n",
    "  plt.savefig(buf, format='png')\n",
    "  buf.seek(0)\n",
    "  plt.savefig(\"./dist.png\")\n",
    "\n",
    "  return np.mean(corr), acc_adj,  predictions, Y, raw, loss, buf, corr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ZPcWGy0rbRFH"
   },
   "source": [
    "Tensorbaord Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 63
    },
    "colab_type": "code",
    "id": "1vhrCkuSm6Kf",
    "outputId": "8f7195c2-0478-4c40-c0b0-dfc7958b0690"
   },
   "outputs": [],
   "source": [
    "if clear_tensor_board_history:\n",
    "  shutil.rmtree(\"/content/runs\", ignore_errors=True)\n",
    "  os.mkdir(\"/content/runs\")\n",
    "\n",
    "summary_writter = SummaryWriter() # in ./run by default\n",
    "#summary_writter.add_graph(model)\n",
    "def write_image_to_tb(\n",
    "    predictions, \n",
    "    raw_truth, \n",
    "    raw, \n",
    "    epoch,\n",
    "    category=\"eval\", \n",
    "    update_frequency=10\n",
    "):\n",
    "  images_to_add_raw = []\n",
    "  images_to_add_predict = []\n",
    "  images_to_add_y = []\n",
    "  print(\"total predictions {}\".format(len(predictions)))\n",
    "  for i, prediction in enumerate(predictions):\n",
    "      if i // update_frequency == 0 or category in [\"test\"]:\n",
    "        raw_image_to_add = raw[i].squeeze(0)\n",
    "        images_to_add_raw.append(raw_image_to_add)\n",
    "        prediction = decode_segmap(prediction, plot=False)\n",
    "        prediction_to_add = torch.from_numpy(prediction).permute(2,0,1)\n",
    "        images_to_add_predict.append(prediction_to_add)\n",
    "        truth = raw_truth[i].squeeze().numpy()\n",
    "        truth = decode_segmap(truth, plot=False)\n",
    "        truth_to_add = torch.from_numpy(truth).permute(2,0,1)\n",
    "        images_to_add_predict.append(truth_to_add)\n",
    "     \n",
    "      if category in [\"test\"]:\n",
    "        summary_writter.add_image(\n",
    "            f'{i}_{category}_raw_img', \n",
    "            raw_image_to_add,\n",
    "            i\n",
    "          )\n",
    "        summary_writter.add_image(\n",
    "            f'{i}_{category}_truth', \n",
    "            truth_to_add,\n",
    "            i\n",
    "          )\n",
    "        summary_writter.add_image(\n",
    "            f'{i}_{category}_prediction', \n",
    "            prediction_to_add,\n",
    "            i\n",
    "          )\n",
    "        summary_writter.add_image(\n",
    "            f'{i}_{category}_combined',\n",
    "            torch.clamp(\n",
    "                raw_image_to_add + prediction_to_add, 0, 1\n",
    "            )\n",
    "        )\n",
    "\n",
    "        summary_writter.flush()\n",
    "        \n",
    "  summary_writter.add_image(\n",
    "    f'{epoch}_{category}_raw_img', \n",
    "    torchvision.utils.make_grid(images_to_add_raw, nrow=1), \n",
    "    epoch\n",
    "  )\n",
    "  summary_writter.add_image(\n",
    "    f'{epoch}_{category}_prediction', \n",
    "    torchvision.utils.make_grid(images_to_add_predict, nrow=1, range=(0, 255)), \n",
    "    epoch\n",
    "  )\n",
    "  # summary_writter.add_image(\n",
    "  #     f'{epoch}_{category}_ground_truth', \n",
    "  #     torchvision.utils.make_grid(images_to_add_y, nrow=1, range=(0, 255)), \n",
    "  #     epoch\n",
    "  # )\n",
    "  summary_writter.flush()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "C-X7elt4iiYY"
   },
   "source": [
    "## Launch Tensorbaord:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if not _run_on_local:\n",
    "    %load_ext tensorboard\n",
    "    %tensorboard --logdir=runs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "CO62PLi344rL"
   },
   "source": [
    "## Train and eval"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 385
    },
    "colab_type": "code",
    "id": "9Qxwzvt844rL",
    "outputId": "7592538e-b26e-43a6-88c3-656aad3f38bd"
   },
   "outputs": [],
   "source": [
    "if inference_mode: \n",
    "  total_epochs = 0\n",
    "  \n",
    "current_it = 1\n",
    "for epoch in range(starting_epoch, total_epochs):\n",
    "  total_loss = 0.0\n",
    "  print(f\"Epoch: {epoch}\")\n",
    "  print(f\"Data argumentation: {data_argumentation}\")\n",
    "  model.train()\n",
    "  with tqdm_notebook(total=len(train_loader.dataset), leave=leave_progress_bar) as pbar:   \n",
    "    for it, (data, target) in enumerate(train_loader):\n",
    "      data, target = data.to(device), target.to(device)\n",
    "      optimizer.zero_grad()\n",
    "      output = model(data)\n",
    "      loss = criterion(output, target.squeeze(1))\n",
    "      loss.backward()\n",
    "      optimizer.step()\n",
    "      #pdb.set_trace()\n",
    "      data_len = len(data)\n",
    "      pbar.update(len(data))\n",
    "      pbar.set_postfix(epoch=epoch, loss=loss.item())\n",
    "      total_it += data_len\n",
    "      #total_loss += loss.item()\n",
    "      summary_writter.add_scalar(\"Loss/train\", loss.item(), total_it)\n",
    "      summary_writter.add_scalar(\"LR/train\", get_lr(optimizer), total_it)\n",
    "      summary_writter.flush()\n",
    "\n",
    "  corr, acc, predictions, raw_truth, raw, loss, buf, results = eval_data_set(\n",
    "      model, eval_loader, iou_numpy\n",
    "  )\n",
    "  print(\"lr = {}\".format(get_lr(optimizer)))\n",
    "  scheduler.step(loss)\n",
    "  write_image_to_tb(predictions, raw_truth, raw, epoch, \"eval\")\n",
    "  print(\"IoU = {}\".format(corr))\n",
    "  print(\"Best IoU = {}\".format(last_result))\n",
    "  print(\"Acc = {}\".format(acc))\n",
    "  print(\"Best acc = {}\".format(last_result_acc))\n",
    "  summary_writter.add_scalar(\"IOU/eval\", corr, total_it)\n",
    "  summary_writter.add_scalar(\"acc/eval\", acc, total_it)\n",
    "  #if corr > last_result or acc > last_result_acc:\n",
    "  if corr > last_result:\n",
    "    print(\"Saving Model...\")\n",
    "    to_save = {\n",
    "        \"epoch\": epoch+1 ,\n",
    "        \"total_iterations\": total_it,\n",
    "        \"last_best\": corr,\n",
    "        \"last_best_acc\": acc,\n",
    "        \"model_state_dict\": model.state_dict(),\n",
    "        \"optimizer_state_dict\": optimizer.state_dict()\n",
    "    }\n",
    "    torch.save(to_save, model_save_path)\n",
    "    last_result = corr\n",
    "    last_result_acc = acc\n",
    "  summary_writter.flush()\n",
    "\n",
    "  if ping_pong_argumentation:\n",
    "    data_argumentation = not data_argumentation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "IJaKJCzwai-X"
   },
   "source": [
    "# Test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "lKK3y0wh0MkZ"
   },
   "outputs": [],
   "source": [
    "corr, acc, predictions, raw_truth, raw, loss, buf, results = eval_data_set(model, test_loader, iou_numpy)\n",
    "#write_image_to_tb(predictions, raw_truth, raw, 1, \"eval\", update_frequency=10)\n",
    "results.sort()\n",
    "print(f\"median iou = {np.median(results)}\")\n",
    "print(f\"mIou={corr}, acc={acc}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Analyze"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Filter per IoU"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "-YrTc9c9I0hF"
   },
   "outputs": [],
   "source": [
    "import random\n",
    "idx = []\n",
    "thres = 0.60\n",
    "compare = \">\"\n",
    "for j, r in enumerate(results):\n",
    "    if compare == \">\":\n",
    "        if r > thres:\n",
    "            idx += [j]\n",
    "    else:\n",
    "        if r < thres:\n",
    "            idx += [j]\n",
    "i = random.sample(idx, 1)[0]\n",
    "i=450\n",
    "print(f\"Checking idx={i}\")\n",
    "print(f\"iou={results[i]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Show Raw Image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Hl7xn4VvBkv_"
   },
   "outputs": [],
   "source": [
    "img = test_data[i][0].permute(1, 2, 0)\n",
    "plt.imshow(img)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Show Ground Truth Mask"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "oh0wqM8SBowM"
   },
   "outputs": [],
   "source": [
    "ground_truth = decode_segmap(np.squeeze(test_data[i][1].permute(1, 2, 0).numpy()))\n",
    "plt.imshow(ground_truth)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Show Prediction Mask"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "yPEg5Ct-JwUf"
   },
   "outputs": [],
   "source": [
    "pred = decode_segmap(predictions[i])\n",
    "plt.imshow(pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Show prediction on original Image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_pic = np.clip(img.numpy() + pred, 0, 1)\n",
    "plt.imshow(final_pic)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Show Ground Truth on Original Image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_pic = np.clip(img.numpy() + ground_truth, 0, 1)\n",
    "plt.imshow(final_pic)"
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "include_colab_link": true,
   "machine_shape": "hm",
   "name": "221_final_model.ipynb",
   "provenance": [],
   "toc_visible": true
  },
  "file_extension": ".py",
  "kernelspec": {
   "display_name": "py36",
   "language": "python",
   "name": "py36"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  },
  "mimetype": "text/x-python",
  "name": "python",
  "npconvert_exporter": "python",
  "pygments_lexer": "ipython3",
  "version": 3
 },
 "nbformat": 4,
 "nbformat_minor": 4
}