diff --git "a/src/run/unet/example/binary_segmentation_resunet.ipynb" "b/src/run/unet/example/binary_segmentation_resunet.ipynb"
new file mode 100644--- /dev/null
+++ "b/src/run/unet/example/binary_segmentation_resunet.ipynb"
@@ -0,0 +1,1614 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "5b042e00-b5f9-4ac8-94b0-465bbbe8312c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/usr/lib/python3/dist-packages/requests/__init__.py:89: RequestsDependencyWarning: urllib3 (1.26.11) or chardet (3.0.4) doesn't match a supported version!\n",
+      "  warnings.warn(\"urllib3 ({}) or chardet ({}) doesn't match a supported \"\n"
+     ]
+    }
+   ],
+   "source": [
+    "import os.path\n",
+    "from typing import Any, Callable, List, Optional, Tuple\n",
+    "\n",
+    "from PIL import Image\n",
+    "from torchvision.datasets import VisionDataset\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "import torch"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "bb6d4808-2ece-45df-b7cd-18ed24307e5b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"2,3\"\n",
+    "torch.cuda.device_count()\n",
+    "\n",
+    "use_cuda = torch.cuda.is_available()\n",
+    "device = torch.device(\"cuda\" if use_cuda else \"cpu\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "58baf6ec-5b3b-4874-b058-9b9b0bcd7782",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class CocoDetection(VisionDataset):\n",
+    "    def __init__(\n",
+    "        self,\n",
+    "        l,\n",
+    "        mean: List,\n",
+    "        std: List,\n",
+    "        root: str,\n",
+    "        annFile: str,\n",
+    "        binary_segmentation: bool,\n",
+    "        class_names: Optional[List] = None,\n",
+    "        transform: Optional[Callable] = None,\n",
+    "        transforms: Optional[Callable] = None,\n",
+    "    ) -> None:\n",
+    "        super().__init__(root, transforms, transform)\n",
+    "        from pycocotools.coco import COCO\n",
+    "\n",
+    "        self.l = l\n",
+    "        self.get_mask = (\n",
+    "            self._get_binary_mask if binary_segmentation else self._get_semantic_mask\n",
+    "        )\n",
+    "        self.coco = COCO(annFile)\n",
+    "\n",
+    "        if class_names is not None:\n",
+    "            cat_ids = self._get_category_ids_from_name(category_names=class_names)\n",
+    "            self.ids = list(\n",
+    "                sorted((self._get_img_ids_for_category_ids(category_ids=cat_ids)))\n",
+    "            )\n",
+    "\n",
+    "        else:\n",
+    "            cat_ids = self.coco.getCatIds()\n",
+    "            self.ids = list(sorted(self.coco.imgs.keys()))\n",
+    "\n",
+    "        self.cat2idx = {cat_id: idx + 1 for idx, cat_id in enumerate(cat_ids)}\n",
+    "        self.cat2idx[0] = 0\n",
+    "\n",
+    "        self.mean = torch.tensor(mean).reshape(len(mean), 1, 1)\n",
+    "        self.std = torch.tensor(std).reshape(len(std), 1, 1)\n",
+    "\n",
+    "    def _load_image(self, id: int) -> Image.Image:\n",
+    "        path = self.coco.loadImgs(id)[0][\"file_name\"]\n",
+    "        return Image.open(os.path.join(self.root, path)).convert(\"RGB\")\n",
+    "\n",
+    "    def _load_target(self, id: int) -> List[Any]:\n",
+    "        return self.coco.loadAnns(self.coco.getAnnIds(id))\n",
+    "\n",
+    "    def __getitem__(self, index: int) -> Tuple[Any, Any]:\n",
+    "        id = self.ids[index]\n",
+    "        image = self._load_image(id)\n",
+    "        mask = self._load_target(id)\n",
+    "\n",
+    "        mask = self.get_mask(image, mask)\n",
+    "        mask = (mask != 0).astype(float)\n",
+    "\n",
+    "        if self.transform is not None:\n",
+    "            augmented = self.transform(image=np.array(image), mask=mask)\n",
+    "            image = augmented[\"image\"]\n",
+    "            mask = augmented[\"mask\"]\n",
+    "\n",
+    "        #         if self.target_transform is not None:\n",
+    "        #             mask = self.target_transform(image=mask)[\"image\"]\n",
+    "\n",
+    "        return image, mask\n",
+    "\n",
+    "    def __len__(self) -> int:\n",
+    "        # return len(self.ids)\n",
+    "        return self.l\n",
+    "\n",
+    "    def _get_all_classes(self):\n",
+    "        catIDs = self.coco.getCatIds()\n",
+    "        return self.coco.loadCats(catIDs)\n",
+    "\n",
+    "    def _get_category_info_from_ids(self, ids: list):\n",
+    "        all_cat = self._get_all_classes()\n",
+    "        return [category for category in all_cat if category[\"id\"] in ids]\n",
+    "\n",
+    "    def _get_category_ids_from_name(self, category_names: list):\n",
+    "        return self.coco.getCatIds(catNms=category_names)\n",
+    "\n",
+    "    def _get_img_ids_for_category_ids(self, category_ids: list):\n",
+    "        img_ids = []\n",
+    "\n",
+    "        for catIds in category_ids:\n",
+    "            img_ids.extend(self.coco.getImgIds(catIds=catIds))\n",
+    "\n",
+    "        return img_ids\n",
+    "\n",
+    "    def _get_img_ids_for_category_names(self, category_names: list):\n",
+    "        img_ids = []\n",
+    "        category_ids = self._get_category_ids_from_name(category_names=class_names)\n",
+    "\n",
+    "        for catIds in category_ids:\n",
+    "            img_ids.extend(self.coco.getImgIds(catIds=catIds))\n",
+    "\n",
+    "        return img_ids\n",
+    "\n",
+    "    def _get_all_category_ids_in_img_id(self, img_id: int) -> List:\n",
+    "        target = self._load_target(img_id)\n",
+    "        return list({annotation[\"category_id\"] for annotation in target})\n",
+    "\n",
+    "    def _get_binary_mask(self, image: Image, annotations: List) -> np.array:\n",
+    "        w, h = image.size\n",
+    "        mask = np.zeros((h, w))\n",
+    "\n",
+    "        for annotation in annotations:\n",
+    "            category_id = annotation[\"category_id\"]\n",
+    "\n",
+    "            if category_id in self.cat2idx:\n",
+    "                pixel_value = self.cat2idx[category_id]\n",
+    "                mask = np.maximum(self.coco.annToMask(annotation) * pixel_value, mask)\n",
+    "\n",
+    "        return mask\n",
+    "\n",
+    "    def _get_semantic_mask(self, image: Image, annotations: List) -> np.array:\n",
+    "        w, h = image.size\n",
+    "        mask = np.zeros((len(self.cat2idx), h, w))\n",
+    "\n",
+    "        for annotation in annotations:\n",
+    "            category_id = annotation[\"category_id\"]\n",
+    "\n",
+    "            if category_id in self.cat2idx:\n",
+    "                pixel_value = self.cat2idx[category_id]\n",
+    "                mask[pixel_value] = np.maximum(\n",
+    "                    self.coco.annToMask(annotation), mask[pixel_value]\n",
+    "                )\n",
+    "\n",
+    "        # [h, w, channels]\n",
+    "        mask = np.transpose(mask, (1, 2, 0))\n",
+    "        return mask\n",
+    "\n",
+    "    def _plot_image_and_mask(self, index, figsize=(7, 3)):\n",
+    "        image, mask = self[index]\n",
+    "\n",
+    "        # denormalise image\n",
+    "        image = image * self.std + self.mean\n",
+    "\n",
+    "        # give unique pixel value to each class\n",
+    "        if len(mask.shape) == 3:\n",
+    "            mask *= torch.arange(255 - mask.shape[0], 255).reshape(-1, 1, 1)\n",
+    "            mask = mask.sum(0, keepdim=True).permute(1, 2, 0)\n",
+    "\n",
+    "        # Create a figure with two subplots side by side\n",
+    "        fig, axs = plt.subplots(1, 2, figsize=figsize)\n",
+    "\n",
+    "        axs[0].imshow(image.permute(1, 2, 0))\n",
+    "        axs[0].set_title(\"Image\")\n",
+    "\n",
+    "        axs[1].imshow(mask)\n",
+    "        axs[1].set_title(\"Mask\")\n",
+    "\n",
+    "        plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "eb10b3ad-6c66-4b22-b9c3-1c7c254a303f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import cv2\n",
+    "import albumentations as A\n",
+    "from albumentations.pytorch import ToTensorV2\n",
+    "\n",
+    "# imagenet mean and std\n",
+    "mean = [0.485, 0.456, 0.406]\n",
+    "std = [0.229, 0.224, 0.225]\n",
+    "IMAGE_SIZE = 224\n",
+    "scale = 1\n",
+    "\n",
+    "\n",
+    "train_transform = A.Compose(\n",
+    "    [\n",
+    "        A.LongestMaxSize(max_size=int(IMAGE_SIZE * scale)),\n",
+    "        A.PadIfNeeded(\n",
+    "            min_height=int(IMAGE_SIZE * scale),\n",
+    "            min_width=int(IMAGE_SIZE * scale),\n",
+    "            border_mode=cv2.BORDER_CONSTANT,\n",
+    "        ),\n",
+    "        A.Rotate(limit=10, interpolation=1, border_mode=4),\n",
+    "        A.RandomCrop(width=IMAGE_SIZE, height=IMAGE_SIZE),\n",
+    "        A.ColorJitter(brightness=0.6, contrast=0.6, saturation=0.6, hue=0.6, p=0.4),\n",
+    "        A.OneOf(\n",
+    "            [\n",
+    "                A.ShiftScaleRotate(\n",
+    "                    rotate_limit=20, p=0.5, border_mode=cv2.BORDER_CONSTANT\n",
+    "                ),\n",
+    "                # A.Affine(shear=15, p=0.5, mode=\"constant\"),\n",
+    "            ],\n",
+    "            p=1.0,\n",
+    "        ),\n",
+    "        A.HorizontalFlip(p=0.5),\n",
+    "        A.Blur(p=0.1),\n",
+    "        A.CLAHE(p=0.1),\n",
+    "        A.Posterize(p=0.1),\n",
+    "        A.ToGray(p=0.1),\n",
+    "        A.ChannelShuffle(p=0.05),\n",
+    "        A.Normalize(\n",
+    "            mean=mean,\n",
+    "            std=std,\n",
+    "            max_pixel_value=255,\n",
+    "        ),\n",
+    "        ToTensorV2(),\n",
+    "    ],\n",
+    ")\n",
+    "\n",
+    "test_transform = A.Compose(\n",
+    "    [\n",
+    "        A.LongestMaxSize(max_size=IMAGE_SIZE),\n",
+    "        A.PadIfNeeded(\n",
+    "            min_height=IMAGE_SIZE, min_width=IMAGE_SIZE, border_mode=cv2.BORDER_CONSTANT\n",
+    "        ),\n",
+    "        A.Normalize(\n",
+    "            mean=mean,\n",
+    "            std=std,\n",
+    "            max_pixel_value=255,\n",
+    "        ),\n",
+    "        ToTensorV2(),\n",
+    "    ]\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "46efcfbf-be53-42e6-af4c-419b6985fedc",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "loading annotations into memory...\n",
+      "Done (t=21.39s)\n",
+      "creating index...\n",
+      "index created!\n",
+      "loading annotations into memory...\n",
+      "Done (t=0.76s)\n",
+      "creating index...\n",
+      "index created!\n"
+     ]
+    }
+   ],
+   "source": [
+    "train_dataset = CocoDetection(\n",
+    "    l=100000,\n",
+    "    mean=mean,\n",
+    "    std=std,\n",
+    "    root=\"./data/train/data\",\n",
+    "    annFile=\"./data/raw/instances_train2017.json\",\n",
+    "    transform=train_transform,\n",
+    "    binary_segmentation=True,\n",
+    ")\n",
+    "\n",
+    "test_dataset = CocoDetection(\n",
+    "    l=1000,\n",
+    "    mean=mean,\n",
+    "    std=std,\n",
+    "    root=\"./data/validation/data\",\n",
+    "    annFile=\"./data/raw/instances_val2017.json\",\n",
+    "    transform=test_transform,\n",
+    "    binary_segmentation=True,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "3754075a-86b1-4a51-970c-47ba06fd9e70",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "img_idx = 15"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "5fec8dc9-a7e8-4b87-9507-7a46e5dbc487",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 720x360 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "train_dataset._plot_image_and_mask(img_idx, figsize=(10, 5))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "1f95189b-a30b-4706-8a3f-d36104beb48f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(torch.Size([3, 224, 224]), torch.Tensor, torch.Size([224, 224]), torch.Tensor)"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "img, mask = train_dataset[img_idx]\n",
+    "img.shape, type(img), mask.shape, type(mask)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "0f76cbda-212b-414f-a045-72e2615eb778",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "13.243383290816327"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "(100 * mask.sum() / mask.numel()).item()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "60aa1019-7421-4144-a259-126da5055869",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[5]"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "cat_ids = train_dataset._get_all_category_ids_in_img_id(train_dataset.ids[img_idx])\n",
+    "cat_ids"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "deb9f641-909e-4ea5-8f11-024587c757a6",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[{'supercategory': 'vehicle', 'id': 5, 'name': 'airplane'}]"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "train_dataset._get_category_info_from_ids(cat_ids)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "371141eb-fb4d-44de-8dfd-472018761c03",
+   "metadata": {},
+   "source": [
+    "# Download Dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "7d99e559-59c5-4875-897f-b4dc191dacf4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# # download Coco dataset\n",
+    "# import fiftyone.zoo as foz\n",
+    "\n",
+    "\n",
+    "# foz.load_zoo_dataset(\n",
+    "#     \"coco-2017\",\n",
+    "#     split=\"train\",\n",
+    "#     label_types=[\"segmentations\"],\n",
+    "#     max_samples=10000,\n",
+    "#     dataset_dir=\"./data\",\n",
+    "# )\n",
+    "\n",
+    "# foz.load_zoo_dataset(\n",
+    "#     \"coco-2017\",\n",
+    "#     split=\"validation\",\n",
+    "#     label_types=[\"segmentations\"],\n",
+    "#     max_samples=1000,\n",
+    "#     dataset_dir=\"./data\",\n",
+    "# )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0c118256-d61c-494a-a3b0-c280c5c726d8",
+   "metadata": {},
+   "source": [
+    "# DataLoader"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "800b107f-3ae1-484a-b6ae-77dcde9d69ce",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "\n",
+    "num_workers = int(0.8 * os.cpu_count())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "2c1109e1-9c8f-45b9-877f-cb35a5cf21d1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# dataloaders\n",
+    "BATCH_SIZE = 16\n",
+    "\n",
+    "train_loader = torch.utils.data.DataLoader(\n",
+    "    train_dataset, batch_size=BATCH_SIZE, shuffle=True, num_workers=num_workers\n",
+    ")\n",
+    "\n",
+    "test_loader = torch.utils.data.DataLoader(\n",
+    "    test_dataset, batch_size=BATCH_SIZE, shuffle=False, num_workers=num_workers\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "164289cc-2ba4-4571-a7d4-cc01ce5bd8f8",
+   "metadata": {},
+   "source": [
+    "# Model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "aee80dbb-e2e2-453e-950f-37e0150f013d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import yaml\n",
+    "from unet import UNet\n",
+    "from easydict import EasyDict\n",
+    "from torchinfo import summary\n",
+    "\n",
+    "from torchvision.models import resnet50, ResNet50_Weights\n",
+    "import torch.nn as nn"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b2f18ac7-39e7-4e00-b1eb-f46848b51f32",
+   "metadata": {},
+   "source": [
+    "### MODEL 1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "01406367-3085-4ded-a7a1-7edcbfeac878",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# config_path = './custom_config.yml'\n",
+    "\n",
+    "# with open(config_path, 'r') as file:\n",
+    "#     yaml_data = yaml.safe_load(file)\n",
+    "\n",
+    "# config = EasyDict(yaml_data)\n",
+    "\n",
+    "# model = UNet(config[\"encoder_config\"], config[\"decoder_config\"], nclasses=1).to(device)\n",
+    "\n",
+    "# summary(\n",
+    "#     model,\n",
+    "#     input_data=torch.rand((1, 3, 512, 512)),\n",
+    "#     device=device\n",
+    "# )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "21f66804-731b-4eaf-9516-bacd7ec314ec",
+   "metadata": {},
+   "source": [
+    "### MODEL 2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "e124dc00-6b27-4935-ae73-c547c9ae1138",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "=========================================================================================================\n",
+       "Layer (type:depth-idx)                                  Output Shape              Param #\n",
+       "=========================================================================================================\n",
+       "UNet                                                    [1, 1, 224, 224]          --\n",
+       "├─Encoder: 1-1                                          [1, 2048, 7, 7]           --\n",
+       "│    └─ModuleDict: 2-1                                  --                        --\n",
+       "│    │    └─Sequential: 3-1                             [1, 64, 112, 112]         (9,536)\n",
+       "│    │    └─Sequential: 3-2                             [1, 256, 56, 56]          (215,808)\n",
+       "│    │    └─Sequential: 3-3                             [1, 512, 28, 28]          (1,219,584)\n",
+       "│    │    └─Sequential: 3-4                             [1, 1024, 14, 14]         (7,098,368)\n",
+       "│    │    └─Sequential: 3-5                             [1, 2048, 7, 7]           (14,964,736)\n",
+       "├─Decoder: 1-2                                          [1, 64, 52, 52]           --\n",
+       "│    └─ModuleDict: 2-2                                  --                        --\n",
+       "│    │    └─DecoderLayer: 3-6                           [1, 1024, 10, 10]         36,711,424\n",
+       "│    │    └─DecoderLayer: 3-7                           [1, 512, 16, 16]          9,180,672\n",
+       "│    │    └─DecoderLayer: 3-8                           [1, 128, 28, 28]          1,263,616\n",
+       "│    │    └─DecoderLayer: 3-9                           [1, 64, 52, 52]           144,064\n",
+       "├─Sequential: 1-3                                       [1, 1, 224, 224]          --\n",
+       "│    └─Conv2d: 2-3                                      [1, 1, 52, 52]            65\n",
+       "│    └─UpsamplingBilinear2d: 2-4                        [1, 1, 224, 224]          --\n",
+       "=========================================================================================================\n",
+       "Total params: 70,807,873\n",
+       "Trainable params: 47,299,841\n",
+       "Non-trainable params: 23,508,032\n",
+       "Total mult-adds (G): 13.97\n",
+       "=========================================================================================================\n",
+       "Input size (MB): 0.60\n",
+       "Forward/backward pass size (MB): 216.64\n",
+       "Params size (MB): 283.23\n",
+       "Estimated Total Size (MB): 500.47\n",
+       "========================================================================================================="
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "config_path = \"./resnet_config.yml\"\n",
+    "\n",
+    "with open(config_path, \"r\") as file:\n",
+    "    yaml_data = yaml.safe_load(file)\n",
+    "\n",
+    "config = EasyDict(yaml_data)\n",
+    "\n",
+    "\n",
+    "class Encoder(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(Encoder, self).__init__()\n",
+    "        resnet = resnet50(weights=ResNet50_Weights.IMAGENET1K_V1)\n",
+    "\n",
+    "        for param in resnet.parameters():\n",
+    "            param.requires_grad_(False)\n",
+    "\n",
+    "        self.stages = nn.ModuleDict(\n",
+    "            {\n",
+    "                \"block1\": nn.Sequential(resnet.conv1, resnet.bn1, resnet.relu),\n",
+    "                \"block2\": nn.Sequential(resnet.maxpool, resnet.layer1),\n",
+    "                \"block3\": resnet.layer2,\n",
+    "                \"block4\": resnet.layer3,\n",
+    "                \"block5\": resnet.layer4,\n",
+    "            }\n",
+    "        )\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        stages = {}\n",
+    "\n",
+    "        for name, stage in self.stages.items():\n",
+    "            x = stage(x)\n",
+    "            stages[name] = x\n",
+    "\n",
+    "        return x, stages\n",
+    "\n",
+    "\n",
+    "class DecoderLayer(nn.Module):\n",
+    "    def __init__(\n",
+    "        self, in_channels, out_channels, kernel_size=2, stride=2, padding=[0, 0]\n",
+    "    ):\n",
+    "        super(DecoderLayer, self).__init__()\n",
+    "        self.up_conv = nn.ConvTranspose2d(\n",
+    "            in_channels=in_channels,\n",
+    "            out_channels=in_channels // 2,\n",
+    "            kernel_size=kernel_size,\n",
+    "            stride=stride,\n",
+    "            padding=padding[0],\n",
+    "        )\n",
+    "\n",
+    "        self.bn1 = nn.BatchNorm2d(in_channels)\n",
+    "\n",
+    "        self.conv = nn.Sequential(\n",
+    "            *[\n",
+    "                self._conv_relu_layer(\n",
+    "                    in_channels=in_channels if i == 0 else out_channels,\n",
+    "                    out_channels=out_channels,\n",
+    "                    padding=padding[1],\n",
+    "                )\n",
+    "                for i in range(2)\n",
+    "            ]\n",
+    "        )\n",
+    "\n",
+    "    def _conv_relu_layer(self, in_channels, out_channels, padding=0):\n",
+    "        return nn.Sequential(\n",
+    "            nn.Conv2d(\n",
+    "                in_channels=in_channels,\n",
+    "                out_channels=out_channels,\n",
+    "                kernel_size=3,\n",
+    "                padding=padding,\n",
+    "            ),\n",
+    "            nn.ReLU(),\n",
+    "            nn.BatchNorm2d(out_channels),\n",
+    "        )\n",
+    "\n",
+    "    @staticmethod\n",
+    "    def crop_cat(x, encoder_output):\n",
+    "        delta = (encoder_output.shape[-1] - x.shape[-1]) // 2\n",
+    "        encoder_output = encoder_output[\n",
+    "            :, :, delta : delta + x.shape[-1], delta : delta + x.shape[-1]\n",
+    "        ]\n",
+    "        return torch.cat((encoder_output, x), dim=1)\n",
+    "\n",
+    "    def forward(self, x, encoder_output):\n",
+    "        x = self.up_conv(x)\n",
+    "        x = self.crop_cat(x, encoder_output)\n",
+    "        x = self.bn1(x)\n",
+    "        return self.conv(x)\n",
+    "\n",
+    "\n",
+    "class Decoder(nn.Module):\n",
+    "    def __init__(self, config):\n",
+    "        super(Decoder, self).__init__()\n",
+    "        self.decoder = nn.ModuleDict(\n",
+    "            {\n",
+    "                name: DecoderLayer(\n",
+    "                    in_channels=block[\"in_channels\"],\n",
+    "                    out_channels=block[\"out_channels\"],\n",
+    "                    kernel_size=block[\"kernel_size\"],\n",
+    "                    stride=block[\"stride\"],\n",
+    "                    padding=block[\"padding\"],\n",
+    "                )\n",
+    "                for name, block in config.items()\n",
+    "            }\n",
+    "        )\n",
+    "\n",
+    "    def forward(self, x, encoder_output):\n",
+    "        for name, block in self.decoder.items():\n",
+    "            x = block(x, encoder_output[name])\n",
+    "\n",
+    "        return x\n",
+    "\n",
+    "\n",
+    "class UNet(nn.Module):\n",
+    "    def __init__(self, decoder_config, nclasses):\n",
+    "        super(UNet, self).__init__()\n",
+    "        self.encoder = Encoder()\n",
+    "        self.decoder = Decoder(config=decoder_config)\n",
+    "\n",
+    "        self.output = nn.Sequential(\n",
+    "            nn.Conv2d(\n",
+    "                in_channels=decoder_config[\"block1\"][\"out_channels\"],\n",
+    "                out_channels=nclasses,\n",
+    "                kernel_size=1,\n",
+    "            ),\n",
+    "            nn.UpsamplingBilinear2d(size=224),\n",
+    "        )\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x, encoder_step_output = self.encoder(x)\n",
+    "        x = self.decoder(x, encoder_step_output)\n",
+    "        x = self.output(x)\n",
+    "        return x\n",
+    "\n",
+    "\n",
+    "model = UNet(config[\"decoder_config\"], nclasses=1).to(device)\n",
+    "\n",
+    "summary(model, input_data=torch.rand((1, 3, 224, 224)), device=device)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2d35b61a-d530-4a5e-bafb-98cb22fe56c8",
+   "metadata": {},
+   "source": [
+    "### MODEL 3"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "8108d5ff-2b69-403f-b4fa-d9562df3d260",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# import segmentation_models_pytorch as smp\n",
+    "# import torch\n",
+    "\n",
+    "# model = smp.create_model(\n",
+    "#             \"FPN\",encoder_name=\"resnet34\", in_channels=3, classes=1,\n",
+    "#         )\n",
+    "\n",
+    "# summary(\n",
+    "#     model,\n",
+    "#     input_data=torch.rand((1, 3, 224, 224)),\n",
+    "#     device=device\n",
+    "# )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "7ccefee7-7606-496b-894d-de293dfa5164",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Total parameters: 70807873\n",
+      "Trainable parameters: 47299841\n",
+      "Non-trainable parameters: 23508032\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Count parameters\n",
+    "total_params = sum(p.numel() for p in model.parameters())\n",
+    "trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad)\n",
+    "\n",
+    "print(f\"Total parameters: {total_params}\")\n",
+    "print(f\"Trainable parameters: {trainable_params}\")\n",
+    "print(f\"Non-trainable parameters: {total_params - trainable_params}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "415a33d9-afe1-411a-9415-d062d24c65bf",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# import torch.optim as optim\n",
+    "# import torch.nn as nn\n",
+    "# import segmentation_models_pytorch as smp\n",
+    "\n",
+    "\n",
+    "# class Loss(nn.Module):\n",
+    "#     def __init__(self):\n",
+    "#         super(Loss, self).__init__()\n",
+    "#         self.dice_criterion = smp.losses.DiceLoss(smp.losses.BINARY_MODE, from_logits=True)\n",
+    "#         self.class_criterion = nn.BCEWithLogitsLoss()\n",
+    "\n",
+    "#         self.lambda_dice = 1\n",
+    "#         self.lambda_class = 1\n",
+    "\n",
+    "#     def forward(self, prediction, target):\n",
+    "#         \"\"\"\n",
+    "#         prediction = [batch, 1, 224, 224]\n",
+    "#         target = [batch, 224, 224]\n",
+    "#         \"\"\"\n",
+    "#         dice_loss = self.dice_criterion(prediction, target)\n",
+    "#         class_loss = self.class_criterion(prediction.squeeze(1), target)\n",
+    "\n",
+    "#         return self.lambda_dice * dice_loss + self.lambda_class * class_loss\n",
+    "\n",
+    "# criterion = Loss()\n",
+    "# optimizer = optim.Adam(\n",
+    "#     model.parameters(), lr=1e-5, weight_decay=1e-4\n",
+    "# )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "1bb7ea64-7516-4735-a7e3-50cbbf934a89",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch.optim as optim\n",
+    "import torch.nn as nn\n",
+    "import segmentation_models_pytorch as smp\n",
+    "\n",
+    "criterion = smp.losses.DiceLoss(smp.losses.BINARY_MODE, from_logits=True)\n",
+    "optimizer = optim.Adam(model.parameters(), lr=0.01)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "6d00d222-3e9b-475f-88ec-ec0527d1ef9c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "epochs = 50\n",
+    "learning_rate = 0.01\n",
+    "\n",
+    "scheduler = optim.lr_scheduler.OneCycleLR(\n",
+    "    optimizer,\n",
+    "    max_lr=learning_rate,\n",
+    "    steps_per_epoch=len(train_loader),\n",
+    "    epochs=epochs,\n",
+    "    pct_start=0.2,\n",
+    "    div_factor=100,\n",
+    "    three_phase=False,\n",
+    "    final_div_factor=100,\n",
+    "    anneal_strategy=\"linear\",\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "3e593556-a456-446e-9bec-7e5f553e7763",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "train_losses = []\n",
+    "train_accuracy = []\n",
+    "\n",
+    "\n",
+    "def train(model, dataloader, optimizer, criterion, scheduler, device):\n",
+    "    model.train()\n",
+    "\n",
+    "    pbar = tqdm(dataloader)\n",
+    "    train_loss = 0\n",
+    "    correct = 0\n",
+    "    processed = 0\n",
+    "\n",
+    "    for batch_idx, (data, target) in enumerate(pbar):\n",
+    "        data, target = data.to(device), target.to(device)\n",
+    "        optimizer.zero_grad()\n",
+    "\n",
+    "        # Predict\n",
+    "        pred = model(data)\n",
+    "\n",
+    "        # Calculate loss\n",
+    "        loss = criterion(pred, target)\n",
+    "\n",
+    "        # Backpropagation\n",
+    "        loss.backward()\n",
+    "        optimizer.step()\n",
+    "        scheduler.step()\n",
+    "\n",
+    "        correct += ((pred.squeeze(1).sigmoid() > 0.4).float() == target).sum().item()\n",
+    "        processed += target.numel()\n",
+    "\n",
+    "        train_loss += loss.item()\n",
+    "\n",
+    "        # Display progress\n",
+    "        pbar.set_description(\n",
+    "            desc=f\"Train: Loss={train_loss / (batch_idx + 1):0.4f} Batch_id={batch_idx} Accuracy={100 * correct / processed:0.2f}\"\n",
+    "        )\n",
+    "\n",
+    "    # Record training statistics\n",
+    "    train_losses.append(train_loss / len(dataloader))\n",
+    "    train_accuracy.append(100 * correct / processed)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "5bfd458c-6452-4e87-a90d-a26870393240",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "test_losses = []\n",
+    "test_accuracy = []\n",
+    "\n",
+    "\n",
+    "def test(model, dataloader, criterion, device):\n",
+    "    model.train()\n",
+    "\n",
+    "    pbar = tqdm(dataloader)\n",
+    "    test_loss = 0\n",
+    "    correct = 0\n",
+    "    processed = 0\n",
+    "\n",
+    "    with torch.no_grad():\n",
+    "        for batch_idx, (data, target) in enumerate(pbar):\n",
+    "            data, target = data.to(device), target.to(device)\n",
+    "\n",
+    "            # Predict\n",
+    "            pred = model(data)\n",
+    "\n",
+    "            # Calculate loss\n",
+    "            pred = pred.squeeze(1)\n",
+    "            target = target.squeeze(1)\n",
+    "\n",
+    "            loss = criterion(pred, target)\n",
+    "            test_loss += loss.item()\n",
+    "\n",
+    "            correct += (\n",
+    "                ((pred.squeeze(1).sigmoid() > 0.4).float() == target).sum().item()\n",
+    "            )\n",
+    "            processed += target.numel()\n",
+    "\n",
+    "            # Display progress\n",
+    "            pbar.set_description(\n",
+    "                desc=f\"Test: Loss={test_loss / (batch_idx + 1):0.4f} Batch_id={batch_idx} Accuracy={100 * correct / processed:0.2f}\"\n",
+    "            )\n",
+    "\n",
+    "    # Record training statistics\n",
+    "    test_losses.append(test_loss / len(dataloader))\n",
+    "    test_accuracy.append(100 * correct / processed)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "c05243fb-772e-4017-bb9e-cc8d2ba3c91f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def infer(input_tensor, actual_mask, figsize=(10, 5)):\n",
+    "    model.eval()\n",
+    "\n",
+    "    # Run inference on the input tensor\n",
+    "    with torch.no_grad():\n",
+    "        output_tensor = model(input_tensor)\n",
+    "\n",
+    "    output_tensor = output_tensor.squeeze(0)\n",
+    "    output_tensor = torch.sigmoid(output_tensor)\n",
+    "\n",
+    "    img = output_tensor.permute(1, 2, 0).cpu().numpy()\n",
+    "    actual_mask = actual_mask.cpu().numpy()\n",
+    "\n",
+    "    # Plot the original image\n",
+    "    input_image = input_tensor[0].permute(1, 2, 0).cpu().numpy()\n",
+    "\n",
+    "    # Create a figure with two subplots side by side\n",
+    "    fig, axs = plt.subplots(1, 3, figsize=figsize)\n",
+    "\n",
+    "    axs[0].imshow(input_image)\n",
+    "    axs[0].set_title(\"Image\")\n",
+    "\n",
+    "    axs[1].imshow(actual_mask)\n",
+    "    axs[1].set_title(\"Actual Mask\")\n",
+    "\n",
+    "    axs[2].imshow(img)\n",
+    "    axs[2].set_title(\"Predicted Mask\")\n",
+    "\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "id": "50f9fd5f-61c4-4944-9208-db752de66bc2",
+   "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"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x432 with 3 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "idx = 15\n",
+    "\n",
+    "input_tensor, actual_mask = train_dataset[idx]\n",
+    "infer(\n",
+    "    input_tensor=input_tensor.unsqueeze(0).to(device),\n",
+    "    actual_mask=actual_mask,\n",
+    "    figsize=(12, 6),\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "a3506cec-ac9e-460f-9e6c-eb068e5aedec",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Train: Loss=0.3507 Batch_id=6249 Accuracy=83.54: 100%|██████████| 6250/6250 [05:55<00:00, 17.60it/s]\n",
+      "Test: Loss=0.3086 Batch_id=62 Accuracy=86.09: 100%|██████████| 63/63 [00:08<00:00,  7.50it/s]\n",
+      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x432 with 3 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Train: Loss=0.3119 Batch_id=6249 Accuracy=85.93: 100%|██████████| 6250/6250 [05:59<00:00, 17.40it/s]\n",
+      "Test: Loss=0.2737 Batch_id=62 Accuracy=87.39: 100%|██████████| 63/63 [00:08<00:00,  7.50it/s]\n",
+      "Train: Loss=0.2883 Batch_id=6249 Accuracy=87.19: 100%|██████████| 6250/6250 [05:58<00:00, 17.43it/s]\n",
+      "Test: Loss=0.2574 Batch_id=62 Accuracy=88.22: 100%|██████████| 63/63 [00:08<00:00,  7.80it/s]\n",
+      "Train: Loss=0.2707 Batch_id=6249 Accuracy=88.06: 100%|██████████| 6250/6250 [05:58<00:00, 17.44it/s]\n",
+      "Test: Loss=0.2441 Batch_id=62 Accuracy=88.51: 100%|██████��███| 63/63 [00:08<00:00,  7.80it/s]\n",
+      "Train: Loss=0.2597 Batch_id=6249 Accuracy=88.61: 100%|██████████| 6250/6250 [05:58<00:00, 17.41it/s]\n",
+      "Test: Loss=0.2329 Batch_id=62 Accuracy=89.38: 100%|██████████| 63/63 [00:08<00:00,  7.25it/s]\n",
+      "Train: Loss=0.2529 Batch_id=6249 Accuracy=88.95: 100%|██████████| 6250/6250 [07:55<00:00, 13.13it/s]\n",
+      "Test: Loss=0.2309 Batch_id=62 Accuracy=89.77: 100%|██████████| 63/63 [00:13<00:00,  4.81it/s]\n",
+      "Train: Loss=0.2486 Batch_id=6249 Accuracy=89.16: 100%|██████████| 6250/6250 [08:06<00:00, 12.85it/s]\n",
+      "Test: Loss=0.2248 Batch_id=62 Accuracy=89.95: 100%|██████████| 63/63 [00:12<00:00,  4.91it/s]\n",
+      "Train: Loss=0.2448 Batch_id=6249 Accuracy=89.34: 100%|██████████| 6250/6250 [08:36<00:00, 12.10it/s]\n",
+      "Test: Loss=0.2235 Batch_id=62 Accuracy=89.80: 100%|██████████| 63/63 [00:14<00:00,  4.47it/s]\n",
+      "Train: Loss=0.2419 Batch_id=6249 Accuracy=89.48: 100%|██████████| 6250/6250 [08:26<00:00, 12.34it/s]\n",
+      "Test: Loss=0.2221 Batch_id=62 Accuracy=89.66: 100%|██████████| 63/63 [00:12<00:00,  4.86it/s]\n",
+      "Train: Loss=0.2397 Batch_id=6249 Accuracy=89.58: 100%|██████████| 6250/6250 [08:07<00:00, 12.83it/s]\n",
+      "Test: Loss=0.2232 Batch_id=62 Accuracy=89.89: 100%|██████████| 63/63 [00:12<00:00,  4.95it/s]\n",
+      "Train: Loss=0.2367 Batch_id=6249 Accuracy=89.72: 100%|██████████| 6250/6250 [08:07<00:00, 12.82it/s]\n",
+      "Test: Loss=0.2181 Batch_id=62 Accuracy=90.04: 100%|██████████| 63/63 [00:12<00:00,  4.93it/s]\n",
+      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x432 with 3 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Train: Loss=0.2326 Batch_id=6249 Accuracy=89.91: 100%|██████████| 6250/6250 [08:08<00:00, 12.79it/s]\n",
+      "Test: Loss=0.2137 Batch_id=62 Accuracy=90.20: 100%|██████████| 63/63 [00:13<00:00,  4.84it/s]\n",
+      "Train: Loss=0.2303 Batch_id=6249 Accuracy=90.04: 100%|██████████| 6250/6250 [08:08<00:00, 12.78it/s]\n",
+      "Test: Loss=0.2123 Batch_id=62 Accuracy=90.37: 100%|██████████| 63/63 [00:13<00:00,  4.69it/s]\n",
+      "Train: Loss=0.2274 Batch_id=6249 Accuracy=90.15: 100%|██████████| 6250/6250 [08:25<00:00, 12.36it/s]\n",
+      "Test: Loss=0.2139 Batch_id=62 Accuracy=90.11: 100%|██████████| 63/63 [00:12<00:00,  5.12it/s]\n",
+      "Train: Loss=0.2247 Batch_id=6249 Accuracy=90.29: 100%|██████████| 6250/6250 [08:03<00:00, 12.93it/s]\n",
+      "Test: Loss=0.2075 Batch_id=62 Accuracy=90.57: 100%|██████████| 63/63 [00:12<00:00,  4.97it/s]\n",
+      "Train: Loss=0.2224 Batch_id=6249 Accuracy=90.40: 100%|██████████| 6250/6250 [10:39<00:00,  9.78it/s]\n",
+      "Test: Loss=0.2043 Batch_id=62 Accuracy=90.96: 100%|██████████| 63/63 [00:15<00:00,  4.00it/s]\n",
+      "Train: Loss=0.2202 Batch_id=6249 Accuracy=90.50: 100%|██████████| 6250/6250 [08:02<00:00, 12.96it/s]\n",
+      "Test: Loss=0.2047 Batch_id=62 Accuracy=90.57: 100%|██████████| 63/63 [00:12<00:00,  4.96it/s]\n",
+      "Train: Loss=0.2184 Batch_id=6249 Accuracy=90.59: 100%|██████████| 6250/6250 [08:01<00:00, 12.99it/s]\n",
+      "Test: Loss=0.2029 Batch_id=62 Accuracy=90.84: 100%|██████████| 63/63 [00:12<00:00,  4.97it/s]\n",
+      "Train: Loss=0.2167 Batch_id=6249 Accuracy=90.69: 100%|██████████| 6250/6250 [08:02<00:00, 12.95it/s]\n",
+      "Test: Loss=0.2050 Batch_id=62 Accuracy=90.69: 100%|██████████| 63/63 [00:13<00:00,  4.59it/s]\n",
+      "Train: Loss=0.2149 Batch_id=6249 Accuracy=90.75: 100%|██████████| 6250/6250 [07:59<00:00, 13.03it/s]\n",
+      "Test: Loss=0.2044 Batch_id=62 Accuracy=90.67: 100%|██████████| 63/63 [00:12<00:00,  4.93it/s]\n",
+      "Train: Loss=0.2135 Batch_id=6249 Accuracy=90.81: 100%|██████████| 6250/6250 [08:01<00:00, 12.97it/s]\n",
+      "Test: Loss=0.2033 Batch_id=62 Accuracy=90.80: 100%|██████████| 63/63 [00:12<00:00,  4.86it/s]\n",
+      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x432 with 3 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Train: Loss=0.2118 Batch_id=6249 Accuracy=90.89: 100%|██████████| 6250/6250 [08:23<00:00, 12.42it/s]\n",
+      "Test: Loss=0.2005 Batch_id=62 Accuracy=91.11: 100%|██████████| 63/63 [00:13<00:00,  4.76it/s]\n",
+      "Train: Loss=0.2101 Batch_id=6249 Accuracy=90.97: 100%|██████████| 6250/6250 [08:06<00:00, 12.84it/s]\n",
+      "Test: Loss=0.2002 Batch_id=62 Accuracy=90.93: 100%|██████████| 63/63 [00:13<00:00,  4.83it/s]\n",
+      "Train: Loss=0.2090 Batch_id=6249 Accuracy=91.04: 100%|██████████| 6250/6250 [08:07<00:00, 12.83it/s]\n",
+      "Test: Loss=0.2006 Batch_id=62 Accuracy=90.86: 100%|██████████| 63/63 [00:12<00:00,  4.96it/s]\n",
+      "Train: Loss=0.2071 Batch_id=6249 Accuracy=91.12: 100%|██████████| 6250/6250 [08:03<00:00, 12.92it/s]\n",
+      "Test: Loss=0.1984 Batch_id=62 Accuracy=91.09: 100%|██████████| 63/63 [00:13<00:00,  4.73it/s]\n",
+      "Train: Loss=0.2058 Batch_id=6249 Accuracy=91.17: 100%|██████████| 6250/6250 [08:06<00:00, 12.86it/s]\n",
+      "Test: Loss=0.2009 Batch_id=62 Accuracy=90.92: 100%|██████████| 63/63 [00:12<00:00,  4.92it/s]\n",
+      "Train: Loss=0.2053 Batch_id=6249 Accuracy=91.22: 100%|██████████| 6250/6250 [08:03<00:00, 12.92it/s]\n",
+      "Test: Loss=0.1997 Batch_id=62 Accuracy=91.06: 100%|██████████| 63/63 [00:12<00:00,  4.94it/s]\n",
+      "Train: Loss=0.2035 Batch_id=6249 Accuracy=91.28: 100%|██████████| 6250/6250 [07:48<00:00, 13.33it/s]\n",
+      "Test: Loss=0.1981 Batch_id=62 Accuracy=90.93: 100%|██████████| 63/63 [00:13<00:00,  4.62it/s]\n",
+      "Train: Loss=0.2027 Batch_id=6249 Accuracy=91.34: 100%|██████████| 6250/6250 [08:06<00:00, 12.84it/s]\n",
+      "Test: Loss=0.1958 Batch_id=62 Accuracy=91.18: 100%|██████████| 63/63 [00:12<00:00,  5.00it/s]\n",
+      "Train: Loss=0.2016 Batch_id=6249 Accuracy=91.37: 100%|██████████| 6250/6250 [08:04<00:00, 12.91it/s]\n",
+      "Test: Loss=0.1983 Batch_id=62 Accuracy=91.18: 100%|██████████| 63/63 [00:12<00:00,  4.89it/s]\n",
+      "Train: Loss=0.2003 Batch_id=6249 Accuracy=91.45: 100%|██████████| 6250/6250 [07:59<00:00, 13.02it/s]\n",
+      "Test: Loss=0.1963 Batch_id=62 Accuracy=91.24: 100%|██████████| 63/63 [00:13<00:00,  4.81it/s]\n",
+      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x432 with 3 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Train: Loss=0.1990 Batch_id=6249 Accuracy=91.50: 100%|██████████| 6250/6250 [07:49<00:00, 13.32it/s]\n",
+      "Test: Loss=0.1974 Batch_id=62 Accuracy=91.16: 100%|██████████| 63/63 [00:12<00:00,  4.89it/s]\n",
+      "Train: Loss=0.1975 Batch_id=6249 Accuracy=91.56: 100%|██████████| 6250/6250 [07:27<00:00, 13.97it/s]\n",
+      "Test: Loss=0.1959 Batch_id=62 Accuracy=91.19: 100%|██████████| 63/63 [00:11<00:00,  5.36it/s]\n",
+      "Train: Loss=0.1962 Batch_id=6249 Accuracy=91.63: 100%|██████████| 6250/6250 [07:26<00:00, 13.99it/s]\n",
+      "Test: Loss=0.1961 Batch_id=62 Accuracy=91.29: 100%|██████████| 63/63 [00:12<00:00,  5.05it/s]\n",
+      "Train: Loss=0.1954 Batch_id=6249 Accuracy=91.65: 100%|██████████| 6250/6250 [07:19<00:00, 14.22it/s]\n",
+      "Test: Loss=0.1951 Batch_id=62 Accuracy=91.31: 100%|██████████| 63/63 [00:12<00:00,  5.18it/s]\n",
+      "Train: Loss=0.1945 Batch_id=6249 Accuracy=91.70: 100%|██████████| 6250/6250 [08:03<00:00, 12.94it/s]\n",
+      "Test: Loss=0.1943 Batch_id=62 Accuracy=91.31: 100%|██████████| 63/63 [00:12<00:00,  4.85it/s]\n",
+      "Train: Loss=0.1932 Batch_id=6249 Accuracy=91.76: 100%|██████████| 6250/6250 [08:05<00:00, 12.88it/s]\n",
+      "Test: Loss=0.1964 Batch_id=62 Accuracy=91.25: 100%|██████████| 63/63 [00:13<00:00,  4.71it/s]\n",
+      "Train: Loss=0.1921 Batch_id=6249 Accuracy=91.81: 100%|██████████| 6250/6250 [08:02<00:00, 12.97it/s]\n",
+      "Test: Loss=0.1947 Batch_id=62 Accuracy=91.47: 100%|██████████| 63/63 [00:12<00:00,  5.17it/s]\n",
+      "Train: Loss=0.1913 Batch_id=6249 Accuracy=91.85: 100%|██████████| 6250/6250 [07:58<00:00, 13.06it/s]\n",
+      "Test: Loss=0.1952 Batch_id=62 Accuracy=91.44: 100%|██████████| 63/63 [00:12<00:00,  4.95it/s]\n",
+      "Train: Loss=0.1904 Batch_id=6249 Accuracy=91.90: 100%|██████████| 6250/6250 [07:48<00:00, 13.33it/s]\n",
+      "Test: Loss=0.2019 Batch_id=62 Accuracy=91.35: 100%|██████████| 63/63 [00:12<00:00,  5.04it/s]\n",
+      "Train: Loss=0.1890 Batch_id=6249 Accuracy=91.96: 100%|██████████| 6250/6250 [08:00<00:00, 13.00it/s]\n",
+      "Test: Loss=0.1956 Batch_id=62 Accuracy=91.28: 100%|██████████| 63/63 [00:12<00:00,  4.91it/s]\n",
+      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x432 with 3 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Train: Loss=0.1884 Batch_id=6249 Accuracy=91.99: 100%|██████████| 6250/6250 [08:00<00:00, 13.00it/s]\n",
+      "Test: Loss=0.1949 Batch_id=62 Accuracy=91.43: 100%|██████████| 63/63 [00:13<00:00,  4.66it/s]\n",
+      "Train: Loss=0.1876 Batch_id=6249 Accuracy=92.03: 100%|██████████| 6250/6250 [08:05<00:00, 12.86it/s]\n",
+      "Test: Loss=0.1916 Batch_id=62 Accuracy=91.33: 100%|██████████| 63/63 [00:12<00:00,  5.01it/s]\n",
+      "Train: Loss=0.1870 Batch_id=6249 Accuracy=92.06: 100%|██████████| 6250/6250 [08:03<00:00, 12.91it/s]\n",
+      "Test: Loss=0.1946 Batch_id=62 Accuracy=91.31: 100%|██████████| 63/63 [00:12<00:00,  5.13it/s]\n",
+      "Train: Loss=0.1860 Batch_id=6249 Accuracy=92.11: 100%|██████████| 6250/6250 [08:01<00:00, 12.99it/s]\n",
+      "Test: Loss=0.1945 Batch_id=62 Accuracy=91.33: 100%|██████████| 63/63 [00:12<00:00,  5.08it/s]\n",
+      "Train: Loss=0.1847 Batch_id=6249 Accuracy=92.16: 100%|██████████| 6250/6250 [08:02<00:00, 12.95it/s]\n",
+      "Test: Loss=0.1921 Batch_id=62 Accuracy=91.36: 100%|██████████| 63/63 [00:12<00:00,  4.95it/s]\n",
+      "Train: Loss=0.1846 Batch_id=6249 Accuracy=92.17: 100%|██████████| 6250/6250 [08:02<00:00, 12.95it/s]\n",
+      "Test: Loss=0.1930 Batch_id=62 Accuracy=91.41: 100%|██████████| 63/63 [00:12<00:00,  5.05it/s]\n",
+      "Train: Loss=0.1835 Batch_id=6249 Accuracy=92.21: 100%|██████████| 6250/6250 [07:59<00:00, 13.04it/s]\n",
+      "Test: Loss=0.1921 Batch_id=62 Accuracy=91.35: 100%|██████████| 63/63 [00:12<00:00,  4.97it/s]\n",
+      "Train: Loss=0.1835 Batch_id=6249 Accuracy=92.20: 100%|██████████| 6250/6250 [08:06<00:00, 12.85it/s]\n",
+      "Test: Loss=0.1924 Batch_id=62 Accuracy=91.39: 100%|██████████| 63/63 [00:12<00:00,  4.90it/s]\n",
+      "Train: Loss=0.1826 Batch_id=6249 Accuracy=92.24: 100%|██████████| 6250/6250 [08:06<00:00, 12.86it/s]\n",
+      "Test: Loss=0.1922 Batch_id=62 Accuracy=91.39: 100%|██████████| 63/63 [00:13<00:00,  4.80it/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "from tqdm import tqdm\n",
+    "\n",
+    "\n",
+    "for epoch in range(epochs):\n",
+    "    train(model, train_loader, optimizer, criterion, scheduler, device)\n",
+    "    test(model, test_loader, criterion, device)\n",
+    "\n",
+    "    if epoch % 10 == 0:\n",
+    "        input_tensor, actual_mask = train_dataset[idx]\n",
+    "        infer(\n",
+    "            input_tensor=input_tensor.unsqueeze(0).to(device),\n",
+    "            actual_mask=actual_mask,\n",
+    "            figsize=(12, 6),\n",
+    "        )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "id": "76a1d388-cda4-43af-9225-0adac6f2cb7c",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "UNet(\n",
+       "  (encoder): Encoder(\n",
+       "    (stages): ModuleDict(\n",
+       "      (block1): Sequential(\n",
+       "        (0): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)\n",
+       "        (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "        (2): ReLU(inplace=True)\n",
+       "      )\n",
+       "      (block2): Sequential(\n",
+       "        (0): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n",
+       "        (1): Sequential(\n",
+       "          (0): Bottleneck(\n",
+       "            (conv1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "            (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "            (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+       "            (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "            (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "            (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "            (relu): ReLU(inplace=True)\n",
+       "            (downsample): Sequential(\n",
+       "              (0): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "              (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "            )\n",
+       "          )\n",
+       "          (1): Bottleneck(\n",
+       "            (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "            (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "            (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+       "            (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "            (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "            (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "            (relu): ReLU(inplace=True)\n",
+       "          )\n",
+       "          (2): Bottleneck(\n",
+       "            (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "            (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "            (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+       "            (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "            (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "            (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "            (relu): ReLU(inplace=True)\n",
+       "          )\n",
+       "        )\n",
+       "      )\n",
+       "      (block3): Sequential(\n",
+       "        (0): Bottleneck(\n",
+       "          (conv1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "          (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "          (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
+       "          (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "          (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "          (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "          (relu): ReLU(inplace=True)\n",
+       "          (downsample): Sequential(\n",
+       "            (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
+       "            (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "          )\n",
+       "        )\n",
+       "        (1): Bottleneck(\n",
+       "          (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "          (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "          (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+       "          (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "          (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "          (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "          (relu): ReLU(inplace=True)\n",
+       "        )\n",
+       "        (2): Bottleneck(\n",
+       "          (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "          (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "          (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+       "          (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "          (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "          (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "          (relu): ReLU(inplace=True)\n",
+       "        )\n",
+       "        (3): Bottleneck(\n",
+       "          (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "          (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "          (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+       "          (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "          (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "          (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "          (relu): ReLU(inplace=True)\n",
+       "        )\n",
+       "      )\n",
+       "      (block4): Sequential(\n",
+       "        (0): Bottleneck(\n",
+       "          (conv1): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "          (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "          (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
+       "          (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "          (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "          (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "          (relu): ReLU(inplace=True)\n",
+       "          (downsample): Sequential(\n",
+       "            (0): Conv2d(512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
+       "            (1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "          )\n",
+       "        )\n",
+       "        (1): Bottleneck(\n",
+       "          (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "          (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "          (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+       "          (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "          (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "          (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "          (relu): ReLU(inplace=True)\n",
+       "        )\n",
+       "        (2): Bottleneck(\n",
+       "          (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "          (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "          (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+       "          (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "          (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "          (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "          (relu): ReLU(inplace=True)\n",
+       "        )\n",
+       "        (3): Bottleneck(\n",
+       "          (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "          (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "          (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+       "          (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "          (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "          (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "          (relu): ReLU(inplace=True)\n",
+       "        )\n",
+       "        (4): Bottleneck(\n",
+       "          (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "          (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "          (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+       "          (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "          (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "          (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "          (relu): ReLU(inplace=True)\n",
+       "        )\n",
+       "        (5): Bottleneck(\n",
+       "          (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "          (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "          (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+       "          (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "          (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "          (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "          (relu): ReLU(inplace=True)\n",
+       "        )\n",
+       "      )\n",
+       "      (block5): Sequential(\n",
+       "        (0): Bottleneck(\n",
+       "          (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "          (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "          (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
+       "          (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "          (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "          (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "          (relu): ReLU(inplace=True)\n",
+       "          (downsample): Sequential(\n",
+       "            (0): Conv2d(1024, 2048, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
+       "            (1): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "          )\n",
+       "        )\n",
+       "        (1): Bottleneck(\n",
+       "          (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "          (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "          (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+       "          (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "          (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "          (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "          (relu): ReLU(inplace=True)\n",
+       "        )\n",
+       "        (2): Bottleneck(\n",
+       "          (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "          (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "          (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+       "          (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "          (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "          (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "          (relu): ReLU(inplace=True)\n",
+       "        )\n",
+       "      )\n",
+       "    )\n",
+       "  )\n",
+       "  (decoder): Decoder(\n",
+       "    (decoder): ModuleDict(\n",
+       "      (block4): DecoderLayer(\n",
+       "        (up_conv): ConvTranspose2d(2048, 1024, kernel_size=(2, 2), stride=(2, 2))\n",
+       "        (bn1): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "        (conv): Sequential(\n",
+       "          (0): Sequential(\n",
+       "            (0): Conv2d(2048, 1024, kernel_size=(3, 3), stride=(1, 1))\n",
+       "            (1): ReLU()\n",
+       "            (2): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "          )\n",
+       "          (1): Sequential(\n",
+       "            (0): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(1, 1))\n",
+       "            (1): ReLU()\n",
+       "            (2): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "          )\n",
+       "        )\n",
+       "      )\n",
+       "      (block3): DecoderLayer(\n",
+       "        (up_conv): ConvTranspose2d(1024, 512, kernel_size=(2, 2), stride=(2, 2))\n",
+       "        (bn1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "        (conv): Sequential(\n",
+       "          (0): Sequential(\n",
+       "            (0): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1))\n",
+       "            (1): ReLU()\n",
+       "            (2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "          )\n",
+       "          (1): Sequential(\n",
+       "            (0): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1))\n",
+       "            (1): ReLU()\n",
+       "            (2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "          )\n",
+       "        )\n",
+       "      )\n",
+       "      (block2): DecoderLayer(\n",
+       "        (up_conv): ConvTranspose2d(512, 256, kernel_size=(2, 2), stride=(2, 2))\n",
+       "        (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "        (conv): Sequential(\n",
+       "          (0): Sequential(\n",
+       "            (0): Conv2d(512, 128, kernel_size=(3, 3), stride=(1, 1))\n",
+       "            (1): ReLU()\n",
+       "            (2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "          )\n",
+       "          (1): Sequential(\n",
+       "            (0): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1))\n",
+       "            (1): ReLU()\n",
+       "            (2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "          )\n",
+       "        )\n",
+       "      )\n",
+       "      (block1): DecoderLayer(\n",
+       "        (up_conv): ConvTranspose2d(128, 64, kernel_size=(2, 2), stride=(2, 2))\n",
+       "        (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "        (conv): Sequential(\n",
+       "          (0): Sequential(\n",
+       "            (0): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1))\n",
+       "            (1): ReLU()\n",
+       "            (2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "          )\n",
+       "          (1): Sequential(\n",
+       "            (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1))\n",
+       "            (1): ReLU()\n",
+       "            (2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "          )\n",
+       "        )\n",
+       "      )\n",
+       "    )\n",
+       "  )\n",
+       "  (output): Sequential(\n",
+       "    (0): Conv2d(64, 1, kernel_size=(1, 1), stride=(1, 1))\n",
+       "    (1): UpsamplingBilinear2d(size=224, mode='bilinear')\n",
+       "  )\n",
+       ")"
+      ]
+     },
+     "execution_count": 40,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "id": "056d6fd7-c776-437c-a25c-91215c887a69",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "torch.save(\n",
+    "    {\n",
+    "        \"model_state_dict\": model.state_dict(),\n",
+    "        \"optimizer_state_dict\": optimizer.state_dict(),\n",
+    "    },\n",
+    "    \"./binary_segmentation_checkpoint/model.pt\",\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "id": "2a8108dc-c24f-4066-a3e2-7be2666f2f22",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "torch.save(\n",
+    "    {\n",
+    "        \"decoder_state_dict\": model.decoder.state_dict(),\n",
+    "        \"output_state_dict\": model.output.state_dict(),\n",
+    "    },\n",
+    "    \"./binary_segmentation_checkpoint/decoder.pt\",\n",
+    ")"
+   ]
+  }
+ ],
+ "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.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}