21_Unet_Semantic_Segmentation.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Copy of Unet_Segmentation.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "machine_shape": "hm",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Gedeon-m-gedus/Image_Processing/blob/master/21_Unet_Semantic_Segmentation.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "44sQRpA2j-3b",
        "outputId": "58186ba4-45e3-4ee5-e8b9-0029b470eaad"
      },
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dwof_LDFn1in"
      },
      "source": [
        "import time\r\n",
        "from tqdm import tqdm\r\n",
        "\r\n",
        "\r\n",
        "from pathlib import Path\r\n",
        "\r\n",
        "import os\r\n",
        "import re\r\n",
        "import numpy as np\r\n",
        "import pandas as pd\r\n",
        "import matplotlib.pyplot as plt\r\n",
        "\r\n",
        "import cv2\r\n",
        "from tqdm import tqdm\r\n",
        "from glob import glob\r\n",
        "from PIL import Image\r\n",
        "from skimage.transform import resize\r\n",
        "from sklearn.model_selection import train_test_split, KFold\r\n",
        "\r\n",
        "import shutil\r\n",
        "\r\n",
        "import torch\r\n",
        "from torch.utils.data import DataLoader,Dataset\r\n",
        "import torch.nn as nn\r\n",
        "import albumentations\r\n",
        "import torchvision \r\n",
        "from torchvision import transforms, models\r\n",
        "\r\n",
        "import random\r\n",
        "from skimage import io,transform\r\n",
        "from PIL import Image\r\n",
        "\r\n",
        "import warnings \r\n",
        "\r\n",
        "warnings.filterwarnings(\"ignore\")"
      ],
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Zci2T-O6j9iS"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-y8-HiqUaZNm",
        "outputId": "a8f24742-76de-44cb-e5fa-85863cdfd248"
      },
      "source": [
        "!pip install imagecodecs"
      ],
      "execution_count": 43,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Requirement already satisfied: imagecodecs in /usr/local/lib/python3.6/dist-packages (2020.5.30)\n",
            "Requirement already satisfied: numpy>=1.15.1 in /usr/local/lib/python3.6/dist-packages (from imagecodecs) (1.19.5)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gpmxKFVSIiOH"
      },
      "source": [
        "device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')"
      ],
      "execution_count": 19,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VI1sb42xsDcl"
      },
      "source": [
        "ROOT = Path(\"/content/drive/MyDrive/IRCAD\")\r\n",
        "#ROOT = Path(\"/content/drive/Shareddrives/IRCAD\")\r\n",
        "\r\n",
        "train_image_path = ROOT / \"train\"\r\n",
        "train_mask_path = ROOT / \"train\"\r\n",
        "test_image_path = ROOT / \"test\"\r\n",
        "\r\n",
        "ALL_MASKS =[os.path.join(train_mask_path,i) for i in os.listdir(train_mask_path) if \"mask\" in i]\r\n",
        "len(ALL_MASKS)\r\n",
        "ALL_IMAGES = [i.replace(\"_mask\",\"\") for i in ALL_MASKS]\r\n",
        "len(ALL_IMAGES)"
      ],
      "execution_count": 20,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 402
        },
        "id": "qXgK3AW-CY5V",
        "outputId": "60f435db-e9d8-4a0a-c7e0-271c2a71e055"
      },
      "source": [
        "\n",
        "df = pd.DataFrame({\"Image\":ALL_IMAGES,\"Mask\":ALL_MASKS})\n",
        "df"
      ],
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>Image</th>\n",
              "      <th>Mask</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>/content/drive/MyDrive/IRCAD/train/6_21.tif</td>\n",
              "      <td>/content/drive/MyDrive/IRCAD/train/6_21_mask.tif</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>/content/drive/MyDrive/IRCAD/train/5_97.tif</td>\n",
              "      <td>/content/drive/MyDrive/IRCAD/train/5_97_mask.tif</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>/content/drive/MyDrive/IRCAD/train/5_82.tif</td>\n",
              "      <td>/content/drive/MyDrive/IRCAD/train/5_82_mask.tif</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>/content/drive/MyDrive/IRCAD/train/5_77.tif</td>\n",
              "      <td>/content/drive/MyDrive/IRCAD/train/5_77_mask.tif</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>/content/drive/MyDrive/IRCAD/train/5_87.tif</td>\n",
              "      <td>/content/drive/MyDrive/IRCAD/train/5_87_mask.tif</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>...</th>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>5630</th>\n",
              "      <td>/content/drive/MyDrive/IRCAD/train/11_60.tif</td>\n",
              "      <td>/content/drive/MyDrive/IRCAD/train/11_60_mask.tif</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>5631</th>\n",
              "      <td>/content/drive/MyDrive/IRCAD/train/11_55.tif</td>\n",
              "      <td>/content/drive/MyDrive/IRCAD/train/11_55_mask.tif</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>5632</th>\n",
              "      <td>/content/drive/MyDrive/IRCAD/train/11_18.tif</td>\n",
              "      <td>/content/drive/MyDrive/IRCAD/train/11_18_mask.tif</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>5633</th>\n",
              "      <td>/content/drive/MyDrive/IRCAD/train/11_14.tif</td>\n",
              "      <td>/content/drive/MyDrive/IRCAD/train/11_14_mask.tif</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>5634</th>\n",
              "      <td>/content/drive/MyDrive/IRCAD/train/11_61.tif</td>\n",
              "      <td>/content/drive/MyDrive/IRCAD/train/11_61_mask.tif</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "<p>5635 rows × 2 columns</p>\n",
              "</div>"
            ],
            "text/plain": [
              "                                             Image                                               Mask\n",
              "0      /content/drive/MyDrive/IRCAD/train/6_21.tif   /content/drive/MyDrive/IRCAD/train/6_21_mask.tif\n",
              "1      /content/drive/MyDrive/IRCAD/train/5_97.tif   /content/drive/MyDrive/IRCAD/train/5_97_mask.tif\n",
              "2      /content/drive/MyDrive/IRCAD/train/5_82.tif   /content/drive/MyDrive/IRCAD/train/5_82_mask.tif\n",
              "3      /content/drive/MyDrive/IRCAD/train/5_77.tif   /content/drive/MyDrive/IRCAD/train/5_77_mask.tif\n",
              "4      /content/drive/MyDrive/IRCAD/train/5_87.tif   /content/drive/MyDrive/IRCAD/train/5_87_mask.tif\n",
              "...                                            ...                                                ...\n",
              "5630  /content/drive/MyDrive/IRCAD/train/11_60.tif  /content/drive/MyDrive/IRCAD/train/11_60_mask.tif\n",
              "5631  /content/drive/MyDrive/IRCAD/train/11_55.tif  /content/drive/MyDrive/IRCAD/train/11_55_mask.tif\n",
              "5632  /content/drive/MyDrive/IRCAD/train/11_18.tif  /content/drive/MyDrive/IRCAD/train/11_18_mask.tif\n",
              "5633  /content/drive/MyDrive/IRCAD/train/11_14.tif  /content/drive/MyDrive/IRCAD/train/11_14_mask.tif\n",
              "5634  /content/drive/MyDrive/IRCAD/train/11_61.tif  /content/drive/MyDrive/IRCAD/train/11_61_mask.tif\n",
              "\n",
              "[5635 rows x 2 columns]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8RXpENxuCY8p"
      },
      "source": [
        "from sklearn import model_selection\n",
        "\n",
        "def makesplits(df,k):\n",
        "    df[\"kfold\"] = -1\n",
        "    df = df.sample(frac=1).reset_index(drop=True)\n",
        "    kf = model_selection.KFold(n_splits=k)\n",
        "\n",
        "    for f,(t_,v_) in enumerate(kf.split(df)):\n",
        "        df.loc[v_,\"kfold\"] = f\n",
        "    return df\n",
        "    \n",
        "kfold_ = makesplits(df,5)\n",
        "kfold_.to_csv(\"Kfolds.csv\",index=None)"
      ],
      "execution_count": 23,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XHybHK6kC11G"
      },
      "source": [
        "## DATA AUGMENTATION\n",
        "def trainaugs():\n",
        "    transform =  [\n",
        "                albumentations.HorizontalFlip(),\n",
        "                albumentations.VerticalFlip()\n",
        "            ]\n",
        "    return albumentations.Compose(transform)\n",
        "\n",
        "def valaugs():\n",
        "    transform = [\n",
        "                albumentations.HorizontalFlip(),\n",
        "                albumentations.VerticalFlip()\n",
        "            ]\n",
        "    return albumentations.Compose(transform)"
      ],
      "execution_count": 24,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "w5cLH1LmC2JE"
      },
      "source": [
        "class NerveDataset(Dataset):\n",
        "    def __init__(self,imagespath,maskspath,augment=None):\n",
        "        self.imagespath = imagespath\n",
        "        self.maskspath = maskspath\n",
        "        self.augment = augment\n",
        "        \n",
        "    def __len__(self):\n",
        "        return len(self.imagespath)\n",
        "    \n",
        "    def __getitem__(self,idx):\n",
        "        image = self.imagespath[idx]\n",
        "        mask = self.maskspath[idx]\n",
        "        image = io.imread(image)\n",
        "        mask = io.imread(mask)\n",
        "        image = transform.resize(image=image,output_shape=(256,256,3)) # (256,256,3)\n",
        "        image = image/255.0\n",
        "        mask = transform.resize(mask,(256,256))  # (256,256,1)\n",
        "        mask = mask / 255.0\n",
        "        \n",
        "        if self.augment:\n",
        "            sample = self.augment(image=image, mask=mask)\n",
        "            image,mask = sample['image'],sample['mask']\n",
        "            \n",
        "        image = image.transpose((2, 0, 1)) # (3,256,256)\n",
        "        mask = np.expand_dims(mask,axis=-1).transpose((2,0,1)) # (1,256,256)\n",
        "            \n",
        "        image = torch.from_numpy(image)\n",
        "        mask = torch.from_numpy(mask)\n",
        "            \n",
        "        return image,mask"
      ],
      "execution_count": 25,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Pe4IDW2nC2Lf"
      },
      "source": [
        "from torchvision import transforms, utils\n",
        "from torch import nn\n",
        "\n",
        "from torch.autograd import Variable\n",
        "from torch.nn import Linear, ReLU, CrossEntropyLoss, Sequential, Conv2d, MaxPool2d, Module, Softmax, BatchNorm2d, Dropout\n",
        "from torch.optim import Adam, SGD\n",
        "\n",
        "import torch\n",
        "import torch.nn.functional as F\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim"
      ],
      "execution_count": 26,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EU_ddvgwC2PR"
      },
      "source": [
        "class ConvBlock(nn.Module):\n",
        "    def __init__(self,in_channels,out_channels,kernel_size=(3,3),padding=1):\n",
        "        super(ConvBlock,self).__init__()\n",
        "        self.conv = nn.Conv2d(in_channels,out_channels,kernel_size,padding=padding,bias=False)\n",
        "        self.batchnorm = nn.BatchNorm2d(out_channels,eps=1e-4)\n",
        "        self.relu = nn.ReLU(inplace=True)\n",
        "        \n",
        "    def forward(self,x):\n",
        "        x = self.conv(x)\n",
        "        x = self.batchnorm(x)\n",
        "        x = self.relu(x)\n",
        "        return x\n",
        "        \n",
        "        \n",
        "class StackEncoder(nn.Module):\n",
        "    def __init__(self,channel1,channel2,kernel_size=(3,3),padding=1):\n",
        "        super(StackEncoder,self).__init__()\n",
        "        self.maxpool = nn.MaxPool2d(kernel_size=2,stride=2)\n",
        "        self.block = nn.Sequential(\n",
        "            ConvBlock(channel1,channel2,kernel_size,padding),\n",
        "            ConvBlock(channel2,channel2,kernel_size,padding),     \n",
        "        )\n",
        "        \n",
        "    def forward(self,x):\n",
        "        big_out = self.block(x)\n",
        "        poolout = self.maxpool(big_out)\n",
        "        return big_out,poolout\n",
        "    \n",
        "class StackDecoder(nn.Module):\n",
        "    def __init__(self,big_channel,channel1,channel2,kernel_size=(3,3),padding=1):\n",
        "        super(StackDecoder,self).__init__()\n",
        "        self.block = nn.Sequential(\n",
        "            ConvBlock(channel1+big_channel,channel2,kernel_size,padding),\n",
        "            ConvBlock(channel2,channel2,kernel_size,padding),\n",
        "            ConvBlock(channel2,channel2,kernel_size,padding),\n",
        "        )\n",
        "        \n",
        "    def forward(self,x,down_tensor):\n",
        "            _, channels, height, width = down_tensor.size()  \n",
        "            x = F.upsample(x, size=(height, width), mode='bilinear')\n",
        "            x = torch.cat([x, down_tensor], 1)  #combining channels of  input from encoder and upsampling input\n",
        "            x = self.block(x)\n",
        "            return x\n",
        "        \n",
        "        \n",
        "class Unet256(nn.Module):\n",
        "    def __init__(self,input_shape):\n",
        "        super(Unet256,self).__init__()\n",
        "        \n",
        "        channel,height,width = input_shape\n",
        "        \n",
        "        self.down1 = StackEncoder(channel,12,kernel_size=(3,3))  #256\n",
        "        self.down2 = StackEncoder(12,24,kernel_size=(3,3))  # 128\n",
        "        self.down3 = StackEncoder(24,46,kernel_size=(3,3))  # 64\n",
        "        self.down4 = StackEncoder(46,64,kernel_size=(3,3))  # 32\n",
        "        self.down5 = StackEncoder(64,128,kernel_size=(3,3))  #16\n",
        "        \n",
        "        self.center = ConvBlock(128,128,kernel_size=(3,3),padding=1) #16\n",
        "        self.up5 = StackDecoder(128,128,64,kernel_size=(3,3))  #32\n",
        "        self.up4 = StackDecoder(64,64,46,kernel_size=(3,3)) #64\n",
        "        self.up3 = StackDecoder(46,46,24,kernel_size=(3,3))\n",
        "        self.up2 = StackDecoder(24,24,12,kernel_size=(3,3))\n",
        "        self.up1 = StackDecoder(12,12,12,kernel_size=(3,3))\n",
        "        self.conv = Conv2d(12,1,kernel_size=(1,1),bias=True)\n",
        "        \n",
        "    def forward(self,x):\n",
        "        down1,out = self.down1(x)  \n",
        "        down2,out = self.down2(out)  \n",
        "        down3,out = self.down3(out)\n",
        "        down4,out = self.down4(out)\n",
        "        down5,out = self.down5(out)\n",
        "        \n",
        "        \n",
        "        out = self.center(out)\n",
        "        \n",
        "        up5 = self.up5(out,down5)\n",
        "        up4 = self.up4(up5,down4)\n",
        "        up3 = self.up3(up4,down3)\n",
        "        up2 = self.up2(up3,down2)\n",
        "        up1 = self.up1(up2,down1)\n",
        "        \n",
        "        out = self.conv(up1)\n",
        "\n",
        "\n",
        "        return out"
      ],
      "execution_count": 27,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "z4KyoLd7EFJ7"
      },
      "source": [
        "class DiceBCELoss(nn.Module):\n",
        "    def __init__(self, weight=None, size_average=True):\n",
        "        super(DiceBCELoss, self).__init__()\n",
        "\n",
        "    def forward(self, inputs, targets, smooth=1):\n",
        "        \n",
        "        #comment out if your model contains a sigmoid or equivalent activation layer\n",
        "        inputs = F.sigmoid(inputs)       \n",
        "        bce_weight = 0.5\n",
        "        #flatten label and prediction tensors\n",
        "        inputs = inputs.view(-1)\n",
        "        targets = targets.view(-1)\n",
        "        \n",
        "        intersection = (inputs * targets).sum()                            \n",
        "        dice_loss = 1 - (2.*intersection + smooth)/(inputs.sum() + targets.sum() + smooth)  \n",
        "        BCE = F.binary_cross_entropy(inputs, targets, reduction='mean')\n",
        "        loss_final = BCE * bce_weight + dice_loss * (1 - bce_weight)\n",
        "        return loss_final\n",
        "    \n",
        "    \n",
        "\n",
        "class IoU(nn.Module):\n",
        "    def __init__(self, weight=None, size_average=True):\n",
        "        super(IoU, self).__init__()\n",
        "\n",
        "    def forward(self, inputs, targets, smooth=1):\n",
        "        \n",
        "        #comment out if your model contains a sigmoid or equivalent activation layer\n",
        "        inputs = F.sigmoid(inputs)       \n",
        "        \n",
        "        #flatten label and prediction tensors\n",
        "        inputs = inputs.view(-1)\n",
        "        targets = targets.view(-1)\n",
        "        intersection = (inputs * targets).sum()\n",
        "        total = (inputs + targets).sum()\n",
        "        union = total - intersection \n",
        "        \n",
        "        IoU = (intersection + smooth)/(union + smooth)\n",
        "                \n",
        "        return IoU * 100\n",
        "\n",
        "    \n",
        "    \n",
        "class DiceScore(nn.Module):\n",
        "    def __init__(self, weight=None, size_average=True):\n",
        "        super(DiceScore, self).__init__()\n",
        "\n",
        "    def forward(self, inputs, targets, smooth=1):\n",
        "        \n",
        "        #comment out if your model contains a sigmoid or equivalent activation layer\n",
        "        inputs = F.sigmoid(inputs)       \n",
        "        \n",
        "        #flatten label and prediction tensors\n",
        "        inputs = inputs.view(-1)\n",
        "        targets = targets.view(-1)\n",
        "        intersection = (inputs * targets).sum()                            \n",
        "        dice_score = (2.*intersection + smooth)/(inputs.sum() + targets.sum() + smooth) \n",
        "        return dice_score"
      ],
      "execution_count": 28,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PzTXuahFEFNt"
      },
      "source": [
        "def train_model(fold):\n",
        "    train_loss = []\n",
        "    train_iou = []\n",
        "    train_dice = []\n",
        "    val_loss = []\n",
        "    val_iou = []\n",
        "    val_dice = []\n",
        "    epochs = 2\n",
        "    train_bs= 8\n",
        "    val_bs = 4\n",
        "    \n",
        "    FILE = f\"./savedmodels/model_Fold_{fold}.pth\"\n",
        "    \n",
        "    if not os.path.exists(\"./savedmodels\"):\n",
        "        os.mkdir(\"savedmodels\")\n",
        "        \n",
        "    print(f\"*\"*20,\"FOLD\",fold, \"*\"*20)\n",
        "    df = pd.read_csv(\"Kfolds.csv\")\n",
        "    df_train = df[df.kfold != fold].reset_index(drop=True)\n",
        "    df_val = df[df.kfold == fold].reset_index(drop=True)\n",
        "    \n",
        "    traindata = NerveDataset(imagespath = df_train['Image'].tolist(),\n",
        "                            maskspath = df_train['Mask'].tolist(),\n",
        "                        augment=trainaugs())\n",
        "\n",
        "    validationdata = NerveDataset(imagespath = df_val['Image'].tolist(),\n",
        "                                maskspath = df_val['Mask'].tolist(),augment=valaugs())\n",
        "\n",
        "    trainloader = DataLoader(traindata,batch_size = train_bs,shuffle=True)\n",
        "    valloader = DataLoader(validationdata,batch_size=val_bs,shuffle=False)\n",
        "    \n",
        "    model = Unet256((3,256,256)).to(device)\n",
        "    iou_ = IoU()\n",
        "    criterion = DiceBCELoss()\n",
        "    learning_rate = 1e-3\n",
        "    optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)\n",
        "    \n",
        "    for epoch in range(epochs):\n",
        "        print('Epoch {}/{}'.format(epoch + 1, epochs))\n",
        "        start_time = time.time()\n",
        "        running_train_loss = []\n",
        "        running_train_iou = []\n",
        "\n",
        "        tk_train = tqdm(trainloader,total = len(trainloader))\n",
        "        for image,mask in tk_train: \n",
        "                image = image.to(device,dtype=torch.float)\n",
        "                mask = mask.to(device,dtype=torch.float)\n",
        "\n",
        "                pred_mask = model.forward(image) # forward propogation\n",
        "                loss = criterion(pred_mask,mask)\n",
        "                iou = iou_(pred_mask,mask)\n",
        "                optimizer.zero_grad() # setting gradient to zero\n",
        "                loss.backward()\n",
        "                optimizer.step()\n",
        "                running_train_loss.append(loss.item())\n",
        "                running_train_iou.append(iou.item())\n",
        "        else:           \n",
        "            running_val_loss = []\n",
        "            running_val_iou = []\n",
        "            \n",
        "            with torch.no_grad():\n",
        "                tk_val = tqdm(valloader,total = len(valloader))\n",
        "                for image,mask in tk_val:\n",
        "                        image = image.to(device,dtype=torch.float)\n",
        "                        mask = mask.to(device,dtype=torch.float)                            \n",
        "                        pred_mask = model.forward(image)\n",
        "                        loss = criterion(pred_mask,mask)\n",
        "                        iou = iou_(pred_mask,mask)\n",
        "                        running_val_loss.append(loss.item())\n",
        "                        running_val_iou.append(iou.item())\n",
        "\n",
        "        epoch_train_loss = np.mean(running_train_loss) \n",
        "        print(f'Fold: {fold} <---> Epoch: {epoch + 1} <---> Train DiceBCELoss: {epoch_train_loss}')                       \n",
        "        train_loss.append(epoch_train_loss)\n",
        "        \n",
        "        epoch_val_loss = np.mean(running_val_loss)\n",
        "        print(f'Fold: {fold} <---> Epoch: {epoch + 1} <---> Validation DiceBCELoss: {epoch_val_loss}')                                \n",
        "        val_loss.append(epoch_val_loss)\n",
        "        \n",
        "        epoch_train_iou = np.mean(running_train_iou)\n",
        "        print(f'Fold: {fold} <---> Epoch: {epoch + 1} <---> Train IOU: {epoch_train_iou}')                                \n",
        "        train_iou.append(epoch_train_iou)\n",
        "        \n",
        "        epoch_val_iou = np.mean(running_val_iou)\n",
        "        print(f'Fold: {fold} <---> Epoch: {epoch + 1} <---> Validation IOU: {epoch_val_iou}')                                \n",
        "        val_iou.append(epoch_val_iou)\n",
        "        \n",
        "\n",
        "        time_elapsed = time.time() - start_time\n",
        "        print('Fold {}: Time Taken: {:.0f}m {:.0f}s'.format(fold,time_elapsed // 60, time_elapsed % 60))\n",
        "        \n",
        "    torch.save(model.state_dict(), FILE)\n",
        "        \n",
        "    return train_loss, val_loss,train_iou,val_iou"
      ],
      "execution_count": 46,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0BmlBg9xEFQO"
      },
      "source": [
        "train_model(0)"
      ],
      "execution_count": 48,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aoEfypXdEFgq"
      },
      "source": [
        "# !pip list"
      ],
      "execution_count": 45,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "m7BYc2BsEFjZ"
      },
      "source": [
        ""
      ],
      "execution_count": 31,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1qOoRJu-EFm8"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tre4p1OsC2YC"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aq0G_E9NC2aV"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5c5-xv8cC2e0"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "elmJe-iAC2hR"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5o3zFOS_CZLn"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "U0fc2L0kuwhY"
      },
      "source": [
        "\r\n",
        "def show_examples(name: str, image: np.ndarray, mask: np.ndarray):\r\n",
        "    plt.figure(figsize=(10, 14))\r\n",
        "    plt.subplot(1, 2, 1)\r\n",
        "    plt.imshow(image)\r\n",
        "    plt.title(f\"Image: {name}\")\r\n",
        "\r\n",
        "    plt.subplot(1, 2, 2)\r\n",
        "    plt.imshow(mask)\r\n",
        "    plt.title(f\"Mask: {name}\")\r\n",
        "\r\n",
        "\r\n",
        "def show(index: int, images: List[Path], masks: List[Path], transforms=None) -> None:\r\n",
        "    image_path = images[index]\r\n",
        "    name = str(image_path)\r\n",
        "    # image=cv2.imread(image_path, 1)\r\n",
        "    # image=cv2.cvtColor(image,cv2.COLOR_BGR2RGB)\r\n",
        "    # mask=cv2.imread(masks[index])\r\n",
        "\r\n",
        "    #image = Image.open(image_path)\r\n",
        "    image = gif_imread(image_path,plugin='pil')\r\n",
        "    #image = np.reshape(np.asarray([image, image, image]), (image.shape[0], image.shape[1], 3))\r\n",
        "    image=cv2.cvtColor(image,cv2.COLOR_BGR2RGB)\r\n",
        "    #image = image.transpose((0, 1, 2)).astype(np.float32)\r\n",
        "    print(image.shape)\r\n",
        "    print(image.astype)\r\n",
        "    mask = gif_imread(masks[index],plugin='pil')\r\n",
        "    print(mask.shape)\r\n",
        "    if transforms is not None:\r\n",
        "        temp = transforms(image=image, mask=mask)\r\n",
        "        image = temp[\"image\"]\r\n",
        "\r\n",
        "        mask = temp[\"mask\"]\r\n",
        "        print(mask.shape)\r\n",
        "        print(image.shape)\r\n",
        "\r\n",
        "    show_examples(name, image, mask)\r\n",
        "\r\n",
        "def show_random(images, masks, transforms=None) -> None:\r\n",
        "    length = len(images)\r\n",
        "    index = random.randint(0, length - 1)\r\n",
        "    show(index, images, masks, transforms)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 298
        },
        "id": "NtIfmyVvue6f",
        "outputId": "6f39a78d-6684-4164-e955-58b621e784ab"
      },
      "source": [
        "show_random(ALL_IMAGES, ALL_MASKS)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(420, 580, 3)\n",
            "<built-in method astype of numpy.ndarray object at 0x7f92ce081ee0>\n",
            "(420, 580)\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x1008 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BUFEmFI5vMXn"
      },
      "source": [
        "class SegmentationDataset(Dataset):\r\n",
        "    def __init__(\r\n",
        "        self,\r\n",
        "        images: List[Path],\r\n",
        "        masks: List[Path] = None,\r\n",
        "        transforms=None\r\n",
        "    ) -> None:\r\n",
        "        self.images = images\r\n",
        "        self.masks = masks\r\n",
        "        self.transforms = transforms\r\n",
        "\r\n",
        "    def __len__(self) -> int:\r\n",
        "        return len(self.images)\r\n",
        "\r\n",
        "    def __getitem__(self, idx: int) -> dict:\r\n",
        "        image_path = self.images[idx]\r\n",
        "        image = gif_imread(image_path,plugin='pil')\r\n",
        "        image=cv2.cvtColor(image,cv2.COLOR_BGR2RGB)\r\n",
        " \r\n",
        "        result = {\"image\": image}\r\n",
        "        \r\n",
        "        if self.masks is not None:\r\n",
        "            mask = gif_imread(self.masks[idx],plugin='pil')\r\n",
        "            result[\"mask\"] = mask\r\n",
        "        \r\n",
        "        if self.transforms is not None:\r\n",
        "            result = self.transforms(**result)\r\n",
        "\r\n",
        "        return result"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fCyP5HY0vdVZ"
      },
      "source": [
        "def pre_transforms(image_size=224):\r\n",
        "    return [albu.Resize(image_size, image_size, interpolation = Image.BILINEAR, p=1)]\r\n",
        "\r\n",
        "\r\n",
        "def hard_transforms():\r\n",
        "    result = [\r\n",
        "      albu.RandomRotate90(),\r\n",
        "      albu.Cutout(),\r\n",
        "      albu.GaussNoise(), \r\n",
        "      albu.HorizontalFlip(p=0.5),\r\n",
        "    ]\r\n",
        "\r\n",
        "    return result\r\n",
        "  \r\n",
        "\r\n",
        "def resize_transforms(image_size=224):\r\n",
        "    BORDER_CONSTANT = 0\r\n",
        "    pre_size = int(image_size * 1.5)\r\n",
        "\r\n",
        "    random_crop = albu.Compose([\r\n",
        "      albu.SmallestMaxSize(pre_size, p=1),\r\n",
        "      albu.RandomCrop(\r\n",
        "          image_size, image_size, p=1\r\n",
        "      )])\r\n",
        "\r\n",
        "    rescale = albu.Compose([albu.Rfrom sklearn import model_selection\r\n",
        "\r\n",
        "def makesplits(df,k):\r\n",
        "    df[\"kfold\"] = -1\r\n",
        "    df = df.sample(frac=1).reset_index(drop=True)\r\n",
        "    kf = model_selection.KFold(n_splits=k)\r\n",
        "\r\n",
        "    for f,(t_,v_) in enumerate(kf.split(df)):\r\n",
        "        df.loc[v_,\"kfold\"] = f\r\n",
        "    return dfesize(image_size, image_size, p=1)])\r\n",
        "\r\n",
        "    random_crop_big = albu.Compose([\r\n",
        "      albu.LongestMaxSize(pre_size, p=1),\r\n",
        "      albu.RandomCrop(\r\n",
        "          image_size, image_size, p=1\r\n",
        "      )])\r\n",
        "\r\n",
        "    # Converts the image to a square of size image_size x image_size\r\n",
        "    result = [\r\n",
        "      albu.OneOf([\r\n",
        "          random_crop,\r\n",
        "          rescale,\r\n",
        "          random_crop_big\r\n",
        "      ], p=1)\r\n",
        "    ]\r\n",
        "\r\n",
        "    return result\r\n",
        "  \r\n",
        "def post_transforms():\r\n",
        "    # we use ImageNet image normalization\r\n",
        "    # and convert it to torch.Tensor\r\n",
        "    return [ToTensor()]\r\n",
        "  \r\n",
        "def compose(transforms_to_compose):\r\n",
        "    # combine all augmentations into single pipeline\r\n",
        "    result = albu.Compose([\r\n",
        "      item for sublist in transforms_to_compose for item in sublist\r\n",
        "    ])\r\n",
        "    return result\r\n",
        "\r\n",
        "\r\n",
        "train_transforms = compose([resize_transforms(), hard_transforms(), post_transforms()])\r\n",
        "valid_transforms = compose([pre_transforms(), post_transforms()])\r\n",
        "\r\n",
        "#show_transforms = compose([resize_transforms(), post_transforms()])\r\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qVtmO7OKCn9j"
      },
      "source": [
        "def get_loaders(\r\n",
        "    images: List[Path],\r\n",
        "    masks: List[Path],\r\n",
        "    random_state: int,\r\n",
        "    valid_size: float = 0.2,\r\n",
        "    batch_size: int = 32,\r\n",
        "    num_workers: int = 4,\r\n",
        "    train_transforms_fn = None,\r\n",
        "    valid_transforms_fn = None,\r\n",
        ") -> dict:\r\n",
        "\r\n",
        "    indices = np.arange(len(images))\r\n",
        "\r\n",
        "    # Let's divide the data set into train and valid parts.\r\n",
        "    train_indices, valid_indices = train_test_split(\r\n",
        "      indices, test_size=valid_size, random_state=random_state, shuffle=True\r\n",
        "    )\r\n",
        "\r\n",
        "    np_images = np.array(images)\r\n",
        "    np_masks = np.array(masks)\r\n",
        "\r\n",
        "    # Creates our train dataset\r\n",
        "    train_dataset = SegmentationDataset(\r\n",
        "      images = np_images[train_indices].tolist(),\r\n",
        "      masks = np_masks[train_indices].tolist(),\r\n",
        "      transforms = train_transforms_fn\r\n",
        "    )\r\n",
        "\r\n",
        "    # Creates our valid dataset\r\n",
        "    valid_dataset = SegmentationDataset(\r\n",
        "      images = np_images[valid_indices].tolist(),\r\n",
        "      masks = np_masks[valid_indices].tolist(),\r\n",
        "      transforms = valid_transforms_fn\r\n",
        "    )\r\n",
        "\r\n",
        "    #Data loaders\r\n",
        "    train_loader = DataLoader(\r\n",
        "      train_dataset,\r\n",
        "      batch_size=batch_size,\r\n",
        "      shuffle=True,\r\n",
        "      num_workers=num_workers,\r\n",
        "      drop_last=True,\r\n",
        "    )\r\n",
        "\r\n",
        "    valid_loader = DataLoader(\r\n",
        "      valid_dataset,\r\n",
        "      batch_size=batch_size,\r\n",
        "      shuffle=False,\r\n",
        "      num_workers=num_workers,\r\n",
        "      drop_last=True,\r\n",
        "    )\r\n",
        "\r\n",
        "    # And excpect to get an OrderedDict of loaders\r\n",
        "    loaders = collections.OrderedDict()\r\n",
        "    loaders[\"train\"] = train_loader\r\n",
        "    loaders[\"valid\"] = valid_loader\r\n",
        "\r\n",
        "    return loaders\r\n",
        "\r\n",
        "batch_size = 32   \r\n",
        "loaders = get_loaders(\r\n",
        "    images=ALL_IMAGES,\r\n",
        "    masks=ALL_MASKS,\r\n",
        "    random_state=42,\r\n",
        "    train_transforms_fn=train_transforms,\r\n",
        "    valid_transforms_fn=valid_transforms,\r\n",
        "    batch_size=batch_size\r\n",
        ")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XQMYiEk2DJql"
      },
      "source": [
        "# def dice_loss(pred, target):\r\n",
        "#     \"\"\"Cacluate dice loss \r\n",
        "#     Parameters\r\n",
        "#     ----------\r\n",
        "#         pred:\r\n",
        "#             predictions from the model\r\n",
        "#         target:\r\n",
        "#             ground truth label\r\n",
        "#     \"\"\"\r\n",
        "                                                                         \r\n",
        "#     smooth = 1.                                                          \r\n",
        "                                                                         \r\n",
        "#     p_flat = pred.contiguous().view(-1)                                   \r\n",
        "#     t_flat = target.contiguous().view(-1)                                 \r\n",
        "#     intersection = (p_flat * t_flat).sum()                                 \r\n",
        "                                                                         \r\n",
        "#     a_sum = torch.sum(p_flat * p_flat)                                     \r\n",
        "#     b_sum = torch.sum(t_flat * t_flat)                                     \r\n",
        "                                                                         \r\n",
        "#     return 1 - ((2. * intersection + smooth) / (a_sum + b_sum + smooth) )\r\n",
        "\r\n",
        "\r\n",
        "\r\n",
        "\r\n",
        "\r\n",
        "class DiceBCELoss(nn.Module):\r\n",
        "    def __init__(self, weight=None, size_average=True):\r\n",
        "        super(DiceBCELoss, self).__init__()\r\n",
        "\r\n",
        "    def forward(self, inputs, targets, smooth=1):\r\n",
        "        \r\n",
        "        #comment out if your model contains a sigmoid or equivalent activation layer\r\n",
        "        inputs = F.sigmoid(inputs)       \r\n",
        "        bce_weight = 0.5\r\n",
        "        #flatten label and prediction tensors\r\n",
        "        inputs = inputs.view(-1)\r\n",
        "        targets = targets.view(-1)\r\n",
        "        \r\n",
        "        intersection = (inputs * targets).sum()                            \r\n",
        "        dice_loss = 1 - (2.*intersection + smooth)/(inputs.sum() + targets.sum() + smooth)  \r\n",
        "        BCE = F.binary_cross_entropy(inputs, targets, reduction='mean')\r\n",
        "        loss_final = BCE * bce_weight + dice_loss * (1 - bce_weight)\r\n",
        "        return loss_final\r\n",
        "    \r\n",
        "    \r\n",
        "\r\n",
        "class IoU(nn.Module):\r\n",
        "    def __init__(self, weight=None, size_average=True):\r\n",
        "        super(IoU, self).__init__()\r\n",
        "\r\n",
        "    def forward(self, inputs, targets, smooth=1):\r\n",
        "        \r\n",
        "        #comment out if your model contains a sigmoid or equivalent activation layer\r\n",
        "        inputs = F.sigmoid(inputs)       \r\n",
        "        \r\n",
        "        #flatten label and prediction tensors\r\n",
        "        inputs = inputs.view(-1)\r\n",
        "        targets = targets.view(-1)\r\n",
        "        intersection = (inputs * targets).sum()\r\n",
        "        total = (inputs + targets).sum()\r\n",
        "        union = total - intersection \r\n",
        "        \r\n",
        "        IoU = (intersection + smooth)/(union + smooth)\r\n",
        "                \r\n",
        "        return IoU * 100\r\n",
        "\r\n",
        "    \r\n",
        "    \r\n",
        "class DiceScore(nn.Module):\r\n",
        "    def __init__(self, weight=None, size_average=True):\r\n",
        "        super(DiceScore, self).__init__()\r\n",
        "\r\n",
        "    def forward(self, inputs, targets, smooth=1):\r\n",
        "        \r\n",
        "        #comment out if your model contains a sigmoid or equivalent activation layer\r\n",
        "        inputs = F.sigmoid(inputs)       \r\n",
        "        \r\n",
        "        #flatten label and prediction tensors\r\n",
        "        inputs = inputs.view(-1)\r\n",
        "        targets = targets.view(-1)\r\n",
        "        intersection = (inputs * targets).sum()                            \r\n",
        "        dice_score = (2.*intersection + smooth)/(inputs.sum() + targets.sum() + smooth) \r\n",
        "        return dice_score"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TBg9m806Dr7n"
      },
      "source": [
        "class DoubleConv(nn.Module):\r\n",
        "    \"\"\"(convolution => [BN] => ReLU) * 2\"\"\"\r\n",
        "\r\n",
        "    def __init__(self, in_channels, out_channels, mid_channels=None):\r\n",
        "        super().__init__()\r\n",
        "        if not mid_channels:\r\n",
        "            mid_channels = out_channels\r\n",
        "        self.double_conv = nn.Sequential(\r\n",
        "            nn.Conv2d(in_channels, mid_channels, kernel_size=3, padding=1),\r\n",
        "            nn.BatchNorm2d(mid_channels),\r\n",
        "            nn.ReLU(inplace=True),\r\n",
        "            nn.Conv2d(mid_channels, out_channels, kernel_size=3, padding=1),\r\n",
        "            nn.BatchNorm2d(out_channels),\r\n",
        "            nn.ReLU(inplace=True)\r\n",
        "        )\r\n",
        "\r\n",
        "    def forward(self, x):\r\n",
        "        return self.double_conv(x)\r\n",
        "\r\n",
        "\r\n",
        "class Down(nn.Module):\r\n",
        "    \"\"\"Downscaling with maxpool then double conv\"\"\"\r\n",
        "\r\n",
        "    def __init__(self, in_channels, out_channels):\r\n",
        "        super().__init__()\r\n",
        "        self.maxpool_conv = nn.Sequential(\r\n",
        "            nn.MaxPool2d(2),\r\n",
        "            DoubleConv(in_channels, out_channels)\r\n",
        "        )\r\n",
        "\r\n",
        "    def forward(self, x):\r\n",
        "        return self.maxpool_conv(x)\r\n",
        "\r\n",
        "\r\n",
        "class Up(nn.Module):\r\n",
        "    \"\"\"Upscaling then double conv\"\"\"\r\n",
        "\r\n",
        "    def __init__(self, in_channels, out_channels, bilinear=True):\r\n",
        "        super().__init__()\r\n",
        "\r\n",
        "        # if bilinear, use the normal convolutions to reduce the number of channels\r\n",
        "        if bilinear:\r\n",
        "            self.up = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True)\r\n",
        "            self.conv = DoubleConv(in_channels, out_channels, in_channels // 2)\r\n",
        "        else:\r\n",
        "            self.up = nn.ConvTranspose2d(in_channels , in_channels // 2, kernel_size=2, stride=2)\r\n",
        "            self.conv = DoubleConv(in_channels, out_channels)\r\n",
        "\r\n",
        "\r\n",
        "    def forward(self, x1, x2):\r\n",
        "        x1 = self.up(x1)\r\n",
        "        # input is CHW\r\n",
        "        diffY = x2.size()[2] - x1.size()[2]\r\n",
        "        diffX = x2.size()[3] - x1.size()[3]\r\n",
        "\r\n",
        "        x1 = F.pad(x1, [diffX // 2, diffX - diffX // 2,\r\n",
        "                        diffY // 2, diffY - diffY // 2])\r\n",
        "        # if you have padding issues, see\r\n",
        "        # https://github.com/HaiyongJiang/U-Net-Pytorch-Unstructured-Buggy/commit/0e854509c2cea854e247a9c615f175f76fbb2e3a\r\n",
        "        # https://github.com/xiaopeng-liao/Pytorch-UNet/commit/8ebac70e633bac59fc22bb5195e513d5832fb3bd\r\n",
        "        x = torch.cat([x2, x1], dim=1)\r\n",
        "        return self.conv(x)\r\n",
        "\r\n",
        "\r\n",
        "class OutConv(nn.Module):\r\n",
        "    def __init__(self, in_channels, out_channels):\r\n",
        "        super(OutConv, self).__init__()\r\n",
        "        self.conv = nn.Conv2d(in_channels, out_channels, kernel_size=1)\r\n",
        "\r\n",
        "    def forward(self, x):\r\n",
        "        return self.conv(x)\r\n",
        "        \r\n",
        "class UNet(nn.Module):\r\n",
        "    def __init__(self, n_channels, n_classes, bilinear=True):\r\n",
        "        super(UNet, self).__init__()\r\n",
        "        self.n_channels = n_channels\r\n",
        "        self.n_classes = n_classes\r\n",
        "        self.bilinear = bilinear\r\n",
        "\r\n",
        "        self.inc = DoubleConv(n_channels, 64)\r\n",
        "        self.down1 = Down(64, 128)\r\n",
        "        self.down2 = Down(128, 256)\r\n",
        "        self.down3 = Down(256, 512)\r\n",
        "        factor = 2 if bilinear else 1\r\n",
        "        self.down4 = Down(512, 1024 // factor)\r\n",
        "        self.up1 = Up(1024, 512 // factor, bilinear)\r\n",
        "        self.up2 = Up(512, 256 // factor, bilinear)\r\n",
        "        self.up3 = Up(256, 128 // factor, bilinear)\r\n",
        "        self.up4 = Up(128, 64, bilinear)\r\n",
        "        self.outc = OutConv(64, n_classes)\r\n",
        "\r\n",
        "    def forward(self, x):\r\n",
        "        x1 = self.inc(x)\r\n",
        "        x2 = self.down1(x1)\r\n",
        "        x3 = self.down2(x2)\r\n",
        "        x4 = self.down3(x3)\r\n",
        "        x5 = self.down4(x4)\r\n",
        "        x = self.up1(x5, x4)\r\n",
        "        x = self.up2(x, x3)\r\n",
        "        x = self.up3(x, x2)\r\n",
        "        x = self.up4(x, x1)\r\n",
        "        logits = self.outc(x)\r\n",
        "        return logits"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qAFgRoGv_HJY"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "C7xBlnjN_HYz"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rKL9SRdz_Hbt"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0vW47eSS_Hdv"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2Rvyyflh_Hh6"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lXq9PdmB_Hj9"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DjmaVVO9Fc3I",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1e3a30c1-7681-41ae-e8b2-af3320743291"
      },
      "source": [
        "#hyperparameters\r\n",
        "learning_rate = 0.01,\r\n",
        "epochs = 5,\r\n",
        "batch_size = 32,\r\n",
        "n_channels = 3,\r\n",
        "n_classes = 1,\r\n",
        "net = UNet(n_channels=3, n_classes=1, bilinear=True)\r\n",
        "optimizer = optim.Adam(net.parameters(), lr=0.01, betas=(0.9, 0.999), eps=1e-08)\r\n",
        "scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, 'max', patience=2)\r\n",
        "#criterion = nn.BCEWithLogitsLoss()\r\n",
        "\r\n",
        "\r\n",
        "from catalyst.dl import SupervisedRunner\r\n",
        "\r\n",
        "num_epochs = 20\r\n",
        "logdir = \"/content/drive/MyDrive/IRCAD/logs/segmentation\"\r\n",
        "\r\n",
        "#device = utils.get_device()\r\n",
        "print(f\"device: {device}\")\r\n",
        "\r\n",
        "fp16_params = None\r\n",
        "\r\n",
        "print(f\"FP16 params: {fp16_params}\")\r\n",
        "\r\n",
        "\r\n",
        "# by default SupervisedRunner uses \"features\" and \"targets\",\r\n",
        "# in our case we get \"image\" and \"mask\" keys in dataset __getitem__\r\n",
        "runner = SupervisedRunner(device=device, input_key=\"image\", input_target_key=\"mask\")\r\n",
        "from torch import nn\r\n",
        "\r\n",
        "from catalyst.contrib.nn import DiceLoss, IoULoss\r\n",
        "\r\n",
        "# we have multiple criterions\r\n",
        "criterion = {\r\n",
        "    \"dice\": DiceLoss(),\r\n",
        "    \"iou\": IoULoss(),\r\n",
        "    \"bce\": nn.BCEWithLogitsLoss()\r\n",
        "}"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "device: cuda\n",
            "FP16 params: None\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yfJPVrW3Hr4Y",
        "outputId": "482b6600-f508-4675-c909-c9aa78a13cc3"
      },
      "source": [
        "epochs = 5\r\n",
        "train_loader = loaders[\"train\"]\r\n",
        "valid_loader = loaders[\"valid\"]\r\n",
        "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\r\n",
        "from catalyst.dl import DiceCallback, IouCallback, \\\r\n",
        "  CriterionCallback, MetricAggregationCallback\r\n",
        "from catalyst.contrib.callbacks import DrawMasksCallback\r\n",
        "\r\n",
        "callbacks = [\r\n",
        "    # Each criterion is calculated separately.\r\n",
        "    CriterionCallback(\r\n",
        "        input_key=\"mask\",\r\n",
        "        prefix=\"loss_dice\",\r\n",
        "        criterion_key=\"dice\"\r\n",
        "    ),\r\n",
        "    CriterionCallback(\r\n",
        "        input_key=\"mask\",\r\n",
        "        prefix=\"loss_iou\",\r\n",
        "        criterion_key=\"iou\"\r\n",
        "    ),\r\n",
        "    CriterionCallback(\r\n",
        "        input_key=\"mask\",\r\n",
        "        prefix=\"loss_bce\",\r\n",
        "        criterion_key=\"bce\"\r\n",
        "    ),\r\n",
        "\r\n",
        "    # And only then we aggregate everything into one loss.\r\n",
        "    MetricAggregationCallback(\r\n",
        "        prefix=\"loss\",\r\n",
        "        mode=\"weighted_sum\", # can be \"sum\", \"weighted_sum\" or \"mean\"\r\n",
        "        # because we want weighted sum, we need to add scale for each loss\r\n",
        "        metrics={\"loss_dice\": 1.0, \"loss_iou\": 1.0, \"loss_bce\": 0.8},\r\n",
        "    ),\r\n",
        "\r\n",
        "    # metrics\r\n",
        "    DiceCallback(input_key=\"mask\"),\r\n",
        "    IouCallback(input_key=\"mask\"),\r\n",
        "    # visualization\r\n",
        "    DrawMasksCallback(output_key='logits',\r\n",
        "                      input_image_key='image',\r\n",
        "                      input_mask_key='mask',\r\n",
        "                      summary_step=50\r\n",
        "    )\r\n",
        "]\r\n",
        "runner.train(\r\n",
        "  model=net,\r\n",
        "  criterion=criterion,\r\n",
        "  optimizer=optimizer,\r\n",
        "  scheduler=scheduler,\r\n",
        "  # our dataloaders\r\n",
        "  loaders=loaders,\r\n",
        "  # We can specify the callbacks list for the experiment;\r\n",
        "  callbacks=callbacks,\r\n",
        "  # path to save logs\r\n",
        "  logdir=logdir,\r\n",
        "  num_epochs=num_epochs,\r\n",
        "  # save our best checkpoint by dice metric\r\n",
        "  main_metric=\"dice\",\r\n",
        "  # IoU needs to be maximized.\r\n",
        "  minimize_metric=True,\r\n",
        "  # for FP16. It uses the variable from the very first cell\r\n",
        "  fp16=fp16_params,\r\n",
        "  # prints train logs    \r\n",
        "  verbose=True,\r\n",
        "\r\n",
        ")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1/20 * Epoch (train):  83% 116/140 [17:15<01:58,  4.96s/it, dice=0.121, iou=0.064, loss=1.899, loss_bce=0.105, loss_dice=0.879, loss_iou=0.936]"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "guudileYcPXG"
      },
      "source": [
        "# Catalyst\r\n",
        "!pip install catalyst==20.12\r\n",
        "\r\n",
        "# for augmentations\r\n",
        "!pip install albumentations==0.4.3\r\n",
        "\r\n",
        "# for pretrained segmentation models for PyTorch\r\n",
        "!pip install segmentation-models-pytorch==0.1.0\r\n",
        "\r\n",
        "# for TTA\r\n",
        "!pip install ttach==0.0.2\r\n",
        "\r\n",
        "# for tensorboard\r\n",
        "#!pip install tensorflow"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kg7XRNZk4iO_"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}