Skip to content

Instantly share code, notes, and snippets.

@st235

st235/Question 10.ipynb

Last active May 22, 2023 21:31
Show Gist options
  • Save st235/9c39f4e7b8d15b701024dda3d4cfa989 to your computer and use it in GitHub Desktop.
Save st235/9c39f4e7b8d15b701024dda3d4cfa989 to your computer and use it in GitHub Desktop.
Download ZIP
HSE Question 10
Display the source blob
Display the rendered blob
Raw
Question 10.ipynb
{
"cells": [
{
"cell_type": "code",
"execution_count": 1,
"id": "86e5d061",
"metadata": {},
"outputs": [],
"source": [
"import torch\n",
"import os\n",
"import glob\n",
"import os\n",
"\n",
"import cv2\n",
"import numpy as np\n",
"import matplotlib.pyplot as plt\n",
"import torch\n",
"from torch.nn import functional as F\n",
"from PIL import Image\n",
"from torch.utils import data\n",
"import albumentations as Al\n",
"from torch.utils.data import DataLoader\n",
"from torch.utils.data import Dataset as BaseDataset\n",
"from albumentations.pytorch.transforms import ToTensorV2\n",
"from PIL import Image\n",
"import random\n",
"import segmentation_models_pytorch as smp\n",
"from segmentation_models_pytorch.utils import base\n",
"from torch.optim.lr_scheduler import *\n",
"from tqdm import tqdm\n",
"from torch.nn.functional import sigmoid"
]
},
{
"cell_type": "code",
"execution_count": 142,
"id": "0f628923",
"metadata": {},
"outputs": [],
"source": [
"class Segmentation_dataset():\n",
" def __init__(self,\n",
" imgs_path,\n",
" mask_path,\n",
" size=(512,512),\n",
" show = False, \n",
" img = 'jpg',\n",
" mask = '_mask.gif'):\n",
" \n",
" self.imgs_path = imgs_path\n",
" self.mask_path = mask_path\n",
" self.size = size\n",
" self.show = show\n",
" self.img = img\n",
" self.mask = mask\n",
" self.data = []\n",
" \n",
" self.load_imgs(self.imgs_path,self.mask_path)\n",
" \n",
" self.transform_norm = Al.Compose([Al.Normalize(),ToTensorV2() ])\n",
" \n",
" self.transform = Al.Compose([Al.Resize(width=self.size[0],\n",
" height=self.size[1])])\n",
" \n",
" def load_imgs(self,imgs_path,mask_path):\n",
" for path in glob.glob(imgs_path + f'*.{self.img}'):\n",
" bn = os.path.basename(path)[:-4]\n",
" mask_path = self.mask_path +bn +f'{self.mask}'\n",
" \n",
" if os.path.exists(mask_path):\n",
" self.data.append({'img_path':path,\n",
" 'mask_path':mask_path})\n",
" \n",
" def __len__(self):\n",
" return len(self.data)\n",
" \n",
" \n",
" def augs(self,img,mask):\n",
" \n",
" train_transform = self.transform(image=img, mask=mask)\n",
" transformed_image = train_transform[\"image\"]\n",
" transformed_mask = train_transform[\"mask\"]\n",
" \n",
" if self.show:\n",
" return transformed_image,transformed_mask\n",
" \n",
" norm_transform = self.transform_norm(image=transformed_image)\n",
" transformed_image = norm_transform[\"image\"] \n",
" \n",
" transform_mask= torch.tensor(transformed_mask,dtype=torch.float)\n",
" transform_mask = torch.unsqueeze(transform_mask,dim=0)\n",
" \n",
" return transformed_image,transform_mask\n",
" \n",
" def __getitem__(self, index):\n",
" \n",
" img_path = self.data[index]['img_path']\n",
" mask_path = self.data[index]['mask_path']\n",
" \n",
" img = Image.open(img_path)\n",
" mask = Image.open(mask_path)\n",
" \n",
" img = np.array(img,dtype = np.uint8)\n",
" img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)\n",
" mask = np.array(mask,dtype = np.uint8)\n",
" \n",
" transform_img,transform_mask = self.augs(img,mask) \n",
"\n",
" return transform_img,transform_mask\n",
" "
]
},
{
"cell_type": "code",
"execution_count": 143,
"id": "3922905e",
"metadata": {},
"outputs": [],
"source": [
"validation_dataset = Segmentation_dataset(imgs_path = '/semantic_segmentation/val_imgs/',\n",
" mask_path = '/semantic_segmentation/val_mask/',show=False, size=(224, 224))"
]
},
{
"cell_type": "code",
"execution_count": 144,
"id": "463824aa",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Unet(\n",
" (encoder): ResNetEncoder(\n",
" (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)\n",
" (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
" (relu): ReLU(inplace=True)\n",
" (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n",
" (layer1): Sequential(\n",
" (0): BasicBlock(\n",
" (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
" (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
" (relu): ReLU(inplace=True)\n",
" (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
" (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
" )\n",
" (1): BasicBlock(\n",
" (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
" (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
" (relu): ReLU(inplace=True)\n",
" (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
" (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
" )\n",
" )\n",
" (layer2): Sequential(\n",
" (0): BasicBlock(\n",
" (conv1): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
" (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
" (relu): ReLU(inplace=True)\n",
" (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
" (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
" (downsample): Sequential(\n",
" (0): Conv2d(64, 128, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
" (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
" )\n",
" )\n",
" (1): BasicBlock(\n",
" (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
" (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
" (relu): ReLU(inplace=True)\n",
" (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
" (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
" )\n",
" )\n",
" (layer3): Sequential(\n",
" (0): BasicBlock(\n",
" (conv1): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
" (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
" (relu): ReLU(inplace=True)\n",
" (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
" (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
" (downsample): Sequential(\n",
" (0): Conv2d(128, 256, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
" (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
" )\n",
" )\n",
" (1): BasicBlock(\n",
" (conv1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
" (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
" (relu): ReLU(inplace=True)\n",
" (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
" (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
" )\n",
" )\n",
" (layer4): Sequential(\n",
" (0): BasicBlock(\n",
" (conv1): Conv2d(256, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
" (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
" (relu): ReLU(inplace=True)\n",
" (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
" (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
" (downsample): Sequential(\n",
" (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
" (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
" )\n",
" )\n",
" (1): BasicBlock(\n",
" (conv1): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
" (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
" (relu): ReLU(inplace=True)\n",
" (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
" (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
" )\n",
" )\n",
" )\n",
" (decoder): UnetDecoder(\n",
" (center): Identity()\n",
" (blocks): ModuleList(\n",
" (0): DecoderBlock(\n",
" (conv1): Conv2dReLU(\n",
" (0): Conv2d(768, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
" (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
" (2): ReLU(inplace=True)\n",
" )\n",
" (attention1): Attention(\n",
" (attention): Identity()\n",
" )\n",
" (conv2): Conv2dReLU(\n",
" (0): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
" (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
" (2): ReLU(inplace=True)\n",
" )\n",
" (attention2): Attention(\n",
" (attention): Identity()\n",
" )\n",
" )\n",
" (1): DecoderBlock(\n",
" (conv1): Conv2dReLU(\n",
" (0): Conv2d(384, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
" (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
" (2): ReLU(inplace=True)\n",
" )\n",
" (attention1): Attention(\n",
" (attention): Identity()\n",
" )\n",
" (conv2): Conv2dReLU(\n",
" (0): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
" (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
" (2): ReLU(inplace=True)\n",
" )\n",
" (attention2): Attention(\n",
" (attention): Identity()\n",
" )\n",
" )\n",
" (2): DecoderBlock(\n",
" (conv1): Conv2dReLU(\n",
" (0): Conv2d(192, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
" (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
" (2): ReLU(inplace=True)\n",
" )\n",
" (attention1): Attention(\n",
" (attention): Identity()\n",
" )\n",
" (conv2): Conv2dReLU(\n",
" (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
" (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
" (2): ReLU(inplace=True)\n",
" )\n",
" (attention2): Attention(\n",
" (attention): Identity()\n",
" )\n",
" )\n",
" (3): DecoderBlock(\n",
" (conv1): Conv2dReLU(\n",
" (0): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
" (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
" (2): ReLU(inplace=True)\n",
" )\n",
" (attention1): Attention(\n",
" (attention): Identity()\n",
" )\n",
" (conv2): Conv2dReLU(\n",
" (0): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
" (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
" (2): ReLU(inplace=True)\n",
" )\n",
" (attention2): Attention(\n",
" (attention): Identity()\n",
" )\n",
" )\n",
" (4): DecoderBlock(\n",
" (conv1): Conv2dReLU(\n",
" (0): Conv2d(32, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
" (1): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
" (2): ReLU(inplace=True)\n",
" )\n",
" (attention1): Attention(\n",
" (attention): Identity()\n",
" )\n",
" (conv2): Conv2dReLU(\n",
" (0): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
" (1): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
" (2): ReLU(inplace=True)\n",
" )\n",
" (attention2): Attention(\n",
" (attention): Identity()\n",
" )\n",
" )\n",
" )\n",
" )\n",
" (segmentation_head): SegmentationHead(\n",
" (0): Conv2d(16, 1, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
" (1): Identity()\n",
" (2): Activation(\n",
" (activation): Identity()\n",
" )\n",
" )\n",
")"
]
},
"execution_count": 144,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"ENCODER = 'resnet18'\n",
"ENCODER_WEIGHTS = 'imagenet'\n",
"\n",
"DEVICE = 'cpu'\n",
"\n",
"model = smp.Unet(\n",
" encoder_name=ENCODER,\n",
" encoder_weights=ENCODER_WEIGHTS,\n",
" classes=1,\n",
" activation=None,\n",
")\n",
"model.to(DEVICE)\n",
"\n",
"model.load_state_dict(torch.load('/semantic_segmentation/pretrain_models/model_unet_resnet18.pth', map_location=torch.device('cpu')))\n",
"model.eval()"
]
},
{
"cell_type": "code",
"execution_count": 145,
"id": "952f0127",
"metadata": {},
"outputs": [],
"source": [
"valid_loader = DataLoader(validation_dataset, batch_size=1, shuffle=False, num_workers=0)"
]
},
{
"cell_type": "code",
"execution_count": 146,
"id": "607fa79d",
"metadata": {},
"outputs": [],
"source": [
"metrics = [smp.utils.metrics.IoU(threshold=0.5)]"
]
},
{
"cell_type": "code",
"execution_count": 147,
"id": "6b5de62b",
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"100%|███████████████████████████████████████████| 15/15 [00:03<00:00, 4.60it/s]\n"
]
}
],
"source": [
"ious = []\n",
"\n",
"for img, mask in tqdm(valid_loader):\n",
" img, mask = img.to('cpu'), mask.to('cpu') \n",
" out = model(img)\n",
" mask = torch.squeeze(mask, dim=1)\n",
" out = torch.squeeze(out, dim=1) \n",
" out = torch.sigmoid(out)\n",
" \n",
" metric_value_val = metrics[0](mask, out).cpu().detach().numpy()\n",
" ious.append(metric_value_val)"
]
},
{
"cell_type": "code",
"execution_count": 148,
"id": "ff8afa36",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[array(0.9816653, dtype=float32),\n",
" array(0.9807698, dtype=float32),\n",
" array(0.9824133, dtype=float32),\n",
" array(0.9802631, dtype=float32),\n",
" array(0.9821047, dtype=float32),\n",
" array(0.9808246, dtype=float32),\n",
" array(0.9816749, dtype=float32),\n",
" array(0.982649, dtype=float32),\n",
" array(0.979672, dtype=float32),\n",
" array(0.9837074, dtype=float32),\n",
" array(0.98542327, dtype=float32),\n",
" array(0.98311174, dtype=float32),\n",
" array(0.9838708, dtype=float32),\n",
" array(0.9847818, dtype=float32),\n",
" array(0.9822773, dtype=float32)]"
]
},
"execution_count": 148,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"ious"
]
},
{
"cell_type": "code",
"execution_count": 149,
"id": "fdfbd2e4",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"0.98234725"
]
},
"execution_count": 149,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"np.mean(ious) "
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "84e17eeb",
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.9.13"
}
},
"nbformat": 4,
"nbformat_minor": 5
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment