B7_SegFormer_huggingface.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"markdown-google-sans\">\n",
    "  <h3>Kiểm tra GPU được cấp phát</h3>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fri Mar  3 00:29:18 2023       \n",
      "+-----------------------------------------------------------------------------+\n",
      "| NVIDIA-SMI 520.61.05    Driver Version: 520.61.05    CUDA Version: 11.8     |\n",
      "|-------------------------------+----------------------+----------------------+\n",
      "| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\n",
      "| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n",
      "|                               |                      |               MIG M. |\n",
      "|===============================+======================+======================|\n",
      "|   0  NVIDIA GeForce ...  Off  | 00000000:65:00.0 Off |                  N/A |\n",
      "|  0%   56C    P8    35W / 370W |      1MiB / 24576MiB |      0%      Default |\n",
      "|                               |                      |                  N/A |\n",
      "+-------------------------------+----------------------+----------------------+\n",
      "|   1  NVIDIA GeForce ...  Off  | 00000000:B3:00.0 Off |                  N/A |\n",
      "|  0%   56C    P8    35W / 420W |      1MiB / 24576MiB |      0%      Default |\n",
      "|                               |                      |                  N/A |\n",
      "+-------------------------------+----------------------+----------------------+\n",
      "                                                                               \n",
      "+-----------------------------------------------------------------------------+\n",
      "| Processes:                                                                  |\n",
      "|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |\n",
      "|        ID   ID                                                   Usage      |\n",
      "|=============================================================================|\n",
      "|  No running processes found                                                 |\n",
      "+-----------------------------------------------------------------------------+\n"
     ]
    }
   ],
   "source": [
    "!nvidia-smi"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"markdown-google-sans\">\n",
    "  <h3>Cài đặt bổ sung một số thư viện</h3>\n",
    "</div>\n",
    "Nền tảng Google Colab cung cấp môi trường với các thư viện Machine Learning, Deep Learning cơ bản đã được cài đặt sẵn, phần này sẽ cài đặt một số thư viện sử dụng thêm."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install segmentation_models_pytorch\n",
    "!pip install albumentations\n",
    "!pip install transformers"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"markdown-google-sans\">\n",
    "  <h3>Import thư viện</h3>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import cv2\n",
    "import matplotlib.pyplot as plt\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "import segmentation_models_pytorch as smp\n",
    "import albumentations as A\n",
    "from albumentations.pytorch import ToTensorV2 # np.array -> torch.tensor\n",
    "import os\n",
    "from tqdm import tqdm\n",
    "from glob import glob\n",
    "from torchvision.datasets import VOCSegmentation\n",
    "import random"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"markdown-google-sans\">\n",
    "  <h3>Định nghĩa Dataset</h3>\n",
    "</div>\n",
    "Viết class kế thừa từ class Dataset cung cấp sẵn trong PyTorch để đọc dữ liệu từ ổ cứng. Yêu cầu viết đủ 3 hàm __init__() để khởi tạo class, __len__() để trả về số điểm dữ liệu có trong tập dữ liệu và __getitem__() trả về 1 điểm dữ liệu cụ thể. Trong phần này, do tập dữ liệu PASCAL VOC đã rất phổ biến nên sẽ tận dụng Class Dataset đã được viết sẵn. Tham khảo thêm: https://albumentations.ai/docs/autoalbument/examples/pascal_voc/\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "cv2.setNumThreads(0)\n",
    "cv2.ocl.setUseOpenCL(False)\n",
    "\n",
    "VOC_CLASSES = [\n",
    "    \"background\",\n",
    "    \"aeroplane\",\n",
    "    \"bicycle\",\n",
    "    \"bird\",\n",
    "    \"boat\",\n",
    "    \"bottle\",\n",
    "    \"bus\",\n",
    "    \"car\",\n",
    "    \"cat\",\n",
    "    \"chair\",\n",
    "    \"cow\",\n",
    "    \"diningtable\",\n",
    "    \"dog\",\n",
    "    \"horse\",\n",
    "    \"motorbike\",\n",
    "    \"person\",\n",
    "    \"potted plant\",\n",
    "    \"sheep\",\n",
    "    \"sofa\",\n",
    "    \"train\",\n",
    "    \"tv/monitor\",\n",
    "]\n",
    "\n",
    "\n",
    "VOC_COLORMAP = [\n",
    "    [0, 0, 0],\n",
    "    [128, 0, 0],\n",
    "    [0, 128, 0],\n",
    "    [128, 128, 0],\n",
    "    [0, 0, 128],\n",
    "    [128, 0, 128],\n",
    "    [0, 128, 128],\n",
    "    [128, 128, 128],\n",
    "    [64, 0, 0],\n",
    "    [192, 0, 0],\n",
    "    [64, 128, 0],\n",
    "    [192, 128, 0],\n",
    "    [64, 0, 128],\n",
    "    [192, 0, 128],\n",
    "    [64, 128, 128],\n",
    "    [192, 128, 128],\n",
    "    [0, 64, 0],\n",
    "    [128, 64, 0],\n",
    "    [0, 192, 0],\n",
    "    [128, 192, 0],\n",
    "    [0, 64, 128],\n",
    "]\n",
    "\n",
    "class PascalVOCSearchDataset(VOCSegmentation):\n",
    "    def __init__(self, root=\"~/data/pascal_voc\", image_set=\"train\", download=True, transform=None):\n",
    "        super().__init__(root=root, image_set=image_set, download=download, transform=transform)\n",
    "\n",
    "    @staticmethod\n",
    "    def _convert_to_segmentation_mask(mask):\n",
    "        # This function converts a mask from the Pascal VOC format to the format required by AutoAlbument.\n",
    "        #\n",
    "        # Pascal VOC uses an RGB image to encode the segmentation mask for that image. RGB values of a pixel\n",
    "        # encode the pixel's class.\n",
    "        #\n",
    "        # AutoAlbument requires a segmentation mask to be a NumPy array with the shape [height, width, num_classes].\n",
    "        # Each channel in this mask should encode values for a single class. Pixel in a mask channel should have\n",
    "        # a value of 1.0 if the pixel of the image belongs to this class and 0.0 otherwise.\n",
    "        height, width = mask.shape[:2]\n",
    "        segmentation_mask = np.zeros((height, width, len(VOC_COLORMAP)), dtype=np.float32)\n",
    "        for label_index, label in enumerate(VOC_COLORMAP):\n",
    "            segmentation_mask[:, :, label_index] = np.all(mask == label, axis=-1).astype(float)\n",
    "        return segmentation_mask #0, 1, 2, 3, ..., 20 (H, W, C) -> (H, W, 1) -> (H, W) #numpy\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        image = cv2.imread(self.images[index])\n",
    "        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
    "        mask = cv2.imread(self.masks[index])\n",
    "        mask = cv2.cvtColor(mask, cv2.COLOR_BGR2RGB)\n",
    "        mask = self._convert_to_segmentation_mask(mask)\n",
    "        if self.transform is not None:\n",
    "            transformed = self.transform(image=image, mask=mask)\n",
    "            image = transformed[\"image\"]\n",
    "            mask = transformed[\"mask\"]\n",
    "        return image, mask.argmax(dim=2).squeeze() #torch.tensor"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"markdown-google-sans\">\n",
    "  <h3>Định nghĩa các phép augmentation trên ảnh</h3>\n",
    "</div>\n",
    "Sử dụng thư viện Albumentations, tham khảo thêm: https://albumentations.ai/docs/api_reference/full_reference/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/bui.thanh.tung/miniconda3/envs/torch_seg/lib/python3.8/site-packages/albumentations/augmentations/dropout/cutout.py:49: FutureWarning: Cutout has been deprecated. Please use CoarseDropout\n",
      "  warnings.warn(\n"
     ]
    }
   ],
   "source": [
    "trainsize = 256\n",
    "\n",
    "train_transform = A.Compose([\n",
    "    A.Resize(width=trainsize, height=trainsize),\n",
    "    A.HorizontalFlip(),\n",
    "    A.RandomBrightnessContrast(),\n",
    "    A.Blur(),\n",
    "    A.Sharpen(),\n",
    "    A.RGBShift(),\n",
    "    A.Cutout(num_holes=5, max_h_size=25, max_w_size=25, fill_value=0),\n",
    "    A.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), max_pixel_value=255.0),\n",
    "    ToTensorV2(),\n",
    "])\n",
    "\n",
    "test_trainsform = A.Compose([\n",
    "    A.Resize(width=trainsize, height=trainsize),\n",
    "    A.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), max_pixel_value=255.0),\n",
    "    ToTensorV2(), # numpy.array -> torch.tensor (B, 3, H, W)\n",
    "])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"markdown-google-sans\">\n",
    "  <h3>Đoạn code dùng để convert ảnh sau khi đã chuẩn hoá thành ảnh ban đầu</h3>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class UnNormalize(object):\n",
    "    def __init__(self, mean, std):\n",
    "        self.mean = mean\n",
    "        self.std = std\n",
    "        \n",
    "    def __call__(self, tensor):\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            tensor (Tensor): Tensor image of size (C, H, W) to be normalized.\n",
    "        Returns:\n",
    "            Tensor: Normalized image.\n",
    "        \"\"\"\n",
    "        for t, m, s in zip(tensor, self.mean, self.std):\n",
    "            t.mul_(s).add_(m)\n",
    "            # The normalize code -> t.sub_(m).div_(s)\n",
    "        return tensor\n",
    "    \n",
    "unorm = UnNormalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"markdown-google-sans\">\n",
    "  <h3>Kiểm tra 1 cặp ảnh đầu vào và ảnh kết quả phân vùng trước khi đưa vào mô hình training</h3>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([ 0,  9, 11, 15])\n"
     ]
    }
   ],
   "source": [
    "train_dataset = PascalVOCSearchDataset(image_set=\"train\", download=False, transform=train_transform)\n",
    "test_dataset = PascalVOCSearchDataset(image_set=\"val\", download=False, transform=test_trainsform)\n",
    "\n",
    "idx = random.randint(0, train_dataset.__len__())\n",
    "\n",
    "image, mask = train_dataset.__getitem__(idx)\n",
    "plt.subplot(1, 2, 1)\n",
    "plt.imshow(unorm(image).permute(1, 2, 0))\n",
    "plt.subplot(1, 2, 2)\n",
    "plt.imshow(mask)\n",
    "plt.show()\n",
    "print(mask.unique())"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"markdown-google-sans\">\n",
    "  <h3>Tạo AverageMeter</h3>\n",
    "</div>\n",
    "AverageMeter có nhiệm vụ lưu lại giá trị trung bình của độ chính xác, giá trị hàm loss, ... trong suốt quá trình training. Tham khảo thêm: https://discuss.pytorch.org/t/meaning-of-parameters/10655"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class AverageMeter(object):\n",
    "    def __init__(self):\n",
    "        self.reset()\n",
    "\n",
    "    def reset(self):\n",
    "        self.val = 0\n",
    "        self.avg = 0\n",
    "        self.sum = 0\n",
    "        self.count = 0\n",
    "\n",
    "    def update(self, val, n=1):\n",
    "        self.val = val\n",
    "        self.sum += val * n\n",
    "        self.count += n\n",
    "        self.avg = self.sum / self.count"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"markdown-google-sans\">\n",
    "  <h3>Lập trình hàm tính toán độ chính xác dựa trên IoU và Dice</h3>\n",
    "</div>\n",
    "Tham khảo: https://github.com/hszhao/semseg/blob/master/util/util.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#metrics\n",
    "def intersectionAndUnionGPU(output, target, K, ignore_index=255):\n",
    "    # 'K' classes, output and target sizes are N or N * L or N * H * W, each value in range 0 to K - 1.\n",
    "    assert (output.dim() in [1, 2, 3])\n",
    "    assert output.shape == target.shape\n",
    "    output = output.view(-1)\n",
    "    target = target.view(-1)\n",
    "    output[target == ignore_index] = ignore_index\n",
    "    intersection = output[output == target]\n",
    "    area_intersection = torch.histc(intersection, bins=K, min=0, max=K-1)\n",
    "    area_output = torch.histc(output, bins=K, min=0, max=K-1)\n",
    "    area_target = torch.histc(target, bins=K, min=0, max=K-1)\n",
    "    area_union = area_output + area_target - area_intersection\n",
    "    return area_intersection, area_union, area_target "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"markdown-google-sans\">\n",
    "  <h3>Chuẩn bị cho quá trình training</h3>\n",
    "</div>\n",
    "\n",
    "\n",
    "1.   Lựa chọn device: PyTorch yêu cầu lựa chọn cụ thể device sẽ train và yêu cầu người dùng tự move dữ liệu, mô hình vào device đã lựa chọn. Device có thể là \"cuda\" - tức là GPU NVIDIA hoặc \"cpu\".\n",
    "2.   Định nghĩa DataLoader, khác với Dataset là cách đọc dữ liệu từ ổ cứng, DataLoader ghép nhiều điểm dữ liệu vào cùng nhau tạo thành 1 batch để đưa vào train mô hình. Lưu ý thêm: batch_size nên đặt là 4, 8, 16, 32, ... và nên để lớn nhất có thể\n",
    "3.   Khởi tạo mô hình dùng thư viện HuggingFace/Transformers\n",
    "4.   Khởi tạo hàm loss\n",
    "5.   Khởi tạo thuật toán tối ưu (optimizer)\n",
    "6.   Khởi tạo các độ đo sẽ sử dụng để đánh giá hiệu năng của mô hình. Phần này sẽ sử dụng các hàm độ đo Dice và IoU được lập trình sẵn trong thư viện torchmetrics\n",
    "7.   Khởi tạo từng AverageMeter để lưu lại giá trị của từng độ đo, giá trị hàm loss, thời gian train, ... trong suốt quá trình train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "num_workers = 8\n"
     ]
    }
   ],
   "source": [
    "#device\n",
    "#!pip install transformers\n",
    "from transformers import SegformerForSemanticSegmentation\n",
    "\n",
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "#load data\n",
    "batch_size = 24\n",
    "n_workers = os.cpu_count()\n",
    "print(\"num_workers =\", n_workers)\n",
    "trainloader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size,\n",
    "                                          shuffle=True, num_workers=n_workers)\n",
    "testloader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size,\n",
    "                                          shuffle=False, num_workers=n_workers)\n",
    "\n",
    "#model\n",
    "model = SegformerForSemanticSegmentation.from_pretrained(\"nvidia/segformer-b4-finetuned-ade-512-512\").to(device)\n",
    "\n",
    "#loss\n",
    "# criterion = smp.losses.DiceLoss(mode=\"multiclass\", classes=21)\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "\n",
    "#optimizer\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=1e-4)\n",
    "n_eps = 15\n",
    "\n",
    "#meter\n",
    "train_loss_meter = AverageMeter()\n",
    "intersection_meter = AverageMeter()\n",
    "union_meter = AverageMeter()\n",
    "target_meter = AverageMeter()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"markdown-google-sans\">\n",
    "  <h3>Training thôi ...</h3>\n",
    "</div>\n",
    "Tham khảo thêm cách viết code training trong PyTorch: https://pytorch.org/tutorials/beginner/blitz/cifar10_tutorial.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 61/61 [00:39<00:00,  1.53it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EP 1, train loss = 2.2553182312699613 IoU = 0.049743007868528366, dice = 0.0709536224603653\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 61/61 [00:38<00:00,  1.60it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EP 2, train loss = 0.9436279378953527 IoU = 0.12834760546684265, dice = 0.19065913558006287\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 61/61 [00:38<00:00,  1.60it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EP 3, train loss = 0.6331157977463769 IoU = 0.2705835998058319, dice = 0.388491690158844\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 61/61 [00:38<00:00,  1.59it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EP 4, train loss = 0.43898681929854094 IoU = 0.4353543221950531, dice = 0.582341730594635\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 61/61 [00:38<00:00,  1.59it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EP 5, train loss = 0.3303663847876377 IoU = 0.5596336126327515, dice = 0.6999542117118835\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 61/61 [00:38<00:00,  1.59it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EP 6, train loss = 0.2742498551235824 IoU = 0.6190670728683472, dice = 0.7504180669784546\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 61/61 [00:38<00:00,  1.59it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EP 7, train loss = 0.22422152953069718 IoU = 0.6835653781890869, dice = 0.8015563488006592\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 61/61 [00:38<00:00,  1.59it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EP 8, train loss = 0.19492979249993309 IoU = 0.7199628353118896, dice = 0.8264026045799255\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 61/61 [00:38<00:00,  1.60it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EP 9, train loss = 0.17810227221152822 IoU = 0.7333475947380066, dice = 0.8365442156791687\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 61/61 [00:38<00:00,  1.58it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EP 10, train loss = 0.16521598264330722 IoU = 0.746581494808197, dice = 0.8466061353683472\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 61/61 [00:38<00:00,  1.59it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EP 11, train loss = 0.1460366357789665 IoU = 0.7763980031013489, dice = 0.8670908808708191\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 61/61 [00:38<00:00,  1.59it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EP 12, train loss = 0.14751851864036966 IoU = 0.7763290405273438, dice = 0.8674067854881287\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 93%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████           | 57/61 [00:36<00:02,  1.77it/s]"
     ]
    }
   ],
   "source": [
    "for ep in range(1, 1+n_eps):\n",
    "    train_loss_meter.reset()\n",
    "    intersection_meter.reset()\n",
    "    union_meter.reset()\n",
    "    target_meter.reset()\n",
    "    model.train()\n",
    "\n",
    "    for batch_id, (x, y) in enumerate(tqdm(trainloader), start=1):\n",
    "        optimizer.zero_grad()\n",
    "        n = x.shape[0]\n",
    "        x = x.to(device).float()\n",
    "        y = y.to(device).long()\n",
    "        y_hat = model(x).logits #(B, C, H, W)\n",
    "        y_hat = F.interpolate(y_hat, y.shape[1:], mode=\"bilinear\")\n",
    "        loss = criterion(y_hat, y) #(B, C, H, W) >< (B, H, W)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "        #save metrics\n",
    "        with torch.no_grad():\n",
    "            train_loss_meter.update(loss.item())\n",
    "            y_hat_mask = y_hat.argmax(dim=1).squeeze(1) # (B, C, H, W) -> (B, 1, H, W) -> (B, H, W)\n",
    "            intersection, union, target = intersectionAndUnionGPU(y_hat_mask.float(), y.float(), 21)\n",
    "            intersection_meter.update(intersection)\n",
    "            union_meter.update(union)\n",
    "            target_meter.update(target)\n",
    "\n",
    "    #compute iou, dice\n",
    "    with torch.no_grad():\n",
    "        iou_class = intersection_meter.sum / (union_meter.sum + 1e-10) #vector 21D\n",
    "        dice_class = (2 * intersection_meter.sum) / (intersection_meter.sum + union_meter.sum + 1e-10) #vector 21D\n",
    "\n",
    "        mIoU = torch.mean(iou_class) #mean vector 21D\n",
    "        mDice = torch.mean(dice_class) #mean vector 21D\n",
    "\n",
    "    print(\"EP {}, train loss = {} IoU = {}, dice = {}\".format(ep, train_loss_meter.avg, mIoU, mDice))\n",
    "    \n",
    "    if ep >= 40:\n",
    "        torch.save(model.state_dict(), \"modelFPN1_ep_{}.pth\".format(ep))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"markdown-google-sans\">\n",
    "  <h3>Viết code đưa ra kết quả trên tập dữ liệu test</h3>\n",
    "</div>\n",
    "Lưu ý: Trong quá trình test cần chuyển model về chế độ eval và nên đặt torch.no_grad(). Điểm khác nhau giữa model.eval() và torch.no_grad() là model.eval() sẽ đặt chế độ của mô hình về chế độ evaluation (thay đổi các layer như dropout, batch norm, ... khác với quá trình training) còn torch.no_grad() sẽ tắt tính toán đạo hàm của PyTorch để tiết kiệm tính toán. Do vậy khi test mô hình nên chú ý dùng cả 2 câu lệnh này."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 91/91 [00:26<00:00,  3.41it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TEST: IoU = 0.6618906855583191, dice = 0.7820723652839661\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "model.eval()\n",
    "test_intersection_meter = AverageMeter()\n",
    "test_union_meter = AverageMeter()\n",
    "test_target_meter = AverageMeter()\n",
    "with torch.no_grad():\n",
    "    for batch_id, (x, y) in enumerate(tqdm(testloader), start=1):\n",
    "        n = x.shape[0]\n",
    "        x = x.to(device).float()\n",
    "        y = y.to(device).long()\n",
    "        y_hat = model(x).logits\n",
    "        y_hat = F.interpolate(y_hat, size=y.shape[1], mode=\"bilinear\")\n",
    "        y_hat = y_hat.squeeze(1)\n",
    "        y_hat_mask = y_hat.argmax(dim=1)\n",
    "        \n",
    "        intersection, union, target = intersectionAndUnionGPU(y_hat_mask, y, 21)\n",
    "        test_intersection_meter.update(intersection)\n",
    "        test_union_meter.update(union)\n",
    "        test_target_meter.update(target)\n",
    "        \n",
    "    iou_class = test_intersection_meter.sum / (test_union_meter.sum + 1e-10)\n",
    "    dice_class = 2*test_intersection_meter.sum / (test_intersection_meter.sum + test_union_meter.sum + 1e-10)\n",
    "\n",
    "    mIoU = torch.mean(iou_class)\n",
    "    mDice = torch.mean(dice_class)\n",
    "        \n",
    "print(\"TEST: IoU = {}, dice = {}\".format(mIoU, mDice))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"markdown-google-sans\">\n",
    "  <h3>Viết code hiển thị kết quả dự đoán</h3>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0 14 15]\n",
      "(256, 256)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#predict\n",
    "import random\n",
    "id = random.randint(0, 1450)\n",
    "with torch.no_grad():\n",
    "    model.eval()\n",
    "    x, y = test_dataset.__getitem__(id)\n",
    "    y_predict = F.interpolate(model(x.unsqueeze(0).to(device)).logits, size=y.shape, mode=\"bilinear\").argmax(dim=1).squeeze().cpu().numpy()\n",
    "    print(np.unique(y_predict))\n",
    "    print(y_predict.shape)\n",
    "    color_mask_predict = np.zeros((*y_predict.shape, 3))\n",
    "    for i, color in enumerate(VOC_COLORMAP):\n",
    "        color_mask_predict[y_predict==i] = np.array(color)\n",
    "    color_mask = np.zeros((*y_predict.shape, 3))\n",
    "    for i, color in enumerate(VOC_COLORMAP):\n",
    "        color_mask[y==i] = np.array(color)\n",
    "    plt.subplot(1,3,1)\n",
    "    plt.imshow(unorm(x).permute(1, 2, 0))\n",
    "    plt.subplot(1,3,2)\n",
    "    plt.imshow(color_mask)\n",
    "    plt.subplot(1,3,3)\n",
    "    plt.imshow(color_mask_predict)\n",
    "    plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.15"
  },
  "vscode": {
   "interpreter": {
    "hash": "ce06b65ffa354aec5ed2625f33c72f9dd46b0d2ee10cd3481aa94d5dfff5c8d3"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}