PyTorch-CustomUNetSegmentation.ipynb

{"cells":[{"cell_type":"markdown","metadata":{"id":"sFTurKkMrpD2"},"source":["# Hopefully final notebook for semantic segmentation component"]},{"cell_type":"code","source":["# install nondefault colab libraries\n","!pip install datasets torchinfo torchmetrics datasets[vision]"],"metadata":{"id":"kjiTYIphuKan","executionInfo":{"status":"ok","timestamp":1700141898706,"user_tz":-330,"elapsed":5742,"user":{"displayName":"Anand Chauhan","userId":"12250269168455404130"}},"outputId":"605a6494-72e7-4d6f-ae7b-5bfe2e507b54","colab":{"base_uri":"https://localhost:8080/"}},"execution_count":1,"outputs":[{"output_type":"stream","name":"stdout","text":["Requirement already satisfied: datasets in /usr/local/lib/python3.10/dist-packages (2.15.0)\n","Requirement already satisfied: torchinfo in /usr/local/lib/python3.10/dist-packages (1.8.0)\n","Requirement already satisfied: torchmetrics in /usr/local/lib/python3.10/dist-packages (1.2.0)\n","Requirement already satisfied: numpy>=1.17 in /usr/local/lib/python3.10/dist-packages (from datasets) (1.23.5)\n","Requirement already satisfied: pyarrow>=8.0.0 in /usr/local/lib/python3.10/dist-packages (from datasets) (9.0.0)\n","Requirement already satisfied: pyarrow-hotfix in /usr/local/lib/python3.10/dist-packages (from datasets) (0.5)\n","Requirement already satisfied: dill<0.3.8,>=0.3.0 in /usr/local/lib/python3.10/dist-packages (from datasets) (0.3.7)\n","Requirement already satisfied: pandas in /usr/local/lib/python3.10/dist-packages (from datasets) (1.5.3)\n","Requirement already satisfied: requests>=2.19.0 in /usr/local/lib/python3.10/dist-packages (from datasets) (2.31.0)\n","Requirement already satisfied: tqdm>=4.62.1 in /usr/local/lib/python3.10/dist-packages (from datasets) (4.66.1)\n","Requirement already satisfied: xxhash in /usr/local/lib/python3.10/dist-packages (from datasets) (3.4.1)\n","Requirement already satisfied: multiprocess in /usr/local/lib/python3.10/dist-packages (from datasets) (0.70.15)\n","Requirement already satisfied: fsspec[http]<=2023.10.0,>=2023.1.0 in /usr/local/lib/python3.10/dist-packages (from datasets) (2023.6.0)\n","Requirement already satisfied: aiohttp in /usr/local/lib/python3.10/dist-packages (from datasets) (3.8.6)\n","Requirement already satisfied: huggingface-hub>=0.18.0 in /usr/local/lib/python3.10/dist-packages (from datasets) (0.19.3)\n","Requirement already satisfied: packaging in /usr/local/lib/python3.10/dist-packages (from datasets) (23.2)\n","Requirement already satisfied: pyyaml>=5.1 in /usr/local/lib/python3.10/dist-packages (from datasets) (6.0.1)\n","Requirement already satisfied: torch>=1.8.1 in /usr/local/lib/python3.10/dist-packages (from torchmetrics) (2.1.0+cu118)\n","Requirement already satisfied: lightning-utilities>=0.8.0 in /usr/local/lib/python3.10/dist-packages (from torchmetrics) (0.9.0)\n","Requirement already satisfied: Pillow>=6.2.1 in /usr/local/lib/python3.10/dist-packages (from datasets) (9.4.0)\n","Requirement already satisfied: attrs>=17.3.0 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasets) (23.1.0)\n","Requirement already satisfied: charset-normalizer<4.0,>=2.0 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasets) (3.3.2)\n","Requirement already satisfied: multidict<7.0,>=4.5 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasets) (6.0.4)\n","Requirement already satisfied: async-timeout<5.0,>=4.0.0a3 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasets) (4.0.3)\n","Requirement already satisfied: yarl<2.0,>=1.0 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasets) (1.9.2)\n","Requirement already satisfied: frozenlist>=1.1.1 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasets) (1.4.0)\n","Requirement already satisfied: aiosignal>=1.1.2 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasets) (1.3.1)\n","Requirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from huggingface-hub>=0.18.0->datasets) (3.13.1)\n","Requirement already satisfied: typing-extensions>=3.7.4.3 in /usr/local/lib/python3.10/dist-packages (from huggingface-hub>=0.18.0->datasets) (4.5.0)\n","Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests>=2.19.0->datasets) (3.4)\n","Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests>=2.19.0->datasets) (2.0.7)\n","Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests>=2.19.0->datasets) (2023.7.22)\n","Requirement already satisfied: sympy in /usr/local/lib/python3.10/dist-packages (from torch>=1.8.1->torchmetrics) (1.12)\n","Requirement already satisfied: networkx in /usr/local/lib/python3.10/dist-packages (from torch>=1.8.1->torchmetrics) (3.2.1)\n","Requirement already satisfied: jinja2 in /usr/local/lib/python3.10/dist-packages (from torch>=1.8.1->torchmetrics) (3.1.2)\n","Requirement already satisfied: triton==2.1.0 in /usr/local/lib/python3.10/dist-packages (from torch>=1.8.1->torchmetrics) (2.1.0)\n","Requirement already satisfied: python-dateutil>=2.8.1 in /usr/local/lib/python3.10/dist-packages (from pandas->datasets) (2.8.2)\n","Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.10/dist-packages (from pandas->datasets) (2023.3.post1)\n","Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.8.1->pandas->datasets) (1.16.0)\n","Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.10/dist-packages (from jinja2->torch>=1.8.1->torchmetrics) (2.1.3)\n","Requirement already satisfied: mpmath>=0.19 in /usr/local/lib/python3.10/dist-packages (from sympy->torch>=1.8.1->torchmetrics) (1.3.0)\n"]}]},{"cell_type":"code","execution_count":2,"metadata":{"id":"H2Cd3uLerpD4","executionInfo":{"status":"ok","timestamp":1700141901873,"user_tz":-330,"elapsed":3169,"user":{"displayName":"Anand Chauhan","userId":"12250269168455404130"}},"outputId":"351ca8bb-8787-4ec1-cdb9-89837afe8fbb","colab":{"base_uri":"https://localhost:8080/"}},"outputs":[{"output_type":"execute_result","data":{"text/plain":["True"]},"metadata":{},"execution_count":2}],"source":["# entire code is being run on an Ubuntu kernel.\n","# not many QoL libraries are needed.\n","# your mileage may vary.\n","import os\n","import numpy as np\n","import pandas as pd\n","import matplotlib.pyplot as plt\n","import datetime\n","from tqdm import tqdm\n","%matplotlib inline\n","\n","# dataset imports\n","from datasets import load_dataset\n","from torch.utils.data import Dataset, DataLoader\n","from torchvision.io import read_image\n","from PIL import Image\n","from torchvision.utils import make_grid\n","import torchvision.transforms as transforms\n","from torchvision.transforms.functional import resize\n","\n","# AI imports\n","from torch.nn import ConvTranspose2d, Conv2d, MaxPool2d, Module, ModuleList\n","from torch.nn import Sequential, Softmax, CrossEntropyLoss, ReLU, BatchNorm2d\n","from torch.nn import functional as F\n","from torch.cuda.amp import autocast, GradScaler\n","import torch\n","\n","# statistics\n","from torchinfo import summary\n","import torchmetrics as TM\n","\n","# test if GPU acceleration is working\n","torch.cuda.is_available()"]},{"cell_type":"markdown","metadata":{"id":"wlBPmMjqrpD6"},"source":["## Standard Helper Functions"]},{"cell_type":"code","execution_count":3,"metadata":{"id":"pMvSr18OrpD6","executionInfo":{"status":"ok","timestamp":1700141901873,"user_tz":-330,"elapsed":4,"user":{"displayName":"Anand Chauhan","userId":"12250269168455404130"}},"outputId":"de5ada5b-7b74-4f43-8437-63d061a72b7d","colab":{"base_uri":"https://localhost:8080/"}},"outputs":[{"output_type":"stream","name":"stdout","text":["CUDA: True\n"]}],"source":["def save_model_checkpoint(model, cp_name):\n","    torch.save(model.state_dict(), os.path.join(\"./models/\", cp_name))\n","\n","\n","def get_device():\n","    if torch.cuda.is_available():\n","        return torch.device(\"cuda\")\n","    else:\n","        return torch.device(\"cpu\")\n","\n","\n","# Load model from saved checkpoint\n","def load_model_from_checkpoint(model, ckp_path):\n","    return model.load_state_dict(\n","        torch.load(\n","            ckp_path,\n","            map_location=get_device(),\n","        )\n","    )\n","\n","\n","# Send the Tensor or Model (input argument x) to the right device\n","# for this notebook. i.e. if GPU is enabled, then send to GPU/CUDA\n","# otherwise send to CPU.\n","def to_device(x):\n","    if torch.cuda.is_available():\n","        return x.cuda()\n","    else:\n","        return x.cpu()\n","\n","\n","def get_model_parameters(m):\n","    total_params = sum(param.numel() for param in m.parameters())\n","    return total_params\n","\n","\n","def print_model_parameters(m):\n","    num_model_parameters = get_model_parameters(m)\n","    print(f\"The Model has {num_model_parameters/1e6:.2f}M parameters\")\n","\n","\n","# end if\n","\n","\n","def close_figures():\n","    while len(plt.get_fignums()) > 0:\n","        plt.close()\n","\n","\n","t2img = transforms.ToPILImage()\n","\n","# Validation: Check if CUDA is available\n","print(f\"CUDA: {torch.cuda.is_available()}\")"]},{"cell_type":"markdown","metadata":{"id":"HmCk6EUMrpD7"},"source":["## Dataset Loading and Initialization"]},{"cell_type":"markdown","source":["### all of this was made to run on my local machine, which no longer works due to memory issues."],"metadata":{"id":"cZSXEfDnx9ma"}},{"cell_type":"code","execution_count":4,"metadata":{"id":"TT8wt7E2rpD7","executionInfo":{"status":"ok","timestamp":1700141901873,"user_tz":-330,"elapsed":3,"user":{"displayName":"Anand Chauhan","userId":"12250269168455404130"}}},"outputs":[],"source":["# load in the ade20k pickle file to examine it.\n","root = \"./ade20k/ADEChallengeData2016/\"\n","images_dir = f\"{root}/images\"\n","annotations_dir = f\"{root}/annotations\""]},{"cell_type":"code","execution_count":5,"metadata":{"id":"FiUMIElorpD7","executionInfo":{"status":"ok","timestamp":1700141901873,"user_tz":-330,"elapsed":3,"user":{"displayName":"Anand Chauhan","userId":"12250269168455404130"}}},"outputs":[],"source":["images_training_dir = f\"{images_dir}/training\"\n","annotations_training_dir = f\"{annotations_dir}/training\"\n","\n","images_validation_dir = f\"{images_dir}/validation\"\n","annotations_validation_dir = f\"{annotations_dir}/validation\"\n","\n","# training_images = sorted(os.listdir(images_training_dir))\n","# print(len(training_images))\n","\n","# training_annotations = sorted(os.listdir(annotations_training_dir))\n","# print(len(training_annotations))"]},{"cell_type":"markdown","source":["# Turns out that this dataset is on HuggingFace Datasets, so we'll see where we can go from there"],"metadata":{"id":"EYJGe7vEt1yU"}},{"cell_type":"code","source":["dataset = load_dataset(\"scene_parse_150\")"],"metadata":{"id":"WG4z83tRt1jh","executionInfo":{"status":"ok","timestamp":1700141903832,"user_tz":-330,"elapsed":1961,"user":{"displayName":"Anand Chauhan","userId":"12250269168455404130"}}},"execution_count":6,"outputs":[]},{"cell_type":"code","execution_count":7,"metadata":{"id":"StjOarlurpD7","executionInfo":{"status":"ok","timestamp":1700141903832,"user_tz":-330,"elapsed":8,"user":{"displayName":"Anand Chauhan","userId":"12250269168455404130"}}},"outputs":[],"source":["# custom loader that probably won't be needed anymore\n","class ADE20KDataset(Dataset):\n","    def __init__(self, images_dir, annotations_dir, transforms=None, target_transforms=None):\n","        self.images_dir = images_dir\n","        self.annotations_dir = annotations_dir\n","        self.transforms = transforms\n","        self.target_transforms = target_transforms\n","        self.image_files = sorted(os.listdir(images_dir))\n","        self.mask_files = sorted(os.listdir(annotations_dir))\n","\n","    def __len__(self):\n","        return len(self.image_files)\n","\n","    def __getitem__(self, idx):\n","        image_filename = self.image_files[idx]\n","\n","        img_name = os.path.join(self.images_dir, image_filename)\n","        image = Image.open(img_name).convert(\"RGB\")\n","\n","        # Generate the mask filename based on the image filename\n","        mask_filename = image_filename.replace(\".jpg\", \".png\")\n","        mask_name = os.path.join(self.annotations_dir, mask_filename)\n","\n","        mask = Image.open(mask_name)\n","\n","        if self.transforms:\n","            image = self.transforms(image)\n","        if self.target_transforms:\n","            mask = self.transforms(mask)\n","\n","        return image, mask"]},{"cell_type":"markdown","metadata":{"id":"R9RmXFtIrpD7"},"source":["### DETOUR 1: Find a good size to scale all images to for all models moving forward"]},{"cell_type":"code","execution_count":8,"metadata":{"id":"oY3jhzBSrpD8","executionInfo":{"status":"ok","timestamp":1700141903832,"user_tz":-330,"elapsed":8,"user":{"displayName":"Anand Chauhan","userId":"12250269168455404130"}}},"outputs":[],"source":["# This detour is no longer being run because it takes too much space,\n","# and the result out of it is no longer valid (due to various memory issues),\n","if False:\n","    img_h, img_w = np.zeros((len(training_images))), np.zeros((len(training_images)))\n","    for idx in range(len(training_images)):\n","        timg = read_image(images_training_dir + \"/\" + training_images[idx])\n","        img_h[idx] = timg.shape[1]\n","        img_w[idx] = timg.shape[2]\n","\n","    image_size = pd.DataFrame({\"H\": img_h, \"W\": img_w}, dtype=\"int\")\n","    image_size[\"ratio\"] = image_size[\"H\"] / image_size[\"W\"]\n","    image_size.hist()"]},{"cell_type":"code","execution_count":9,"metadata":{"id":"AikOyX8KrpD8","executionInfo":{"status":"ok","timestamp":1700141903832,"user_tz":-330,"elapsed":7,"user":{"displayName":"Anand Chauhan","userId":"12250269168455404130"}}},"outputs":[],"source":["# Let's see how many samples we will be alienating from the dataset\n","# image_size[image_size[\"H\"] > 768].shape[0] + image_size[image_size[\"W\"] > 768].shape[0]"]},{"cell_type":"code","source":["dataset = dataset\n","train, test, val = dataset[\"train\"].with_format(\"torch\"), dataset[\"test\"].with_format(\"torch\"), dataset[\"validation\"].with_format(\"torch\")\n","train[0], test[0], val[0]"],"metadata":{"id":"ug758ZokvFzm","executionInfo":{"status":"ok","timestamp":1700141903833,"user_tz":-330,"elapsed":8,"user":{"displayName":"Anand Chauhan","userId":"12250269168455404130"}},"outputId":"7e8da0f4-780c-4537-ff8c-25115b6badb2","colab":{"base_uri":"https://localhost:8080/"}},"execution_count":10,"outputs":[{"output_type":"execute_result","data":{"text/plain":["({'image': tensor([[[ 29,  27,  28],\n","           [ 29,  27,  28],\n","           [ 28,  28,  28],\n","           ...,\n","           [137, 119, 159],\n","           [130, 112, 154],\n","           [132, 114, 162]],\n","  \n","          [[ 29,  27,  28],\n","           [ 29,  27,  28],\n","           [ 28,  28,  28],\n","           ...,\n","           [139, 121, 161],\n","           [137, 119, 161],\n","           [142, 125, 170]],\n","  \n","          [[ 29,  27,  28],\n","           [ 29,  27,  28],\n","           [ 28,  28,  28],\n","           ...,\n","           [138, 120, 160],\n","           [140, 122, 164],\n","           [134, 117, 162]],\n","  \n","          ...,\n","  \n","          [[255, 240, 239],\n","           [ 42,  18,  18],\n","           [ 18,   0,   0],\n","           ...,\n","           [110,  59,  40],\n","           [107,  58,  41],\n","           [102,  56,  40]],\n","  \n","          [[255, 249, 248],\n","           [ 50,  26,  26],\n","           [ 26,   0,   1],\n","           ...,\n","           [118,  70,  48],\n","           [122,  76,  53],\n","           [106,  63,  44]],\n","  \n","          [[252, 231, 230],\n","           [ 40,  16,  16],\n","           [ 28,   2,   3],\n","           ...,\n","           [110,  64,  40],\n","           [120,  75,  52],\n","           [105,  63,  41]]], dtype=torch.uint8),\n","  'annotation': tensor([[ 3,  3,  3,  ...,  0,  0,  0],\n","          [ 3,  3,  3,  ...,  0,  0,  0],\n","          [ 3,  3,  3,  ...,  3,  3,  0],\n","          ...,\n","          [ 0,  0, 55,  ..., 55,  0,  0],\n","          [ 0,  0,  0,  ...,  0,  0,  0],\n","          [ 0,  0,  0,  ...,  0,  0,  0]], dtype=torch.uint8),\n","  'scene_category': tensor(873)},\n"," {'image': tensor([[[ 90, 105, 110],\n","           [ 90, 105, 110],\n","           [ 90, 105, 110],\n","           ...,\n","           [135, 152, 180],\n","           [135, 151, 184],\n","           [134, 150, 183]],\n","  \n","          [[ 90, 105, 110],\n","           [ 89, 104, 109],\n","           [ 89, 104, 109],\n","           ...,\n","           [137, 154, 182],\n","           [136, 153, 183],\n","           [136, 152, 185]],\n","  \n","          [[ 90, 103, 109],\n","           [ 90, 103, 109],\n","           [ 90, 103, 109],\n","           ...,\n","           [138, 155, 183],\n","           [138, 155, 185],\n","           [138, 155, 185]],\n","  \n","          ...,\n","  \n","          [[ 56,  43,  27],\n","           [ 53,  40,  24],\n","           [ 51,  37,  24],\n","           ...,\n","           [132, 132, 134],\n","           [ 82,  83,  87],\n","           [128, 129, 133]],\n","  \n","          [[ 54,  40,  27],\n","           [ 51,  37,  24],\n","           [ 48,  34,  23],\n","           ...,\n","           [123, 125, 137],\n","           [ 64,  66,  79],\n","           [ 99, 103, 115]],\n","  \n","          [[ 51,  39,  27],\n","           [ 48,  36,  24],\n","           [ 45,  32,  23],\n","           ...,\n","           [126, 127, 147],\n","           [ 57,  59,  80],\n","           [ 79,  84, 104]]], dtype=torch.uint8),\n","  'annotation': None,\n","  'scene_category': tensor(nan)},\n"," {'image': tensor([[[236, 246, 247],\n","           [236, 246, 247],\n","           [236, 246, 247],\n","           ...,\n","           [255, 255, 255],\n","           [255, 255, 255],\n","           [255, 255, 255]],\n","  \n","          [[236, 246, 247],\n","           [236, 246, 247],\n","           [236, 246, 247],\n","           ...,\n","           [255, 255, 255],\n","           [255, 255, 255],\n","           [255, 255, 255]],\n","  \n","          [[236, 246, 247],\n","           [236, 246, 247],\n","           [236, 246, 247],\n","           ...,\n","           [255, 255, 255],\n","           [255, 255, 255],\n","           [255, 255, 255]],\n","  \n","          ...,\n","  \n","          [[ 41,  41,  43],\n","           [ 42,  42,  44],\n","           [ 44,  44,  46],\n","           ...,\n","           [255, 255, 255],\n","           [255, 255, 255],\n","           [255, 255, 255]],\n","  \n","          [[ 41,  41,  43],\n","           [ 41,  41,  43],\n","           [ 43,  43,  45],\n","           ...,\n","           [255, 254, 255],\n","           [255, 254, 255],\n","           [255, 255, 255]],\n","  \n","          [[ 42,  42,  44],\n","           [ 43,  43,  45],\n","           [ 44,  44,  46],\n","           ...,\n","           [255, 254, 255],\n","           [255, 254, 255],\n","           [255, 254, 255]]], dtype=torch.uint8),\n","  'annotation': tensor([[0, 0, 0,  ..., 0, 0, 0],\n","          [0, 3, 3,  ..., 2, 2, 2],\n","          [0, 3, 3,  ..., 2, 2, 2],\n","          ...,\n","          [0, 7, 7,  ..., 2, 2, 2],\n","          [0, 7, 7,  ..., 2, 2, 2],\n","          [0, 7, 7,  ..., 2, 2, 2]], dtype=torch.uint8),\n","  'scene_category': tensor(927)})"]},"metadata":{},"execution_count":10}]},{"cell_type":"markdown","metadata":{"id":"IAMPMLOrrpD8"},"source":["#### /DETOUR 1"]},{"cell_type":"markdown","metadata":{"id":"Odrum-q0rpD8"},"source":["### create data loaders"]},{"cell_type":"code","execution_count":11,"metadata":{"id":"enJXvFyyrpD8","executionInfo":{"status":"ok","timestamp":1700141903833,"user_tz":-330,"elapsed":8,"user":{"displayName":"Anand Chauhan","userId":"12250269168455404130"}}},"outputs":[],"source":["train_batch = 8\n","val_batch = 4\n","target_size = 384 # for the purposes of segmentation for attention masks we feel\n","                  # higher resolution images are important.\n","\n","imgtransform = transforms.Compose(\n","    [\n","        # transforms.ToPILImage(),\n","        transforms.Resize((target_size)),\n","        transforms.ToTensor(),\n","    ]\n",")\n","\n","msktransform = transforms.Compose(\n","    [\n","        # transforms.ToPILImage(),\n","        transforms.Resize((target_size)),\n","    ]\n",")\n","\n","\n","import torch\n","import torch.nn.functional as F\n","\n","def irregular_image_collate(batch):\n","    inputs, targets = [], []\n","\n","    # Define the resize transform\n","    resize_transform = transforms.Compose([\n","        transforms.ToPILImage(),\n","        transforms.Resize(target_size),\n","        transforms.ToTensor(),\n","    ])\n","\n","    max_height, max_width = 0, 0\n","\n","    for i in batch:\n","        # Apply resize transform to the image\n","        resized_image = resize_transform(i[\"image\"].permute(2, 0, 1))\n","\n","        inputs.append(resized_image)\n","\n","        resized_annotation = resize_transform(i[\"annotation\"].unsqueeze(2).permute(2, 0, 1))\n","        targets.append(resized_annotation)\n","\n","        # Update max height and width\n","        max_height = max(max_height, resized_image.size(1), resized_annotation.size(1))\n","        max_width = max(max_width, resized_image.size(2), resized_annotation.size(2))\n","\n","    # pad each input and target image to the maximum size\n","    padded_inputs = [\n","        F.pad(img, (0, max_width - img.size(2), 0, max_height - img.size(1)))\n","        for img in inputs\n","    ]\n","\n","    padded_targets = [\n","        F.pad(img, (0, max_width - img.size(2), 0, max_height - img.size(1)))\n","        for img in targets\n","    ]\n","\n","    del inputs, targets\n","\n","    # stack the padded inputs and targets to create the batch\n","    padded_inputs = torch.stack(padded_inputs, dim=0)\n","    padded_targets = torch.stack(padded_targets, dim=0)\n","\n","    return padded_inputs, padded_targets\n"]},{"cell_type":"code","execution_count":12,"metadata":{"id":"u2yEObC_rpD8","executionInfo":{"status":"ok","timestamp":1700141903833,"user_tz":-330,"elapsed":7,"user":{"displayName":"Anand Chauhan","userId":"12250269168455404130"}}},"outputs":[],"source":["# make dataloaders for training and testing piplelines\n","train_loader = DataLoader(train, batch_size=train_batch, shuffle=False,\n","                          collate_fn=irregular_image_collate\n","                          )\n","\n","val_loader = DataLoader(val, batch_size=val_batch, shuffle=False,\n","                        collate_fn=irregular_image_collate\n","                        )"]},{"cell_type":"markdown","metadata":{"id":"wnDT4klVrpD9"},"source":["## Test Dataloader"]},{"cell_type":"code","execution_count":13,"metadata":{"id":"11n2yxbbrpD9","executionInfo":{"status":"ok","timestamp":1700141903833,"user_tz":-330,"elapsed":7,"user":{"displayName":"Anand Chauhan","userId":"12250269168455404130"}}},"outputs":[],"source":["def visualize_image_mask(image, mask):\n","    plt.subplot(1, 2, 1)\n","    plt.xticks([])\n","    plt.yticks([])\n","    plt.imshow(\n","        image # .permute(1, 2, 0)\n","    )  # for visualization we have to transpose back to HWC\n","    plt.subplot(1, 2, 2)\n","    # Turn off tick labels\n","    plt.xticks([])\n","    plt.yticks([])\n","    plt.imshow(\n","        mask # .permute(1, 2, 0)\n","    )  # for visualization we have to remove 3rd dimension of mask\n","    plt.show()"]},{"cell_type":"code","execution_count":14,"metadata":{"id":"if0Xqa_QrpD9","executionInfo":{"status":"ok","timestamp":1700141903833,"user_tz":-330,"elapsed":7,"user":{"displayName":"Anand Chauhan","userId":"12250269168455404130"}},"outputId":"896e7ba1-585f-4e63-9e0e-6a341830982c","colab":{"base_uri":"https://localhost:8080/"}},"outputs":[{"output_type":"stream","name":"stdout","text":["torch.Size([480, 753, 3])\n","torch.Size([480, 753])\n"]}],"source":["image = train[0][\"image\"]\n","mask = train[0][\"annotation\"]\n","print(image.shape)\n","print(mask.shape)"]},{"cell_type":"code","execution_count":15,"metadata":{"id":"wT40FkEwrpD9","executionInfo":{"status":"ok","timestamp":1700141905666,"user_tz":-330,"elapsed":1837,"user":{"displayName":"Anand Chauhan","userId":"12250269168455404130"}},"outputId":"227e1e9f-2ab0-445b-937c-d0d8bcb2b37b","colab":{"base_uri":"https://localhost:8080/","height":180}},"outputs":[{"output_type":"display_data","data":{"text/plain":["<Figure size 640x480 with 2 Axes>"],"image/png":"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\n"},"metadata":{}}],"source":["visualize_image_mask(image, mask)"]},{"cell_type":"markdown","metadata":{"id":"vcnoR-O9rpD9"},"source":["## Everything is in order, time to build the model and train it!"]},{"cell_type":"markdown","metadata":{"id":"Au6mG1FprpD9"},"source":["## Model Definition"]},{"cell_type":"code","execution_count":16,"metadata":{"id":"f95k71gfrpD9","executionInfo":{"status":"ok","timestamp":1700141905666,"user_tz":-330,"elapsed":3,"user":{"displayName":"Anand Chauhan","userId":"12250269168455404130"}}},"outputs":[],"source":["class DoubleConv(Module):\n","    def __init__(self, in_channels, out_channels):\n","        super(DoubleConv, self).__init__()\n","        self.conv = Sequential(\n","            Conv2d(in_channels, out_channels, 3, 1, 1, bias=False),\n","            BatchNorm2d(out_channels),\n","            ReLU(inplace=True),\n","            Conv2d(out_channels, out_channels, 3, 1, 1, bias=False),\n","            BatchNorm2d(out_channels),\n","            ReLU(inplace=True),\n","        )\n","\n","    def forward(self, x):\n","        return self.conv(x)\n","\n","class UNet(Module):\n","    def __init__(\n","            self, in_channels=3, out_channels=1, features=[64, 128, 256],\n","    ):\n","        super(UNet, self).__init__()\n","        self.ups = ModuleList()\n","        self.downs = ModuleList()\n","        self.pool = MaxPool2d(kernel_size=2, stride=2)\n","\n","        # Down part of UNET\n","        for feature in features:\n","            self.downs.append(DoubleConv(in_channels, feature))\n","            in_channels = feature\n","\n","        # Up part of UNET\n","        for feature in reversed(features):\n","            self.ups.append(\n","                ConvTranspose2d(\n","                    feature*2, feature, kernel_size=4, stride=2, padding=1, bias=False\n","                )\n","            )\n","            self.ups.append(DoubleConv(feature*2, feature))\n","\n","        self.bottleneck = DoubleConv(features[-1], features[-1]*2)\n","        self.final_conv = Conv2d(features[0], out_channels, kernel_size=3, padding=1)\n","\n","    def forward(self, x):\n","        skip_connections = []\n","\n","        for down in self.downs:\n","            x = down(x)\n","            skip_connections.append(x)\n","            x = self.pool(x)\n","\n","        x = self.bottleneck(x)\n","        skip_connections = skip_connections[::-1]\n","\n","        for idx in range(0, len(self.ups), 2):\n","            x = self.ups[idx](x)\n","            skip_connection = skip_connections[idx//2]\n","\n","            if x.shape != skip_connection.shape:\n","                x = F.interpolate(x, size=skip_connection.shape[2:], mode='bilinear', align_corners=False)\n","\n","            concat_skip = torch.cat((skip_connection, x), dim=1)\n","            x = self.ups[idx+1](concat_skip)\n","\n","        return self.final_conv(x)"]},{"cell_type":"code","execution_count":17,"metadata":{"id":"8vDOdkTYrpD9","executionInfo":{"status":"ok","timestamp":1700141906942,"user_tz":-330,"elapsed":1279,"user":{"displayName":"Anand Chauhan","userId":"12250269168455404130"}}},"outputs":[],"source":["model = UNet(in_channels=3, out_channels=151)\n","if torch.cuda.is_available():\n","    model.cuda()"]},{"cell_type":"code","execution_count":18,"metadata":{"id":"sQrEG07_rpD-","executionInfo":{"status":"ok","timestamp":1700141907409,"user_tz":-330,"elapsed":469,"user":{"displayName":"Anand Chauhan","userId":"12250269168455404130"}},"outputId":"570a6357-6b70-4aad-eb6f-d972988f11f1","colab":{"base_uri":"https://localhost:8080/"}},"outputs":[{"output_type":"stream","name":"stdout","text":["==========================================================================================\n","Layer (type:depth-idx)                   Output Shape              Param #\n","==========================================================================================\n","UNet                                     [8, 151, 384, 384]        --\n","├─ModuleList: 1-5                        --                        (recursive)\n","│    └─DoubleConv: 2-1                   [8, 64, 384, 384]         --\n","│    │    └─Sequential: 3-1              [8, 64, 384, 384]         38,848\n","├─MaxPool2d: 1-2                         [8, 64, 192, 192]         --\n","├─ModuleList: 1-5                        --                        (recursive)\n","│    └─DoubleConv: 2-2                   [8, 128, 192, 192]        --\n","│    │    └─Sequential: 3-2              [8, 128, 192, 192]        221,696\n","├─MaxPool2d: 1-4                         [8, 128, 96, 96]          --\n","├─ModuleList: 1-5                        --                        (recursive)\n","│    └─DoubleConv: 2-3                   [8, 256, 96, 96]          --\n","│    │    └─Sequential: 3-3              [8, 256, 96, 96]          885,760\n","├─MaxPool2d: 1-6                         [8, 256, 48, 48]          --\n","├─DoubleConv: 1-7                        [8, 512, 48, 48]          --\n","│    └─Sequential: 2-4                   [8, 512, 48, 48]          --\n","│    │    └─Conv2d: 3-4                  [8, 512, 48, 48]          1,179,648\n","│    │    └─BatchNorm2d: 3-5             [8, 512, 48, 48]          1,024\n","│    │    └─ReLU: 3-6                    [8, 512, 48, 48]          --\n","│    │    └─Conv2d: 3-7                  [8, 512, 48, 48]          2,359,296\n","│    │    └─BatchNorm2d: 3-8             [8, 512, 48, 48]          1,024\n","│    │    └─ReLU: 3-9                    [8, 512, 48, 48]          --\n","├─ModuleList: 1-8                        --                        --\n","│    └─ConvTranspose2d: 2-5              [8, 256, 96, 96]          2,097,152\n","│    └─DoubleConv: 2-6                   [8, 256, 96, 96]          --\n","│    │    └─Sequential: 3-10             [8, 256, 96, 96]          1,770,496\n","│    └─ConvTranspose2d: 2-7              [8, 128, 192, 192]        524,288\n","│    └─DoubleConv: 2-8                   [8, 128, 192, 192]        --\n","│    │    └─Sequential: 3-11             [8, 128, 192, 192]        442,880\n","│    └─ConvTranspose2d: 2-9              [8, 64, 384, 384]         131,072\n","│    └─DoubleConv: 2-10                  [8, 64, 384, 384]         --\n","│    │    └─Sequential: 3-12             [8, 64, 384, 384]         110,848\n","├─Conv2d: 1-9                            [8, 151, 384, 384]        87,127\n","==========================================================================================\n","Total params: 9,851,159\n","Trainable params: 9,851,159\n","Non-trainable params: 0\n","Total mult-adds (T): 1.20\n","==========================================================================================\n","Input size (MB): 14.16\n","Forward/backward pass size (MB): 5619.84\n","Params size (MB): 39.40\n","Estimated Total Size (MB): 5673.40\n","==========================================================================================\n"]}],"source":["# test model with dummy batch\n","with torch.autocast(device_type=\"cuda\"):\n","    print(summary(model, input_size=(train_batch, 3, target_size, target_size)))"]},{"cell_type":"markdown","metadata":{"id":"Z0ZaHF-4rpD-"},"source":["### IoU Loss Functions"]},{"cell_type":"code","execution_count":19,"metadata":{"id":"zmqgJLPlrpD-","executionInfo":{"status":"ok","timestamp":1700141907409,"user_tz":-330,"elapsed":5,"user":{"displayName":"Anand Chauhan","userId":"12250269168455404130"}},"colab":{"base_uri":"https://localhost:8080/"},"outputId":"e906a2f8-fa2f-4492-be7e-55bae24d2b49"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["tensor(5.6941, device='cuda:0', grad_fn=<NegBackward0>)"]},"metadata":{},"execution_count":19}],"source":["# Define a custom IoU Metric for validating the model.\n","def IoUMetric(pred, gt, softmax=False):\n","    # Run softmax if input is logits.\n","    if softmax is True:\n","        pred = Softmax(dim=1)(pred).to(\"cuda\")\n","\n","    # Add the one-hot encoded masks for all 150 output channels\n","    # (for all the classes) to a tensor named 'gt' (ground truth).\n","    gt = torch.cat([(gt == i) for i in range(151)], dim=1).to(\"cuda\")\n","\n","    intersection = gt * pred\n","    union = gt + pred - intersection\n","\n","    # Compute the sum over all the dimensions except for the batch dimension.\n","    iou = (intersection.sum(dim=(1, 2, 3)) + 0.001) / (union.sum(dim=(1, 2, 3)) + 0.001)\n","\n","    # Compute the mean over the batch dimension.\n","    return iou.mean()\n","\n","\n","class IoULoss(Module):\n","    def __init__(self, softmax=False):\n","        super().__init__()\n","        self.softmax = softmax\n","\n","    # pred => Predictions (logits, B, 3, H, W)\n","    # gt => Ground Truth Labales (B, 1, H, W)\n","    def forward(self, pred, gt):\n","        # return 1.0 - IoUMetric(pred, gt, self.softmax)\n","        # Compute the negative log loss for stable training.\n","        return -(IoUMetric(pred, gt, self.softmax).log())\n","\n","\n","def test_custom_iou_loss():\n","    #               B, C, H, W\n","    x = torch.rand((2, 151, 2, 2), requires_grad=True)\n","    y = torch.randint(0, 3, (2, 1, 2, 2), dtype=torch.long)\n","    z = IoULoss(softmax=True)(x, y)\n","    return z\n","\n","\n","test_custom_iou_loss()"]},{"cell_type":"markdown","metadata":{"id":"nbUge76srpD-"},"source":["## Model Training"]},{"cell_type":"markdown","metadata":{"id":"Q1m9aRPbrpD-"},"source":["### Helper Functions"]},{"cell_type":"code","execution_count":20,"metadata":{"id":"8r2NZTdErpD-","executionInfo":{"status":"ok","timestamp":1700141907409,"user_tz":-330,"elapsed":2,"user":{"displayName":"Anand Chauhan","userId":"12250269168455404130"}}},"outputs":[],"source":["def prediction_accuracy(ground_truth_labels, predicted_labels):\n","    eq = ground_truth_labels == predicted_labels\n","    return eq.sum().item() / predicted_labels.numel()\n","\n","\n","def print_test_dataset_masks(\n","    model, test_targets, test_labels, epoch, save_path, show_plot, batch_size=2, resize_input=None\n","):\n","    model.eval()  # Set the model to evaluation mode\n","    model = model.to(\"cuda\")  # Ensure the model is on the GPU\n","    to_device(model)\n","    model.half()\n","\n","    with torch.no_grad(), autocast():\n","        # Move input tensors to the GPU\n","        selected_targets = test_targets.to(\"cuda\").half()\n","        selected_labels = test_labels.to(\"cuda\").half()\n","\n","        # Evaluation metrics on CPU\n","        iou = TM.classification.MulticlassJaccardIndex(151, average=\"micro\")\n","        pixel_metric = TM.classification.MulticlassAccuracy(151, average=\"micro\")\n","\n","        # Iterate through batches\n","        for i in range(0, selected_targets.size(0), batch_size):\n","            batch_targets = selected_targets[i:i + batch_size]\n","            batch_labels = selected_labels[i:i + batch_size]\n","\n","            # Forward pass\n","            predictions = model(batch_targets)\n","            pred = torch.nn.functional.softmax(predictions, dim=1)\n","            pred_labels = pred.argmax(dim=1).unsqueeze(1).to(torch.float)\n","\n","            # Move predictions and labels to the CPU for metric computation\n","            pred_labels_cpu = pred_labels.cpu()\n","            selected_labels_cpu = batch_labels.cpu()\n","\n","            # Compute metrics\n","            iou_accuracy = iou(pred_labels_cpu, selected_labels_cpu)\n","            pixel_accuracy = pixel_metric(pred_labels_cpu, selected_labels_cpu)\n","            custom_iou = IoUMetric(pred, selected_labels_cpu)\n","\n","            title = f\"Epoch: {epoch:02d}, Accuracy[Pixel: {pixel_accuracy:.4f}, IoU: {iou_accuracy:.4f}, Custom IoU: {custom_iou:.4f}]\"\n","            print(title)\n","\n","    close_figures()\n","\n","    fig = plt.figure(figsize=(10, 6))\n","    fig.suptitle(title, fontsize=12)\n","\n","    # Limit the number of samples to visualize\n","    num_samples = min(batch_size, selected_targets.size(0))\n","\n","    fig.add_subplot(3, 1, 1)\n","    plt.imshow(t2img(make_grid(selected_targets[:num_samples], nrow=num_samples)))\n","    plt.axis(\"off\")\n","    plt.title(\"Targets\")\n","\n","    fig.add_subplot(3, 1, 2)\n","    plt.imshow(t2img(make_grid(selected_labels[:num_samples].float() / 2.0, nrow=num_samples)))\n","    plt.axis(\"off\")\n","    plt.title(\"Ground Truth Labels\")\n","\n","    fig.add_subplot(3, 1, 3)\n","    plt.imshow(t2img(make_grid(pred_labels[:num_samples] / 2.0, nrow=num_samples)))\n","    plt.axis(\"off\")\n","    plt.title(\"Predicted Labels\")\n","\n","    if save_path is not None:\n","        plt.savefig(\n","            os.path.join(save_path, f\"epoch_{epoch:02}.png\"),\n","            format=\"png\",\n","            bbox_inches=\"tight\",\n","            pad_inches=0.4,\n","        )\n","\n","    if not show_plot:\n","        close_figures()\n","    else:\n","        plt.show()"]},{"cell_type":"code","execution_count":21,"metadata":{"id":"1bw7_AG8rpD_","executionInfo":{"status":"ok","timestamp":1700141908283,"user_tz":-330,"elapsed":876,"user":{"displayName":"Anand Chauhan","userId":"12250269168455404130"}}},"outputs":[],"source":["def test_dataset_accuracy(model, loader):\n","    model.eval()\n","    iou = TM.classification.MulticlassJaccardIndex(150, average=\"micro\")\n","    pixel_metric = TM.classification.MulticlassAccuracy(150, average=\"micro\")\n","\n","    iou_accuracies = []\n","    pixel_accuracies = []\n","    custom_iou_accuracies = []\n","\n","    print_model_parameters(model)\n","\n","    inputs, targets = next(iter((loader, 0)))\n","    predictions = model(inputs)\n","    print(predictions[0, 1, :, :])\n","\n","    pred_probabilities = Softmax(dim=1)(predictions)\n","    pred_labels = predictions.argmax(dim=1)\n","\n","    # Add a value 1 dimension at dim=1\n","    pred_labels = pred_labels.unsqueeze(1)\n","    # print(\"pred_labels.shape: {}\".format(pred_labels.shape))\n","    pred_mask = pred_labels.to(torch.float)\n","\n","    iou_accuracy = iou(pred_mask, targets)\n","    # pixel_accuracy = pixel_metric(pred_mask, targets)\n","    pixel_accuracy = pixel_metric(pred_labels, targets)\n","    custom_iou = IoUMetric(pred_probabilities, targets)\n","    iou_accuracies.append(iou_accuracy.item())\n","    pixel_accuracies.append(pixel_accuracy.item())\n","    custom_iou_accuracies.append(custom_iou.item())\n","\n","    del inputs\n","    del targets\n","    del predictions\n","\n","    iou_tensor = torch.FloatTensor(iou_accuracies)\n","    pixel_tensor = torch.FloatTensor(pixel_accuracies)\n","    custom_iou_tensor = torch.FloatTensor(custom_iou_accuracies)\n","\n","    print(\"Test Dataset Accuracy\")\n","    print(\n","        f\"Pixel Accuracy: {pixel_tensor.mean():.4f}, IoU Accuracy: {iou_tensor.mean():.4f}, Custom IoU Accuracy: {custom_iou_tensor.mean():.4f}\"\n","    )"]},{"cell_type":"markdown","metadata":{"id":"7coEXRqxrpD_"},"source":["### DETOUR 2: A little Sanity check"]},{"cell_type":"code","execution_count":22,"metadata":{"id":"VqUgaoZrrpD_","executionInfo":{"status":"ok","timestamp":1700141908283,"user_tz":-330,"elapsed":4,"user":{"displayName":"Anand Chauhan","userId":"12250269168455404130"}}},"outputs":[],"source":["torch.cuda.empty_cache()\n","save_path = os.path.join(\"./logs/\", \"segnet_basic_training_progress_images\")\n","os.makedirs(save_path, exist_ok=True)\n","# train_x, train_y = next(iter(val_loader))\n","# print_test_dataset_masks(\n","#     model, train_x, train_y, epoch=0, save_path=None, show_plot=True, batch_size=4\n","# )"]},{"cell_type":"markdown","metadata":{"id":"48PFidRKrpEA"},"source":["/DETOUR 2"]},{"cell_type":"markdown","metadata":{"id":"9bh6Xso4rpEA"},"source":["### Core training definition"]},{"cell_type":"code","execution_count":23,"metadata":{"id":"GRWEl_EKrpEA","executionInfo":{"status":"ok","timestamp":1700141908283,"user_tz":-330,"elapsed":4,"user":{"displayName":"Anand Chauhan","userId":"12250269168455404130"}}},"outputs":[],"source":["# Optimizer and Learning Rate Scheduler.\n","to_device(model.train())\n","optimizer = torch.optim.Adam(model.parameters(), lr=1e-3, weight_decay=1e-5)\n","scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=7, gamma=0.7)"]},{"cell_type":"code","execution_count":24,"metadata":{"id":"jQjZzMK7rpD-","executionInfo":{"status":"ok","timestamp":1700141908283,"user_tz":-330,"elapsed":4,"user":{"displayName":"Anand Chauhan","userId":"12250269168455404130"}}},"outputs":[],"source":["# Train the model for a single epoch\n","def train_model(model, loader, optimizer, cel=True, epoch=1, gradient_accumulation_steps=2):\n","    to_device(model.train())\n","\n","    if cel:\n","        criterion = CrossEntropyLoss(reduction=\"mean\")\n","    else:\n","        criterion = IoULoss(softmax=True)\n","\n","    scaler = GradScaler()\n","\n","    running_loss = 0.0\n","    running_samples = 0\n","\n","    # Use tqdm to create a progress bar for the training loop\n","    progress_bar = tqdm(enumerate(loader, 1), total=len(loader), desc=f'Epoch {epoch}', dynamic_ncols=True)\n","\n","    for batch_id, (inputs, targets) in progress_bar:\n","        inputs, targets = inputs.half().to(\"cuda\"), targets.to(\"cuda\")\n","\n","        with autocast():\n","            predictions = model(inputs)\n","            if cel:\n","                targets = targets.squeeze(dim=1)\n","                targets = targets.long()\n","            loss = criterion(predictions, targets)\n","\n","            del inputs, predictions\n","            # Scale the loss for gradient accumulation\n","            loss = loss / gradient_accumulation_steps\n","\n","            # Perform backpropagation only every `gradient_accumulation_steps` batches\n","            scaler.scale(loss).backward()\n","\n","            if batch_id % gradient_accumulation_steps == 0:\n","                scaler.step(optimizer)\n","                scaler.update()\n","                optimizer.zero_grad()\n","\n","            running_samples += targets.size(0)\n","            running_loss += loss.item()\n","\n","            del targets\n","        # Display the averaged loss over the entire epoch\n","        if batch_id % gradient_accumulation_steps == 0 or batch_id == len(loader):\n","            progress_bar.set_postfix(loss=f'{running_loss / running_samples:.4f}')\n","\n","        del loss\n","        torch.cuda.empty_cache()\n","\n","    progress_bar.close()\n","\n","    # Release GPU memory explicitly\n","    torch.cuda.empty_cache()\n","\n","    # Move loss calculation to CPU\n","    running_loss /= running_samples\n","\n","    # Clean up\n","    del inputs, targets, predictions, loss"]},{"cell_type":"code","execution_count":25,"metadata":{"id":"mKSWGR2_rpEA","executionInfo":{"status":"ok","timestamp":1700141908283,"user_tz":-330,"elapsed":4,"user":{"displayName":"Anand Chauhan","userId":"12250269168455404130"}}},"outputs":[],"source":["def train_loop(model, loader, test_loader, epochs, optimizer, scheduler, save_path):\n","    epoch_i, epoch_j = epochs\n","\n","    # Move model to GPU and set to training mode\n","    model = model.to(\"cuda\")\n","    to_device(model)\n","    model.train()\n","\n","    # Define metrics and loss function\n","    iou_metric = TM.classification.MulticlassJaccardIndex(151, average=\"micro\")\n","    pixel_metric = TM.classification.MulticlassAccuracy(151, average=\"micro\")\n","    criterion = IoULoss(softmax=True).to(\"cuda\")\n","\n","    for epoch in tqdm(range(epoch_i, epoch_j)):\n","        print(f\"Epoch: {epoch:02d}, Learning Rate: {optimizer.param_groups[0]['lr']}\")\n","\n","        # Training\n","        train_model(model, loader, optimizer, cel=True, epoch=epoch)\n","\n","        # Evaluation\n","        model.eval()\n","        with torch.no_grad(), autocast():\n","            test_inputs, test_targets = next(iter(test_loader))\n","            test_inputs, test_targets = test_inputs.to(\"cuda\").half(), test_targets.to(\"cuda\").half()\n","\n","            # Forward pass\n","            predictions = model(test_inputs)\n","            pred = torch.nn.functional.softmax(predictions, dim=1)\n","            pred_labels = pred.argmax(dim=1).unsqueeze(1).to(torch.float)\n","\n","            # Compute metrics on CPU\n","            iou_accuracy = iou_metric(pred_labels.cpu(), test_targets.cpu())\n","            pixel_accuracy = pixel_metric(pred_labels.cpu(), test_targets.cpu())\n","            custom_iou = IoUMetric(pred, test_targets.cpu())\n","\n","            title = f\"Epoch: {epoch:02d}, Accuracy[Pixel: {pixel_accuracy:.4f}, IoU: {iou_accuracy:.4f}, Custom IoU: {custom_iou:.4f}]\"\n","            print(title)\n","\n","            # Save figures only at the end of training\n","            if epoch == epoch_j - 1:\n","                print_test_dataset_masks(\n","                    model,\n","                    test_inputs,\n","                    test_targets,\n","                    epoch=epoch,\n","                    save_path=save_path,\n","                    show_plot=True,\n","                )\n","\n","        # Learning rate scheduler step\n","        if scheduler is not None:\n","            scheduler.step()\n","\n","        # Release GPU memory explicitly\n","        torch.cuda.empty_cache()\n","\n","        print(\"\")"]},{"cell_type":"code","execution_count":29,"metadata":{"id":"MAvU3BlFrpEB","executionInfo":{"status":"error","timestamp":1700142428826,"user_tz":-330,"elapsed":1800,"user":{"displayName":"Anand Chauhan","userId":"12250269168455404130"}},"colab":{"base_uri":"https://localhost:8080/","height":516},"outputId":"374f3ba9-21d1-470c-e8c4-32b49d10df9e"},"outputs":[{"output_type":"stream","name":"stderr","text":["\r  0%|          | 0/5 [00:00<?, ?it/s]"]},{"output_type":"stream","name":"stdout","text":["Epoch: 01, Learning Rate: 0.001\n"]},{"output_type":"stream","name":"stderr","text":["\n","Epoch 1:   0%|          | 0/2527 [00:00<?, ?it/s]\n","  0%|          | 0/5 [00:00<?, ?it/s]\n"]},{"output_type":"error","ename":"OutOfMemoryError","evalue":"ignored","traceback":["\u001b[0;31m---------------------------------------------------------------------------\u001b[0m","\u001b[0;31mOutOfMemoryError\u001b[0m                          Traceback (most recent call last)","\u001b[0;32m<ipython-input-29-2d50c7662bf4>\u001b[0m in \u001b[0;36m<cell line: 21>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     19\u001b[0m \u001b[0msave_path\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mos\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpath\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjoin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"./logs/\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"model-training-\"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mmodel_timestamp\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     20\u001b[0m \u001b[0mos\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmakedirs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msave_path\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mexist_ok\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 21\u001b[0;31m train_loop(model,\n\u001b[0m\u001b[1;32m     22\u001b[0m     \u001b[0mtrain_loader\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     23\u001b[0m     \u001b[0mval_loader\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m<ipython-input-25-fdfcb605bb87>\u001b[0m in \u001b[0;36mtrain_loop\u001b[0;34m(model, loader, test_loader, epochs, optimizer, scheduler, save_path)\u001b[0m\n\u001b[1;32m     16\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     17\u001b[0m         \u001b[0;31m# Training\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 18\u001b[0;31m         \u001b[0mtrain_model\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mloader\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moptimizer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcel\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mepoch\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mepoch\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     19\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     20\u001b[0m         \u001b[0;31m# Evaluation\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m<ipython-input-24-bd59124244b2>\u001b[0m in \u001b[0;36mtrain_model\u001b[0;34m(model, loader, optimizer, cel, epoch, gradient_accumulation_steps)\u001b[0m\n\u001b[1;32m     20\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     21\u001b[0m         \u001b[0;32mwith\u001b[0m \u001b[0mautocast\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 22\u001b[0;31m             \u001b[0mpredictions\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minputs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     23\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mcel\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     24\u001b[0m                 \u001b[0mtargets\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtargets\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msqueeze\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdim\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m_wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1516\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_compiled_call_impl\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore[misc]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1517\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1518\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_call_impl\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1519\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1520\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m_call_impl\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1525\u001b[0m                 \u001b[0;32mor\u001b[0m \u001b[0m_global_backward_pre_hooks\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0m_global_backward_hooks\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1526\u001b[0m                 or _global_forward_hooks or _global_forward_pre_hooks):\n\u001b[0;32m-> 1527\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mforward_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1528\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1529\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m<ipython-input-16-529221d3df42>\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, x)\u001b[0m\n\u001b[1;32m     59\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     60\u001b[0m             \u001b[0mconcat_skip\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mskip_connection\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdim\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 61\u001b[0;31m             \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mups\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0midx\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconcat_skip\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     62\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     63\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfinal_conv\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m_wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1516\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_compiled_call_impl\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore[misc]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1517\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1518\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_call_impl\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1519\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1520\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m_call_impl\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1525\u001b[0m                 \u001b[0;32mor\u001b[0m \u001b[0m_global_backward_pre_hooks\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0m_global_backward_hooks\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1526\u001b[0m                 or _global_forward_hooks or _global_forward_pre_hooks):\n\u001b[0;32m-> 1527\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mforward_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1528\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1529\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m<ipython-input-16-529221d3df42>\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, x)\u001b[0m\n\u001b[1;32m     12\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconv\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     15\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     16\u001b[0m \u001b[0;32mclass\u001b[0m \u001b[0mUNet\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mModule\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m_wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1516\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_compiled_call_impl\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore[misc]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1517\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1518\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_call_impl\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1519\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1520\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m_call_impl\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1525\u001b[0m                 \u001b[0;32mor\u001b[0m \u001b[0m_global_backward_pre_hooks\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0m_global_backward_hooks\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1526\u001b[0m                 or _global_forward_hooks or _global_forward_pre_hooks):\n\u001b[0;32m-> 1527\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mforward_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1528\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1529\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/nn/modules/container.py\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, input)\u001b[0m\n\u001b[1;32m    213\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    214\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0mmodule\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 215\u001b[0;31m             \u001b[0minput\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodule\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    216\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    217\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m_wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1516\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_compiled_call_impl\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore[misc]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1517\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1518\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_call_impl\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1519\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1520\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m_call_impl\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1525\u001b[0m                 \u001b[0;32mor\u001b[0m \u001b[0m_global_backward_pre_hooks\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0m_global_backward_hooks\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1526\u001b[0m                 or _global_forward_hooks or _global_forward_pre_hooks):\n\u001b[0;32m-> 1527\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mforward_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1528\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1529\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/nn/modules/batchnorm.py\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, input)\u001b[0m\n\u001b[1;32m    169\u001b[0m         \u001b[0mused\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mnormalization\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m \u001b[0;32min\u001b[0m \u001b[0meval\u001b[0m \u001b[0mmode\u001b[0m \u001b[0mwhen\u001b[0m \u001b[0mbuffers\u001b[0m \u001b[0mare\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    170\u001b[0m         \"\"\"\n\u001b[0;32m--> 171\u001b[0;31m         return F.batch_norm(\n\u001b[0m\u001b[1;32m    172\u001b[0m             \u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    173\u001b[0m             \u001b[0;31m# If buffers are not to be tracked, ensure that they won't be updated\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/nn/functional.py\u001b[0m in \u001b[0;36mbatch_norm\u001b[0;34m(input, running_mean, running_var, weight, bias, training, momentum, eps)\u001b[0m\n\u001b[1;32m   2476\u001b[0m         \u001b[0m_verify_batch_size\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msize\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2477\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2478\u001b[0;31m     return torch.batch_norm(\n\u001b[0m\u001b[1;32m   2479\u001b[0m         \u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mweight\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbias\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrunning_mean\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrunning_var\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtraining\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmomentum\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0meps\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackends\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcudnn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0menabled\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2480\u001b[0m     )\n","\u001b[0;31mOutOfMemoryError\u001b[0m: CUDA out of memory. Tried to allocate 76.00 MiB. GPU 0 has a total capacty of 14.75 GiB of which 20.81 MiB is free. Process 752930 has 14.72 GiB memory in use. Of the allocated memory 13.41 GiB is allocated by PyTorch, and 228.89 MiB is reserved by PyTorch but unallocated. If reserved but unallocated memory is large try setting max_split_size_mb to avoid fragmentation.  See documentation for Memory Management and PYTORCH_CUDA_ALLOC_CONF"]}],"source":["# Train our model for a fixed number of epochs, and record the following:\n","#\n","# 1. Training Loss\n","# 2. Test accuracy metrics for a single batch of test images. The following\n","#    metrics are computed:\n","#   2.1. Pixel Accuracy\n","#   2.2. IoU Accuracy (weighted)\n","#   2.3. Custom IoU Accuracy\n","#\n","# We also plot the following for each image in the validation batch:\n","# 1. Input image\n","# 2. Ground truth segmentation mask\n","# 3. Predicted segmentation mask\n","#\n","# so that we can visually inspect the model's progres and determine how well the model\n","# is doing qualitatively.\n","torch.cuda.empty_cache()\n","model_timestamp = datetime.datetime.now().strftime(\"%Y%m%d-%H%M%S\")\n","save_path = os.path.join(\"./logs/\", \"model-training-\" + model_timestamp)\n","os.makedirs(save_path, exist_ok=True)\n","train_loop(model,\n","    train_loader,\n","    val_loader,\n","    (1, 6),\n","    optimizer,\n","    scheduler,\n","    save_path)"]},{"cell_type":"code","execution_count":30,"metadata":{"id":"fswADPH1rpEB","executionInfo":{"status":"ok","timestamp":1700143336458,"user_tz":-330,"elapsed":960,"user":{"displayName":"Anand Chauhan","userId":"12250269168455404130"}}},"outputs":[],"source":["checkpoint = model.state_dict(),\n","checkpoint_timestamp = datetime.datetime.now().strftime(\"%H:%M\")\n","torch.save(checkpoint, f\"./model_{model_timestamp}-checkpoint_{checkpoint_timestamp}.pth\")"]},{"cell_type":"code","source":["print(type(checkpoint))"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"WF13H4O4gC0b","executionInfo":{"status":"ok","timestamp":1700144392238,"user_tz":-330,"elapsed":2,"user":{"displayName":"Anand Chauhan","userId":"12250269168455404130"}},"outputId":"56a89d20-43dc-407a-e1d4-1eb534b832eb"},"execution_count":33,"outputs":[{"output_type":"stream","name":"stdout","text":["<class 'tuple'>\n"]}]}],"metadata":{"kernelspec":{"display_name":"Python 3","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.10.12"},"orig_nbformat":4,"colab":{"provenance":[{"file_id":"https://github.com/projectayre/ayre/blob/vqa/semantic-segmentation/segmentation-ai-experimentation.ipynb","timestamp":1700132472942}],"gpuType":"T4"},"accelerator":"GPU"},"nbformat":4,"nbformat_minor":0}