diff --git "a/seg_testing.ipynb" "b/seg_testing.ipynb" new file mode 100644--- /dev/null +++ "b/seg_testing.ipynb" @@ -0,0 +1,882 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 22, + "id": "353bacbe-6a28-418d-a983-28016654b47d", + "metadata": {}, + "outputs": [], + "source": [ + "from transformers import AutoFeatureExtractor, SegformerForSemanticSegmentation\n", + "from PIL import Image\n", + "import gradio as gr\n", + "import matplotlib.pyplot as plt\n", + "import torch\n", + "import torch.nn as nn\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "f2fa55ed-a69d-4830-adce-e7dadeedcb1c", + "metadata": { + "scrolled": true, + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\users\\shyam\\onedrive\\documents\\deeplearning\\deep_learn\\lib\\site-packages\\transformers\\models\\segformer\\image_processing_segformer.py:102: FutureWarning: The `reduce_labels` parameter is deprecated and will be removed in a future version. Please use `do_reduce_labels` instead.\n", + " warnings.warn(\n", + "Some weights of the model checkpoint at nvidia/mit-b0 were not used when initializing SegformerForSemanticSegmentation: ['classifier.bias', 'classifier.weight']\n", + "- This IS expected if you are initializing SegformerForSemanticSegmentation from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n", + "- This IS NOT expected if you are initializing SegformerForSemanticSegmentation from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n", + "Some weights of SegformerForSemanticSegmentation were not initialized from the model checkpoint at nvidia/mit-b0 and are newly initialized: ['decode_head.linear_c.2.proj.bias', 'decode_head.linear_fuse.weight', 'decode_head.batch_norm.weight', 'decode_head.linear_c.0.proj.bias', 'decode_head.linear_c.1.proj.bias', 'decode_head.linear_c.0.proj.weight', 'decode_head.linear_c.3.proj.weight', 'decode_head.linear_c.1.proj.weight', 'decode_head.classifier.weight', 'decode_head.linear_c.2.proj.weight', 'decode_head.batch_norm.running_mean', 'decode_head.classifier.bias', 'decode_head.linear_c.3.proj.bias', 'decode_head.batch_norm.bias', 'decode_head.batch_norm.num_batches_tracked', 'decode_head.batch_norm.running_var']\n", + "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SegformerForSemanticSegmentation(\n", + " (segformer): SegformerModel(\n", + " (encoder): SegformerEncoder(\n", + " (patch_embeddings): ModuleList(\n", + " (0): SegformerOverlapPatchEmbeddings(\n", + " (proj): Conv2d(3, 32, kernel_size=(7, 7), stride=(4, 4), padding=(3, 3))\n", + " (layer_norm): LayerNorm((32,), eps=1e-05, elementwise_affine=True)\n", + " )\n", + " (1): SegformerOverlapPatchEmbeddings(\n", + " (proj): Conv2d(32, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n", + " (layer_norm): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n", + " )\n", + " (2): SegformerOverlapPatchEmbeddings(\n", + " (proj): Conv2d(64, 160, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n", + " (layer_norm): LayerNorm((160,), eps=1e-05, elementwise_affine=True)\n", + " )\n", + " (3): SegformerOverlapPatchEmbeddings(\n", + " (proj): Conv2d(160, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n", + " (layer_norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " )\n", + " )\n", + " (block): ModuleList(\n", + " (0): ModuleList(\n", + " (0): SegformerLayer(\n", + " (layer_norm_1): LayerNorm((32,), eps=1e-05, elementwise_affine=True)\n", + " (attention): SegformerAttention(\n", + " (self): SegformerEfficientSelfAttention(\n", + " (query): Linear(in_features=32, out_features=32, bias=True)\n", + " (key): Linear(in_features=32, out_features=32, bias=True)\n", + " (value): Linear(in_features=32, out_features=32, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " (sr): Conv2d(32, 32, kernel_size=(8, 8), stride=(8, 8))\n", + " (layer_norm): LayerNorm((32,), eps=1e-05, elementwise_affine=True)\n", + " )\n", + " (output): SegformerSelfOutput(\n", + " (dense): Linear(in_features=32, out_features=32, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (drop_path): Identity()\n", + " (layer_norm_2): LayerNorm((32,), eps=1e-05, elementwise_affine=True)\n", + " (mlp): SegformerMixFFN(\n", + " (dense1): Linear(in_features=32, out_features=128, bias=True)\n", + " (dwconv): SegformerDWConv(\n", + " (dwconv): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=128)\n", + " )\n", + " (intermediate_act_fn): GELUActivation()\n", + " (dense2): Linear(in_features=128, out_features=32, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (1): SegformerLayer(\n", + " (layer_norm_1): LayerNorm((32,), eps=1e-05, elementwise_affine=True)\n", + " (attention): SegformerAttention(\n", + " (self): SegformerEfficientSelfAttention(\n", + " (query): Linear(in_features=32, out_features=32, bias=True)\n", + " (key): Linear(in_features=32, out_features=32, bias=True)\n", + " (value): Linear(in_features=32, out_features=32, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " (sr): Conv2d(32, 32, kernel_size=(8, 8), stride=(8, 8))\n", + " (layer_norm): LayerNorm((32,), eps=1e-05, elementwise_affine=True)\n", + " )\n", + " (output): SegformerSelfOutput(\n", + " (dense): Linear(in_features=32, out_features=32, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (drop_path): SegformerDropPath(p=0.014285714365541935)\n", + " (layer_norm_2): LayerNorm((32,), eps=1e-05, elementwise_affine=True)\n", + " (mlp): SegformerMixFFN(\n", + " (dense1): Linear(in_features=32, out_features=128, bias=True)\n", + " (dwconv): SegformerDWConv(\n", + " (dwconv): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=128)\n", + " )\n", + " (intermediate_act_fn): GELUActivation()\n", + " (dense2): Linear(in_features=128, out_features=32, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " )\n", + " (1): ModuleList(\n", + " (0): SegformerLayer(\n", + " (layer_norm_1): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n", + " (attention): SegformerAttention(\n", + " (self): SegformerEfficientSelfAttention(\n", + " (query): Linear(in_features=64, out_features=64, bias=True)\n", + " (key): Linear(in_features=64, out_features=64, bias=True)\n", + " (value): Linear(in_features=64, out_features=64, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " (sr): Conv2d(64, 64, kernel_size=(4, 4), stride=(4, 4))\n", + " (layer_norm): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n", + " )\n", + " (output): SegformerSelfOutput(\n", + " (dense): Linear(in_features=64, out_features=64, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (drop_path): SegformerDropPath(p=0.02857142873108387)\n", + " (layer_norm_2): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n", + " (mlp): SegformerMixFFN(\n", + " (dense1): Linear(in_features=64, out_features=256, bias=True)\n", + " (dwconv): SegformerDWConv(\n", + " (dwconv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=256)\n", + " )\n", + " (intermediate_act_fn): GELUActivation()\n", + " (dense2): Linear(in_features=256, out_features=64, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (1): SegformerLayer(\n", + " (layer_norm_1): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n", + " (attention): SegformerAttention(\n", + " (self): SegformerEfficientSelfAttention(\n", + " (query): Linear(in_features=64, out_features=64, bias=True)\n", + " (key): Linear(in_features=64, out_features=64, bias=True)\n", + " (value): Linear(in_features=64, out_features=64, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " (sr): Conv2d(64, 64, kernel_size=(4, 4), stride=(4, 4))\n", + " (layer_norm): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n", + " )\n", + " (output): SegformerSelfOutput(\n", + " (dense): Linear(in_features=64, out_features=64, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (drop_path): SegformerDropPath(p=0.04285714402794838)\n", + " (layer_norm_2): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n", + " (mlp): SegformerMixFFN(\n", + " (dense1): Linear(in_features=64, out_features=256, bias=True)\n", + " (dwconv): SegformerDWConv(\n", + " (dwconv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=256)\n", + " )\n", + " (intermediate_act_fn): GELUActivation()\n", + " (dense2): Linear(in_features=256, out_features=64, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " )\n", + " (2): ModuleList(\n", + " (0): SegformerLayer(\n", + " (layer_norm_1): LayerNorm((160,), eps=1e-05, elementwise_affine=True)\n", + " (attention): SegformerAttention(\n", + " (self): SegformerEfficientSelfAttention(\n", + " (query): Linear(in_features=160, out_features=160, bias=True)\n", + " (key): Linear(in_features=160, out_features=160, bias=True)\n", + " (value): Linear(in_features=160, out_features=160, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " (sr): Conv2d(160, 160, kernel_size=(2, 2), stride=(2, 2))\n", + " (layer_norm): LayerNorm((160,), eps=1e-05, elementwise_affine=True)\n", + " )\n", + " (output): SegformerSelfOutput(\n", + " (dense): Linear(in_features=160, out_features=160, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (drop_path): SegformerDropPath(p=0.05714285746216774)\n", + " (layer_norm_2): LayerNorm((160,), eps=1e-05, elementwise_affine=True)\n", + " (mlp): SegformerMixFFN(\n", + " (dense1): Linear(in_features=160, out_features=640, bias=True)\n", + " (dwconv): SegformerDWConv(\n", + " (dwconv): Conv2d(640, 640, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=640)\n", + " )\n", + " (intermediate_act_fn): GELUActivation()\n", + " (dense2): Linear(in_features=640, out_features=160, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (1): SegformerLayer(\n", + " (layer_norm_1): LayerNorm((160,), eps=1e-05, elementwise_affine=True)\n", + " (attention): SegformerAttention(\n", + " (self): SegformerEfficientSelfAttention(\n", + " (query): Linear(in_features=160, out_features=160, bias=True)\n", + " (key): Linear(in_features=160, out_features=160, bias=True)\n", + " (value): Linear(in_features=160, out_features=160, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " (sr): Conv2d(160, 160, kernel_size=(2, 2), stride=(2, 2))\n", + " (layer_norm): LayerNorm((160,), eps=1e-05, elementwise_affine=True)\n", + " )\n", + " (output): SegformerSelfOutput(\n", + " (dense): Linear(in_features=160, out_features=160, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (drop_path): SegformerDropPath(p=0.0714285746216774)\n", + " (layer_norm_2): LayerNorm((160,), eps=1e-05, elementwise_affine=True)\n", + " (mlp): SegformerMixFFN(\n", + " (dense1): Linear(in_features=160, out_features=640, bias=True)\n", + " (dwconv): SegformerDWConv(\n", + " (dwconv): Conv2d(640, 640, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=640)\n", + " )\n", + " (intermediate_act_fn): GELUActivation()\n", + " (dense2): Linear(in_features=640, out_features=160, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " )\n", + " (3): ModuleList(\n", + " (0): SegformerLayer(\n", + " (layer_norm_1): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (attention): SegformerAttention(\n", + " (self): SegformerEfficientSelfAttention(\n", + " (query): Linear(in_features=256, out_features=256, bias=True)\n", + " (key): Linear(in_features=256, out_features=256, bias=True)\n", + " (value): Linear(in_features=256, out_features=256, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (output): SegformerSelfOutput(\n", + " (dense): Linear(in_features=256, out_features=256, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (drop_path): SegformerDropPath(p=0.08571428805589676)\n", + " (layer_norm_2): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (mlp): SegformerMixFFN(\n", + " (dense1): Linear(in_features=256, out_features=1024, bias=True)\n", + " (dwconv): SegformerDWConv(\n", + " (dwconv): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=1024)\n", + " )\n", + " (intermediate_act_fn): GELUActivation()\n", + " (dense2): Linear(in_features=1024, out_features=256, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (1): SegformerLayer(\n", + " (layer_norm_1): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (attention): SegformerAttention(\n", + " (self): SegformerEfficientSelfAttention(\n", + " (query): Linear(in_features=256, out_features=256, bias=True)\n", + " (key): Linear(in_features=256, out_features=256, bias=True)\n", + " (value): Linear(in_features=256, out_features=256, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (output): SegformerSelfOutput(\n", + " (dense): Linear(in_features=256, out_features=256, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (drop_path): SegformerDropPath(p=0.10000000149011612)\n", + " (layer_norm_2): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (mlp): SegformerMixFFN(\n", + " (dense1): Linear(in_features=256, out_features=1024, bias=True)\n", + " (dwconv): SegformerDWConv(\n", + " (dwconv): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=1024)\n", + " )\n", + " (intermediate_act_fn): GELUActivation()\n", + " (dense2): Linear(in_features=1024, out_features=256, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " )\n", + " )\n", + " (layer_norm): ModuleList(\n", + " (0): LayerNorm((32,), eps=1e-05, elementwise_affine=True)\n", + " (1): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n", + " (2): LayerNorm((160,), eps=1e-05, elementwise_affine=True)\n", + " (3): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " )\n", + " )\n", + " )\n", + " (decode_head): SegformerDecodeHead(\n", + " (linear_c): ModuleList(\n", + " (0): SegformerMLP(\n", + " (proj): Linear(in_features=32, out_features=256, bias=True)\n", + " )\n", + " (1): SegformerMLP(\n", + " (proj): Linear(in_features=64, out_features=256, bias=True)\n", + " )\n", + " (2): SegformerMLP(\n", + " (proj): Linear(in_features=160, out_features=256, bias=True)\n", + " )\n", + " (3): SegformerMLP(\n", + " (proj): Linear(in_features=256, out_features=256, bias=True)\n", + " )\n", + " )\n", + " (linear_fuse): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (batch_norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (activation): ReLU()\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " (classifier): Conv2d(256, 1000, kernel_size=(1, 1), stride=(1, 1))\n", + " )\n", + ")\n" + ] + } + ], + "source": [ + "\n", + "\n", + "image = Image.open('me.jpg')\n", + "\n", + "feature_extractor = AutoFeatureExtractor.from_pretrained(\"nvidia/mit-b0\")\n", + "model = SegformerForSemanticSegmentation.from_pretrained(\"nvidia/mit-b0\")\n", + "print(model)\n", + "\n", + "inputs = feature_extractor(images=image, return_tensors=\"pt\")\n", + "outputs = model(**inputs)\n", + "logits = outputs.logits\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "67acd889-6b2a-4e04-939f-b02afbe8e154", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# The ADE20k dataset consists of 150 classes, so the list below has 150 elements.\n", + "\n", + "def ade_palette():\n", + " \"\"\"ADE20K palette that maps each class to RGB values.\"\"\"\n", + " return [[120, 120, 120], [180, 120, 120], [6, 230, 230], [80, 50, 50],\n", + " [4, 200, 3], [120, 120, 80], [140, 140, 140], [204, 5, 255],\n", + " [230, 230, 230], [4, 250, 7], [224, 5, 255], [235, 255, 7],\n", + " [150, 5, 61], [120, 120, 70], [8, 255, 51], [255, 6, 82],\n", + " [143, 255, 140], [204, 255, 4], [255, 51, 7], [204, 70, 3],\n", + " [0, 102, 200], [61, 230, 250], [255, 6, 51], [11, 102, 255],\n", + " [255, 7, 71], [255, 9, 224], [9, 7, 230], [220, 220, 220],\n", + " [255, 9, 92], [112, 9, 255], [8, 255, 214], [7, 255, 224],\n", + " [255, 184, 6], [10, 255, 71], [255, 41, 10], [7, 255, 255],\n", + " [224, 255, 8], [102, 8, 255], [255, 61, 6], [255, 194, 7],\n", + " [255, 122, 8], [0, 255, 20], [255, 8, 41], [255, 5, 153],\n", + " [6, 51, 255], [235, 12, 255], [160, 150, 20], [0, 163, 255],\n", + " [140, 140, 140], [250, 10, 15], [20, 255, 0], [31, 255, 0],\n", + " [255, 31, 0], [255, 224, 0], [153, 255, 0], [0, 0, 255],\n", + " [255, 71, 0], [0, 235, 255], [0, 173, 255], [31, 0, 255],\n", + " [11, 200, 200], [255, 82, 0], [0, 255, 245], [0, 61, 255],\n", + " [0, 255, 112], [0, 255, 133], [255, 0, 0], [255, 163, 0],\n", + " [255, 102, 0], [194, 255, 0], [0, 143, 255], [51, 255, 0],\n", + " [0, 82, 255], [0, 255, 41], [0, 255, 173], [10, 0, 255],\n", + " [173, 255, 0], [0, 255, 153], [255, 92, 0], [255, 0, 255],\n", + " [255, 0, 245], [255, 0, 102], [255, 173, 0], [255, 0, 20],\n", + " [255, 184, 184], [0, 31, 255], [0, 255, 61], [0, 71, 255],\n", + " [255, 0, 204], [0, 255, 194], [0, 255, 82], [0, 10, 255],\n", + " [0, 112, 255], [51, 0, 255], [0, 194, 255], [0, 122, 255],\n", + " [0, 255, 163], [255, 153, 0], [0, 255, 10], [255, 112, 0],\n", + " [143, 255, 0], [82, 0, 255], [163, 255, 0], [255, 235, 0],\n", + " [8, 184, 170], [133, 0, 255], [0, 255, 92], [184, 0, 255],\n", + " [255, 0, 31], [0, 184, 255], [0, 214, 255], [255, 0, 112],\n", + " [92, 255, 0], [0, 224, 255], [112, 224, 255], [70, 184, 160],\n", + " [163, 0, 255], [153, 0, 255], [71, 255, 0], [255, 0, 163],\n", + " [255, 204, 0], [255, 0, 143], [0, 255, 235], [133, 255, 0],\n", + " [255, 0, 235], [245, 0, 255], [255, 0, 122], [255, 245, 0],\n", + " [10, 190, 212], [214, 255, 0], [0, 204, 255], [20, 0, 255],\n", + " [255, 255, 0], [0, 153, 255], [0, 41, 255], [0, 255, 204],\n", + " [41, 0, 255], [41, 255, 0], [173, 0, 255], [0, 245, 255],\n", + " [71, 0, 255], [122, 0, 255], [0, 255, 184], [0, 92, 255],\n", + " [184, 255, 0], [0, 133, 255], [255, 214, 0], [25, 194, 194],\n", + " [102, 255, 0], [92, 0, 255]]\n", + "\n", + "## The model outputs logits of shape (batch_size, num_labels, height/4, width/4). \n", + "# We first rescale the logits to match the original size of the image using \n", + "# \"bilinear interpolation\". Next, we perform an argmax on the class dimension,\n", + "# and we create a color map which we draw over the image.\n", + "\n", + "# First, rescale logits to original image size\n", + "logits = nn.functional.interpolate(outputs.logits.detach().cpu(),\n", + " size=image.size[::-1], # (height, width)\n", + " mode='bilinear',\n", + " align_corners=False)\n", + "# Second, apply argmax on the class dimension\n", + "seg = logits.argmax(dim=1)[0]\n", + "color_seg = np.zeros((seg.shape[0], seg.shape[1], 3), dtype=np.uint8) # height, width, 3\n", + "palette = np.array(ade_palette())\n", + "for label, color in enumerate(palette):\n", + " color_seg[seg == label, :] = color\n", + "# Convert to BGR\n", + "color_seg = color_seg[..., ::-1]\n", + "\n", + "# Show image + mask\n", + "img = np.array(image) * 0.5 + color_seg * 0.5\n", + "img = img.astype(np.uint8)\n", + "\n", + "plt.figure(figsize=(15, 10))\n", + "plt.imshow(img)\n", + "plt.show()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "38e332f3-ce70-4169-bbbf-01e71d4eaccb", + "metadata": { + "scrolled": true, + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\users\\shyam\\onedrive\\documents\\deeplearning\\deep_learn\\lib\\site-packages\\transformers\\models\\segformer\\image_processing_segformer.py:102: FutureWarning: The `reduce_labels` parameter is deprecated and will be removed in a future version. Please use `do_reduce_labels` instead.\n", + " warnings.warn(\n", + "Some weights of the model checkpoint at nvidia/mit-b0 were not used when initializing SegformerForSemanticSegmentation: ['classifier.bias', 'classifier.weight']\n", + "- This IS expected if you are initializing SegformerForSemanticSegmentation from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n", + "- This IS NOT expected if you are initializing SegformerForSemanticSegmentation from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n", + "Some weights of SegformerForSemanticSegmentation were not initialized from the model checkpoint at nvidia/mit-b0 and are newly initialized: ['decode_head.linear_c.2.proj.bias', 'decode_head.linear_fuse.weight', 'decode_head.batch_norm.weight', 'decode_head.linear_c.0.proj.bias', 'decode_head.linear_c.1.proj.bias', 'decode_head.linear_c.0.proj.weight', 'decode_head.linear_c.3.proj.weight', 'decode_head.linear_c.1.proj.weight', 'decode_head.classifier.weight', 'decode_head.linear_c.2.proj.weight', 'decode_head.batch_norm.running_mean', 'decode_head.classifier.bias', 'decode_head.linear_c.3.proj.bias', 'decode_head.batch_norm.bias', 'decode_head.batch_norm.num_batches_tracked', 'decode_head.batch_norm.running_var']\n", + "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SegformerForSemanticSegmentation(\n", + " (segformer): SegformerModel(\n", + " (encoder): SegformerEncoder(\n", + " (patch_embeddings): ModuleList(\n", + " (0): SegformerOverlapPatchEmbeddings(\n", + " (proj): Conv2d(3, 32, kernel_size=(7, 7), stride=(4, 4), padding=(3, 3))\n", + " (layer_norm): LayerNorm((32,), eps=1e-05, elementwise_affine=True)\n", + " )\n", + " (1): SegformerOverlapPatchEmbeddings(\n", + " (proj): Conv2d(32, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n", + " (layer_norm): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n", + " )\n", + " (2): SegformerOverlapPatchEmbeddings(\n", + " (proj): Conv2d(64, 160, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n", + " (layer_norm): LayerNorm((160,), eps=1e-05, elementwise_affine=True)\n", + " )\n", + " (3): SegformerOverlapPatchEmbeddings(\n", + " (proj): Conv2d(160, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n", + " (layer_norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " )\n", + " )\n", + " (block): ModuleList(\n", + " (0): ModuleList(\n", + " (0): SegformerLayer(\n", + " (layer_norm_1): LayerNorm((32,), eps=1e-05, elementwise_affine=True)\n", + " (attention): SegformerAttention(\n", + " (self): SegformerEfficientSelfAttention(\n", + " (query): Linear(in_features=32, out_features=32, bias=True)\n", + " (key): Linear(in_features=32, out_features=32, bias=True)\n", + " (value): Linear(in_features=32, out_features=32, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " (sr): Conv2d(32, 32, kernel_size=(8, 8), stride=(8, 8))\n", + " (layer_norm): LayerNorm((32,), eps=1e-05, elementwise_affine=True)\n", + " )\n", + " (output): SegformerSelfOutput(\n", + " (dense): Linear(in_features=32, out_features=32, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (drop_path): Identity()\n", + " (layer_norm_2): LayerNorm((32,), eps=1e-05, elementwise_affine=True)\n", + " (mlp): SegformerMixFFN(\n", + " (dense1): Linear(in_features=32, out_features=128, bias=True)\n", + " (dwconv): SegformerDWConv(\n", + " (dwconv): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=128)\n", + " )\n", + " (intermediate_act_fn): GELUActivation()\n", + " (dense2): Linear(in_features=128, out_features=32, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (1): SegformerLayer(\n", + " (layer_norm_1): LayerNorm((32,), eps=1e-05, elementwise_affine=True)\n", + " (attention): SegformerAttention(\n", + " (self): SegformerEfficientSelfAttention(\n", + " (query): Linear(in_features=32, out_features=32, bias=True)\n", + " (key): Linear(in_features=32, out_features=32, bias=True)\n", + " (value): Linear(in_features=32, out_features=32, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " (sr): Conv2d(32, 32, kernel_size=(8, 8), stride=(8, 8))\n", + " (layer_norm): LayerNorm((32,), eps=1e-05, elementwise_affine=True)\n", + " )\n", + " (output): SegformerSelfOutput(\n", + " (dense): Linear(in_features=32, out_features=32, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (drop_path): SegformerDropPath(p=0.014285714365541935)\n", + " (layer_norm_2): LayerNorm((32,), eps=1e-05, elementwise_affine=True)\n", + " (mlp): SegformerMixFFN(\n", + " (dense1): Linear(in_features=32, out_features=128, bias=True)\n", + " (dwconv): SegformerDWConv(\n", + " (dwconv): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=128)\n", + " )\n", + " (intermediate_act_fn): GELUActivation()\n", + " (dense2): Linear(in_features=128, out_features=32, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " )\n", + " (1): ModuleList(\n", + " (0): SegformerLayer(\n", + " (layer_norm_1): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n", + " (attention): SegformerAttention(\n", + " (self): SegformerEfficientSelfAttention(\n", + " (query): Linear(in_features=64, out_features=64, bias=True)\n", + " (key): Linear(in_features=64, out_features=64, bias=True)\n", + " (value): Linear(in_features=64, out_features=64, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " (sr): Conv2d(64, 64, kernel_size=(4, 4), stride=(4, 4))\n", + " (layer_norm): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n", + " )\n", + " (output): SegformerSelfOutput(\n", + " (dense): Linear(in_features=64, out_features=64, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (drop_path): SegformerDropPath(p=0.02857142873108387)\n", + " (layer_norm_2): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n", + " (mlp): SegformerMixFFN(\n", + " (dense1): Linear(in_features=64, out_features=256, bias=True)\n", + " (dwconv): SegformerDWConv(\n", + " (dwconv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=256)\n", + " )\n", + " (intermediate_act_fn): GELUActivation()\n", + " (dense2): Linear(in_features=256, out_features=64, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (1): SegformerLayer(\n", + " (layer_norm_1): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n", + " (attention): SegformerAttention(\n", + " (self): SegformerEfficientSelfAttention(\n", + " (query): Linear(in_features=64, out_features=64, bias=True)\n", + " (key): Linear(in_features=64, out_features=64, bias=True)\n", + " (value): Linear(in_features=64, out_features=64, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " (sr): Conv2d(64, 64, kernel_size=(4, 4), stride=(4, 4))\n", + " (layer_norm): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n", + " )\n", + " (output): SegformerSelfOutput(\n", + " (dense): Linear(in_features=64, out_features=64, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (drop_path): SegformerDropPath(p=0.04285714402794838)\n", + " (layer_norm_2): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n", + " (mlp): SegformerMixFFN(\n", + " (dense1): Linear(in_features=64, out_features=256, bias=True)\n", + " (dwconv): SegformerDWConv(\n", + " (dwconv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=256)\n", + " )\n", + " (intermediate_act_fn): GELUActivation()\n", + " (dense2): Linear(in_features=256, out_features=64, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " )\n", + " (2): ModuleList(\n", + " (0): SegformerLayer(\n", + " (layer_norm_1): LayerNorm((160,), eps=1e-05, elementwise_affine=True)\n", + " (attention): SegformerAttention(\n", + " (self): SegformerEfficientSelfAttention(\n", + " (query): Linear(in_features=160, out_features=160, bias=True)\n", + " (key): Linear(in_features=160, out_features=160, bias=True)\n", + " (value): Linear(in_features=160, out_features=160, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " (sr): Conv2d(160, 160, kernel_size=(2, 2), stride=(2, 2))\n", + " (layer_norm): LayerNorm((160,), eps=1e-05, elementwise_affine=True)\n", + " )\n", + " (output): SegformerSelfOutput(\n", + " (dense): Linear(in_features=160, out_features=160, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (drop_path): SegformerDropPath(p=0.05714285746216774)\n", + " (layer_norm_2): LayerNorm((160,), eps=1e-05, elementwise_affine=True)\n", + " (mlp): SegformerMixFFN(\n", + " (dense1): Linear(in_features=160, out_features=640, bias=True)\n", + " (dwconv): SegformerDWConv(\n", + " (dwconv): Conv2d(640, 640, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=640)\n", + " )\n", + " (intermediate_act_fn): GELUActivation()\n", + " (dense2): Linear(in_features=640, out_features=160, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (1): SegformerLayer(\n", + " (layer_norm_1): LayerNorm((160,), eps=1e-05, elementwise_affine=True)\n", + " (attention): SegformerAttention(\n", + " (self): SegformerEfficientSelfAttention(\n", + " (query): Linear(in_features=160, out_features=160, bias=True)\n", + " (key): Linear(in_features=160, out_features=160, bias=True)\n", + " (value): Linear(in_features=160, out_features=160, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " (sr): Conv2d(160, 160, kernel_size=(2, 2), stride=(2, 2))\n", + " (layer_norm): LayerNorm((160,), eps=1e-05, elementwise_affine=True)\n", + " )\n", + " (output): SegformerSelfOutput(\n", + " (dense): Linear(in_features=160, out_features=160, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (drop_path): SegformerDropPath(p=0.0714285746216774)\n", + " (layer_norm_2): LayerNorm((160,), eps=1e-05, elementwise_affine=True)\n", + " (mlp): SegformerMixFFN(\n", + " (dense1): Linear(in_features=160, out_features=640, bias=True)\n", + " (dwconv): SegformerDWConv(\n", + " (dwconv): Conv2d(640, 640, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=640)\n", + " )\n", + " (intermediate_act_fn): GELUActivation()\n", + " (dense2): Linear(in_features=640, out_features=160, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " )\n", + " (3): ModuleList(\n", + " (0): SegformerLayer(\n", + " (layer_norm_1): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (attention): SegformerAttention(\n", + " (self): SegformerEfficientSelfAttention(\n", + " (query): Linear(in_features=256, out_features=256, bias=True)\n", + " (key): Linear(in_features=256, out_features=256, bias=True)\n", + " (value): Linear(in_features=256, out_features=256, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (output): SegformerSelfOutput(\n", + " (dense): Linear(in_features=256, out_features=256, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (drop_path): SegformerDropPath(p=0.08571428805589676)\n", + " (layer_norm_2): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (mlp): SegformerMixFFN(\n", + " (dense1): Linear(in_features=256, out_features=1024, bias=True)\n", + " (dwconv): SegformerDWConv(\n", + " (dwconv): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=1024)\n", + " )\n", + " (intermediate_act_fn): GELUActivation()\n", + " (dense2): Linear(in_features=1024, out_features=256, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (1): SegformerLayer(\n", + " (layer_norm_1): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (attention): SegformerAttention(\n", + " (self): SegformerEfficientSelfAttention(\n", + " (query): Linear(in_features=256, out_features=256, bias=True)\n", + " (key): Linear(in_features=256, out_features=256, bias=True)\n", + " (value): Linear(in_features=256, out_features=256, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (output): SegformerSelfOutput(\n", + " (dense): Linear(in_features=256, out_features=256, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (drop_path): SegformerDropPath(p=0.10000000149011612)\n", + " (layer_norm_2): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (mlp): SegformerMixFFN(\n", + " (dense1): Linear(in_features=256, out_features=1024, bias=True)\n", + " (dwconv): SegformerDWConv(\n", + " (dwconv): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=1024)\n", + " )\n", + " (intermediate_act_fn): GELUActivation()\n", + " (dense2): Linear(in_features=1024, out_features=256, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " )\n", + " )\n", + " (layer_norm): ModuleList(\n", + " (0): LayerNorm((32,), eps=1e-05, elementwise_affine=True)\n", + " (1): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n", + " (2): LayerNorm((160,), eps=1e-05, elementwise_affine=True)\n", + " (3): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " )\n", + " )\n", + " )\n", + " (decode_head): SegformerDecodeHead(\n", + " (linear_c): ModuleList(\n", + " (0): SegformerMLP(\n", + " (proj): Linear(in_features=32, out_features=256, bias=True)\n", + " )\n", + " (1): SegformerMLP(\n", + " (proj): Linear(in_features=64, out_features=256, bias=True)\n", + " )\n", + " (2): SegformerMLP(\n", + " (proj): Linear(in_features=160, out_features=256, bias=True)\n", + " )\n", + " (3): SegformerMLP(\n", + " (proj): Linear(in_features=256, out_features=256, bias=True)\n", + " )\n", + " )\n", + " (linear_fuse): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (batch_norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (activation): ReLU()\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " (classifier): Conv2d(256, 1000, kernel_size=(1, 1), stride=(1, 1))\n", + " )\n", + ")\n" + ] + } + ], + "source": [ + "\n", + "\n", + "image = Image.open('dog.jpg')\n", + "image.resize((200,200))\n", + "feature_extractor = AutoFeatureExtractor.from_pretrained(\"nvidia/mit-b0\")\n", + "model = SegformerForSemanticSegmentation.from_pretrained(\"nvidia/mit-b0\")\n", + "print(model)\n", + "\n", + "inputs = feature_extractor(images=image, return_tensors=\"pt\")\n", + "outputs = model(**inputs)\n", + "logits = outputs.logits\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "0573af30-c1e3-42a6-b9eb-5fc600aeb6a0", + "metadata": {}, + "outputs": [ + { + "ename": "RuntimeError", + "evalue": "[enforce fail at C:\\actions-runner\\_work\\pytorch\\pytorch\\builder\\windows\\pytorch\\c10\\core\\impl\\alloc_cpu.cpp:81] data. DefaultCPUAllocator: not enough memory: you tried to allocate 11198464000 bytes.", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mRuntimeError\u001b[0m Traceback (most recent call last)", + "Input \u001b[1;32mIn [27]\u001b[0m, in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 5\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m [[\u001b[38;5;241m120\u001b[39m, \u001b[38;5;241m120\u001b[39m, \u001b[38;5;241m120\u001b[39m], [\u001b[38;5;241m180\u001b[39m, \u001b[38;5;241m120\u001b[39m, \u001b[38;5;241m120\u001b[39m], [\u001b[38;5;241m6\u001b[39m, \u001b[38;5;241m230\u001b[39m, \u001b[38;5;241m230\u001b[39m], [\u001b[38;5;241m80\u001b[39m, \u001b[38;5;241m50\u001b[39m, \u001b[38;5;241m50\u001b[39m],\n\u001b[0;32m 6\u001b[0m [\u001b[38;5;241m4\u001b[39m, \u001b[38;5;241m200\u001b[39m, \u001b[38;5;241m3\u001b[39m], [\u001b[38;5;241m120\u001b[39m, \u001b[38;5;241m120\u001b[39m, \u001b[38;5;241m80\u001b[39m], [\u001b[38;5;241m140\u001b[39m, \u001b[38;5;241m140\u001b[39m, \u001b[38;5;241m140\u001b[39m], [\u001b[38;5;241m204\u001b[39m, \u001b[38;5;241m5\u001b[39m, \u001b[38;5;241m255\u001b[39m],\n\u001b[0;32m 7\u001b[0m [\u001b[38;5;241m230\u001b[39m, \u001b[38;5;241m230\u001b[39m, \u001b[38;5;241m230\u001b[39m], [\u001b[38;5;241m4\u001b[39m, \u001b[38;5;241m250\u001b[39m, \u001b[38;5;241m7\u001b[39m], [\u001b[38;5;241m224\u001b[39m, \u001b[38;5;241m5\u001b[39m, \u001b[38;5;241m255\u001b[39m], [\u001b[38;5;241m235\u001b[39m, \u001b[38;5;241m255\u001b[39m, \u001b[38;5;241m7\u001b[39m],\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 41\u001b[0m [\u001b[38;5;241m184\u001b[39m, \u001b[38;5;241m255\u001b[39m, \u001b[38;5;241m0\u001b[39m], [\u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m133\u001b[39m, \u001b[38;5;241m255\u001b[39m], [\u001b[38;5;241m255\u001b[39m, \u001b[38;5;241m214\u001b[39m, \u001b[38;5;241m0\u001b[39m], [\u001b[38;5;241m25\u001b[39m, \u001b[38;5;241m194\u001b[39m, \u001b[38;5;241m194\u001b[39m],\n\u001b[0;32m 42\u001b[0m [\u001b[38;5;241m102\u001b[39m, \u001b[38;5;241m255\u001b[39m, \u001b[38;5;241m0\u001b[39m], [\u001b[38;5;241m92\u001b[39m, \u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m255\u001b[39m]]\n\u001b[0;32m 44\u001b[0m \u001b[38;5;66;03m## The model outputs logits of shape (batch_size, num_labels, height/4, width/4). \u001b[39;00m\n\u001b[0;32m 45\u001b[0m \u001b[38;5;66;03m# We first rescale the logits to match the original size of the image using \u001b[39;00m\n\u001b[0;32m 46\u001b[0m \u001b[38;5;66;03m# \"bilinear interpolation\". Next, we perform an argmax on the class dimension,\u001b[39;00m\n\u001b[0;32m 47\u001b[0m \u001b[38;5;66;03m# and we create a color map which we draw over the image.\u001b[39;00m\n\u001b[0;32m 48\u001b[0m \n\u001b[0;32m 49\u001b[0m \u001b[38;5;66;03m# First, rescale logits to original image size\u001b[39;00m\n\u001b[1;32m---> 50\u001b[0m logits \u001b[38;5;241m=\u001b[39m \u001b[43mnn\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfunctional\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minterpolate\u001b[49m\u001b[43m(\u001b[49m\u001b[43moutputs\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlogits\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdetach\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcpu\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 51\u001b[0m \u001b[43m \u001b[49m\u001b[43msize\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mimage\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msize\u001b[49m\u001b[43m[\u001b[49m\u001b[43m:\u001b[49m\u001b[43m:\u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;66;43;03m# (height, width)\u001b[39;49;00m\n\u001b[0;32m 52\u001b[0m \u001b[43m \u001b[49m\u001b[43mmode\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mbilinear\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[0;32m 53\u001b[0m \u001b[43m \u001b[49m\u001b[43malign_corners\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[0;32m 54\u001b[0m \u001b[38;5;66;03m# Second, apply argmax on the class dimension\u001b[39;00m\n\u001b[0;32m 55\u001b[0m seg \u001b[38;5;241m=\u001b[39m logits\u001b[38;5;241m.\u001b[39margmax(dim\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m)[\u001b[38;5;241m0\u001b[39m]\n", + "File \u001b[1;32mc:\\users\\shyam\\onedrive\\documents\\deeplearning\\deep_learn\\lib\\site-packages\\torch\\nn\\functional.py:3919\u001b[0m, in \u001b[0;36minterpolate\u001b[1;34m(input, size, scale_factor, mode, align_corners, recompute_scale_factor, antialias)\u001b[0m\n\u001b[0;32m 3917\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m antialias:\n\u001b[0;32m 3918\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m torch\u001b[38;5;241m.\u001b[39m_C\u001b[38;5;241m.\u001b[39m_nn\u001b[38;5;241m.\u001b[39m_upsample_bilinear2d_aa(\u001b[38;5;28minput\u001b[39m, output_size, align_corners, scale_factors)\n\u001b[1;32m-> 3919\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mtorch\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_C\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_nn\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mupsample_bilinear2d\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43moutput_size\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43malign_corners\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mscale_factors\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 3920\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28minput\u001b[39m\u001b[38;5;241m.\u001b[39mdim() \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m5\u001b[39m \u001b[38;5;129;01mand\u001b[39;00m mode \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mtrilinear\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n\u001b[0;32m 3921\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m align_corners \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n", + "\u001b[1;31mRuntimeError\u001b[0m: [enforce fail at C:\\actions-runner\\_work\\pytorch\\pytorch\\builder\\windows\\pytorch\\c10\\core\\impl\\alloc_cpu.cpp:81] data. DefaultCPUAllocator: not enough memory: you tried to allocate 11198464000 bytes." + ] + } + ], + "source": [ + "# The ADE20k dataset consists of 150 classes, so the list below has 150 elements.\n", + "\n", + "def ade_palette():\n", + " \"\"\"ADE20K palette that maps each class to RGB values.\"\"\"\n", + " return [[120, 120, 120], [180, 120, 120], [6, 230, 230], [80, 50, 50],\n", + " [4, 200, 3], [120, 120, 80], [140, 140, 140], [204, 5, 255],\n", + " [230, 230, 230], [4, 250, 7], [224, 5, 255], [235, 255, 7],\n", + " [150, 5, 61], [120, 120, 70], [8, 255, 51], [255, 6, 82],\n", + " [143, 255, 140], [204, 255, 4], [255, 51, 7], [204, 70, 3],\n", + " [0, 102, 200], [61, 230, 250], [255, 6, 51], [11, 102, 255],\n", + " [255, 7, 71], [255, 9, 224], [9, 7, 230], [220, 220, 220],\n", + " [255, 9, 92], [112, 9, 255], [8, 255, 214], [7, 255, 224],\n", + " [255, 184, 6], [10, 255, 71], [255, 41, 10], [7, 255, 255],\n", + " [224, 255, 8], [102, 8, 255], [255, 61, 6], [255, 194, 7],\n", + " [255, 122, 8], [0, 255, 20], [255, 8, 41], [255, 5, 153],\n", + " [6, 51, 255], [235, 12, 255], [160, 150, 20], [0, 163, 255],\n", + " [140, 140, 140], [250, 10, 15], [20, 255, 0], [31, 255, 0],\n", + " [255, 31, 0], [255, 224, 0], [153, 255, 0], [0, 0, 255],\n", + " [255, 71, 0], [0, 235, 255], [0, 173, 255], [31, 0, 255],\n", + " [11, 200, 200], [255, 82, 0], [0, 255, 245], [0, 61, 255],\n", + " [0, 255, 112], [0, 255, 133], [255, 0, 0], [255, 163, 0],\n", + " [255, 102, 0], [194, 255, 0], [0, 143, 255], [51, 255, 0],\n", + " [0, 82, 255], [0, 255, 41], [0, 255, 173], [10, 0, 255],\n", + " [173, 255, 0], [0, 255, 153], [255, 92, 0], [255, 0, 255],\n", + " [255, 0, 245], [255, 0, 102], [255, 173, 0], [255, 0, 20],\n", + " [255, 184, 184], [0, 31, 255], [0, 255, 61], [0, 71, 255],\n", + " [255, 0, 204], [0, 255, 194], [0, 255, 82], [0, 10, 255],\n", + " [0, 112, 255], [51, 0, 255], [0, 194, 255], [0, 122, 255],\n", + " [0, 255, 163], [255, 153, 0], [0, 255, 10], [255, 112, 0],\n", + " [143, 255, 0], [82, 0, 255], [163, 255, 0], [255, 235, 0],\n", + " [8, 184, 170], [133, 0, 255], [0, 255, 92], [184, 0, 255],\n", + " [255, 0, 31], [0, 184, 255], [0, 214, 255], [255, 0, 112],\n", + " [92, 255, 0], [0, 224, 255], [112, 224, 255], [70, 184, 160],\n", + " [163, 0, 255], [153, 0, 255], [71, 255, 0], [255, 0, 163],\n", + " [255, 204, 0], [255, 0, 143], [0, 255, 235], [133, 255, 0],\n", + " [255, 0, 235], [245, 0, 255], [255, 0, 122], [255, 245, 0],\n", + " [10, 190, 212], [214, 255, 0], [0, 204, 255], [20, 0, 255],\n", + " [255, 255, 0], [0, 153, 255], [0, 41, 255], [0, 255, 204],\n", + " [41, 0, 255], [41, 255, 0], [173, 0, 255], [0, 245, 255],\n", + " [71, 0, 255], [122, 0, 255], [0, 255, 184], [0, 92, 255],\n", + " [184, 255, 0], [0, 133, 255], [255, 214, 0], [25, 194, 194],\n", + " [102, 255, 0], [92, 0, 255]]\n", + "\n", + "## The model outputs logits of shape (batch_size, num_labels, height/4, width/4). \n", + "# We first rescale the logits to match the original size of the image using \n", + "# \"bilinear interpolation\". Next, we perform an argmax on the class dimension,\n", + "# and we create a color map which we draw over the image.\n", + "\n", + "# First, rescale logits to original image size\n", + "logits = nn.functional.interpolate(outputs.logits.detach().cpu(),\n", + " size=image.size[::-1], # (height, width)\n", + " mode='bilinear',\n", + " align_corners=False)\n", + "# Second, apply argmax on the class dimension\n", + "seg = logits.argmax(dim=1)[0]\n", + "color_seg = np.zeros((seg.shape[0], seg.shape[1], 3), dtype=np.uint8) # height, width, 3\n", + "palette = np.array(ade_palette())\n", + "for label, color in enumerate(palette):\n", + " color_seg[seg == label, :] = color\n", + "# Convert to BGR\n", + "color_seg = color_seg[..., ::-1]\n", + "\n", + "# Show image + mask\n", + "img = np.array(image) * 0.5 + color_seg * 0.5\n", + "img = img.astype(np.uint8)\n", + "\n", + "plt.figure(figsize=(15, 10))\n", + "plt.imshow(img)\n", + "plt.show()\n", + "\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": {}, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}