8a.Object_Detection.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/beppe/opt/anaconda3/envs/ptc/lib/python3.9/site-packages/torchvision/io/image.py:11: UserWarning: Failed to load image Python extension: dlopen(/Users/beppe/opt/anaconda3/envs/ptc/lib/python3.9/site-packages/torchvision/image.so, 0x0006): Symbol not found: __ZN2at4_ops19empty_memory_format4callEN3c108ArrayRefIxEENS2_8optionalINS2_10ScalarTypeEEENS5_INS2_6LayoutEEENS5_INS2_6DeviceEEENS5_IbEENS5_INS2_12MemoryFormatEEE\n",
      "  Referenced from: /Users/beppe/opt/anaconda3/envs/ptc/lib/python3.9/site-packages/torchvision/image.so\n",
      "  Expected in: /Users/beppe/opt/anaconda3/envs/ptc/lib/python3.9/site-packages/torch/lib/libtorch_cpu.dylib\n",
      "  warn(f\"Failed to load image Python extension: {e}\")\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch.nn import functional as F\n",
    "import torchvision\n",
    "import cv2\n",
    "\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Anchor Boxes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def draw_grid(input, line_color=(0, 255, 0), thickness=1, type_= cv2.LINE_AA, pxstep=50):\n",
    "    img = input.copy()\n",
    "        \n",
    "    cv2.rectangle(img,(0,0),(img.shape[0]-1,img.shape[1]-1),line_color,thickness)\n",
    "    \n",
    "    x = 0\n",
    "    y = 0\n",
    "    while x < img.shape[1]:\n",
    "        cv2.line(img, (x, 0), (x, img.shape[0]), color=line_color, lineType=type_, thickness=thickness)\n",
    "        x += pxstep\n",
    "\n",
    "    while y < img.shape[0]:\n",
    "        cv2.line(img, (0, y), (img.shape[1], y), color=line_color, lineType=type_, thickness=thickness)\n",
    "        y += pxstep\n",
    "        \n",
    "    return img"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Immagine di esempio"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import cv2\n",
    "\n",
    "\n",
    "img = np.ones((800, 800,3),dtype = 'uint8')*255\n",
    "\n",
    "# [y1, x1, y2, x2] format\n",
    "bbox = [250,550,550,750]\n",
    "\n",
    "x, y = 430,420\n",
    "r = 100\n",
    "\n",
    "\n",
    "cv2.circle(img, (x,y), r, (255, 255, 0),cv2.FILLED)\n",
    "\n",
    "\n",
    "plt.figure(figsize=(10,10))\n",
    "\n",
    "plt.imshow(img)\n",
    "plt.axis('off')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "cv2.rectangle(img, (x-r,y-r), (x+r, y+r), (255, 0, 0),thickness=2)\n",
    "\n",
    "\n",
    "\n",
    "plt.figure(figsize=(10,10))\n",
    "\n",
    "plt.imshow(img)\n",
    "plt.axis('off')\n",
    "plt.show()\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La griglia rappresenta il livello di downsample ottenuto calcolando le feature maps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Downloading: \"https://download.pytorch.org/models/vgg16-397923af.pth\" to /Users/beppe/.cache/torch/hub/checkpoints/vgg16-397923af.pth\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "fa6149dd24024c81b9b26ec9a6aee571",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0.00/528M [00:00<?, ?B/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "model_ft = torchvision.models.vgg16(pretrained=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "VGG(\n",
       "  (features): Sequential(\n",
       "    (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (1): ReLU(inplace=True)\n",
       "    (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (3): ReLU(inplace=True)\n",
       "    (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "    (5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (6): ReLU(inplace=True)\n",
       "    (7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (8): ReLU(inplace=True)\n",
       "    (9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "    (10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (11): ReLU(inplace=True)\n",
       "    (12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (13): ReLU(inplace=True)\n",
       "    (14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (15): ReLU(inplace=True)\n",
       "    (16): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "    (17): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (18): ReLU(inplace=True)\n",
       "    (19): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (20): ReLU(inplace=True)\n",
       "    (21): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (22): ReLU(inplace=True)\n",
       "    (23): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "    (24): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (25): ReLU(inplace=True)\n",
       "    (26): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (27): ReLU(inplace=True)\n",
       "    (28): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (29): ReLU(inplace=True)\n",
       "    (30): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "  )\n",
       "  (avgpool): AdaptiveAvgPool2d(output_size=(7, 7))\n",
       "  (classifier): Sequential(\n",
       "    (0): Linear(in_features=25088, out_features=4096, bias=True)\n",
       "    (1): ReLU(inplace=True)\n",
       "    (2): Dropout(p=0.5, inplace=False)\n",
       "    (3): Linear(in_features=4096, out_features=4096, bias=True)\n",
       "    (4): ReLU(inplace=True)\n",
       "    (5): Dropout(p=0.5, inplace=False)\n",
       "    (6): Linear(in_features=4096, out_features=1000, bias=True)\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model_ft"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_ft = model_ft.features[:-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Sequential(\n",
       "  (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (1): ReLU(inplace=True)\n",
       "  (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (3): ReLU(inplace=True)\n",
       "  (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "  (5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (6): ReLU(inplace=True)\n",
       "  (7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (8): ReLU(inplace=True)\n",
       "  (9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "  (10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (11): ReLU(inplace=True)\n",
       "  (12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (13): ReLU(inplace=True)\n",
       "  (14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (15): ReLU(inplace=True)\n",
       "  (16): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "  (17): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (18): ReLU(inplace=True)\n",
       "  (19): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (20): ReLU(inplace=True)\n",
       "  (21): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (22): ReLU(inplace=True)\n",
       "  (23): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "  (24): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (25): ReLU(inplace=True)\n",
       "  (26): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (27): ReLU(inplace=True)\n",
       "  (28): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (29): ReLU(inplace=True)\n",
       ")"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model_ft"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/beppe/opt/anaconda3/envs/ptc/lib/python3.9/site-packages/torch/nn/functional.py:718: UserWarning: Named tensors and all their associated APIs are an experimental feature and subject to change. Please do not use them for anything important until they are released as stable. (Triggered internally at  /tmp/pip-req-build-accccgfm/c10/core/TensorImpl.h:1156.)\n",
      "  return torch.max_pool2d(input, kernel_size, stride, padding, dilation, ceil_mode)\n"
     ]
    }
   ],
   "source": [
    "input = torch.randn((1,3,800,800))\n",
    "\n",
    "output = model_ft(input)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1, 512, 50, 50])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "output.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(0., grad_fn=<SelectBackward>)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "output[0,0,0,0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(15,15))\n",
    "\n",
    "\n",
    "cell_size = 160\n",
    "\n",
    "img_grid = draw_grid(img,pxstep=cell_size)\n",
    "\n",
    "plt.imshow(img_grid)\n",
    "plt.axis('off')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualizzare gli anchor boxes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generiamo la griglia degli anchor points"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_anchors(img, sub_sample, ratios=[0.5, 1, 2], anchor_scales=[0.5, 1, 2]):\n",
    "    fe_size = [img.shape[0] // sub_sample, img.shape[1] // sub_sample]\n",
    "\n",
    "    ctr_x = np.arange(sub_sample, (fe_size[0] + 1) * sub_sample, sub_sample).astype('int')\n",
    "    ctr_y = np.arange(sub_sample, (fe_size[1] + 1) * sub_sample, sub_sample).astype('int')\n",
    "\n",
    "    ctr = np.zeros((len(ctr_x) * len(ctr_y), 2)).astype('int')\n",
    "        \n",
    "    index = 0\n",
    "    for x in range(len(ctr_x)):\n",
    "        for y in range(len(ctr_y)):\n",
    "            ctr[index, 1] = ctr_x[x] - (sub_sample//2)\n",
    "            ctr[index, 0] = ctr_y[y] - (sub_sample//2)\n",
    "\n",
    "            index += 1\n",
    "\n",
    "    n_of_anchors = len(ratios) * len(anchor_scales)\n",
    "    anchors = np.zeros(((fe_size[0] * fe_size[1] * n_of_anchors), 4)).astype('int')\n",
    "\n",
    "    index = 0\n",
    "\n",
    "    for c_id, c in enumerate(ctr):\n",
    "        ctr_y, ctr_x = c\n",
    "        for i in range(len(ratios)):\n",
    "            for j in range(len(anchor_scales)):\n",
    "                h = sub_sample * anchor_scales[j] * np.sqrt(ratios[i])\n",
    "                w = sub_sample * anchor_scales[j] * np.sqrt(1. / ratios[i])\n",
    "                anchors[index, 0] = ctr_y - h / 2.\n",
    "                anchors[index, 1] = ctr_x - w / 2.\n",
    "                anchors[index, 2] = ctr_y + h / 2.\n",
    "                anchors[index, 3] = ctr_x + w / 2.\n",
    "                index += 1\n",
    "\n",
    "    index_inside = np.where(\n",
    "        (anchors[:, 0] >= 0) &\n",
    "        (anchors[:, 1] >= 0) &\n",
    "        (anchors[:, 2] <= 800) &\n",
    "        (anchors[:, 3] <= 800)\n",
    "    )[0]\n",
    "\n",
    "    return ctr,anchors[index_inside]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "ctr,anchors = generate_anchors(img_grid,cell_size,anchor_scales=[1,2,4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  0,   0,  40,  40],\n",
       "       [ 40,   0,  80,  40],\n",
       "       [ 31,   5,  88,  34],\n",
       "       ...,\n",
       "       [720, 760, 760, 800],\n",
       "       [711, 765, 768, 794],\n",
       "       [760, 760, 800, 800]])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "anchors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def draw_anchors(image,ctr,anchors, point_col = (0, 0, 0), anch_col = (150, 150, 150),thickness=1, type_= cv2.LINE_AA):\n",
    "    im = image.copy()\n",
    "    \n",
    "    if ctr is not None:\n",
    "        for c in ctr:\n",
    "            cv2.circle(im, (c[0],c[1]), 0, point_col, thickness=5)\n",
    "        \n",
    "        \n",
    "    for a in anchors:\n",
    "        cv2.rectangle(im,(a[0], a[1]), (a[2], a[3]),anch_col,thickness)\n",
    "    \n",
    "    return im"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(15,15))\n",
    "\n",
    "\n",
    "cell_size = 160\n",
    "\n",
    "img_anch = draw_anchors(img_grid,ctr,anchors[1325:1335])#[312:321])\n",
    "#img_anch = draw_anchors(img_grid,ctr,anchors)\n",
    "\n",
    "\n",
    "plt.imshow(img_anch)\n",
    "plt.axis('off')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Region Proposal Network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "class RegioProposalNetwork(nn.Module):\n",
    "    def __init__(self,in_channels = 512, mid_channels = 512, n_anchor = 9):\n",
    "        super(RegioProposalNetwork, self).__init__()\n",
    "        conv1 = nn.Conv2d(in_channels, mid_channels, 3, 1, 1)\n",
    "        nn.init.normal(conv1.weight, mean=0, std=0.001)\n",
    "        nn.init.zeros(conv1.bias)\n",
    "            \n",
    "        reg_layer = nn.Conv2d(mid_channels, n_anchor *4, 1, 1, 0)\n",
    "        nn.init.normal(reg_layer.weight, mean=0, std=0.001)\n",
    "        nn.init.zeros(reg_layer.bias)\n",
    "\n",
    "        cls_layer = nn.Conv2d(mid_channels, n_anchor *2, 1, 1, 0) \n",
    "        nn.init.normal(cls_layer.weight, mean=0, std=0.001)\n",
    "        nn.init.zeros(cls_layer.bias)\n",
    "\n",
    "    \n",
    "    def forward(self, x):\n",
    "        x = conv1(x)\n",
    "        pred_anchor_locs = reg_layer(x)\n",
    "        pred_cls_scores = cls_layer(x)\n",
    "        \n",
    "        pred_anchor_locs = pred_anchor_locs.permute(0, 2, 3, 1).contiguous().view(1, -1, 4)\n",
    "        pred_cls_scores = pred_cls_scores.permute(0, 2, 3, 1).contiguous()\n",
    "\n",
    "        pred_cls_scores  = pred_cls_scores.view(pred_cls_scores.shape[0], -1, 2)\n",
    "        \n",
    "        return pred_anchor_locs, pred_cls_scores\n",
    "        \n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## RetinaNet"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Riferimento su [github](https://github.com/kuangliu/pytorch-retinanet)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "pt = np.linspace(0,1,2000)\n",
    "pt = pt[1:]\n",
    "\n",
    "FL= lambda gamma: -1*(1-pt)**gamma*np.log(pt)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "plt.figure(figsize=(10,6))\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "plt.plot(pt,FL(0),label=r'$CE(p_t)$')\n",
    "plt.plot(pt,FL(0.5),label=r'$FL(p_t,0.5)$')\n",
    "plt.plot(pt,FL(1),label=r'$FL(p_t,1)$')\n",
    "plt.plot(pt,FL(2),label=r'$FL(p_t,2)$')\n",
    "plt.plot(pt,FL(5),label=r'$FL(p_t,5)$')\n",
    "plt.legend()\n",
    "\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python (ptc)",
   "language": "python",
   "name": "ptc"
  },
  "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.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}