Unet.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Unet.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU",
    "widgets": {
      "application/vnd.jupyter.widget-state+json": {
        "237de72ffbd94eac8e5b846390f8ee6e": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HBoxModel",
          "state": {
            "_view_name": "HBoxView",
            "_dom_classes": [],
            "_model_name": "HBoxModel",
            "_view_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_view_count": null,
            "_view_module_version": "1.5.0",
            "box_style": "",
            "layout": "IPY_MODEL_ac3934e048a348ea866b073cdf91070e",
            "_model_module": "@jupyter-widgets/controls",
            "children": [
              "IPY_MODEL_023a4fb4089e4dc7aba4dee0c371182d",
              "IPY_MODEL_84d9bd7025544e9abbca6813eabe2781"
            ]
          }
        },
        "ac3934e048a348ea866b073cdf91070e": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "state": {
            "_view_name": "LayoutView",
            "grid_template_rows": null,
            "right": null,
            "justify_content": null,
            "_view_module": "@jupyter-widgets/base",
            "overflow": null,
            "_model_module_version": "1.2.0",
            "_view_count": null,
            "flex_flow": null,
            "width": null,
            "min_width": null,
            "border": null,
            "align_items": null,
            "bottom": null,
            "_model_module": "@jupyter-widgets/base",
            "top": null,
            "grid_column": null,
            "overflow_y": null,
            "overflow_x": null,
            "grid_auto_flow": null,
            "grid_area": null,
            "grid_template_columns": null,
            "flex": null,
            "_model_name": "LayoutModel",
            "justify_items": null,
            "grid_row": null,
            "max_height": null,
            "align_content": null,
            "visibility": null,
            "align_self": null,
            "height": null,
            "min_height": null,
            "padding": null,
            "grid_auto_rows": null,
            "grid_gap": null,
            "max_width": null,
            "order": null,
            "_view_module_version": "1.2.0",
            "grid_template_areas": null,
            "object_position": null,
            "object_fit": null,
            "grid_auto_columns": null,
            "margin": null,
            "display": null,
            "left": null
          }
        },
        "023a4fb4089e4dc7aba4dee0c371182d": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "FloatProgressModel",
          "state": {
            "_view_name": "ProgressView",
            "style": "IPY_MODEL_be3602da49c74fa39ca634b59efd7b7a",
            "_dom_classes": [],
            "description": "100%",
            "_model_name": "FloatProgressModel",
            "bar_style": "success",
            "max": 46827520,
            "_view_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "value": 46827520,
            "_view_count": null,
            "_view_module_version": "1.5.0",
            "orientation": "horizontal",
            "min": 0,
            "description_tooltip": null,
            "_model_module": "@jupyter-widgets/controls",
            "layout": "IPY_MODEL_b0999dba18154c939adde87e5392b782"
          }
        },
        "84d9bd7025544e9abbca6813eabe2781": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "state": {
            "_view_name": "HTMLView",
            "style": "IPY_MODEL_fc902fe08ccf43a0b90007f132050035",
            "_dom_classes": [],
            "description": "",
            "_model_name": "HTMLModel",
            "placeholder": "​",
            "_view_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "value": " 44.7M/44.7M [01:45&lt;00:00, 443kB/s]",
            "_view_count": null,
            "_view_module_version": "1.5.0",
            "description_tooltip": null,
            "_model_module": "@jupyter-widgets/controls",
            "layout": "IPY_MODEL_def741b02efc420a9e211d88d1672fdf"
          }
        },
        "be3602da49c74fa39ca634b59efd7b7a": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "ProgressStyleModel",
          "state": {
            "_view_name": "StyleView",
            "_model_name": "ProgressStyleModel",
            "description_width": "initial",
            "_view_module": "@jupyter-widgets/base",
            "_model_module_version": "1.5.0",
            "_view_count": null,
            "_view_module_version": "1.2.0",
            "bar_color": null,
            "_model_module": "@jupyter-widgets/controls"
          }
        },
        "b0999dba18154c939adde87e5392b782": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "state": {
            "_view_name": "LayoutView",
            "grid_template_rows": null,
            "right": null,
            "justify_content": null,
            "_view_module": "@jupyter-widgets/base",
            "overflow": null,
            "_model_module_version": "1.2.0",
            "_view_count": null,
            "flex_flow": null,
            "width": null,
            "min_width": null,
            "border": null,
            "align_items": null,
            "bottom": null,
            "_model_module": "@jupyter-widgets/base",
            "top": null,
            "grid_column": null,
            "overflow_y": null,
            "overflow_x": null,
            "grid_auto_flow": null,
            "grid_area": null,
            "grid_template_columns": null,
            "flex": null,
            "_model_name": "LayoutModel",
            "justify_items": null,
            "grid_row": null,
            "max_height": null,
            "align_content": null,
            "visibility": null,
            "align_self": null,
            "height": null,
            "min_height": null,
            "padding": null,
            "grid_auto_rows": null,
            "grid_gap": null,
            "max_width": null,
            "order": null,
            "_view_module_version": "1.2.0",
            "grid_template_areas": null,
            "object_position": null,
            "object_fit": null,
            "grid_auto_columns": null,
            "margin": null,
            "display": null,
            "left": null
          }
        },
        "fc902fe08ccf43a0b90007f132050035": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_view_name": "StyleView",
            "_model_name": "DescriptionStyleModel",
            "description_width": "",
            "_view_module": "@jupyter-widgets/base",
            "_model_module_version": "1.5.0",
            "_view_count": null,
            "_view_module_version": "1.2.0",
            "_model_module": "@jupyter-widgets/controls"
          }
        },
        "def741b02efc420a9e211d88d1672fdf": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "state": {
            "_view_name": "LayoutView",
            "grid_template_rows": null,
            "right": null,
            "justify_content": null,
            "_view_module": "@jupyter-widgets/base",
            "overflow": null,
            "_model_module_version": "1.2.0",
            "_view_count": null,
            "flex_flow": null,
            "width": null,
            "min_width": null,
            "border": null,
            "align_items": null,
            "bottom": null,
            "_model_module": "@jupyter-widgets/base",
            "top": null,
            "grid_column": null,
            "overflow_y": null,
            "overflow_x": null,
            "grid_auto_flow": null,
            "grid_area": null,
            "grid_template_columns": null,
            "flex": null,
            "_model_name": "LayoutModel",
            "justify_items": null,
            "grid_row": null,
            "max_height": null,
            "align_content": null,
            "visibility": null,
            "align_self": null,
            "height": null,
            "min_height": null,
            "padding": null,
            "grid_auto_rows": null,
            "grid_gap": null,
            "max_width": null,
            "order": null,
            "_view_module_version": "1.2.0",
            "grid_template_areas": null,
            "object_position": null,
            "object_fit": null,
            "grid_auto_columns": null,
            "margin": null,
            "display": null,
            "left": null
          }
        }
      }
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Hqy4lCV5Mhdu",
        "outputId": "140f6fe1-072d-46f3-c2f9-a53b16477ac5"
      },
      "source": [
        "import os\n",
        "import glob\n",
        "from google.colab import drive\n",
        "\n",
        "## load train, test and validation label arrays\n",
        "drive = drive.mount('/content/drive')"
      ],
      "execution_count": null,
      "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": "zYQtW8C5Mia-"
      },
      "source": [
        "import os\n",
        "import time\n",
        "import copy\n",
        "from collections import defaultdict\n",
        "import torch\n",
        "import shutil\n",
        "import pandas as pd\n",
        "from skimage import io, transform\n",
        "import numpy as np\n",
        "from PIL import Image\n",
        "import matplotlib.pyplot as plt\n",
        "from torch.utils.data import Dataset, DataLoader, random_split\n",
        "from torchvision import transforms, utils\n",
        "from torch import nn\n",
        "import albumentations as A\n",
        "from albumentations.pytorch import ToTensor\n",
        "#import tqdm as tqdm\n",
        "from tqdm import tqdm as tqdm\n",
        "\n",
        "from albumentations import (HorizontalFlip, ShiftScaleRotate, Normalize, Resize, Compose, GaussNoise)\n",
        "import cv2\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",
        "import torch.nn.functional as F\n",
        "from PIL import Image\n",
        "from torch import nn\n",
        "import zipfile\n",
        "\n",
        "import random\n",
        "\n",
        "#device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "S1wv-rYkNWdP"
      },
      "source": [
        "import random \n",
        "import cv2 \n",
        "def unet_augment(sample,vertical_prob,horizontal_prob): \n",
        "  image, masks= sample['image'], sample['masks'] \n",
        "  if (random.random()<vertical_prob): \n",
        "    image=cv2.flip(image,1) \n",
        "    masks=cv2.flip(masks,1) \n",
        "  if (random.random()<horizontal_prob): \n",
        "    image=cv2.flip(image,0) \n",
        "    masks=cv2.flip(masks,0) \n",
        "  return {'image': image, 'masks': masks} "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dH5HmXskNiPT"
      },
      "source": [
        "class MyDataset(Dataset):\n",
        "\n",
        "    def __init__(self, root, img_transform = None, mask_transform = None, transform= None):\n",
        "        self.root = root\n",
        "        self.folders = os.listdir(root)#指定路径包含的所有文件list\n",
        "        \n",
        "        paths = os.listdir(os.path.join(root, 'train_images'))\n",
        "        self.imgs = [os.path.join(root, 'train_images', p) for p in paths]\n",
        "        self.masks = [os.path.join(root, 'train_masks', p) for p in paths]\n",
        "        \n",
        "        self.img_transform = img_transform\n",
        "        self.mask_transform = mask_transform\n",
        "        self.transform = transform\n",
        "\n",
        "        \n",
        "    def __getitem__(self, idx):\n",
        "        img_folder = os.path.join(self.root, 'train_images')\n",
        "        mask_folder = os.path.join(self.root, 'train_masks')\n",
        "        \n",
        "        img_path = self.imgs[idx]\n",
        "        mask_path = self.masks[idx]\n",
        "        \n",
        "        img=cv2.imread(img_path)\n",
        "        #img = Image.open(img_path)\n",
        "        #input_net_1=img\n",
        "        #input_net_2=img \n",
        "\n",
        "        img=cv2.resize(img,(256,256), interpolation = cv2.INTER_CUBIC)\n",
        "        img= img.reshape((256,256,3))\n",
        "        #input_net_2=cv2.resize(input_net_2,(128,128), interpolation = cv2.INTER_CUBIC)\n",
        "        #img = img.convert('RGB')\n",
        "        #mask = Image.open(mask_path)\n",
        "\n",
        "        mask = cv2.imread(mask_path,cv2.IMREAD_GRAYSCALE)\n",
        "        mask = cv2.resize(mask,(256,256), interpolation = cv2.INTER_CUBIC)\n",
        "        mask= mask.reshape((256,256,1))       \n",
        "\n",
        "\n",
        "        sample = {'image': img, 'masks': mask}  \n",
        "\n",
        "        if self.transform:\n",
        "          sample=unet_augment(sample,vertical_prob=0.25,horizontal_prob=0.3)\n",
        "\n",
        "        sample['image']= sample['image'].transpose((2, 0, 1))#The convolution function in pytorch expects data in format (N,C,H,W) N is batch size , C are channels H is height and W is width. here we convert image from (H,W,C) to (C,H,W)\n",
        "        sample['masks']= sample['masks'].reshape((256,256,1)).transpose((2, 0, 1))\n",
        "       \n",
        "        sample[\"image\"] = self.img_transform(img)\n",
        "        \n",
        "       # mask = mask.convert('RGB')\n",
        "        sample[\"masks\"] = self.mask_transform(mask)\n",
        "        \n",
        "        return (sample[\"image\"],sample[\"masks\"])\n",
        "\n",
        "    \n",
        "    def __len__(self):\n",
        "        \n",
        "        return len(self.imgs)\n",
        "            \n",
        "\n",
        "        "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "l5LA_pUNNkKe"
      },
      "source": [
        "img_transform = transforms.Compose([\n",
        "    transforms.ToTensor(),\n",
        "    transforms.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)),\n",
        "  \n",
        "])\n",
        "\n",
        "mask_transform = transforms.Compose([\n",
        "    transforms.ToTensor(),\n",
        "])\n",
        "\n",
        "# Generate dataset\n",
        "dataset = MyDataset('drive/My Drive/FDLHW', img_transform, mask_transform,transform= True)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JfayZHpUQofC",
        "outputId": "30a7072d-8d03-4f1a-8a62-2330b59f303b"
      },
      "source": [
        "image, mask = dataset.__getitem__(0)\n",
        "print(image.shape)\n",
        "print(mask.shape)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "torch.Size([3, 256, 256])\n",
            "torch.Size([1, 256, 256])\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_G_KluLrQuOV"
      },
      "source": [
        "import numpy as np\n",
        "def format_image(img):\n",
        "    img = np.array(np.transpose(img, (1,2,0)))\n",
        "    mean = np.array((0.485, 0.456, 0.406))\n",
        "    std = np.array((0.229, 0.224, 0.225))\n",
        "    img  = std * img + mean\n",
        "    img = img * 255\n",
        "    img = img.astype(np.uint8)\n",
        "    return img\n",
        "\n",
        "def format_mask(mask):\n",
        "    mask = np.squeeze(np.transpose(mask, (1,2,0)))\n",
        "    return mask"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Gs98fkE2Qxdw"
      },
      "source": [
        "import random\n",
        "from matplotlib import pyplot as plt\n",
        "# Visualize images as well as masks\n",
        "def visualize_dataset(n_images, predict=None):\n",
        "    images = random.sample(range(0, 670), n_images)\n",
        "    figure, ax = plt.subplots(nrows=len(images), ncols=2, figsize=(5, 8))\n",
        "    print(images)\n",
        "    \n",
        "    for i in range(0, len(images)):\n",
        "        img_no = images[i]\n",
        "        image, mask = dataset.__getitem__(img_no)\n",
        "        image = format_image(image)\n",
        "        mask = format_mask(mask)\n",
        "        ax[i, 0].imshow(image)\n",
        "        ax[i, 1].imshow(mask, interpolation=\"nearest\", cmap=\"gray\")\n",
        "        ax[i, 0].set_title(\"Ground Truth Image\")\n",
        "        ax[i, 1].set_title(\"Mask\")\n",
        "        ax[i, 0].set_axis_off()\n",
        "        ax[i, 1].set_axis_off()\n",
        "    plt.tight_layout()\n",
        "    plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 603
        },
        "id": "z6U6kly9Q0-1",
        "outputId": "974a8960-b98a-420d-fa22-0e3acb375533"
      },
      "source": [
        "visualize_dataset(5)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[463, 59, 25, 328, 10]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 360x576 with 10 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Tf-28QCsQ3gm",
        "outputId": "8c50aa06-f34c-4ce1-e8cd-750d31c57d0a"
      },
      "source": [
        "import numpy as np\n",
        "from torch.utils.data import DataLoader, random_split\n",
        "split_ratio = 0.25\n",
        "train_size=int(np.round(dataset.__len__()*(1 - split_ratio),0))\n",
        "valid_size=int(np.round(dataset.__len__()*split_ratio,0))\n",
        "\n",
        "train_data, valid_data = random_split(dataset, [train_size, valid_size])\n",
        "\n",
        "train_loader = DataLoader(dataset=train_data, batch_size=20, shuffle=True)\n",
        "val_loader = DataLoader(dataset=valid_data, batch_size=20)\n",
        "\n",
        "print(\"Length of train and valid datas: {}, {}\".format(len(train_data), len(valid_data)))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Length of train and valid datas: 1992, 664\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kDe_CVE8Q-rw"
      },
      "source": [
        "import torch.nn as nn\n",
        "        \n",
        "        \n",
        "ALPHA = 0.8\n",
        "GAMMA = 2\n",
        "\n",
        "class FocalDiceLoss(nn.Module):\n",
        "    def __init__(self, weight=None, size_average=True):\n",
        "        super(FocalLoss, self).__init__()\n",
        "\n",
        "    def forward(self, inputs, targets, alpha=ALPHA, gamma=GAMMA, 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",
        "        \n",
        "        #DICE\n",
        "        intersection = (inputs * targets).sum()                            \n",
        "        dice = 1-(2.*intersection + smooth)/(inputs.sum() + targets.sum() + smooth) \n",
        "        \n",
        "        \n",
        "        #FOCAL\n",
        "        BCE = F.binary_cross_entropy(inputs, targets, reduction='mean')\n",
        "        BCE_EXP = torch.exp(-BCE)\n",
        "        focal_loss = alpha * (1-BCE_EXP)**gamma * BCE\n",
        "                       \n",
        "        #FINAL\n",
        "        final_loss=1\n",
        "        \n",
        "        return focal_loss      \n",
        "        \n",
        "    \n",
        "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",
        "        \n",
        "        #comment out if your model contains a sigmoid or equivalent activation layer\n",
        "        inputs = torch.sigmoid(inputs)       \n",
        "        \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",
        "        Dice_BCE = BCE + dice_loss\n",
        "        \n",
        "        return Dice_BCE\n",
        "\n",
        "\n",
        "class DiceLoss(nn.Module):\n",
        "    def __init__(self, weight=None, size_average=True):\n",
        "        super(DiceLoss, 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",
        "        \n",
        "        intersection = (inputs * targets).sum()                            \n",
        "        dice = (2.*intersection + smooth)/(inputs.sum() + targets.sum() + smooth)  \n",
        "        \n",
        "        return 1 - dice\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",
        "        \n",
        "        #intersection is equivalent to True Positive count\n",
        "        #union is the mutually inclusive area of all labels & predictions \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"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tLa0e3N2RBuw"
      },
      "source": [
        "def write_results(ff, save_folder, epoch, train_score, val_score, train_loss, val_loss):\n",
        "    ff=open('{}/progress.txt'.format(save_folder),'a')\n",
        "    ff.write(' E: ')\n",
        "    ff.write(str(epoch))\n",
        "    ff.write('         ')\n",
        "    ff.write(' TRAIN_SCORE: ')\n",
        "    ff.write(str('%.3f' % train_score))\n",
        "    ff.write(' VAL_SCORE: ')\n",
        "    ff.write(str('%.3f' % val_score))\n",
        "    ff.write('         ')\n",
        "    ff.write(' TRAIN_LOSS: ')\n",
        "    ff.write(str('%.3f' % train_loss))\n",
        "    ff.write(' VAL_LOSS: ')\n",
        "    ff.write(str('%.3f' % val_loss))\n",
        "    ff.write('\\n')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "991fLvZrRJd_"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "# create a function that creates train-val loss graph and saves the figure in a destination folder\n",
        "def save_graph(train_loss, val_loss, nb_epochs, save_folder):\n",
        "    plt.plot(list(range(nb_epochs+1))[1:], train_loss)\n",
        "    plt.plot(list(range(nb_epochs+1))[1:], val_loss)\n",
        "    plt.legend(['train', 'val'])\n",
        "    plt.xlabel('Epochs')\n",
        "    plt.ylabel('Loss')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "g4U8f93iRLHF"
      },
      "source": [
        "#model\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "from torchvision import models, datasets, transforms\n",
        "from torch.nn import functional as F\n",
        "\n",
        "\n",
        "def get_backbone(name, pretrained=True):\n",
        "\n",
        "    \"\"\" Loading backbone, defining names for skip-connections and encoder output. \"\"\"\n",
        "\n",
        "    # TODO: More backbones\n",
        "\n",
        "    # loading backbone model\n",
        "    if name == 'resnet18':\n",
        "        backbone = models.resnet18(pretrained=pretrained)\n",
        "    elif name == 'resnet34':\n",
        "        backbone = models.resnet34(pretrained=pretrained)\n",
        "    elif name == 'resnet50':\n",
        "        backbone = models.resnet50(pretrained=pretrained)\n",
        "    elif name == 'resnet101':\n",
        "        backbone = models.resnet101(pretrained=pretrained)\n",
        "    elif name == 'resnet152':\n",
        "        backbone = models.resnet152(pretrained=pretrained)\n",
        "    elif name == 'vgg16':\n",
        "        backbone = models.vgg16_bn(pretrained=pretrained).features\n",
        "    elif name == 'vgg19':\n",
        "        backbone = models.vgg19_bn(pretrained=pretrained).features\n",
        "    # elif name == 'inception_v3':\n",
        "    #     backbone = models.inception_v3(pretrained=pretrained, aux_logits=False)\n",
        "    elif name == 'densenet121':\n",
        "        backbone = models.densenet121(pretrained=True).features\n",
        "    elif name == 'densenet161':\n",
        "        backbone = models.densenet161(pretrained=True).features\n",
        "    elif name == 'densenet169':\n",
        "        backbone = models.densenet169(pretrained=True).features\n",
        "    elif name == 'densenet201':\n",
        "        backbone = models.densenet201(pretrained=True).features\n",
        "    elif name == 'unet_encoder':\n",
        "        from unet_backbone import UnetEncoder\n",
        "        backbone = UnetEncoder(3)\n",
        "    else:\n",
        "        raise NotImplemented('{} backbone model is not implemented so far.'.format(name))\n",
        "\n",
        "    # specifying skip feature and output names\n",
        "    if name.startswith('resnet'):\n",
        "        feature_names = [None, 'relu', 'layer1', 'layer2', 'layer3']\n",
        "        backbone_output = 'layer4'\n",
        "    elif name == 'vgg16':\n",
        "        # TODO: consider using a 'bridge' for VGG models, there is just a MaxPool between last skip and backbone output\n",
        "        feature_names = ['5', '12', '22', '32', '42']\n",
        "        backbone_output = '43'\n",
        "    elif name == 'vgg19':\n",
        "        feature_names = ['5', '12', '25', '38', '51']\n",
        "        backbone_output = '52'\n",
        "    # elif name == 'inception_v3':\n",
        "    #     feature_names = [None, 'Mixed_5d', 'Mixed_6e']\n",
        "    #     backbone_output = 'Mixed_7c'\n",
        "    elif name.startswith('densenet'):\n",
        "        feature_names = [None, 'relu0', 'denseblock1', 'denseblock2', 'denseblock3']\n",
        "        backbone_output = 'denseblock4'\n",
        "    elif name == 'unet_encoder':\n",
        "        feature_names = ['module1', 'module2', 'module3', 'module4']\n",
        "        backbone_output = 'module5'\n",
        "    else:\n",
        "        raise NotImplemented('{} backbone model is not implemented so far.'.format(name))\n",
        "\n",
        "    return backbone, feature_names, backbone_output\n",
        "\n",
        "\n",
        "class UpsampleBlock(nn.Module):\n",
        "\n",
        "    # TODO: separate parametric and non-parametric classes?\n",
        "    # TODO: skip connection concatenated OR added\n",
        "\n",
        "    def __init__(self, ch_in, ch_out=None, skip_in=0, use_bn=True, parametric=False):\n",
        "        super(UpsampleBlock, self).__init__()\n",
        "\n",
        "        self.parametric = parametric\n",
        "        ch_out = ch_in/2 if ch_out is None else ch_out\n",
        "\n",
        "        # first convolution: either transposed conv, or conv following the skip connection\n",
        "        if parametric:\n",
        "            # versions: kernel=4 padding=1, kernel=2 padding=0\n",
        "            self.up = nn.ConvTranspose2d(in_channels=ch_in, out_channels=ch_out, kernel_size=(4, 4),\n",
        "                                         stride=2, padding=1, output_padding=0, bias=(not use_bn))\n",
        "            self.bn1 = nn.BatchNorm2d(ch_out) if use_bn else None\n",
        "        else:\n",
        "            self.up = None\n",
        "            ch_in = ch_in + skip_in\n",
        "            self.conv1 = nn.Conv2d(in_channels=ch_in, out_channels=ch_out, kernel_size=(3, 3),\n",
        "                                   stride=1, padding=1, bias=(not use_bn))\n",
        "            self.bn1 = nn.BatchNorm2d(ch_out) if use_bn else None\n",
        "\n",
        "        self.relu = nn.ReLU(inplace=True)\n",
        "\n",
        "        # second convolution\n",
        "        conv2_in = ch_out if not parametric else ch_out + skip_in\n",
        "        self.conv2 = nn.Conv2d(in_channels=conv2_in, out_channels=ch_out, kernel_size=(3, 3),\n",
        "                               stride=1, padding=1, bias=(not use_bn))\n",
        "        self.bn2 = nn.BatchNorm2d(ch_out) if use_bn else None\n",
        "\n",
        "    def forward(self, x, skip_connection=None):\n",
        "\n",
        "        x = self.up(x) if self.parametric else F.interpolate(x, size=None, scale_factor=2, mode='bilinear',\n",
        "                                                             align_corners=None)\n",
        "        if self.parametric:\n",
        "            x = self.bn1(x) if self.bn1 is not None else x\n",
        "            x = self.relu(x)\n",
        "\n",
        "        if skip_connection is not None:\n",
        "            x = torch.cat([x, skip_connection], dim=1)\n",
        "\n",
        "        if not self.parametric:\n",
        "            x = self.conv1(x)\n",
        "            x = self.bn1(x) if self.bn1 is not None else x\n",
        "            x = self.relu(x)\n",
        "        x = self.conv2(x)\n",
        "        x = self.bn2(x) if self.bn2 is not None else x\n",
        "        x = self.relu(x)\n",
        "\n",
        "        return x\n",
        "\n",
        "\n",
        "class Unet(nn.Module):\n",
        "\n",
        "    \"\"\" U-Net (https://arxiv.org/pdf/1505.04597.pdf) implementation with pre-trained torchvision backbones.\"\"\"\n",
        "\n",
        "    def __init__(self,\n",
        "                 backbone_name='resnet50',\n",
        "                 pretrained=True,\n",
        "                 encoder_freeze=False,\n",
        "                 classes=1,\n",
        "                 decoder_filters=(256, 128, 64, 32, 16),\n",
        "                 parametric_upsampling=True,\n",
        "                 shortcut_features='default',\n",
        "                 decoder_use_batchnorm=True):\n",
        "        super(Unet, self).__init__()\n",
        "\n",
        "        self.backbone_name = backbone_name\n",
        "\n",
        "        self.backbone, self.shortcut_features, self.bb_out_name = get_backbone(backbone_name, pretrained=pretrained)\n",
        "        shortcut_chs, bb_out_chs = self.infer_skip_channels()\n",
        "        if shortcut_features != 'default':\n",
        "            self.shortcut_features = shortcut_features\n",
        "\n",
        "        # build decoder part\n",
        "        self.upsample_blocks = nn.ModuleList()\n",
        "        decoder_filters = decoder_filters[:len(self.shortcut_features)]  # avoiding having more blocks than skip connections\n",
        "        decoder_filters_in = [bb_out_chs] + list(decoder_filters[:-1])\n",
        "        num_blocks = len(self.shortcut_features)\n",
        "        for i, [filters_in, filters_out] in enumerate(zip(decoder_filters_in, decoder_filters)):\n",
        "            print('upsample_blocks[{}] in: {}   out: {}'.format(i, filters_in, filters_out))\n",
        "            self.upsample_blocks.append(UpsampleBlock(filters_in, filters_out,\n",
        "                                                      skip_in=shortcut_chs[num_blocks-i-1],\n",
        "                                                      parametric=parametric_upsampling,\n",
        "                                                      use_bn=decoder_use_batchnorm))\n",
        "\n",
        "        self.final_conv = nn.Conv2d(decoder_filters[-1], classes, kernel_size=(1, 1))\n",
        "\n",
        "        if encoder_freeze:\n",
        "            self.freeze_encoder()\n",
        "\n",
        "        self.replaced_conv1 = False  # for accommodating  inputs with different number of channels later\n",
        "\n",
        "    def freeze_encoder(self):\n",
        "\n",
        "        \"\"\" Freezing encoder parameters, the newly initialized decoder parameters are remaining trainable. \"\"\"\n",
        "\n",
        "        for param in self.backbone.parameters():\n",
        "            param.requires_grad = False\n",
        "\n",
        "    def forward(self, *input):\n",
        "\n",
        "        \"\"\" Forward propagation in U-Net. \"\"\"\n",
        "\n",
        "        x, features = self.forward_backbone(*input)\n",
        "\n",
        "        for skip_name, upsample_block in zip(self.shortcut_features[::-1], self.upsample_blocks):\n",
        "            skip_features = features[skip_name]\n",
        "            x = upsample_block(x, skip_features)\n",
        "\n",
        "        x = self.final_conv(x)\n",
        "        return x\n",
        "\n",
        "    def forward_backbone(self, x):\n",
        "\n",
        "        \"\"\" Forward propagation in backbone encoder network.  \"\"\"\n",
        "\n",
        "        features = {None: None} if None in self.shortcut_features else dict()\n",
        "        for name, child in self.backbone.named_children():\n",
        "            x = child(x)\n",
        "            if name in self.shortcut_features:\n",
        "                features[name] = x\n",
        "            if name == self.bb_out_name:\n",
        "                break\n",
        "\n",
        "        return x, features\n",
        "\n",
        "    def infer_skip_channels(self):\n",
        "\n",
        "        \"\"\" Getting the number of channels at skip connections and at the output of the encoder. \"\"\"\n",
        "\n",
        "        x = torch.zeros(1, 3, 224, 224)\n",
        "        has_fullres_features = self.backbone_name.startswith('vgg') or self.backbone_name == 'unet_encoder'\n",
        "        channels = [] if has_fullres_features else [0]  # only VGG has features at full resolution\n",
        "\n",
        "        # forward run in backbone to count channels (dirty solution but works for *any* Module)\n",
        "        for name, child in self.backbone.named_children():\n",
        "            x = child(x)\n",
        "            if name in self.shortcut_features:\n",
        "                channels.append(x.shape[1])\n",
        "            if name == self.bb_out_name:\n",
        "                out_channels = x.shape[1]\n",
        "                break\n",
        "        return channels, out_channels\n",
        "\n",
        "    def get_pretrained_parameters(self):\n",
        "        for name, param in self.backbone.named_parameters():\n",
        "            if not (self.replaced_conv1 and name == 'conv1.weight'):\n",
        "                yield param\n",
        "\n",
        "    def get_random_initialized_parameters(self):\n",
        "        pretrained_param_names = set()\n",
        "        for name, param in self.backbone.named_parameters():\n",
        "            if not (self.replaced_conv1 and name == 'conv1.weight'):\n",
        "                pretrained_param_names.add('backbone.{}'.format(name))\n",
        "\n",
        "        for name, param in self.named_parameters():\n",
        "            if name not in pretrained_param_names:\n",
        "                yield param\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 173,
          "referenced_widgets": [
            "237de72ffbd94eac8e5b846390f8ee6e",
            "ac3934e048a348ea866b073cdf91070e",
            "023a4fb4089e4dc7aba4dee0c371182d",
            "84d9bd7025544e9abbca6813eabe2781",
            "be3602da49c74fa39ca634b59efd7b7a",
            "b0999dba18154c939adde87e5392b782",
            "fc902fe08ccf43a0b90007f132050035",
            "def741b02efc420a9e211d88d1672fdf"
          ]
        },
        "id": "k77g3Wk2RP9F",
        "outputId": "108f847a-b732-4b5b-f67d-40f2fc5a8c00"
      },
      "source": [
        "model = Unet(backbone_name='resnet18').cuda()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Downloading: \"https://download.pytorch.org/models/resnet18-5c106cde.pth\" to /root/.cache/torch/hub/checkpoints/resnet18-5c106cde.pth\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "display_data",
          "data": {
            "application/vnd.jupyter.widget-view+json": {
              "model_id": "237de72ffbd94eac8e5b846390f8ee6e",
              "version_minor": 0,
              "version_major": 2
            },
            "text/plain": [
              "HBox(children=(FloatProgress(value=0.0, max=46827520.0), HTML(value='')))"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "upsample_blocks[0] in: 512   out: 256\n",
            "upsample_blocks[1] in: 256   out: 128\n",
            "upsample_blocks[2] in: 128   out: 64\n",
            "upsample_blocks[3] in: 64   out: 32\n",
            "upsample_blocks[4] in: 32   out: 16\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KDs1-yUxRTtl"
      },
      "source": [
        "optimizer = torch.optim.Adam(model.parameters(),lr = 1e-3,weight_decay=0.001)\n",
        "criterion = DiceBCELoss()\n",
        "accuracy_metric = IoU()\n",
        "num_epochs=30\n",
        "#valid_loss_min = np.Inf"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "xVpncKxgRbUU",
        "outputId": "b5cff8cc-4295-4a9c-b8f5-c36cf33e996f"
      },
      "source": [
        "#import lovasz_losses as L\n",
        "#optimizer = torch.optim.SGD(model.parameters(),lr = 1e-3,weight_decay=0.0001,momentum=0.99)\n",
        "save_folder = 'drive/My Drive/FDLHW/Results_Res34'\n",
        "ff=open('{}/progress.txt'.format(save_folder),'w')\n",
        "total_train_loss = []\n",
        "total_train_score = []\n",
        "total_valid_loss = []\n",
        "total_valid_score = []\n",
        "\n",
        "losses_value = 0\n",
        "for epoch in range(10):\n",
        "    model.train()\n",
        "  \n",
        "    train_loss = []\n",
        "    train_score = []\n",
        "    valid_loss = []\n",
        "    valid_score = []\n",
        "    #<-----------Training Loop---------------------------->\n",
        "    p = tqdm(train_loader, desc = 'description')\n",
        "    for x_train, y_train in p:\n",
        "        x_train = torch.autograd.Variable(x_train).cuda()\n",
        "        y_train = torch.autograd.Variable(y_train).cuda()\n",
        "        optimizer.zero_grad()\n",
        "        output = model(x_train)\n",
        "        \n",
        "      #Loss\n",
        "        loss = criterion(output,y_train)\n",
        "        losses_value = loss.item()\n",
        "      #Score\n",
        "        score = accuracy_metric(output,y_train)\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "        train_loss.append(losses_value)\n",
        "        train_score.append(score.item())\n",
        "        #train_score.append(score)\n",
        "        p.set_description(f\"Epoch: {epoch+1}, loss: {losses_value}, IoU: {score}\")\n",
        "\n",
        "    #<---------------Validation Loop---------------------->\n",
        "    model.eval()\n",
        "    with torch.no_grad():\n",
        "        for image,mask in val_loader:\n",
        "            image = torch.autograd.Variable(image).cuda()\n",
        "            mask = torch.autograd.Variable(mask).cuda()\n",
        "            output = model(image)\n",
        "            \n",
        "        ## Compute Loss Value.\n",
        "            loss = criterion(output,mask)\n",
        "            losses_value = loss.item()\n",
        "        ## Compute Accuracy Score\n",
        "            score = accuracy_metric(output,mask)\n",
        "            valid_loss.append(losses_value)\n",
        "            valid_score.append(score.item())\n",
        "\n",
        "        total_train_loss.append(np.mean(train_loss))\n",
        "        total_train_score.append(np.mean(train_score))\n",
        "        total_valid_loss.append(np.mean(valid_loss))\n",
        "        total_valid_score.append(np.mean(valid_score))\n",
        "        print(f\"\\n###############Train Loss: {total_train_loss[-1]}, Train IOU: {total_train_score[-1]}###############\")\n",
        "        print(f\"###############Valid Loss: {total_valid_loss[-1]}, Valid IOU: {total_valid_score[-1]}###############\")\n",
        "        \n",
        "    write_results(ff, save_folder, epoch, total_train_score[-1], total_valid_score[-1], total_valid_loss[-1], total_valid_score[-1])\n",
        "\n",
        "    torch.save(model.state_dict(), save_folder + '/model_{}.pt'.format(epoch+20))\n",
        "save_graph(total_train_loss, total_valid_loss, num_epochs, save_folder)\n",
        "   "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\rdescription:   0%|          | 0/100 [00:00<?, ?it/s]/usr/local/lib/python3.6/dist-packages/torch/nn/functional.py:1639: UserWarning: nn.functional.sigmoid is deprecated. Use torch.sigmoid instead.\n",
            "  warnings.warn(\"nn.functional.sigmoid is deprecated. Use torch.sigmoid instead.\")\n",
            "Epoch: 1, loss: 0.31084030866622925, IoU: 0.7264013886451721: 100%|██████████| 100/100 [01:03<00:00,  1.57it/s]\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "###############Train Loss: 0.24364440262317658, Train IOU: 0.769759110212326###############\n",
            "###############Valid Loss: 0.42452451849684997, Valid IOU: 0.6409708208897534###############\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "Epoch: 2, loss: 0.28205060958862305, IoU: 0.7368696928024292: 100%|██████████| 100/100 [01:03<00:00,  1.57it/s]\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "###############Train Loss: 0.2551242455840111, Train IOU: 0.7590303599834443###############\n",
            "###############Valid Loss: 0.3911632001399994, Valid IOU: 0.6689631290295545###############\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "Epoch: 3, loss: 0.2905014157295227, IoU: 0.7464106678962708: 100%|██████████| 100/100 [01:02<00:00,  1.59it/s]\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "###############Train Loss: 0.25599313735961915, Train IOU: 0.7580465269088745###############\n",
            "###############Valid Loss: 0.43326393471044655, Valid IOU: 0.6358937586055082###############\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "Epoch: 4, loss: 0.3569524586200714, IoU: 0.7038225531578064: 100%|██████████| 100/100 [01:03<00:00,  1.59it/s]\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "###############Train Loss: 0.27268622651696206, Train IOU: 0.7435343104600907###############\n",
            "###############Valid Loss: 0.4044478614540661, Valid IOU: 0.6505631664220024###############\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "Epoch: 5, loss: 0.3109855651855469, IoU: 0.729970395565033: 100%|██████████| 100/100 [01:03<00:00,  1.59it/s]\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "###############Train Loss: 0.27806210398674014, Train IOU: 0.7379008644819259###############\n",
            "###############Valid Loss: 0.4964444944087197, Valid IOU: 0.5954118686563828###############\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "Epoch: 6, loss: 0.25237059593200684, IoU: 0.7607423067092896: 100%|██████████| 100/100 [01:03<00:00,  1.58it/s]\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "###############Train Loss: 0.2793951243162155, Train IOU: 0.7369046187400818###############\n",
            "###############Valid Loss: 0.3906113575486576, Valid IOU: 0.6557567926014171###############\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "Epoch: 7, loss: 0.286325603723526, IoU: 0.7318757176399231: 100%|██████████| 100/100 [01:03<00:00,  1.58it/s]\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "###############Train Loss: 0.2738563840091228, Train IOU: 0.7419094508886337###############\n",
            "###############Valid Loss: 0.4032617202576469, Valid IOU: 0.6571851846049813###############\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "Epoch: 8, loss: 0.27017703652381897, IoU: 0.7351458072662354: 100%|██████████| 100/100 [01:03<00:00,  1.58it/s]\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "###############Train Loss: 0.27980893209576607, Train IOU: 0.7368593430519104###############\n",
            "###############Valid Loss: 0.39819835915284996, Valid IOU: 0.6478112269850338###############\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "Epoch: 9, loss: 0.3044794797897339, IoU: 0.7141232490539551: 100%|██████████| 100/100 [01:03<00:00,  1.58it/s]\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "###############Train Loss: 0.28727653220295907, Train IOU: 0.7302019673585892###############\n",
            "###############Valid Loss: 0.4295933386858772, Valid IOU: 0.646258764407214###############\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "Epoch: 10, loss: 0.32859355211257935, IoU: 0.7207075357437134: 100%|██████████| 100/100 [01:03<00:00,  1.57it/s]\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "###############Train Loss: 0.2949503107368946, Train IOU: 0.7234220188856125###############\n",
            "###############Valid Loss: 0.40826189167359295, Valid IOU: 0.652382493019104###############\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "error",
          "ename": "ValueError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-23-4624763b7c20>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     62\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     63\u001b[0m     \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msave\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstate_dict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msave_folder\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m'/model_{}.pt'\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mepoch\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m20\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 64\u001b[0;31m \u001b[0msave_graph\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtotal_train_loss\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtotal_valid_loss\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnum_epochs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msave_folder\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     65\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-15-3d17e19d986e>\u001b[0m in \u001b[0;36msave_graph\u001b[0;34m(train_loss, val_loss, nb_epochs, save_folder)\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;31m# create a function that creates train-val loss graph and saves the figure in a destination folder\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0msave_graph\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrain_loss\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mval_loss\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnb_epochs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msave_folder\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m     \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlist\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnb_epochs\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrain_loss\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      5\u001b[0m     \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlist\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnb_epochs\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mval_loss\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m     \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlegend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'train'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'val'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/matplotlib/pyplot.py\u001b[0m in \u001b[0;36mplot\u001b[0;34m(scalex, scaley, data, *args, **kwargs)\u001b[0m\n\u001b[1;32m   2761\u001b[0m     return gca().plot(\n\u001b[1;32m   2762\u001b[0m         *args, scalex=scalex, scaley=scaley, **({\"data\": data} if data\n\u001b[0;32m-> 2763\u001b[0;31m         is not None else {}), **kwargs)\n\u001b[0m\u001b[1;32m   2764\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2765\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/matplotlib/axes/_axes.py\u001b[0m in \u001b[0;36mplot\u001b[0;34m(self, scalex, scaley, data, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1645\u001b[0m         \"\"\"\n\u001b[1;32m   1646\u001b[0m         \u001b[0mkwargs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcbook\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnormalize_kwargs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmlines\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mLine2D\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1647\u001b[0;31m         \u001b[0mlines\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get_lines\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1648\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0mline\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mlines\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1649\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd_line\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mline\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/matplotlib/axes/_base.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    214\u001b[0m                 \u001b[0mthis\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    215\u001b[0m                 \u001b[0margs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 216\u001b[0;31m             \u001b[0;32myield\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_plot_args\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mthis\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    217\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    218\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mget_next_color\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/matplotlib/axes/_base.py\u001b[0m in \u001b[0;36m_plot_args\u001b[0;34m(self, tup, kwargs)\u001b[0m\n\u001b[1;32m    340\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    341\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 342\u001b[0;31m             raise ValueError(f\"x and y must have same first dimension, but \"\n\u001b[0m\u001b[1;32m    343\u001b[0m                              f\"have shapes {x.shape} and {y.shape}\")\n\u001b[1;32m    344\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mndim\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m2\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mndim\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mValueError\u001b[0m: x and y must have same first dimension, but have shapes (30,) and (10,)"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9hgQfbeOYD0l"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xjy7kE4YYEM3"
      },
      "source": [
        "import torch.nn as nn\n",
        "        \n",
        "        \n",
        "ALPHA = 0.8\n",
        "GAMMA = 2\n",
        "\n",
        "class FocalDiceLoss(nn.Module):\n",
        "    def __init__(self, weight=None, size_average=True):\n",
        "        super(FocalLoss, self).__init__()\n",
        "\n",
        "    def forward(self, inputs, targets, alpha=ALPHA, gamma=GAMMA, 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",
        "        \n",
        "        #DICE\n",
        "        intersection = (inputs * targets).sum()                            \n",
        "        dice = 1-(2.*intersection + smooth)/(inputs.sum() + targets.sum() + smooth) \n",
        "        \n",
        "        \n",
        "        #FOCAL\n",
        "        BCE = F.binary_cross_entropy(inputs, targets, reduction='mean')\n",
        "        BCE_EXP = torch.exp(-BCE)\n",
        "        focal_loss = alpha * (1-BCE_EXP)**gamma * BCE\n",
        "                       \n",
        "        #FINAL\n",
        "        final_loss=1\n",
        "        \n",
        "        return focal_loss      \n",
        "        \n",
        "    \n",
        "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",
        "        \n",
        "        #comment out if your model contains a sigmoid or equivalent activation layer\n",
        "       # inputs = torch.sigmoid(inputs)       \n",
        "        \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",
        "        Dice_BCE = BCE + dice_loss\n",
        "        \n",
        "        return Dice_BCE\n",
        "\n",
        "\n",
        "class DiceLoss(nn.Module):\n",
        "    def __init__(self, weight=None, size_average=True):\n",
        "        super(DiceLoss, 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",
        "        \n",
        "        intersection = (inputs * targets).sum()                            \n",
        "        dice = (2.*intersection + smooth)/(inputs.sum() + targets.sum() + smooth)  \n",
        "        \n",
        "        return 1 - dice\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",
        "        \n",
        "        #intersection is equivalent to True Positive count\n",
        "        #union is the mutually inclusive area of all labels & predictions \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"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RTKb8EwHYEmJ"
      },
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "\n",
        "\n",
        "# Utility Functions\n",
        "''' when filter kernel= 3x3, padding=1 makes in&out matrix same size'''\n",
        "def conv_bn_leru(in_channels, out_channels, kernel_size=3, stride=1, padding=1):\n",
        "    return nn.Sequential(\n",
        "            nn.Conv2d(in_channels, out_channels, kernel_size=kernel_size, stride=stride, padding=padding),\n",
        "            nn.BatchNorm2d(out_channels),\n",
        "            nn.ReLU(inplace=True),\n",
        "            nn.Conv2d(out_channels, out_channels, kernel_size=kernel_size, stride=stride, padding=padding),\n",
        "            nn.BatchNorm2d(out_channels),\n",
        "            nn.ReLU(inplace=True),\n",
        "    )\n",
        "\n",
        "def down_pooling():\n",
        "    return nn.MaxPool2d(2)\n",
        "\n",
        "def up_pooling(in_channels, out_channels, kernel_size=2, stride=2):\n",
        "    return nn.Sequential(\n",
        "        nn.ConvTranspose2d(in_channels, out_channels, kernel_size=kernel_size, stride=stride),\n",
        "        nn.BatchNorm2d(out_channels),\n",
        "        nn.ReLU(inplace=True)\n",
        "    )\n",
        "\n",
        "class UNet(nn.Module):\n",
        "    def __init__(self, input_channels, nclasses):\n",
        "        super().__init__()\n",
        "        # go down\n",
        "        self.conv1 = conv_bn_leru(input_channels,64)\n",
        "        self.conv2 = conv_bn_leru(64, 128)\n",
        "        self.conv3 = conv_bn_leru(128, 256)\n",
        "        self.conv4 = conv_bn_leru(256, 512)\n",
        "        self.conv5 = conv_bn_leru(512, 1024)\n",
        "        self.down_pooling = nn.MaxPool2d(2)\n",
        "\n",
        "        # go up\n",
        "        self.up_pool6 = up_pooling(1024, 512)\n",
        "        self.conv6 = conv_bn_leru(1024, 512)\n",
        "        self.up_pool7 = up_pooling(512, 256)\n",
        "        self.conv7 = conv_bn_leru(512, 256)\n",
        "        self.up_pool8 = up_pooling(256, 128)\n",
        "        self.conv8 = conv_bn_leru(256, 128)\n",
        "        self.up_pool9 = up_pooling(128, 64)\n",
        "        self.conv9 = conv_bn_leru(128, 64)\n",
        "\n",
        "        self.conv10 = nn.Conv2d(64, nclasses, 1)\n",
        "\n",
        "\n",
        "        # test weight init\n",
        "        for m in self.modules():\n",
        "            if isinstance(m, nn.Conv2d):\n",
        "                nn.init.kaiming_normal(m.weight.data, a=0, mode='fan_out')\n",
        "                if m.bias is not None:\n",
        "                    m.bias.data.zero_()\n",
        "\n",
        "\n",
        "    def forward(self, x):\n",
        "        # normalize input data\n",
        "        #x = x/255.\n",
        "        # go down\n",
        "        x1 = self.conv1(x)\n",
        "        p1 = self.down_pooling(x1)\n",
        "        x2 = self.conv2(p1)\n",
        "        p2 = self.down_pooling(x2)\n",
        "        x3 = self.conv3(p2)\n",
        "        p3 = self.down_pooling(x3)\n",
        "        x4 = self.conv4(p3)\n",
        "        p4 = self.down_pooling(x4)\n",
        "        x5 = self.conv5(p4)\n",
        "\n",
        "        # go up\n",
        "        p6 = self.up_pool6(x5)\n",
        "        x6 = torch.cat([p6, x4], dim=1)\n",
        "        x6 = self.conv6(x6)\n",
        "\n",
        "        p7 = self.up_pool7(x6)\n",
        "        x7 = torch.cat([p7, x3], dim=1)\n",
        "        x7 = self.conv7(x7)\n",
        "\n",
        "        p8 = self.up_pool8(x7)\n",
        "        x8 = torch.cat([p8, x2], dim=1)\n",
        "        x8 = self.conv8(x8)\n",
        "\n",
        "        p9 = self.up_pool9(x8)\n",
        "        x9 = torch.cat([p9, x1], dim=1)\n",
        "        x9 = self.conv9(x9)\n",
        "\n",
        "\n",
        "        output = self.conv10(x9)\n",
        "        output = F.sigmoid(output)\n",
        "\n",
        "        return output\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_InQ9d81Zpux"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DQNWwgcdY--D",
        "outputId": "eebbfdb0-f6f2-400e-d03d-5475f318f976"
      },
      "source": [
        "model2 = UNet(3,1).cuda()\n",
        "optimizer = torch.optim.Adam(model.parameters(),lr = 1e-2,weight_decay=0.0001)\n",
        "criterion = DiceBCELoss()\n",
        "accuracy_metric = IoU()\n",
        "num_epochs=30"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:55: UserWarning: nn.init.kaiming_normal is now deprecated in favor of nn.init.kaiming_normal_.\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 260
        },
        "id": "OiNub_utZOvR",
        "outputId": "c9a483df-c87c-42c1-8330-f103ba1445d3"
      },
      "source": [
        "#import lovasz_losses as L\n",
        "#optimizer = torch.optim.SGD(model.parameters(),lr = 1e-3,weight_decay=0.0001,momentum=0.99)\n",
        "save_folder = 'drive/My Drive/FDLHW/Results_2'\n",
        "ff=open('{}/progress.txt'.format(save_folder),'w')\n",
        "total_train_loss = []\n",
        "total_train_score = []\n",
        "total_valid_loss = []\n",
        "total_valid_score = []\n",
        "\n",
        "losses_value = 0\n",
        "for epoch in range(10):\n",
        "    model.train()\n",
        "  \n",
        "    train_loss = []\n",
        "    train_score = []\n",
        "    valid_loss = []\n",
        "    valid_score = []\n",
        "    #<-----------Training Loop---------------------------->\n",
        "    p = tqdm(train_loader, desc = 'description')\n",
        "    for x_train, y_train in p:\n",
        "        x_train = torch.autograd.Variable(x_train).cuda()\n",
        "        y_train = torch.autograd.Variable(y_train).cuda()\n",
        "        optimizer.zero_grad()\n",
        "        output = model(x_train)\n",
        "        \n",
        "      #Loss\n",
        "        loss = criterion(output,y_train)\n",
        "        losses_value = loss.item()\n",
        "      #Score\n",
        "        score = accuracy_metric(output,y_train)\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "        train_loss.append(losses_value)\n",
        "        train_score.append(score.item())\n",
        "        #train_score.append(score)\n",
        "        p.set_description(f\"Epoch: {epoch+1}, loss: {losses_value}, IoU: {score}\")\n",
        "\n",
        "    #<---------------Validation Loop---------------------->\n",
        "    model.eval()\n",
        "    with torch.no_grad():\n",
        "        for image,mask in val_loader:\n",
        "            image = torch.autograd.Variable(image).cuda()\n",
        "            mask = torch.autograd.Variable(mask).cuda()\n",
        "            output = model(image)\n",
        "            \n",
        "        ## Compute Loss Value.\n",
        "            loss = criterion(output,mask)\n",
        "            losses_value = loss.item()\n",
        "        ## Compute Accuracy Score\n",
        "            score = accuracy_metric(output,mask)\n",
        "            valid_loss.append(losses_value)\n",
        "            valid_score.append(score.item())\n",
        "\n",
        "        total_train_loss.append(np.mean(train_loss))\n",
        "        total_train_score.append(np.mean(train_score))\n",
        "        total_valid_loss.append(np.mean(valid_loss))\n",
        "        total_valid_score.append(np.mean(valid_score))\n",
        "        print(f\"\\n###############Train Loss: {total_train_loss[-1]}, Train IOU: {total_train_score[-1]}###############\")\n",
        "        print(f\"###############Valid Loss: {total_valid_loss[-1]}, Valid IOU: {total_valid_score[-1]}###############\")\n",
        "        \n",
        "    write_results(ff, save_folder, epoch, total_train_score[-1], total_valid_score[-1], total_valid_loss[-1], total_valid_score[-1])\n",
        "\n",
        "    torch.save(model.state_dict(), save_folder + '/model_{}.pt'.format(epoch))\n",
        "save_graph(total_train_loss, total_val_loss, num_epochs, save_folder)\n",
        "   "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\rdescription:   0%|          | 0/100 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "error",
          "ename": "RuntimeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mRuntimeError\u001b[0m                              Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-28-ec2867a02514>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     26\u001b[0m       \u001b[0;31m#Loss\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     27\u001b[0m         \u001b[0mloss\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcriterion\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moutput\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0my_train\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 28\u001b[0;31m         \u001b[0mlosses_value\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mloss\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mitem\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     29\u001b[0m       \u001b[0;31m#Score\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     30\u001b[0m         \u001b[0mscore\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0maccuracy_metric\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moutput\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0my_train\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mRuntimeError\u001b[0m: CUDA error: device-side assert triggered"
          ]
        }
      ]
    }
  ]
}