Object Detection Architecture များ

နားလည်ထားရမယ့် အချက်

R-CNN လိုမျိုး ရှေးဦး object detector တွေဟာ separate stage နှစ်ခုနဲ့ အလုပ်လုပ်ခဲ့ကြပါတယ်— ပထမဆုံး region-proposal အဆင့်က ပုံကို scan လုပ်ပြီး object ပါနိုင်တဲ့ candidate box ထောင်ချီကို အကြံပြုပါတယ်၊ ပြီးရင် ဒုတိယ network တစ်ခုက candidate တစ်ခုချင်းစီကို crop လုပ်ပြီး classify လုပ်ပါတယ်။ ဒါဟာ accuracy ကောင်းပေမယ့် နှေးပါတယ်၊ classification network ကို proposed region တစ်ခုစီအတွက် တစ်ကြိမ်စီ run ရလို့ပါ။ YOLO ('You Only Look Once') နဲ့ တခြား single-shot detector တွေကတော့ လုံးဝ ကွဲပြားတဲ့ ချဉ်းကပ်မှုကို သုံးပါတယ်— proposal အဆင့်ကို လုံးဝ ကျော်ပြီး၊ ပုံကို grid ပုံသေတစ်ခုအဖြစ် ခွဲကာ network ကို forward pass တစ်ခါတည်းနဲ့ grid cell တိုင်းရဲ့ အထဲမှာ ဘာရှိသလဲဆိုတာ တစ်ပြိုင်နက် predict ခိုင်းပါတယ်။ cell တစ်ခုစီဟာ ကိုယ့် အထဲမှာ center ကျရောက်နေတဲ့ object ကို ဖော်ထုတ်ဖို့ တာဝန်ရှိပြီး— network က region တွေကို အစဉ်လိုက် 'ကြည့်' တာမျိုး မဟုတ်ဘဲ shared feature map တစ်ခုတည်းကနေ prediction အားလုံးကို တစ်ပြိုင်နက် ထုတ်ပေးပါတယ်။

တိတိကျကျ ပြောရရင် single-shot detector တစ်ခုရဲ့ grid cell တစ်ခုစီက output ဟာ 'anchor' (pedestrian အတွက် ရှည်ချောင်တဲ့ box၊ car အတွက် ကျယ်ပြန့်တဲ့ box လိုမျိုး ကြိုတင်သတ်မှတ်ထားတဲ့ box ပုံသဏ္ဌာန်) တစ်ခုစီအတွက် ထပ်ခါထပ်ခါ ရှိနေတဲ့ fixed-size vector တစ်ခုပါ။ anchor တစ်ခုစီအတွက် network က objectness score (ဒီနေရာမှာ object တစ်ခုခု ရှိသလား?) တစ်ခုနဲ့ box-coordinate offset 4 ခု (anchor ရဲ့ default position နဲ့ size ကို actual object နဲ့ ကိုက်ညီအောင် ချိန်ညှိချက်) ကို predict လုပ်ပါတယ်။ ဒါကြောင့် anchor 3 ခုနဲ့ value 5 ခုစီ ရှိတဲ့ grid cell တစ်ခုဟာ spatial location တစ်ခုမှာ output channel 15 ခု လိုအပ်ပါတယ်။ ဒါကြောင့် detection head ဟာ backbone ရဲ့ feature map အပေါ်မှာ ထပ်တင်ထားတဲ့ convolutional layer သေးငယ်တစ်ခုပါပဲ— in_channels ကို num_anchors * num_outputs အဖြစ် map လုပ်တဲ့ 1x1 (ဒါမှမဟုတ် 3x3) convolution တစ်ခုက grid cell တစ်ခုစီအတွက် prediction bundle တစ်ခုကို dense tensor တစ်ခုတည်းအဖြစ် ထုတ်ပေးပါတယ်— crop လုပ်စရာ၊ region တစ်ခုစီအတွက် network ခေါ်ဆိုစရာ မလိုအပ်တော့ဘဲ၊ ဒါက single-shot detection ကို real-time သုံးဖို့ လုံလောက်စွာ မြန်ဆန်စေတဲ့ အကြောင်းရင်းအတိအကျပါပဲ။

လက်တွေ့ scenario နဲ့ ချိတ်ကြည့်မယ်

Tutorial Platform မှာ lesson content ထဲက embed လုပ်ထားတဲ့ screenshot များအတွင်းရှိ UI element များ — button, code block, input field များ — ကို အလိုအလျောက် ရှာဖွေတည်နေရာသတ်မှတ်ဖို့ ဒီလိုမျိုး single-shot detection head ကို သုံးနိုင်ပါတယ်၊ bounding box တွေကို ထုတ်ပေးပြီး auto-generated alt-text ('Submit ခလုတ်အစိမ်းရောင် ပြသနေတဲ့ screenshot') နဲ့ interactive click-to-zoom hotspot နှစ်ခုစလုံးကို ဖန်တီးပေးနိုင်ပါတယ်၊ author က lesson အသစ်တစ်ခု upload လုပ်တိုင်း screenshot တွေကို အစုလိုက် process လုပ်ရမှာမို့ ပိုနှေးတဲ့ two-stage pipeline မလိုအပ်တော့ပါဘူး။

• Two-stage detector တွေဟာ candidate region တွေကို အရင်အကြံပြုပြီး တစ်ခုချင်းစီ သီးခြား classify လုပ်ပါတယ်၊ accuracy ကောင်းပေမယ့် network ကို region တစ်ခုစီအတွက် တစ်ကြိမ်စီ run ရလို့ နှေးပါတယ်။
• YOLO လိုမျိုး single-shot detector တွေဟာ proposal အဆင့်ကို ကျော်ပြီး grid cell တိုင်းအတွက် objectness နဲ့ box coordinate ကို forward pass တစ်ခါတည်းနဲ့ predict လုပ်ပါတယ်။
• grid cell တစ်ခုစီရဲ့ output channel ဟာ num_anchors ကို num_outputs နဲ့ မြှောက်ထားတဲ့ ကိန်းနဲ့ညီပါတယ်၊ cell ထဲက anchor shape တစ်ခုစီမှာ ကိုယ်ပိုင် objectness score နဲ့ box offset ရှိလို့ပါ။

အတူတူ စမ်းရေးကြည့်မယ်

import torch
import torch.nn as nn

class TinyDetectionHead(nn.Module):
    def __init__(self, in_channels, num_anchors=3, num_outputs=5):
        super().__init__()
        self.backbone = nn.Sequential(
            nn.Conv2d(3, 16, kernel_size=3, stride=2, padding=1),          # 32x32 -> 16x16
            nn.ReLU(),
            nn.Conv2d(16, in_channels, kernel_size=3, stride=2, padding=1),  # 16x16 -> 8x8
            nn.ReLU(),
        )
        self.head = nn.Conv2d(in_channels, num_anchors * num_outputs, kernel_size=1)
        self.num_anchors = num_anchors
        self.num_outputs = num_outputs

    def forward(self, x):
        features = self.backbone(x)                      # (batch, in_channels, grid_h, grid_w)
        raw = self.head(features)                         # (batch, num_anchors*num_outputs, grid_h, grid_w)
        batch, _, grid_h, grid_w = raw.shape
        return raw.view(batch, self.num_anchors, self.num_outputs, grid_h, grid_w)

torch.manual_seed(0)
model = TinyDetectionHead(in_channels=32)
images = torch.randn(4, 3, 32, 32)  # fake batch of 4 RGB images
predictions = model(images)
print(predictions.shape)

torch.Size([4, 3, 5, 8, 8]) — backbone ရဲ့ stride-2 convolution နှစ်ခုက 32x32 input ကို 8x8 feature grid အဖြစ် ချုံ့ပေးပြီး၊ detection head က grid cell 64 ခုစလုံးအတွက် anchor 3 ခု x value 5 ခုစီ (objectness score 1 ခု + box coordinate 4 ခု) ကို ထုတ်ပေးပါတယ်၊ ဒါကို (batch, num_anchors, num_outputs, grid_h, grid_w) tensor အဖြစ် reshape လုပ်ထားပါတယ်။

Wikipedia — You Only Look Once — Computer Vision