Object detection আর segmentation-এর পরিচয় — bounding box, IoU আর U-Net

এতদিন CNN-কে একটি প্রশ্ন করেছেন: “ছবিটি কীসের?” পর্ব ২০ (Convolution) থেকে পর্ব ২৪ (Data augmentation) পর্যন্ত এই মডিউলের সব পর্ব এই এক প্রশ্নের উত্তর আরও ভালো করার কথা। বাস্তবে প্রশ্ন প্রায়ই অন্য: বাজারঘরের গুদামের তাকে কয়টি বোতল আছে, কোনটি কোথায়, কোন তাক ফাঁকা? এই পর্বে তিনটি পাতার ব্লক ব্রাউজারের Python আর NumPy-তে চলে (প্রথমবার প্যাকেজ নামতে কয়েক সেকেন্ড লাগে)। PyTorch আর torchvision-এর সব সংখ্যা ডেস্কটপের সত্যিকারের run থেকে, CPU-তে।

১ · ছবির চারটি প্রশ্ন — classification থেকে instance segmentation

Classification-এ network-এর শেষে C টি শ্রেণির logits. Localisation-এ (ছবিতে একটিই প্রধান বস্তু ধরে নিয়ে) তার সঙ্গে একটি box-এর চারটি সংখ্যা regression করা হয়। Detection-এ বস্তুর সংখ্যা আগে থেকে জানা নেই: শূন্য, এক বা পঞ্চাশ; output একটি পরিবর্তনশীল দৈর্ঘ্যের তালিকা, যেখানে প্রতিটি সারি (box, শ্রেণি, score). এই “কয়টি জানি না” সমস্যাটিই detection-কে classification-এর চেয়ে কঠিন করে, আর NMS, anchor আর matching-এর মতো সব যন্ত্রপাতি এখান থেকেই আসে। Semantic segmentation প্রতিটি pixel-এ একটি শ্রেণি দেয়, output H × W; একই শ্রেণির দুটি বস্তু ছুঁয়ে থাকলে তাদের আলাদা করে না। Instance segmentation প্রতিটি বস্তুর আলাদা mask দেয়, যেন detection আর segmentation একসঙ্গে। দুটি মিলিয়ে আকাশ বা রাস্তার মতো “অগণনীয়” অংশসহ পুরো ছবি ভাগ করাকে বলে panoptic segmentation (Kirillov ও সহকর্মীরা, ২০১৯)।

ছবি কীভাবে array হয়, channel কী, তা AI-এর ভিত্তি কোর্সের পর্ব ১৮-এ দেখেছেন। এখানে একটি নিয়ম মনে রাখুন: ছবির স্থানাঙ্কে x ডানে বাড়ে, y নিচে বাড়ে, আর (0, 0) বাম-ওপরের কোণ।

২ · Bounding box আর IoU — দুটি box কতটা মেলে

একটি অক্ষ-সমান্তরাল box চারটি সংখ্যায় লেখা যায়, কিন্তু কোন চারটি, তা লাইব্রেরি ভেদে আলাদা। ভুল ফরম্যাট হলো detection কোডের সবচেয়ে সাধারণ নীরব বাগ:

torchvision-এ torchvision.ops.box_convert(boxes, in_fmt="xywh", out_fmt="xyxy") এই রূপান্তর করে। এবার মূল মাপ। দুটি box A আর B কতটা মেলে, তা বলে Intersection over Union:

IoU(A, B) = |A ∩ B| ÷ |A ∪ B| = ছেদের ক্ষেত্রফল ÷ (|A| + |B| − ছেদের ক্ষেত্রফল)

|A| মানে A-এর ক্ষেত্রফল। IoU ০ মানে একেবারে না মেলা, ১ মানে হুবহু এক। ধারণাটি পুরোনো: উদ্ভিদবিজ্ঞানী Paul Jaccard বিশ শতকের শুরুতে দুটি এলাকার উদ্ভিদ-প্রজাতির মিল মাপতে এই অনুপাত ব্যবহার করেন, তাই একে Jaccard index-ও বলে। ছেদ বের করার কৌশল: ছেদের বাম-ওপর কোণ হলো দুটি বাম-ওপর কোণের বড়টি, ডান-নিচ কোণ দুটি ডান-নিচ কোণের ছোটটি; প্রস্থ বা উচ্চতা ঋণাত্মক হলে ছেদ নেই।

IoU-এর একটি গুণ হলো এটি মাপ-নিরপেক্ষ: দুটি box-কে একসঙ্গে দ্বিগুণ বড় করলে IoU বদলায় না। তাই ছোট আর বড় বস্তুর জন্য একই threshold চলে। কিন্তু ছোট বস্তুতে কয়েক pixel সরে যাওয়াও IoU অনেক কমায়: ১০ × ১০ box ২ pixel ডানে সরলে IoU ৮০ ÷ ১২০ ≈ ০.৬৭, অথচ ১০০ × ১০০ box ২ pixel সরলে প্রায় ০.৯৬. ছোট বস্তু detection-এ কঠিন হওয়ার একটি কারণ এটাই।

৩ · NumPy-তে IoU আর NMS — তাকের ওপর একাধিক box ছাঁটা

একটি detector প্রায় কখনোই একটি বস্তুর জন্য একটি box দেয় না। কাছাকাছি অনেক অবস্থান থেকে একই বোতল “দেখা” যায়, তাই একই বস্তুর চারপাশে কয়েকটি একটু আলাদা box আসে, প্রতিটির একটি confidence score. Non-maximum suppression (NMS) এই ডুপ্লিকেট ছাঁটে, greedy নিয়মে:

1. সব box score অনুযায়ী বড় থেকে ছোট সাজান।
2. তালিকার প্রথমটি (সর্বোচ্চ score) রাখুন।
3. তালিকার বাকি যেসব box-এর তার সঙ্গে IoU threshold-এর বেশি, সেগুলো বাদ দিন।
4. তালিকা খালি না হওয়া পর্যন্ত ধাপ ২-এ ফিরুন।

নিচের ব্লকে বাজারঘরের গুদামের একটি কৃত্রিম তাক: চারটি পণ্য (দুটি বোতল, একটি বাক্স, একটি বয়াম), আর একটি কাল্পনিক detector-এর আটটি box, d0 থেকে d7. box_iou vectorised: N × 4 আর M × 4 থেকে broadcasting দিয়ে একবারে N × M IoU-এর matrix.

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.patches import Rectangle

def box_iou(A, B):                       # A: (N,4), B: (M,4), [x1,y1,x2,y2] -> (N,M)
    lt = np.maximum(A[:, None, :2], B[None, :, :2])   # ছেদের বাম-ওপর কোণ
    rb = np.minimum(A[:, None, 2:], B[None, :, 2:])   # ছেদের ডান-নিচ কোণ
    wh = np.clip(rb - lt, 0, None)                     # না মিললে প্রস্থ 0
    inter = wh[..., 0] * wh[..., 1]
    area = lambda X: (X[:, 2] - X[:, 0]) * (X[:, 3] - X[:, 1])
    return inter / (area(A)[:, None] + area(B)[None, :] - inter)
def nms(boxes, scores, thr=0.5):         # greedy: সেরাটি রাখা, বেশি মেলা বাকিগুলো বাদ
    order, keep = np.argsort(-scores), []
    while order.size:
        i, rest = order[0], order[1:]
        keep.append(int(i))
        order = rest[box_iou(boxes[[i]], boxes[rest])[0] <= thr]
    return keep
A, B = np.array([[10, 20, 50, 80.]]), np.array([[30, 40, 70, 90.]])
print("IoU(A, B) =", round(box_iou(A, B)[0, 0], 4))
D = np.array([[21, 11, 46, 53], [18, 8, 44, 50], [59, 12, 86, 51], [62, 6, 90, 55],
              [108, 18, 168, 53], [130, 22, 175, 50], [188, 26, 226, 53], [40, 15, 65, 50]], float)
S = np.array([0.92, 0.81, 0.88, 0.55, 0.95, 0.60, 0.70, 0.40])
for thr in (0.5, 0.3): print(f"NMS thr {thr}: keep", nms(D, S, thr))
img = np.full((70, 240, 3), 0.93); img[54:60] = (0.55, 0.38, 0.22)    # দেয়াল আর তাক
for (x1, y1, x2, y2), c in zip([[20, 10, 45, 54], [60, 10, 86, 54], [110, 20, 170, 54], [190, 26, 225, 54]],
                               [(.1, .5, .2), (.2, .4, .8), (.9, .6, .2), (.8, .2, .3)]):
    img[y1:y2, x1:x2] = c                                         # চারটি পণ্য
keep = nms(D, S, 0.5); fig, ax = plt.subplots(figsize=(7, 2.6)); ax.imshow(img)
for k, ((x1, y1, x2, y2), s) in enumerate(zip(D, S)):
    on = k in keep                                                # রাখা হলে মোটা কালো, নইলে ড্যাশ
    ax.add_patch(Rectangle((x1, y1), x2 - x1, y2 - y1, fill=False, lw=2 if on else 1,
                           ec="black" if on else "gray", ls="-" if on else "--"))
    ax.text(x1, y1 - 1 if on and k != 7 else y2 + 9, f"d{k} {s:.2f}", fontsize=7)
ax.set_title("Shelf: kept boxes solid, suppressed dashed (thr 0.5)"); ax.axis("off"); plt.show()

IoU(A, B) = 0.2222
NMS thr 0.5: keep [4, 0, 2, 6, 5, 7]
NMS thr 0.3: keep [4, 0, 2, 6, 7]

এখন যাচাই। একই NumPy function দুটি ডেস্কটপে ৫০০টি এলোমেলো box-এ চালিয়ে torchvision-এর C++ বাস্তবায়নের সঙ্গে মেলানো হলো (torchvision.ops.nms নিয়ম লেখে: IoU > threshold হলে বাদ, তাই NumPy-তে <= thr রাখা হয়েছে)। সত্যিকারের run, লেখার সময়ের সংস্করণ:

~/bazarghar-dl$ uv run python nms_check.py
Python 3.14.4 | torch 2.15.0+cpu | torchvision 0.29.2+cpu
box_iou: 500x500 matrix, max |numpy - torchvision| = 9.23e-07
nms thr 0.3: numpy keeps 239, torchvision keeps 239, identical order: True
nms thr 0.5: numpy keeps 409, torchvision keeps 409, identical order: True
nms thr 0.7: numpy keeps 488, torchvision keeps 488, identical order: True
batched_nms (3 classes, thr 0.5) keeps 462: boxes of different classes never suppress each other

IoU-এর ৫০০ × ৫০০ matrix-এ সবচেয়ে বড় পার্থক্য float32-এর গোলকরণের মাপে, আর তিনটি threshold-এই রাখা box-এর তালিকা ক্রমসহ এক। শেষ লাইনটি বাস্তবের একটি খুঁটিনাটি: আসল detector-এ NMS চলে প্রতিটি শ্রেণির ভেতরে আলাদাভাবে (batched_nms), যাতে একটি বোতল তার গায়ে লাগা কাপের box মুছে না দেয়।

৪ · Detector কীভাবে box খোঁজে — anchor, two-stage আর one-stage

প্রথম ভাবনা হতে পারে: ছবির ওপর অনেক আকারের জানালা সরিয়ে প্রতিটিতে classifier চালানো (sliding window). কাজ করে, কিন্তু হাজার হাজার জানালায় আলাদা CNN চালানো অত্যন্ত ধীর। আধুনিক detector দুটি চালাকি করে। প্রথমত, পুরো ছবিতে একবার CNN চালিয়ে একটি feature map নেয়, তারপর জানালার কাজ সেই map-এর ওপর করে, কারণ convolution-এর পরে map-এর প্রতিটি অবস্থান ছবির একটি অংশের সারাংশ (পর্ব ২০, Convolution-এর receptive field). দ্বিতীয়ত, প্রতিটি অবস্থানে কয়েকটি পূর্বনির্ধারিত box রাখে, যাদের বলে anchor: যেমন অংশ ৬-এর torchvision model-এর RPN-এ ৫টি মাপ (৩২ থেকে ৫১২ pixel) × ৩টি অনুপাত (০.৫, ১, ২) = ১৫টি। Network প্রতিটি anchor-এর জন্য দুটি জিনিস শেখে: এতে বস্তু আছে কি না (আর কোন শ্রেণির), আর anchor-কে কতটা সরিয়ে-বড় করে আসল box পাওয়া যায় (চারটি offset).

Training-এর সময় প্রতিটি anchor-কে লেবেল দেওয়া হয় IoU দিয়েই: কোনো ground-truth box-এর সঙ্গে IoU বেশি হলে (Faster R-CNN-এর RPN-এ ০.৭-এর ওপরে) “বস্তু”, খুব কম হলে (০.৩-এর নিচে) “পটভূমি”, মাঝের গুলো উপেক্ষা। তাই IoU শুধু মূল্যায়নের মাপ নয়, training-এর লেবেল বানানোর যন্ত্রও। পটভূমির anchor বস্তুর anchor-এর চেয়ে বহু গুণ বেশি; এই ভারসাম্যহীনতা সামলাতে focal loss প্রস্তাব হয়েছিল (পর্ব ১৩)।

একটি সাধারণ অংশ প্রায় সব আধুনিক detector-এ: backbone (ResNet বা MobileNet-এর মতো CNN, প্রায়ই ImageNet-এ pretrained, পর্ব ২২ আর ২৩-এর বিষয়) আর তার ওপর Feature Pyramid Network (FPN; Lin ও সহকর্মীরা, ২০১৭), যা গভীর স্তরের “কী” আর অগভীর স্তরের “কোথায়” মিলিয়ে কয়েকটি মাপের feature map বানায়। বড় বস্তু খোঁজা হয় ছোট (মোটা দাগের) map-এ, ছোট বস্তু বড় map-এ। গতি আর নির্ভুলতার তুলনা নির্ভর করে backbone, ছবির মাপ আর যন্ত্রের ওপর; “one-stage সবসময় দ্রুত” বা “two-stage সবসময় নিখুঁত” কোনোটিই নিয়ম নয়, নিজের যন্ত্রে মেপে দেখতে হয়।

৫ · mAP — detector-এর স্কোরকার্ড

Classifier-এর accuracy এক সংখ্যায় বলা যায়। Detector-এর ক্ষেত্রে প্রতিটি predicted box-কে আগে ঠিক বা ভুল ঘোষণা করতে হয়, তারপর precision আর recall (AI-এর ভিত্তি কোর্সের পর্ব ৬০)। নিয়মটি ক্রিকেটের স্কোরকার্ডের মতো কড়া:

• একটি শ্রেণির সব detection, সব ছবি মিলিয়ে, score অনুযায়ী সাজান।
• প্রতিটি detection-কে তার ছবির সবচেয়ে বেশি মেলা ground-truth box-এর সঙ্গে মেলান। IoU ≥ ০.৫ আর সেই ground truth আগে কারও সঙ্গে মেলেনি হলে TP; নইলে FP. একই বোতলের দ্বিতীয় box তাই FP: ডুপ্লিকেটের শাস্তি এখানেই।
• প্রতিটি অবস্থানে জমা TP থেকে precision = TP ÷ (এ পর্যন্ত detection) আর recall = TP ÷ (মোট ground truth).
• AP = precision-recall curve-এর নিচের ক্ষেত্রফল, তবে আগে curve-কে “interpolate” করা হয়: প্রতিটি recall-এ precision হিসেবে নেওয়া হয় ওই recall বা তার ডানের সর্বোচ্চ precision. ফলে curve সিঁড়ির মতো, কখনো ওপরে ওঠে না।

নিচের ব্লকে দুটি ছবিতে মোট চারটি বোতল আর সাতটি detection; ডেটা হাতে বানানো যাতে প্রতিটি ধরনের ঘটনা (ঠিক, ডুপ্লিকেট, কম IoU, পটভূমি) একবার করে আসে।

import numpy as np
import matplotlib.pyplot as plt

def iou1(a, g):                          # একটি box বনাম অনেক ground-truth box
    w = np.clip(np.minimum(a[2], g[:, 2]) - np.maximum(a[0], g[:, 0]), 0, None)
    h = np.clip(np.minimum(a[3], g[:, 3]) - np.maximum(a[1], g[:, 1]), 0, None)
    area = lambda X: (X[..., 2] - X[..., 0]) * (X[..., 3] - X[..., 1])
    return w * h / (area(a) + area(g) - w * h)

gt = {"A": np.array([[10, 10, 40, 60], [60, 10, 90, 60.]]),      # দুটি ছবি, মোট ৪টি bottle
      "B": np.array([[20, 15, 50, 65], [70, 20, 100, 70.]])}
dets = [("A", .95, [12, 12, 41, 61]), ("B", .90, [21, 14, 52, 66]), ("A", .80, [9, 8, 39, 58]),
        ("A", .70, [58, 12, 88, 62]), ("B", .60, [80, 35, 110, 85]), ("A", .50, [100, 30, 130, 80]),
        ("B", .40, [68, 18, 99, 69])]                              # score অনুযায়ী সাজানো
used = {k: np.zeros(len(v), bool) for k, v in gt.items()}
n_gt, tp, rows = 4, [], []
for img, s, box in dets:
    ious = iou1(np.array(box, float), gt[img]); j = ious.argmax()
    ok = ious[j] >= 0.5 and not used[img][j]                     # একটি GT একবারই মেলে
    used[img][j] |= ok; tp.append(ok)
    rows.append((img, s, round(ious[j], 3), "TP" if ok else "FP"))
ctp = np.cumsum(tp); prec = ctp / np.arange(1, len(tp) + 1); rec = ctp / n_gt
print("img score maxIoU  TP/FP precision recall")
for (img, s, m, t), p, r in zip(rows, prec, rec):
    print(f" {img}   {s:.2f}  {m:5.3f}   {t}    {p:6.3f}   {r:5.2f}")
r = np.concatenate([[0], rec, [1]]); p = np.concatenate([[1], prec, [0]])
p_env = np.maximum.accumulate(p[::-1])[::-1]                     # ডানদিকের সর্বোচ্চ precision
idx = np.where(r[1:] != r[:-1])[0]
print("AP (all-point) =", round(np.sum((r[idx + 1] - r[idx]) * p_env[idx + 1]), 4))
grid = np.linspace(0, 1, 101)
print("AP (COCO 101-point) =", round(np.mean([p_env[r >= t].max() for t in grid]), 4))
plt.figure(figsize=(4.6, 3.2)); plt.plot(rec, prec, "o--", label="raw")
plt.step(r[:-1], p_env[:-1], where="post", label="interpolated"); plt.xlabel("recall"); plt.ylabel("precision")
plt.title("PR curve, class 'bottle', IoU 0.5"); plt.legend(); plt.show()

img score maxIoU  TP/FP precision recall
 A   0.95  0.852   TP     1.000    0.25
 B   0.90  0.872   TP     1.000    0.50
 A   0.80  0.866   FP     0.667    0.50
 A   0.70  0.812   TP     0.750    0.75
 B   0.60  0.304   FP     0.600    0.75
 A   0.50  0.000   FP     0.500    0.75
 B   0.40  0.856   TP     0.571    1.00
AP (all-point) = 0.8304
AP (COCO 101-point) = 0.832

AP থেকে mAP. প্রতিটি শ্রেণির AP-এর গড় হলো mAP. PASCAL VOC-তে IoU threshold একটিই, ০.৫ (তাই লেখা হয় AP₅₀ বা mAP@0.5). COCO আরও কড়া: IoU ০.৫০, ০.৫৫, …, ০.৯৫ এই দশটি threshold-এ AP মেপে গড় করে, যাকে সাধারণত শুধু “AP” বা mAP@[.5:.95] লেখা হয়; ফলে box-এর অবস্থান যত নিখুঁত, নম্বর তত বেশি। COCO বস্তুর মাপ ধরে AP_S, AP_M, AP_L-ও আলাদা দেয়। ভারসাম্যহীন ডেটায় precision-recall curve কেন ROC-এর চেয়ে বেশি বলে, তা মেশিন লার্নিং কোর্সের পর্ব ৫০-এ আছে।

৬ · সত্যিকারের detector — torchvision-এর pretrained model

এবার একটি আসল, COCO-তে প্রশিক্ষিত detector. torchvision-এ দুটি ছোট model বেছে নেওয়া হলো, যাতে ল্যাপটপের CPU-তে চলে: fasterrcnn_mobilenet_v3_large_fpn (two-stage, MobileNetV3 backbone আর FPN) আর ssdlite320_mobilenet_v3_large (one-stage, ৩২০ pixel ছবি)। Weights এসেছে PyTorch-এর অফিশিয়াল সার্ভার থেকে, weights enum FasterRCNN_MobileNet_V3_Large_FPN_Weights.COCO_V1 আর SSDLite320_MobileNet_V3_Large_Weights.COCO_V1. COCO-র ৮০টি শ্রেণির মধ্যে আছে bottle, cup, chair, spoon, dining table ইত্যাদি। ছবি হিসেবে নেওয়া হলো scikit-image লাইব্রেরির সঙ্গে আসা data.coffee(): একটি কফির কাপের ছবি, যার লাইসেন্স scikit-image-এর নথিতে CC0 লেখা; ছবিতে কোনো মানুষ নেই।

W = FasterRCNN_MobileNet_V3_Large_FPN_Weights.COCO_V1
model = fasterrcnn_mobilenet_v3_large_fpn(weights=W).eval()
pre, cats = W.transforms(), W.meta["categories"]
x = [pre(img)]                          # একটি CHW uint8 ছবির list
with torch.inference_mode():
    out = model(x)[0]                   # dict: boxes (N,4 xyxy), labels, scores
for b, l, s in zip(out["boxes"], out["labels"], out["scores"]):
    if s >= 0.3:
        x1, y1, x2, y2 = [round(v) for v in b.tolist()]
        print(f"  {cats[l]:<14s} score {s:.3f}  box [{x1}, {y1}, {x2}, {y2}]")

পুরো ফাইল একই loop দুটি model-এ চালায়, সময় মাপে আর ০.৩-এর নিচের box গোনে। সত্যিকারের run (ডেস্কটপ, CPU-তে; সময় এক run-এর, warm-up-এর পরে):

~/bazarghar-dl$ TORCH_HOME=./torch_home uv run python detect.py
image: skimage.data.coffee() (CC0) (3, 400, 600) torch.uint8

FasterRCNN_MobileNet_V3_Large_FPN_Weights.COCO_V1  params 19.39M  CPU time 418 ms  raw detections 5
  COCO box mAP (from weights meta): 32.8
  cup            score 0.995  box [164, 19, 421, 311]
  dining table   score 0.969  box [9, 0, 596, 395]
  below 0.3: 3 boxes, highest: [('spoon', 0.296), ('bowl', 0.147), ('spoon', 0.09)]

SSDLite320_MobileNet_V3_Large_Weights.COCO_V1  params 3.44M  CPU time 70 ms  raw detections 300
  COCO box mAP (from weights meta): 21.3
  cup            score 0.991  box [170, 19, 418, 265]
  dining table   score 0.866  box [5, 2, 596, 399]
  below 0.3: 298 boxes, highest: [('cup', 0.231), ('spoon', 0.064), ('spoon', 0.031)]

দুটি model-ই কাপটি প্রায় নিশ্চিতভাবে খুঁজেছে (০.৯৯৫ আর ০.৯৯১), আর পুরো ছবি জুড়ে কাঠের টেবিলকে বলেছে “dining table”. কিন্তু box আলাদা: Faster R-CNN-এর box নিচে ৩১১ পর্যন্ত নেমে হাতল ধরেছে, SSDLite-এর box ২৬৫-তে থেমে হাতলের বেশির ভাগ বাদ দিয়েছে। দুটি box-এর IoU প্রায় ০.৮১: একই আসল box-এর বিপরীতে IoU ০.৫-এ দুটিই সহজে TP হতে পারত, কিন্তু COCO-র ০.৯-এর মতো কড়া threshold-এ দুটিরই TP হওয়া কঠিন। ছবিতে স্পষ্ট দেখা যায় এমন চামচটি Faster R-CNN দেখেছে ০.২৯৬ score-এ, ০.৩-এর ঠিক নিচে: threshold বাছাই একটি সিদ্ধান্ত, প্রকৃতির নিয়ম নয়। SSDLite ৩০০টি box ফেরত দিয়েছে, কারণ তার builder-এর default score threshold মাত্র ০.০০১ আর সর্বোচ্চ ৩০০টি box; নিজের threshold না বসালে output অর্থহীন লম্বা হয়, যেখানে Faster R-CNN-এর default ০.০৫। SSDLite-এর parameter প্রায় ছয় ভাগের এক ভাগ আর এই CPU-তে প্রায় ছয় গুণ দ্রুত, কিন্তু weights-এর meta-তে লেখা COCO box mAP ২১.৩ বনাম ৩২.৮. সময়গুলো এক যন্ত্রের এক run, সাধারণ ফল নয়।

কয়েকটি ব্যবহারিক কথা এই run থেকে। Model-কে দিতে হয় ছবির একটি list, কারণ ছবির মাপ আলাদা হতে পারে; ভেতরে model নিজেই মাপ বদলায় আর box মূল ছবির স্থানাঙ্কে ফেরত দেয়। Model-এর ভেতরে NMS আর score threshold-এর ধাপ আগে থেকেই আছে (Faster R-CNN-এ builder-এর box_score_thresh, box_nms_thresh), তাই output-এ সাধারণত ডুপ্লিকেট কম। .eval() না দিলে model training mode-এ থাকে আর target চায়। আর একটি সতর্কতা: torchvision-এর নথি বলে, pretrained model-এর নিজস্ব লাইসেন্স বা শর্ত থাকতে পারে যা training ডেটা থেকে আসে, আর ব্যবহারের অনুমতি আছে কি না তা ব্যবহারকারীকেই যাচাই করতে হয়; model card আর লাইসেন্সের অভ্যাস AI-এর ভিত্তি কোর্সের পর্ব ৭১-এ। নিজের পণ্যের জন্য সাধারণত এমন pretrained detector নিয়ে নিজের ছবিতে fine-tune করা হয় (পর্ব ২৩, Transfer learning).

৭ · Semantic segmentation আর U-Net — encoder, decoder আর skip connection

Segmentation-এ প্রতিটি pixel-এর জন্য একটি উত্তর চাই, তাই output-এর মাপ input-এর সমান। কিন্তু classification CNN স্তরে স্তরে ছবি ছোট করে (pooling, stride), যাতে প্রতিটি অবস্থান বড় এলাকা দেখে আর “কী” বোঝে। এই দুই চাহিদা মেলানোর কাঠামো encoder–decoder: encoder ছোট করে অর্থ বোঝে, decoder আবার বড় করে অবস্থান ফেরায়। Long, Shelhamer আর Darrell-এর Fully Convolutional Network (CVPR ২০১৫) দেখায় যে শেষের fully connected স্তর বাদ দিয়ে পুরোটা convolution রাখলে যেকোনো মাপের ছবিতে pixel ধরে predict করা যায়।

২০১৫ সালে Olaf Ronneberger, Philipp Fischer আর Thomas Brox চিকিৎসার microscopy ছবিতে কোষ আলাদা করতে U-Net প্রস্তাব করেন। নাম এসেছে আকার থেকে: বাম বাহু encoder নামে, ডান বাহু decoder ওঠে, আর প্রতিটি স্তরে encoder-এর feature map সরাসরি decoder-এর একই মাপের স্তরে পাঠানো হয় এবং channel ধরে জোড়া (concatenate) হয়। এই skip connection পর্ব ১৭-এর residual connection-এর মতো যোগ নয়, পাশাপাশি জোড়া; উদ্দেশ্যও আলাদা: gradient নয়, স্থানিক খুঁটিনাটি পৌঁছে দেওয়া।

ছোট থেকে বড় করা: transposed convolution. Decoder-এ মাপ বাড়ানোর একটি উপায় সাধারণ upsampling (প্রতিটি pixel পাশাপাশি কপি করা, বা bilinear), তারপর convolution. আরেকটি শেখা যায় এমন উপায় nn.ConvTranspose2d: input-এর প্রতিটি মান kernel দিয়ে গুণ হয়ে output-এ একটি ছোট টুকরো “ছাপ” দেয়, আর stride সেই ছাপগুলোর দূরত্ব ঠিক করে। Output-এর মাপ (dilation আর output_padding ছাড়া):

out = (in − 1) × stride − 2 × padding + kernel

U-Net-এর মতো kernel 2, stride 2, padding 0 নিলে (16 − 1) × 2 + 2 = ৩২: ঠিক দ্বিগুণ, আর ছাপগুলো একটি আরেকটির ওপর পড়ে না। Kernel ৩ আর stride ২ নিলে ছাপ অসমানভাবে ওভারল্যাপ করে, আর output-এ দাবার ছকের মতো দাগ (checkerboard artifact) আসতে পারে; Odena, Dumoulin আর Olah ২০১৬ সালে এর ব্যাখ্যা দেন, আর upsampling-এর পরে convolution বিকল্প হিসেবে প্রস্তাব করেন। নাম “transposed” কারণ সাধারণ convolution-কে matrix হিসেবে লিখলে এটি তার transpose-এর গুণ, যা convolution-এর backward pass-এর হিসাবও। একে “deconvolution” বলাটা প্রচলিত হলেও গাণিতিকভাবে ভুল নাম: এটি convolution-কে উল্টায় না।

Skip connection কেন লাগে. নিচের stepper একটি ৮ pixel-এর সারি দিয়ে দেখায়, max-pooling-এ কী হারায় আর skip তা কীভাবে ফেরায়। ধরে নেওয়া হলো decoder শিখেছে “upsample করা মান আর skip-এর মান দুটিই ১ হলে ১”, অর্থাৎ দুটির ছোটটি; আসল decoder-এ convolution এমন কিছু নিজে শেখে। পাশে আসল ছোট U-Net-এর shape.

৮ · Dice আর IoU — segmentation মাপা আর শেখানো

Segmentation-এ একটি mask-কে pixel-এর একটি set ধরলে box-এর IoU একই সংজ্ঞায় চলে: |P ∩ G| ÷ |P ∪ G|, যেখানে P predicted আর G ground-truth pixel. চিকিৎসা-ছবিতে বেশি প্রচলিত Dice coefficient, যা উদ্ভিদবিজ্ঞানে Lee R. Dice (১৯৪৫) আর Thorvald Sørensen (১৯৪৮)-এর মিলের মাপ থেকে এসেছে:

Dice = 2|P ∩ G| ÷ (|P| + |G|) = 2·IoU ÷ (1 + IoU)

দুটি একই ক্রমে চলে (একটি বাড়লে অন্যটিও), তবে Dice সবসময় IoU-এর সমান বা বেশি। Pixel accuracy (ঠিক pixel ÷ মোট pixel) সহজ কিন্তু বিভ্রান্তিকর: পটভূমি যদি ছবির বেশির ভাগ হয়, “সব পটভূমি” বলেও accuracy প্রায় ১। Training-এ hard mask-এর বদলে probability p বসিয়ে soft Dice বানানো যায়, যা differentiable; Dice loss = 1 − soft Dice. Milletari, Navab আর Ahmadi-র V-Net (২০১৬) প্রবন্ধ এটিকে loss হিসেবে জনপ্রিয় করে। প্রায়ই BCE-এর সঙ্গে যোগ করে ব্যবহার হয়: BCE প্রতিটি pixel-এ স্থির gradient দেয়, Dice ছোট বস্তুকে উপেক্ষা হতে দেয় না।

import numpy as np
import matplotlib.pyplot as plt

def dice(p, g, eps=1e-7):                # p, g: 0/1 mask বা 0..1 probability
    return (2 * np.sum(p * g) + eps) / (np.sum(p) + np.sum(g) + eps)

def iou(p, g, eps=1e-7):
    inter = np.sum(p * g)
    return (inter + eps) / (np.sum(p) + np.sum(g) - inter + eps)

g = np.zeros((10, 10)); g[2:8, 2:7] = 1      # ground truth: ৬ × ৫ = ৩০ pixel
p = np.zeros((10, 10)); p[3:9, 3:8] = 1      # prediction: এক ঘর ডানে-নিচে সরানো
print("pixels: gt", int(g.sum()), "| pred", int(p.sum()), "| overlap", int((p * g).sum()))
d, j = dice(p, g), iou(p, g)
print(f"Dice = {d:.4f} | IoU = {j:.4f} | 2*IoU/(1+IoU) = {2 * j / (1 + j):.4f}")
print(f"pixel accuracy = {np.mean(p == g):.2f}")

prob = np.where(p == 1, 0.9, 0.1)            # নিশ্চিত নয় এমন model-এর probability
print(f"soft Dice = {dice(prob, g):.4f} -> Dice loss = {1 - dice(prob, g):.4f}")

g2 = np.zeros((64, 64)); g2[30:34, 30:34] = 1    # বড় ছবিতে ছোট বস্তু: ১৬ pixel
empty = np.zeros((64, 64))                        # model কিছুই খুঁজে পায়নি
print(f"tiny object: pixel accuracy = {np.mean(empty == g2):.4f}, Dice = {dice(empty, g2):.4f}")

rgb = np.ones((10, 10, 3))
rgb[(p == 1) & (g == 1)] = (0.2, 0.7, 0.3)   # TP সবুজ
rgb[(p == 1) & (g == 0)] = (0.9, 0.3, 0.3)   # FP লাল
rgb[(p == 0) & (g == 1)] = (0.3, 0.4, 0.9)   # FN নীল
fig, axs = plt.subplots(1, 3, figsize=(7, 2.6))
for ax, im, t in zip(axs, [g, p, rgb], ["ground truth", "prediction", "TP green, FP red, FN blue"]):
    ax.imshow(im, cmap="gray_r" if im.ndim == 2 else None); ax.set_title(t, fontsize=9)
    ax.set_xticks([]); ax.set_yticks([])
plt.show()

pixels: gt 30 | pred 30 | overlap 20
Dice = 0.6667 | IoU = 0.5000 | 2*IoU/(1+IoU) = 0.6667
pixel accuracy = 0.80
soft Dice = 0.5938 -> Dice loss = 0.4062
tiny object: pixel accuracy = 0.9961, Dice = 0.0000

এবার সব মিলিয়ে একটি সত্যিকারের ছোট U-Net. ডেটা seed দিয়ে বানানো বাজারঘরের কৃত্রিম “পণ্যের ছবি”: ৬৪ × ৬৪ ধূসর ছবিতে ১–৩টি উপবৃত্ত, বাক্স আর সরু দণ্ড (বোতলের গলার মতো), ছায়া আর noise-সহ; mask হলো বস্তুর pixel. ২০০০টি train, ৪০০টি validation ছবি। একই model দুবার শেখানো হলো: skip connection-সহ, আর skip বাদ দিয়ে (decoder শুধু upsampled map পায়)। Loss = BCE with logits + (1 − soft Dice), AdamW lr 3e-3, batch ৩২, ৮ epoch. প্রতিটি block-এ দুটি 3 × 3 convolution, BatchNorm আর ReLU.

~/bazarghar-dl$ uv run python unet_train.py
Python 3.14.4 | torch 2.15.0+cpu | CPU
train (2000, 1, 64, 64), val (400, 1, 64, 64), foreground pixels in val: 0.094
shapes through TinyUNet (batch 2):
  input          (2, 1, 64, 64)
  enc1 (skip 1)  (2, 16, 64, 64)
  enc2 (skip 2)  (2, 32, 32, 32)
  bottleneck     (2, 64, 16, 16)
  up2            (2, 32, 32, 32)
  dec2           (2, 32, 32, 32)
  up1            (2, 16, 64, 64)
  dec1           (2, 16, 64, 64)
  logits         (2, 1, 64, 64)

U-Net (skips): 117,393 parameters
epoch  train loss  val Dice  val IoU  edge acc
    1      0.9162    0.9289   0.8672     0.7921
    2      0.3485    0.9638   0.9301     0.8907
    3      0.1346    0.9654   0.9332     0.8994
    4      0.0865    0.9688   0.9394     0.9067
    5      0.0672    0.9612   0.9254     0.8868
    6      0.0610    0.9701   0.9419     0.9122
    7      0.0548    0.9715   0.9445     0.9141
    8      0.0509    0.9714   0.9443     0.9146
time: 108 s on CPU

no skips: 105,873 parameters
epoch  train loss  val Dice  val IoU  edge acc
    1      0.7871    0.9096   0.8343     0.7305
    2      0.2929    0.9442   0.8943     0.8259
    3      0.1354    0.9523   0.9089     0.8514
    4      0.0912    0.9612   0.9252     0.8842
    5      0.0785    0.9571   0.9177     0.8767
    6      0.0711    0.9625   0.9277     0.8864
    7      0.0637    0.9656   0.9335     0.8978
    8      0.0593    0.9668   0.9357     0.9004
time: 86 s on CPU

প্রথমে shape-এর তালিকা: stepper-এর শেষ সারির সঙ্গে হুবহু মেলে (সামনে batch-এর মাত্রা ২ বাড়তি)। U-Net প্রথম epoch-এই validation Dice ০.৯২৮৯ পেয়েছে, আট epoch-এ ০.৯৭১৪ (IoU ০.৯৪৪৩)। শেষ কলাম “edge acc” হলো বস্তুর কিনারার দুই পাশের এক pixel চওড়া পট্টিতে ঠিক pixel-এর অনুপাত; খুঁটিনাটি হারালে এখানেই ধরা পড়ে। Skip বাদ দেওয়া model প্রতিটি epoch-এ পিছিয়ে, শেষে Dice ০.৯৬৬৮ আর edge acc ০.৯০০৪ (U-Net-এ ০.৯১৪৬)। Dice-এর পার্থক্য ছোট, কিনারার পার্থক্য তার প্রায় তিন গুণ, যা stepper-এর যুক্তির সঙ্গে মেলে। পার্থক্য আরও বড় নয় কারণ এই ছোট network মাত্র দুবার অর্ধেক করে (৬৪ থেকে ১৬), তাই bottleneck-এ এখনো অনেক অবস্থান-তথ্য থাকে; মূল U-Net-এর মতো চারবার অর্ধেক করলে skip ছাড়া হারায় অনেক বেশি। পঞ্চম epoch-এ দুটিরই সামান্য পতন ছোট ডেটায় স্বাভাবিক ওঠানামা। Parameter-এর পার্থক্য (১,১৭,৩৯৩ বনাম ১,০৫,৮৭৩) শুধু decoder-এর বাড়তি input channel থেকে। এটি একটি seed-এর এক run, আর Dice মাপা হয়েছে dataset-স্তরে, সব pixel একসঙ্গে যোগ করে।

৯ · বাস্তবে চালানো — গতি, ভুলের ধরন আর ডেটা

Augmentation-এ একটি ফাঁদ: ছবি উল্টালে, কাটলে বা ঘোরালে box আর mask-কেও একইভাবে বদলাতে হয়। torchvision-এর transforms.v2 tv_tensors.BoundingBoxes আর tv_tensors.Mask চিনে ছবির সঙ্গে একসঙ্গে বদলায় (পর্ব ২৪, Data augmentation). গোপনীয়তার দিকও আছে: মানুষ বা গাড়ির নম্বরপ্লেটের ছবি নিয়ে detection মানে নজরদারির ক্ষমতা; কাদের ছবি, কার অনুমতিতে, কী কাজে, তা নকশার শুরুতেই ঠিক করা দরকার।

১০ · AI-এর যুগে — detection আর segmentation কোডে AI-এর ভুল ধরা

AI assistant দিয়ে detection-এর কোড লেখানো সহজ, কারণ torchvision আর জনপ্রিয় লাইব্রেরির উদাহরণ অনলাইনে প্রচুর। কিন্তু এখানে ভুল প্রায়ই নীরব: কোড চলে, ছবিতে box-ও আঁকে, শুধু ভুল জায়গায় বা ভুল সংখ্যায়।

AI-এর দেওয়া detection বা segmentation কোড — যাচাইয়ের চেকলিস্ট

• কয়েকটি ছবিতে predicted box আর mask এঁকে চোখে দেখেছি, শুধু সংখ্যা দেখে সন্তুষ্ট হইনি
• Box-এর ফরম্যাট আর স্থানাঙ্ক (pixel নাকি ০–১) প্রতিটি ধাপে মিলিয়েছি
• API নিজের torchvision version-এর docs-এ মিলিয়েছি; weights-এর লাইসেন্স আর model card পড়েছি
• নিজের IoU/NMS-কে torchvision-এর সঙ্গে, নিজের mAP-কে প্রতিষ্ঠিত evaluator-এর সঙ্গে মিলিয়েছি
• Test ছবি training বা threshold বাছাইয়ে ব্যবহার করিনি; কয়েকটি seed-এ ফল দেখেছি
• AI-এর বলা প্রবন্ধ, সাল আর benchmark-এর সংখ্যা নিজে খুঁজে দেখেছি; ব্যক্তিগত ছবি বা key পেস্ট করিনি