{ "cells": [ { "cell_type": "markdown", "metadata": { "id": "cKui1ohHsWrI" }, "source": [ "##UNet Model Implementation" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "HttqPer8qeCd" }, "outputs": [], "source": [ "import torch\n", "import torch.nn as nn\n", "import torch.nn.functional as F\n", "\n", "class DoubleConv(nn.Module):\n", " def __init__(self, in_channels, out_channels):\n", " super().__init__()\n", " self.conv_op = nn.Sequential(\n", " nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1),\n", " nn.BatchNorm2d(out_channels),\n", " nn.ReLU(inplace=True),\n", " nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1),\n", " nn.BatchNorm2d(out_channels),\n", " nn.ReLU(inplace=True)\n", " )\n", "\n", " def forward(self, x):\n", " return self.conv_op(x)\n", "\n", "class Downsample(nn.Module):\n", " def __init__(self, in_channels, out_channels):\n", " super().__init__()\n", " self.conv = DoubleConv(in_channels, out_channels)\n", " self.pool = nn.MaxPool2d(kernel_size=2, stride=2)\n", "\n", " def forward(self, x):\n", " down = self.conv(x)\n", " p = self.pool(down)\n", " return down, p\n", "\n", "class UpSample(nn.Module):\n", " def __init__(self, in_channels, out_channels):\n", " super().__init__()\n", " self.up = nn.ConvTranspose2d(in_channels, in_channels // 2, kernel_size=2, stride=2)\n", " self.conv = DoubleConv(in_channels, out_channels)\n", "\n", " def forward(self, x1, x2):\n", " x1 = self.up(x1)\n", "\n", " \n", " diffY = x2.size()[2] - x1.size()[2]\n", " diffX = x2.size()[3] - x1.size()[3]\n", " x1 = F.pad(x1, [diffX // 2, diffX - diffX // 2,\n", " diffY // 2, diffY - diffY // 2])\n", "\n", " x = torch.cat([x2, x1], dim=1)\n", " return self.conv(x)\n", "\n", "class UNet(nn.Module):\n", " def __init__(self, in_channels, num_classes):\n", " super().__init__()\n", " self.down1 = Downsample(in_channels, 64)\n", " self.down2 = Downsample(64, 128)\n", " self.down3 = Downsample(128, 256)\n", " self.down4 = Downsample(256, 512)\n", "\n", " self.bottleneck = DoubleConv(512, 1024)\n", "\n", " self.up1 = UpSample(1024, 512)\n", " self.up2 = UpSample(512, 256)\n", " self.up3 = UpSample(256, 128)\n", " self.up4 = UpSample(128, 64)\n", "\n", " self.out = nn.Conv2d(64, num_classes, kernel_size=1)\n", "\n", " def forward(self, x):\n", " d1, p1 = self.down1(x)\n", " d2, p2 = self.down2(p1)\n", " d3, p3 = self.down3(p2)\n", " d4, p4 = self.down4(p3)\n", "\n", " b = self.bottleneck(p4)\n", "\n", " u1 = self.up1(b, d4)\n", " u2 = self.up2(u1, d3)\n", " u3 = self.up3(u2, d2)\n", " u4 = self.up4(u3, d1)\n", "\n", " return self.out(u4)\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "4S4iBMSJqeCd", "outputId": "fbad68dd-9728-46a3-ba44-3da820cf66c0" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "DoubleConv(\n", " (conv_op): Sequential(\n", " (0): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (2): ReLU(inplace=True)\n", " (3): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (4): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (5): ReLU(inplace=True)\n", " )\n", ")\n", "torch.Size([1, 10, 512, 512])\n" ] } ], "source": [ "double_conv=DoubleConv(256,256)\n", "print(double_conv)\n", "input_image=torch.rand((1,3,512,512))\n", "model=UNet(3,10)\n", "output=model(input_image)\n", "print(output.size())" ] }, { "cell_type": "markdown", "metadata": { "id": "Nu5BHzW7smGl" }, "source": [ "##Download Dataset" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "Grlzwc6dOuZN", "outputId": "f343ca67-9efe-4f80-c152-de9da91567ea" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Downloading from https://www.kaggle.com/api/v1/datasets/download/newra008/lung-mask-image-dataset?dataset_version_number=3...\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "100%|██████████| 2.59G/2.59G [00:35<00:00, 78.9MB/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Extracting files...\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Path to dataset files: /root/.cache/kagglehub/datasets/newra008/lung-mask-image-dataset/versions/3\n" ] } ], "source": [ "import kagglehub\n", "\n", "# Download latest version\n", "path = kagglehub.dataset_download(\"newra008/lung-mask-image-dataset\")\n", "\n", "print(\"Path to dataset files:\", path)" ] }, { "cell_type": "markdown", "metadata": { "id": "FBxjF9pzspff" }, "source": [ "##Dataloader" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "kE3PotkUO7qI" }, "outputs": [], "source": [ "import os\n", "from PIL import Image\n", "import torch\n", "from torch.utils.data import Dataset, DataLoader\n", "from torchvision import transforms\n", "\n", "class Data(Dataset):\n", " def __init__(self, root_path, test=False, train=True, val=False, limit_train=5000):\n", " self.root_path = root_path\n", "\n", " if test:\n", " img_dir = os.path.join(root_path, \"ChestXray/test/image\")\n", " mask_dir = os.path.join(root_path, \"ChestXray/test/mask\")\n", "\n", " elif val:\n", " img_dir = os.path.join(root_path, \"ChestXray/val/image\")\n", " mask_dir = os.path.join(root_path, \"ChestXray/val/mask\")\n", "\n", " elif train:\n", " img_dir = os.path.join(root_path, \"ChestXray/train/image\")\n", " mask_dir = os.path.join(root_path, \"ChestXray/train/mask\")\n", "\n", " self.images = sorted([os.path.join(img_dir, i) for i in os.listdir(img_dir)])\n", " self.masks = sorted([os.path.join(mask_dir, i) for i in os.listdir(mask_dir)])\n", "\n", " #Limit training data to 5000\n", " if train and len(self.images) > limit_train:\n", " self.images = self.images[:limit_train]\n", " self.masks = self.masks[:limit_train]\n", "\n", " self.transform = transforms.Compose([\n", " transforms.Resize((150, 150)),\n", " transforms.ToTensor()\n", " ])\n", "\n", " def __getitem__(self, index):\n", " img = Image.open(self.images[index]).convert(\"RGB\")\n", " mask = Image.open(self.masks[index]).convert(\"L\")\n", "\n", " img = self.transform(img)\n", " mask = self.transform(mask)\n", " return img, mask\n", "\n", " def __len__(self):\n", " return len(self.images)\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "EWP1GxzlO7qJ", "outputId": "d877ce69-fe64-43c0-b1ff-4c558bffac49" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Train samples: 5000\n", "Val samples: 2117\n", "Test samples: 2116\n" ] } ], "source": [ "batch_size = 32\n", "data_path = \"/content/ChestXray\"\n", "\n", "train_dataset = Data(root_path=data_path, train=True, limit_train=5000)\n", "val_dataset = Data(root_path=data_path, val=True)\n", "test_dataset = Data(root_path=data_path, test=True)\n", "\n", "train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)\n", "val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False)\n", "test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)\n", "\n", "print(f\"Train samples: {len(train_dataset)}\")\n", "print(f\"Val samples: {len(val_dataset)}\")\n", "print(f\"Test samples: {len(test_dataset)}\")" ] }, { "cell_type": "markdown", "metadata": { "id": "AJOa2pmDsuD9" }, "source": [ "##Training" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "UPFFX7CUux9o", "outputId": "55a46b36-34c1-45f9-ce7f-8dc3e1e1d532" }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Epoch 1/15 [Train]: 100%|██████████| 1250/1250 [03:21<00:00, 6.21it/s]\n", "Epoch 1/15 [Val]: 100%|██████████| 530/530 [00:43<00:00, 12.23it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Epoch [1/15] - Train Loss: 0.0639 | Val Loss: 0.1032\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "Epoch 2/15 [Train]: 100%|██████████| 1250/1250 [03:20<00:00, 6.23it/s]\n", "Epoch 2/15 [Val]: 100%|██████████| 530/530 [00:43<00:00, 12.14it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Epoch [2/15] - Train Loss: 0.0356 | Val Loss: 0.0961\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "Epoch 3/15 [Train]: 100%|██████████| 1250/1250 [03:20<00:00, 6.24it/s]\n", "Epoch 3/15 [Val]: 100%|██████████| 530/530 [00:43<00:00, 12.24it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Epoch [3/15] - Train Loss: 0.0317 | Val Loss: 0.0745\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "Epoch 4/15 [Train]: 100%|██████████| 1250/1250 [03:20<00:00, 6.23it/s]\n", "Epoch 4/15 [Val]: 100%|██████████| 530/530 [00:43<00:00, 12.31it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Epoch [4/15] - Train Loss: 0.0303 | Val Loss: 0.1163\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "Epoch 5/15 [Train]: 100%|██████████| 1250/1250 [03:20<00:00, 6.24it/s]\n", "Epoch 5/15 [Val]: 100%|██████████| 530/530 [00:42<00:00, 12.43it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Epoch [5/15] - Train Loss: 0.0294 | Val Loss: 0.1235\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "Epoch 6/15 [Train]: 100%|██████████| 1250/1250 [03:20<00:00, 6.24it/s]\n", "Epoch 6/15 [Val]: 100%|██████████| 530/530 [00:42<00:00, 12.36it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Epoch [6/15] - Train Loss: 0.0294 | Val Loss: 0.0550\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "Epoch 7/15 [Train]: 100%|██████████| 1250/1250 [03:20<00:00, 6.24it/s]\n", "Epoch 7/15 [Val]: 100%|██████████| 530/530 [00:43<00:00, 12.18it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Epoch [7/15] - Train Loss: 0.0265 | Val Loss: 0.0569\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "Epoch 8/15 [Train]: 100%|██████████| 1250/1250 [03:20<00:00, 6.25it/s]\n", "Epoch 8/15 [Val]: 100%|██████████| 530/530 [00:43<00:00, 12.28it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Epoch [8/15] - Train Loss: 0.0264 | Val Loss: 0.1338\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "Epoch 9/15 [Train]: 100%|██████████| 1250/1250 [03:20<00:00, 6.24it/s]\n", "Epoch 9/15 [Val]: 100%|██████████| 530/530 [00:43<00:00, 12.31it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Epoch [9/15] - Train Loss: 0.0265 | Val Loss: 0.0540\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "Epoch 10/15 [Train]: 100%|██████████| 1250/1250 [03:20<00:00, 6.23it/s]\n", "Epoch 10/15 [Val]: 100%|██████████| 530/530 [00:43<00:00, 12.28it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Epoch [10/15] - Train Loss: 0.0266 | Val Loss: 0.0495\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "Epoch 11/15 [Train]: 100%|██████████| 1250/1250 [03:20<00:00, 6.23it/s]\n", "Epoch 11/15 [Val]: 100%|██████████| 530/530 [00:42<00:00, 12.43it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Epoch [11/15] - Train Loss: 0.0252 | Val Loss: 0.0505\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "Epoch 12/15 [Train]: 100%|██████████| 1250/1250 [03:20<00:00, 6.25it/s]\n", "Epoch 12/15 [Val]: 100%|██████████| 530/530 [00:42<00:00, 12.33it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Epoch [12/15] - Train Loss: 0.0251 | Val Loss: 0.0934\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "Epoch 13/15 [Train]: 100%|██████████| 1250/1250 [03:21<00:00, 6.22it/s]\n", "Epoch 13/15 [Val]: 100%|██████████| 530/530 [00:47<00:00, 11.19it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Epoch [13/15] - Train Loss: 0.0247 | Val Loss: 0.0478\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "Epoch 14/15 [Train]: 100%|██████████| 1250/1250 [03:25<00:00, 6.08it/s]\n", "Epoch 14/15 [Val]: 100%|██████████| 530/530 [00:45<00:00, 11.55it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Epoch [14/15] - Train Loss: 0.0242 | Val Loss: 0.0531\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "Epoch 15/15 [Train]: 100%|██████████| 1250/1250 [03:24<00:00, 6.10it/s]\n", "Epoch 15/15 [Val]: 100%|██████████| 530/530 [00:44<00:00, 11.84it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Epoch [15/15] - Train Loss: 0.0241 | Val Loss: 0.0464\n", "Model saved as unet.pth\n" ] } ], "source": [ "import torch\n", "from torch.utils.data import DataLoader\n", "import torch.optim as optim\n", "import torch.nn as nn\n", "from tqdm import tqdm\n", "\n", "lr = 0.001\n", "epochs = 15\n", "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", "\n", "model = UNet(in_channels=3, num_classes=1).to(device)\n", "criterion = nn.BCEWithLogitsLoss()\n", "optimizer = optim.Adam(model.parameters(), lr=lr)\n", "\n", "for epoch in range(epochs):\n", " model.train()\n", " train_loss = 0.0\n", " for imgs, masks in tqdm(train_loader, desc=f\"Epoch {epoch+1}/{epochs} [Train]\"):\n", " imgs, masks = imgs.to(device), masks.to(device)\n", "\n", " optimizer.zero_grad()\n", " outputs = model(imgs)\n", " loss = criterion(outputs, masks)\n", " loss.backward()\n", " optimizer.step()\n", "\n", " train_loss += loss.item()\n", "\n", " train_loss /= len(train_loader)\n", "\n", "\n", " model.eval()\n", " val_loss = 0.0\n", " with torch.no_grad():\n", " for imgs, masks in tqdm(val_loader, desc=f\"Epoch {epoch+1}/{epochs} [Val]\"):\n", " imgs, masks = imgs.to(device), masks.to(device)\n", " outputs = model(imgs)\n", " loss = criterion(outputs, masks)\n", " val_loss += loss.item()\n", "\n", " val_loss /= len(val_loader)\n", "\n", " print(f\"Epoch [{epoch+1}/{epochs}] - Train Loss: {train_loss:.4f} | Val Loss: {val_loss:.4f}\")\n", "\n", "torch.save(model.state_dict(), \"unet.pth\")\n", "print(\"Model saved as unet.pth\")\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "d0CGdovE31Fp", "outputId": "09dd8151-6707-42e9-f879-699811175362" }, "outputs": [ { "data": { "text/plain": [ "UNet(\n", " (down1): Downsample(\n", " (conv): DoubleConv(\n", " (conv_op): Sequential(\n", " (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (2): ReLU(inplace=True)\n", " (3): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (4): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (5): ReLU(inplace=True)\n", " )\n", " )\n", " (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", " )\n", " (down2): Downsample(\n", " (conv): DoubleConv(\n", " (conv_op): Sequential(\n", " (0): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (2): ReLU(inplace=True)\n", " (3): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (4): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (5): ReLU(inplace=True)\n", " )\n", " )\n", " (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", " )\n", " (down3): Downsample(\n", " (conv): DoubleConv(\n", " (conv_op): Sequential(\n", " (0): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (2): ReLU(inplace=True)\n", " (3): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (4): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (5): ReLU(inplace=True)\n", " )\n", " )\n", " (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", " )\n", " (down4): Downsample(\n", " (conv): DoubleConv(\n", " (conv_op): Sequential(\n", " (0): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (2): ReLU(inplace=True)\n", " (3): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (4): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (5): ReLU(inplace=True)\n", " )\n", " )\n", " (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", " )\n", " (bottleneck): DoubleConv(\n", " (conv_op): Sequential(\n", " (0): Conv2d(512, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (2): ReLU(inplace=True)\n", " (3): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (4): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (5): ReLU(inplace=True)\n", " )\n", " )\n", " (up1): UpSample(\n", " (up): ConvTranspose2d(1024, 512, kernel_size=(2, 2), stride=(2, 2))\n", " (conv): DoubleConv(\n", " (conv_op): Sequential(\n", " (0): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (2): ReLU(inplace=True)\n", " (3): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (4): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (5): ReLU(inplace=True)\n", " )\n", " )\n", " )\n", " (up2): UpSample(\n", " (up): ConvTranspose2d(512, 256, kernel_size=(2, 2), stride=(2, 2))\n", " (conv): DoubleConv(\n", " (conv_op): Sequential(\n", " (0): Conv2d(512, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (2): ReLU(inplace=True)\n", " (3): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (4): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (5): ReLU(inplace=True)\n", " )\n", " )\n", " )\n", " (up3): UpSample(\n", " (up): ConvTranspose2d(256, 128, kernel_size=(2, 2), stride=(2, 2))\n", " (conv): DoubleConv(\n", " (conv_op): Sequential(\n", " (0): Conv2d(256, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (2): ReLU(inplace=True)\n", " (3): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (4): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (5): ReLU(inplace=True)\n", " )\n", " )\n", " )\n", " (up4): UpSample(\n", " (up): ConvTranspose2d(128, 64, kernel_size=(2, 2), stride=(2, 2))\n", " (conv): DoubleConv(\n", " (conv_op): Sequential(\n", " (0): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (2): ReLU(inplace=True)\n", " (3): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (4): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (5): ReLU(inplace=True)\n", " )\n", " )\n", " )\n", " (out): Conv2d(64, 1, kernel_size=(1, 1), stride=(1, 1))\n", ")" ] }, "execution_count": 39, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import torch\n", "import matplotlib.pyplot as plt\n", "\n", "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", "\n", "model = UNet(in_channels=3, num_classes=1).to(device)\n", "model.load_state_dict(torch.load(\"unet.pth\"))\n", "model.eval()" ] }, { "cell_type": "markdown", "metadata": { "id": "JTP_FphjszS3" }, "source": [ "##Visualization" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 1000 }, "id": "VJ9ysV6P4hro", "outputId": "660a9c5c-d8c2-4a99-d87b-2782c11f2067" }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import numpy as np\n", "\n", "def visualize_sample(model, dataloader, num_samples=5):\n", " model.eval()\n", " with torch.no_grad():\n", " for i, (imgs, masks) in enumerate(dataloader):\n", " imgs = imgs.to(device)\n", " preds = model(imgs)\n", " preds = torch.sigmoid(preds)\n", " preds = (preds > 0.5).float()\n", "\n", " imgs = imgs.cpu().numpy()\n", " masks = masks.cpu().numpy()\n", " preds = preds.cpu().numpy()\n", "\n", "\n", " for j in range(min(num_samples, len(imgs))):\n", " plt.figure(figsize=(10, 3))\n", " plt.subplot(1, 3, 1)\n", " plt.imshow(np.transpose(imgs[j], (1, 2, 0)))\n", " plt.title(\"Input Image\")\n", " plt.axis(\"off\")\n", "\n", " plt.subplot(1, 3, 2)\n", " plt.imshow(masks[j][0], cmap=\"gray\")\n", " plt.title(\"Ground Truth Mask\")\n", " plt.axis(\"off\")\n", "\n", " plt.subplot(1, 3, 3)\n", " plt.imshow(preds[j][0], cmap=\"gray\")\n", " plt.title(\"Predicted Mask\")\n", " plt.axis(\"off\")\n", "\n", " plt.show()\n", " break\n", "\n", "\n", "visualize_sample(model, test_loader, num_samples=5)\n" ] }, { "cell_type": "markdown", "metadata": { "id": "ft7cj0MBtPIa" }, "source": [ "##Metrics" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import torch\n", "import numpy as np\n", "\n", "def evaluate_segmentation_metrics(y_pred, y_true, threshold=0.5, eps=1e-7):\n", "\n", " y_pred = torch.sigmoid(y_pred)\n", " y_pred = (y_pred > threshold).float()\n", "\n", " y_true = y_true.float()\n", "\n", " TP = (y_pred * y_true).sum(dim=(1,2,3))\n", " FP = (y_pred * (1 - y_true)).sum(dim=(1,2,3))\n", " FN = ((1 - y_pred) * y_true).sum(dim=(1,2,3))\n", " TN = ((1 - y_pred) * (1 - y_true)).sum(dim=(1,2,3))\n", "\n", " accuracy = (TP + TN) / (TP + TN + FP + FN + eps)\n", " precision = TP / (TP + FP + eps)\n", " recall = TP / (TP + FN + eps)\n", " f1 = 2 * precision * recall / (precision + recall + eps)\n", " iou = TP / (TP + FP + FN + eps)\n", " dice = 2 * TP / (2 * TP + FP + FN + eps)\n", "\n", " return {\n", " \"Accuracy\": accuracy.mean().item(),\n", " \"Precision\": precision.mean().item(),\n", " \"Recall\": recall.mean().item(),\n", " \"F1\": f1.mean().item(),\n", " \"IoU\": iou.mean().item(),\n", " \"Dice\": dice.mean().item()\n", " }\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "yKXYa8AVN8uO", "outputId": "1adf511f-26e2-4f0f-e876-55afe2c2bd53" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Segmentation Model Evaluation:\n", "Accuracy : 0.9899\n", "Precision : 0.9828\n", "Recall : 0.9749\n", "F1 : 0.9788\n", "IoU : 0.9585\n", "Dice : 0.9788\n" ] } ], "source": [ "model.eval()\n", "all_metrics = {\"Accuracy\": [], \"Precision\": [], \"Recall\": [], \"F1\": [], \"IoU\": [], \"Dice\": []}\n", "\n", "with torch.no_grad():\n", " for imgs, masks in test_loader:\n", " imgs, masks = imgs.to(device), masks.to(device)\n", " preds = model(imgs)\n", "\n", " metrics = evaluate_segmentation_metrics(preds, masks)\n", " for key in all_metrics.keys():\n", " all_metrics[key].append(metrics[key])\n", "\n", "for key in all_metrics.keys():\n", " all_metrics[key] = np.mean(all_metrics[key])\n", "\n", "print(\"Segmentation Model Evaluation:\")\n", "for k, v in all_metrics.items():\n", " print(f\"{k:10s}: {v:.4f}\")\n" ] } ], "metadata": { "colab": { "provenance": [] }, "kernelspec": { "display_name": "Python 3", "name": "python3" }, "language_info": { "name": "python" } }, "nbformat": 4, "nbformat_minor": 0 }