Classical Feature Detection

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

keypoint ကောင်းတစ်ခု — Harris corner (သို့) SIFT ကဲ့သို့ classical detector များ ရှာဖွေနေသော အမျိုးအစား — ဆိုသည်မှာ local image content သည် ယုံကြည်စိတ်ချစွာ ပြန်လည်သတ်မှတ်နိုင်လောက်အောင် ထူးခြားသော နေရာတစ်ခု ဖြစ်ပြီး၊ 'ထူးခြားခြင်း' ကို formalize လုပ်သည့် standard နည်းလမ်းမှာ window သေးငယ်တစ်ခုကို လမ်းကြောင်းမည်သည့်ဘက်ကိုမဆို အနည်းငယ် ရွှေ့လိုက်လျှင် pixel value များ ဘာဖြစ်လာသလဲဟု မေးခြင်းပင် ဖြစ်သည်။ တပြေးညီ ညီညာသော ဧရိယာတစ်ခုတွင် window ရွှေ့လိုက်ခြင်းသည် ဘာမျှ သိပ်မပြောင်းလဲပါ — ထို့နေရာတွင် ထူးခြားသည့်အရာ မရှိပါ။ ဖြောင့်တန်းသော edge တစ်လျှောက်တွင်လည်း edge နှင့်ပြိုင်၍ window ရွှေ့လိုက်ခြင်းသည် edge ကို ဖြတ်၍ ရွှေ့သည်ထက် ဘာမျှ သိပ်မပြောင်းလဲပါ — edge တစ်ခုသည် ဦးတည်ချက်တစ်ခုတည်းတွင်သာ ထူးခြားခြင်းကြောင့် gradient ပြင်းထန်သော်လည်း keypoint ကောင်းတစ်ခု မဖြစ်တတ်ပါ။ corner အစစ်တစ်ခုတွင်တော့ window ကို မည်သည့်ဘက် ရွှေ့ရွှေ့ content သည် များစွာ ပြောင်းလဲသွားသည် — အကြောင်းမှာ edge နှစ်ခု ထိုနေရာတွင် ဆုံသည့်အတွက် ဖြစ်သည် — ဤ ဦးတည်ချက်နှစ်ခု property ကို Harris ကဲ့သို့ corner detector အစစ်တစ်ခုက (structure tensor မှတဆင့်) တိတိကျကျ စစ်ဆေးပေးပြီး ဒီသင်ခန်းစာ code တွက်ချက်သော ရိုးရှင်းသော ဦးတည်ချက်တစ်ခုတည်း gradient magnitude ထက် တစ်ဆင့်ပို၍ လုပ်ဆောင်ပေးသည်။

SIFT, Harris corner ကဲ့သို့ classical feature detector များသည် 'ထူးခြားပြီး ပြန်ရှာတွေ့နိုင်ခြင်း' ဆိုသည်မှာ ဘာလဲဆိုသည့် လူ့ hypothesis တစ်ခုကို မည်သူမဆို ဖတ်ပြီး စဉ်းစားနိုင်၊ training data မလိုဘဲ run နိုင်သော ရှင်းလင်းသော mathematical test တစ်ခုအဖြစ် ဖော်ပြထားသည်။ CNN တစ်ခုတွင်တော့ ထိုကဲ့သို့ ရှင်းလင်းသော hypothesis မရှိပါ — ၎င်း architecture အတွင်း 'corner ကို ရှာဖွေပါ' ဟု ဘယ်နေရာမှ ညွှန်ကြားထားခြင်း မရှိပါ။ သို့သော် trained CNN တစ်ခု၏ early convolutional filter များ အမှန်တကယ် ဘာကို respond လုပ်သလဲဟု visualize လုပ်ကြည့်လျှင် လက်ဖြင့်ဒီဇိုင်းဆွဲထားသော ဟာများနှင့် အံ့သြစရာကောင်းလောက်အောင် ဆင်တူသော edge, blob detector များကို မကြာခဏ တွေ့ရသည် — ထိုပုံစံများသည် training loss ကို လျှော့ချရာတွင် အသုံးဝင်ကြောင်း ပေါ်ပေါက်လာသောကြောင့် သန့်စင်စွာ သင်ယူထားခြင်းသာ ဖြစ်သည်။ deeper layer များကတော့ ပိုမို ရှေ့ဆက်သွားပြီး pattern ပေါင်းစပ်မှုများ — အမွှေးအမှင် texture, ဘီးပုံသဏ္ဍာန် curve, မျက်လုံးပုံ blob — အတွက် detector များကို သင်ယူသည် — ၎င်းတို့အတွက် mathematical rule တစ်ခုကို လူတစ်ဦးက လက်ဖြင့်ဒီဇိုင်းဆွဲရန် အလွန်ခက်ခဲမည် ဖြစ်သည်။ ထို့ကြောင့်ပင် image stitching (သို့) simple tracking ကဲ့သို့ ဈေးသက်သာပြီး interpretable ဖြစ်သော၊ training မလိုသော task များအတွက် classical detector များ ယနေ့တိုင် အသုံးဝင်နေဆဲဖြစ်ပြီး၊ interest ရှိသော pattern သည် လက်ဖြင့်ဖော်ပြရန် ရှုပ်ထွေးလွန်းသည့်နေရာတိုင်းတွင် learned feature များက လွှမ်းမိုးထားသည်။

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

Tutorial Platform ၏ course-thumbnail uploader သည် ဈေးကြီးသော learned similarity model ကို ခေါ်မီ ဈေးသက်သာသော classical fingerprint check တစ်ခုကို ဦးစွာ run လုပ်သည် — upload လုပ်လိုက်သော thumbnail အသစ်တိုင်းအတွက် gradient-magnitude 'keypoint density' map တစ်ခု (ဒီသင်ခန်းစာ code ကဲ့သို့ပင်) တွက်ချက်ပြီး ရှိပြီးသား thumbnail များ၏ fingerprint များနှင့် နှိုင်းယှဉ်ကြည့်သည် — instructor တစ်ဦးက banner image အတူတူ (သို့) crop အနည်းငယ်သာ ကွာသည့် ပုံကို ပြန် upload လုပ်လိုက်သည့် ဖြစ်ရပ်များစွာကို ချက်ချင်းနီးပါး ဖမ်းမိစေပြီး၊ ဈေးသက်သာသော classical check က duplicate ဟုတ်၊ မဟုတ် ယုံကြည်စိတ်ချစွာ ဆုံးဖြတ်မရသည့်အခါမှသာ ပိုနှေးသော learned embedding model ကို ပြန်လှည့်သုံးသည်။

• corner/keypoint အစစ်တစ်ခုသည် ညီညာသော ဧရိယာ (response မရှိ) (သို့) edge (ဦးတည်ချက်တစ်ခုတည်းတွင်သာ response ရှိ) နှင့် မတူဘဲ ဦးတည်ချက် တိုင်း တွင် response ပြင်းထန်စွာ ပြသသည်။
• ဒီသင်ခန်းစာ၏ gradient-magnitude threshold သည် keypoint detection ကို ခန့်မှန်းပေးသော်လည်း edge များကိုပါ flag လုပ်မိသည် — corner detector အစစ်တစ်ခုမှာ multi-directional test (ဥပမာ Harris ၏ structure tensor) လိုအပ်သည်။
• CNN layer အစောပိုင်းများသည် လက်ဖြင့်ဒီဇိုင်းဆွဲထားသော ဟာများနှင့် ဆင်တူသော edge/blob detector များကို မကြာခဏ သင်ယူသော်လည်း deeper layer များကတော့ မည်သူမျှ လက်ဖြင့်ဒီဇိုင်းဆွဲရန် ခက်ခဲသော ပိုမိုရှုပ်ထွေးသည့် task-specific pattern များကို သင်ယူသည်။

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

import torch
import torch.nn.functional as F

torch.manual_seed(0)

# Synthetic grayscale image standing in for a course thumbnail.
image = torch.rand(1, 1, 20, 20)

sobel_x = torch.tensor([[-1., 0., 1.],
                         [-2., 0., 2.],
                         [-1., 0., 1.]]).view(1, 1, 3, 3)
sobel_y = torch.tensor([[-1., -2., -1.],
                         [ 0.,  0.,  0.],
                         [ 1.,  2.,  1.]]).view(1, 1, 3, 3)

grad_x = F.conv2d(image, sobel_x, padding=1)
grad_y = F.conv2d(image, sobel_y, padding=1)
gradient_magnitude = torch.sqrt(grad_x ** 2 + grad_y ** 2)

# A classical corner/keypoint detector is, at its core, looking for
# locations where this gradient magnitude is unusually high in
# *multiple* directions -- flat regions and simple edges score low,
# corner-like regions score high. We approximate that here with a
# blunt threshold instead of a full Harris response.
threshold = gradient_magnitude.mean() + gradient_magnitude.std()
keypoint_mask = gradient_magnitude > threshold

print("gradient_magnitude shape:", gradient_magnitude.shape)
print("keypoint_mask shape:", keypoint_mask.shape)
print("number of candidate keypoints:", keypoint_mask.sum().item())
print("fraction of image flagged as a keypoint:", (keypoint_mask.float().mean() > 0).item())

gradient_magnitude shape: torch.Size([1, 1, 20, 20]) နှင့် keypoint_mask shape: torch.Size([1, 1, 20, 20]) ကို print ထုတ်သည်။ number of candidate keypoints သည် pixel စုစုပေါင်း 400 ထက် အများကြီး နည်းသော positive integer သေးငယ်တစ်ခု ဖြစ်သည် — threshold (mean + standard deviation တစ်ခု) သည် ဒီဇိုင်းအရ distribution ၏ magnitude အမြင့်ဆုံး tail ကိုသာ ထားခဲ့သဖြင့် pixel အနည်းစုသာ ဖြတ်နိုင်သည် — အတိအကျ count သည် seed ပေါ်မူတည်၍ deterministic ဖြစ်သော်လည်း ဤနေရာတွင် လက်ဖြင့် မတွက်ချက်ထားပါ။ နောက်ဆုံးလိုင်းက fraction of image flagged as a keypoint: True ဟု print ထုတ်သည် — အကြောင်းမှာ constant မဟုတ်သော data ပေါ်တွင် mean + std ၏ အဓိပ္ပာယ်အရ pixel အနည်းဆုံးတစ်ချို့ threshold ထက် ကျော်နေမည် ဖြစ်သောကြောင့်ပင်။

Wikipedia — Feature (computer vision) — Computer Vision