Object Detection

Key ideas

• Task: for every object, output a class label and a bounding box. A box is 4 numbers: corners $(x_1, y_1, x_2, y_2)$ or centre format $(c_x, c_y, w, h)$, with $y$ pointing down in pixel coordinates. Classification answers "what", detection also "where"; pixel masks are segmentation.
• IoU (Jaccard index) = area of intersection / area of union: 1 for identical boxes, 0 for disjoint ones¹. A detection counts as correct only if its IoU with a ground-truth box reaches a threshold, 0.5 in PASCAL VOC's metric⁴; IoU punishes missed area as much as extra background.
• Anchor boxes: reference boxes of several scales and aspect ratios centred on a grid; the network predicts a class and four offsets per anchor¹. d2l gives an anchor of scale $s$ and ratio $r$ the size $ws\sqrt r \times hs/\sqrt r$ and keeps the $n + m - 1$ scale–ratio pairs that contain $s_1$ or $r_1$ at every pixel¹. Offsets measure the centre shift in units of the anchor's width and height and the size change as a log ratio^1,4; d2l also divides them by 0.1 (centre) and 0.2 (size) so the targets are more evenly spread and easier to fit¹. The log treats doubling and halving symmetrically ($\pm\log 2$), and decoding $w = w_a e^{t_w}$ always gives a positive width.
• Labelling anchors: in Faster R-CNN an anchor is positive if it has the highest IoU with some ground-truth box or an IoU above 0.7, negative if its IoU is below 0.3 for every ground-truth box, and ignored otherwise⁴. d2l likewise first gives every ground-truth box its best anchor, then applies a threshold¹.
• Non-maximum suppression: sort the boxes by score, keep the best, delete the remaining boxes whose IoU with it exceeds a threshold, repeat with the next survivor¹. A box that only overlaps an already deleted box survives. d2l's NMS, like torchvision's nms, puts all classes into one list; batched_nms runs it per class, so it never suppresses across classes (see the code). The greedy rule is hand-crafted, but a network can also learn to suppress duplicates⁸.
• Two-stage detectors³: R-CNN runs a CNN on each of about 2000 selective-search proposals (slow). Fast R-CNN runs the CNN once per image and uses RoI pooling, which splits each proposal's window into an $h_2 \times w_2$ grid and max-pools every cell, so all proposals give features of the same shape. Faster R-CNN drops selective search and lets a learned region proposal network (RPN) propose regions from the shared feature map. The RPN predicts $2k$ objectness scores and $4k$ box coordinates per position for $k = 9$ anchors (3 scales × 3 ratios)⁴.
• One-stage detectors predict classes and boxes for all positions in a single pass, which makes them fast⁵. YOLO frames detection as one regression from the image to an $S \times S \times (5B + C)$ tensor. The cell containing an object's centre is responsible for it and predicts the centre relative to the cell and the size relative to the image; a cell's few boxes share one set of class probabilities, so groups of small objects (flocks of birds) are hard⁵. SSD predicts from dense anchors on several feature maps with $3 \times 3$ convolutions that output $a(q + 1)$ class channels and $4a$ offset channels for $a$ anchors per position²; deeper, coarser maps have larger receptive fields and detect larger objects².
• Feature pyramids: FPN adds a top-down pathway with lateral connections, so even the fine, high-resolution maps carry strong semantics and can detect small objects; its RPN puts anchors of a single scale (three aspect ratios) on each pyramid level⁷.
• Class imbalance: almost every candidate location is easy background. Two-stage detectors cut the candidates to one or two thousand proposals and sample minibatches with a fixed positive/negative ratio (the RPN: 256 anchors per image, up to 1:1)^4,6. One-stage detectors face the full imbalance: SSD-style models mine hard negatives, while RetinaNet uses the focal loss, which down-weights well-classified examples, and initializes the classifier bias so that every anchor starts at foreground probability $\pi = 0.01$⁶.
• Box regression loss: L1 (d2l's SSD) or smooth L1 (Faster R-CNN) on the offsets, computed for positive anchors only^2,4.
• Evaluation: go down the detections in order of confidence and pair each with a still unclaimed ground-truth object; every object can be claimed only once, so a second detection of it is a false positive that costs precision⁸. A detection is a true positive if it claims a ground-truth box at the IoU threshold, otherwise a false positive; ground-truth boxes nobody claims are false negatives. AP summarizes the precision–recall curve of one class, and mAP averages AP over classes. COCO's main metric averages AP over the IoU thresholds $0.50, 0.55, \ldots, 0.95$, written mAP@[.5, .95], while PASCAL VOC uses mAP@0.5⁴. A detector can win at 0.5 and lose on the stricter average if its boxes are loose⁴.

Formulas

Faster R-CNN regresses these offsets directly⁴; d2l divides $t_x, t_y$ by 0.1 and $t_w, t_h$ by 0.2¹.

Here $p_t$ is the predicted probability of the true class and $b$ the prior bias⁶. Smooth L1 with parameter $\sigma$ is $(\sigma x)^2/2$ for $\lvert x \rvert < 1/\sigma^2$ and $\lvert x \rvert - 0.5/\sigma^2$ otherwise².

Worked example

Boxes $A = (0, 0, 10, 10)$ score 0.9, $B = (5, 0, 15, 10)$ score 0.8, $C = (1, 1, 11, 11)$ score 0.7, $D = (20, 20, 30, 30)$ score 0.6.

• $\mathrm{IoU}(A, B)$: overlap $5 \times 10 = 50$, union $100 + 100 - 50 = 150$, so $1/3$. $\mathrm{IoU}(A, C)$: overlap $9 \times 9 = 81$, union $119$, so $0.681$.
• NMS at threshold 0.5: keep $A$, delete $C$ (0.681 > 0.5), keep $B$ (only 1/3 with $A$), keep $D$. Result: $A, B, D$.
• AP with 3 ground-truth objects and ranked detections TP, FP, TP, TP: precisions at the TPs are $1/1$, $2/3$, $3/4$, so AP $= (1 + 0.667 + 0.75)/3 \approx 0.806$.

In code

import torch
from torchvision.ops import batched_nms, box_iou, nms
boxes = torch.tensor([[0., 0., 10., 10.],    # A  (x1, y1, x2, y2)
                      [5., 0., 15., 10.],    # B
                      [1., 1., 11., 11.],    # C
                      [20., 20., 30., 30.]]) # D
scores = torch.tensor([0.9, 0.8, 0.7, 0.6])
print(box_iou(boxes, boxes)[0])               # tensor([1.0000, 0.3333, 0.6807, 0.0000])
print(nms(boxes, scores, iou_threshold=0.5))  # tensor([0, 1, 3])
labels = torch.tensor([0, 0, 1, 0])           # now C belongs to another class
print(batched_nms(boxes, scores, labels, 0.5))  # tensor([0, 1, 2, 3])  C survives

Common pitfalls

• A predicted box with a tiny IoU is a false positive, not a false negative; a false negative is a ground-truth object that nothing detected.
• A box lying entirely inside the object can still fail the 0.5 threshold, because IoU also punishes the missed area.
• Two detections of the same object: only the higher-ranked match is a TP, the other is a FP⁸.
• Plain NMS ignores classes: a dog box can delete an overlapping cat box unless NMS runs per class (batched_nms).
• Geometric augmentation must transform the boxes too: a horizontal flip maps $(x_1, x_2)$ to $(W - x_2, W - x_1)$, and random crops must clip or drop boxes.
• YOLO predicts $5B + C$ numbers per cell: class probabilities are shared by the cell's boxes, not repeated per box⁵.
• Deep, coarse feature maps are for large objects (large receptive fields); small objects need the fine, early maps².
• A higher AP@0.5 does not imply a higher COCO AP@[.5, .95]⁴.