Intuition

Detection answers two questions per object: 'where' (a bounding box) and 'what' (a class). The history of the field is essentially the story of moving the expensive parts of that pipeline — region proposals, per-region computation, ranking — onto the GPU and into a single shared backbone. By 2016 the two-stage R-CNN family had matured (R-CNN → Fast → Faster); YOLO then asked 'why two stages at all?' and reframed detection as a single regression problem in one CNN forward pass.

Explanation

The task staircase. Classification predicts one label per image. Classification + localisation adds one box (x, y, w, h) for an image known to contain ONE object. Detection drops that assumption — variable number of objects per image, each needing a (label, box) pair. Instance segmentation goes further: per-instance pixel masks. Detection is harder than localisation for three concrete reasons: variable-length output (1 object vs 47), mixed output types (discrete class + continuous box), and resolution (classification works at $224\times 224$; detection needs ~$800\times 600$ because tiny objects vanish at low resolution).

Modal vs amodal boxes. A modal box covers only the visible portion (the dog's box stops at the chair that occludes it). An amodal box covers the full extent even through occlusion. PASCAL VOC, COCO and standard benchmarks use MODAL boxes — this is a common one-mark trap.

IoU = Jaccard index. $\text{IoU}(A,B)=|A\cap B|/|A\cup B|$. Symmetric. Calibration: $>0.5$ decent, $>0.7$ good, $>0.9$ near-perfect. Important warning: IoU = 0.5 is NOT 'boxes overlap by 50%' — two equal squares sharing only one-third of each other can have IoU = 0.5. Don't reason from it as a percentage.

Idea #1 — localisation as regression. With exactly one object per image, slap a regression head on a CNN that outputs four numbers (x, y, w, h), trained with L2 loss against the ground-truth box. Two flavours exam questions test: class-AGNOSTIC (4 outputs, single box) vs class-SPECIFIC (C × 4 outputs, one box per class). Generalises to K objects only if K is fixed — not real detection.

Idea #2 — sliding window (Overfeat, ICLR 2014, ILSVRC 2013 winner). Run the network at every position and scale; classify each window; regress a box; merge. The clever trick: convert fully-connected layers into 1×1 convolutions so all positions are handled by a single forward pass — no Python-level sliding loop. Cost: still expensive across scales; can't gracefully handle variable object counts.

Idea #3 — propose then classify. Treat detection as classification on a small set of CANDIDATE windows. The class-agnostic proposer is Selective Search (Uijlings et al., IJCV 2013): a classical bottom-up segmentation algorithm that starts from oversegmentation and greedily merges similar regions using colour, texture, size and fill similarity measures. Output: ~2000 boxes per image. Not learned, runs on CPU, fast enough — and the workhorse for the entire R-CNN family.

R-CNN (Girshick, CVPR 2014). Five training steps drawn straight from the lecture: (1) pretrain a CNN on ImageNet; (2) fine-tune the classification head to $20+1=21$ classes (PASCAL classes + background) on detection data; (3) extract pool5 features for every proposal — about 2000 per image, each warped to $227\times 227$ — and cache to disk (about 200 GB for the PASCAL set!); (4) train one binary SVM per class on those cached features; (5) train a class-specific box regressor predicting offsets $(\Delta x,\Delta y,\Delta w,\Delta h)$ in normalised coords. Test time: proposals → warp → CNN → SVM scores + box refinement → NMS → done. Three deep flaws: SLOW at test time (~47 s/image because ~2000 CNN forwards per image on overlapping crops); POST-HOC training (CNN is frozen before the SVMs and regressors are trained, so the features can't adapt to what's actually useful); MULTI-STAGE pipeline (five separate stages, none end-to-end).

Fast R-CNN (Girshick, ICCV 2015). Key insight: 2000 forward passes are wasteful because the proposals all come from the same image — the early conv layers redo the same work. Run the backbone ONCE on the full image, then crop per-proposal from the feature map via RoI Pooling: project the proposal box onto the feature map (scale by the network's stride), divide the projected region into a fixed $h\times w$ grid (typically $7\times 7$), and max-pool inside each cell. Output is a uniform $C\times h\times w$ tensor per proposal — same shape for every region regardless of proposal size. RoI Pool is differentiable, so the whole network trains end-to-end with one multi-task loss (CE on classification + smooth-L1 on box regression). Numbers: training $84\text{ hr}\to 9.5\text{ hr}$ (~8.8×), test $47\text{ s}\to 0.32\text{ s}$ (~146×), mAP $66.0\to 66.9$ on VOC 2007. Problems #2 (post-hoc) and #3 (multi-stage) are gone.

Faster R-CNN (Ren et al., NIPS 2015) — the RPN. Fast R-CNN's 0.32 s test time hides a ~2 s Selective Search step running on CPU. Replace that with a Region Proposal Network that shares the CNN backbone. After the last conv layer, slide a $3\times 3$ conv over the feature map; two $1\times 1$ conv heads branch off — one for objectness (binary: 'is this anchor an object?'), one for box regression. At each spatial location the RPN predicts $k$ anchors — typically $k=9=3$ scales $\times$ 3 aspect ratios. Outputs per location: $9\cdot (2+4)=54$ numbers. Two properties matter: TRANSLATION INVARIANCE (same anchor set at every location — the RPN learns what objects look like, not where they live) and ANCHOR-RELATIVE OFFSETS (regress $t_x=(x-x_a)/w_a,t_y=(y-y_a)/h_a,t_w=\log (w/w_a),t_h=\log (h/h_a)$ — much easier to learn than raw coordinates because the anchor already gives a rough size/shape prior). Once the RPN gives proposals, the rest is Fast R-CNN. End-to-end test: ~0.2 s/img, mAP 66.9, $250\times$ speedup over R-CNN. Two stages, one network.

YOLO v1 (Redmon et al., CVPR 2016) — single-shot. Reframe detection as a SINGLE regression problem. Resize the image to $448\times 448$, divide into an $S\times S$ grid ($S=7$), and let EACH CELL be responsible for the object whose CENTRE lies in that cell (not 'overlapping' — centre). Each cell outputs B = 2 candidate boxes, each with 5 numbers — $(x,y)$ centre relative to the CELL, $(w,h)$ size relative to the WHOLE IMAGE, $c$ objectness — plus C = 20 class probabilities SHARED across the cell's $B$ boxes. Output tensor: $7\times 7\times (2\cdot 5+20)=7\times 7\times 30$. Why two boxes? At training time both predict and we pick whichever has higher IoU with the ground truth as the 'responsible' predictor (the other is trained toward objectness 0). The two boxes specialise — one tends to learn tall, the other wide.

YOLO loss decomposition. Sum of squared errors, summed cell-by-cell, with two scaling weights to fix the object/no-object imbalance: ${\lambda }_{\text{coord}}=5$ upweights box-coord errors; ${\lambda }_{\text{noobj}}=0.5$ downweights no-object confidence loss. Five terms: (1) box-centre $(x,y)$ on object cells; (2) box-size $(\sqrt{w},\sqrt{h})$ on object cells (the square root makes equal absolute pixel error matter more on small boxes — exam gold); (3) objectness on object cells (target = IoU with GT); (4) objectness on no-object cells (target = 0, weighted by ${\lambda }_{\text{noobj}}$); (5) classification on object cells. Test-time post-processing: per-class confidence = box objectness $\times$ class prob; threshold low scores; per-class NMS to clean overlaps.

YOLO v1's three limitations (the most likely exam question): (1) AT MOST 49 OBJECTS detectable — $7\times 7$ grid, one object per cell, so 50+ objects can't all be represented; (2) STRUGGLES WITH SMALL CLUSTERED OBJECTS (birds in a flock, faces in a crowd — multiple centres fall in one cell, only one survives); (3) POOR LOCALISATION because direct $(x,y,w,h)$ regression is harder than refining anchors. v2 onward fixed (3) by reintroducing anchors. YOLO generalised surprisingly well to non-natural images (paintings) where Selective Search struggled.

Two-stage vs single-stage trade-off. Two-stage (R-CNN family): propose → classify; historically higher mAP; slower; output is variable per-image. Single-stage (YOLO, SSD, RetinaNet): one forward pass; real-time; fixed-size tensor; historically lower mAP, closed by v3+ and Focal Loss. Two-stage 'thinks like a careful detective', single-stage 'thinks like a reflex'. For real-time (self-driving, robotics, video surveillance) use single-stage; for accuracy-critical (medical, security) use two-stage.

Losses for better gradients. GIoU adds a penalty $|C\setminus (A\cup B)|/|C|$ (with $C$ = smallest enclosing box) so non-overlapping boxes still have non-zero gradient — pure IoU loss stalls at $\partial \text{IoU}/\partial \text{box}=0$ when boxes are disjoint. Focal Loss $\text{FL}=-(1-p_t{)}^{\gamma }\log p_t$ (with $\gamma =2$) multiplies cross-entropy by a modulating factor that crushes easy-classified examples (high $p_t$) — essential for single-stage detectors where the background class dominates anchor counts ($\sim$ tens of thousands of background anchors per image vs a handful of foreground).

Soft-NMS variants. Hard NMS zeros the score of suppressed boxes. Soft-NMS multiplies by a decay: linear $s_i\leftarrow s_i\cdot (1-\text{IoU})$ or Gaussian $s_i\leftarrow s_i\cdot \exp (-{\text{IoU}}^2/\sigma )$. The Gaussian variant lets nearby legitimate objects (two pedestrians shoulder-to-shoulder, IoU $\approx 0.8$) keep some confidence rather than vanishing entirely.

Evaluation in detail — Precision, Recall, AP, mAP. Fix a class and an IoU threshold (say 0.5). Each detection is TP (matches an unmatched GT box with IoU $\ge 0.5$), FP (matches nothing, or claims an already-matched GT), or FN if a GT is unmatched. $\text{Precision}=\text{TP}/(\text{TP}+\text{FP})$ — fraction of your detections that are correct. $\text{Recall}=\text{TP}/(\text{TP}+\text{FN})$ — fraction of true objects you found. Sweep the confidence threshold: high threshold $\to$ high precision, low recall; low threshold $\to$ vice versa. AP = area under the resulting PR curve. mAP = mean over classes. VOC reports mAP@0.5 with 11-point interpolation (precisions at recall = $0,0.1,\dots ,1.0$ averaged). COCO reports the AVERAGE of mAP@$\{0.5,0.55,\dots ,0.95\}$ — ten thresholds, 101-point interpolation — which is why COCO numbers look much smaller than VOC's despite the same detector.

Datasets to name-drop. PASCAL VOC 2010: 20 classes, ~20 k images, 2.4 objects/image. ImageNet Detection (ILSVRC 2014): 200 classes, ~470 k images, but only 1.1 objects/image — almost every image has one centred object, so ImageNet is great for classification and BAD for detection benchmarking. MS-COCO 2014: 80 classes, ~120 k images, 7.2 objects/image — the modern standard for crowded-scene evaluation.

What comes next. Mask R-CNN adds an instance-segmentation mask head on top of Faster R-CNN (Unit 2). FPN (Feature Pyramid Network) adds multi-scale features via top-down lateral connections so the same detector can find both small and large objects — standard in every modern detector. RetinaNet introduced Focal Loss to let single-stage finally beat two-stage. DETR (2020) reformulates detection as set prediction with attention — no anchors, no NMS.

Definitions

• Bounding box (modal vs amodal) — Modal: covers only the visible portion of the object; standard in PASCAL VOC, COCO, KITTI. Amodal: covers the full extent including occluded parts; used in specialised benchmarks.
• Anchor — A predefined box prior at fixed scale and aspect ratio; predictions are regression offsets from it. Faster R-CNN uses $k=9$ anchors per location (3 scales × 3 ratios).
• Selective Search — Classical bottom-up segmentation (Uijlings et al., IJCV 2013). Starts from oversegmentation, greedily merges similar regions using colour + texture + size + fill similarity. Produces ~2000 class-agnostic proposals per image. Workhorse of R-CNN and Fast R-CNN; not learned.
• RoI Pool — Project the proposal to the feature map (quantising to integer cells), divide into a fixed $h\times w$ grid (typically $7\times 7$), max-pool per cell. Differentiable, but the two roundings cause sub-pixel misalignment in the input image — fatal for masks.
• RPN (Region Proposal Network) — Faster R-CNN's learned, backbone-sharing proposal generator. $3\times 3$ conv → two $1\times 1$ heads (objectness + box regression). Translation-invariant: same anchor set at every spatial location.
• FPN (Feature Pyramid Network) — Multi-scale feature representation with top-down lateral connections (Lin et al., CVPR 2017). High-resolution shallow features + low-resolution deep features fused via $1\times 1$ lateral convs. Lets one detector head handle small + large objects together. Standard in every modern detector.
• GIoU — Generalised IoU. Adds the penalty $|C\setminus (A\cup B)|/|C|$ where $C$ is the smallest enclosing box. Non-zero gradient even when boxes don't overlap. Bounded in $[-1,1]$.
• Focal Loss — Cross-entropy multiplied by $(1-p_t{)}^{\gamma }$ with $\gamma \approx 2$ (Lin et al., ICCV 2017). Crushes the gradient contribution of easy-classified examples — essential for single-stage detectors where background anchors vastly outnumber foreground.
• Non-Maximum Suppression — Per-class procedure: sort detections by score; keep the top one; suppress all with IoU > $\tau$; repeat. $\tau \approx 0.5$ typical. Fails in dense crowds where legitimate overlapping objects get suppressed.
• Soft-NMS — Variant that DECAYS suppressed scores instead of zeroing them. Linear: $s_i\leftarrow s_i\cdot (1-\text{IoU})$. Gaussian: $s_i\leftarrow s_i\cdot \exp (-{\text{IoU}}^2/\sigma )$. Lets nearby legitimate objects coexist.
• mAP — Mean of per-class Average Precision (area under PR curve). VOC uses 11-point interpolation at IoU = 0.5. COCO averages mAP over IoU thresholds $\{0.5,0.55,\dots ,0.95\}$ (101-point interp per threshold). COCO numbers are smaller because the metric is stricter.
• Smooth-L1 loss — Quadratic near zero (smooth gradient at the minimum), linear elsewhere (robust to outliers). Used for box regression in Fast/Faster R-CNN: $\ell (z)=0.5z^2$ if $|z|<1$ else $|z|-0.5$.
• Overfeat — Sermanet et al., ICLR 2014 (ILSVRC 2013 detection winner). Sliding-window classification + box regression, made practical by converting FC layers into $1\times 1$ convs so the whole image is processed in one forward pass.

Formulas

• $$\text{IoU}(A,B)=\frac{|A\cap B|}{|A\cup B|}(\text{aka Jaccard index})$$
• $$\text{GIoU}(A,B)=\text{IoU}(A,B)-\frac{|C\setminus (A\cup B)|}{|C|},C=\text{smallest enclosing box}$$
• $$\text{FL}(p_t)=-(1-p_t{)}^{\gamma }\log p_t,\gamma =2$$
• $$\text{Anchor regression targets:}{t}_x=\frac{x-x_a}{w_a},t_y=\frac{y-y_a}{h_a},t_w=\log \frac{w}{w_a},t_h=\log \frac{h}{h_a}$$
• $$\text{Smooth-L1:}\ell (z)=\{\begin{array}{ll}0.5z^2& |z|<1\\ |z|-0.5& |z|\ge 1\end{array}$$
• $$\text{Soft-NMS (Gaussian):}{s}_i\leftarrow s_i\cdot \exp \left(-\frac{\text{IoU}(M,b_i{)}^2}{\sigma }\right)$$
• $$\text{Soft-NMS (linear):}{s}_i\leftarrow s_i\cdot (1-\text{IoU}(M,b_i))\text{if IoU}>\tau$$
• $$\text{YOLO output tensor:}S\times S\times (B\cdot 5+C)(\text{PASCAL VOC: }7\times 7\times 30)$$
• $$\text{RPN output per location:}k\cdot (2+4)=9\cdot 6=54\text{numbers}$$
• $$\text{VOC mAP@0.5}=\frac{1}{C}\sum _{c=1}^C{\text{AP}}_c\left(\text{IoU}\ge 0.5\right)$$
• $$\text{COCO mAP}=\frac{1}{10}\sum _{t\in \{0.5,0.55,\dots ,0.95\}}\text{mAP@}t$$
• $$\text{Precision}=\frac{\text{TP}}{\text{TP}+\text{FP}},\text{Recall}=\frac{\text{TP}}{\text{TP}+\text{FN}}$$

Derivations

GIoU restores gradient on non-overlapping boxes. Pure IoU is zero whenever $A\cap B=\varnothing$, so $\partial \text{IoU}/\partial \text{box}=0$ — no signal pulls a far-away predicted box toward the ground truth. GIoU adds $-|C\setminus (A\cup B)|/|C|$ where $C$ is the smallest enclosing box. Off-overlap, this term varies smoothly with the relative position of $A$ and $B$, restoring a useful gradient direction. Bound: when $A=B$, IoU = 1 and the enclosing-box term is 0 so GIoU = 1; when $A$ and $B$ are tiny and far apart, IoU $\to 0$ and the term $\to 1$ so GIoU $\to -1$. Hence GIoU $\in [-1,1]$.

**Why $\sqrt{w}$, $\sqrt{h}$ in YOLO size loss.** Without $\sqrt{\cdot }$: a 10-pixel error on a 400-pixel-wide box and a 10-pixel error on a 20-pixel-wide box contribute equally. But the small-box error matters far more in human terms (10 px is half the object!). Predicting $\sqrt{w}$ and $\sqrt{h}$ instead: $\frac{d\sqrt{w}}{dw}=\frac{1}{2\sqrt{w}}$, so the GRADIENT of the loss with respect to $w$ scales as $\frac{1}{\sqrt{w}}$ — small boxes get larger gradient per pixel of width error, big boxes get smaller. Balances localisation across scales.

RoI Pool quantisation arithmetic — worked example. Suppose backbone stride is 16. Selective Search returns a proposal at image coordinates $(x_1,y_1,x_2,y_2)=(16,32,159,224)$. Project to feature map by dividing by stride: float bounds $(1.0,2.0,9.9375,14.0)$. RoI Pool ROUNDS to integer cells: $(1,2,9,14)$ — already a sub-pixel shift in the original image. Now divide into a $7\times 7$ grid: bin width $(9-1)/7\approx 1.143$ cells; RoI Pool rounds again at each bin boundary. The cumulative error can be $\sim 1$ feature pixel = $16$ original pixels in the worst case — fatal for mask prediction (Mask R-CNN's RoI Align fixes this with bilinear sampling at 4 points per bin and no rounding).

R-CNN's five training stages, traced. (1) Pretrain CNN (AlexNet) on ImageNet 1000-way classification. (2) Fine-tune classifier head to 21 classes (20 PASCAL + background); positives = proposals with IoU $>0.5$ to any GT, negatives otherwise. (3) Run Selective Search on every training image, warp each proposal to $227\times 227$, forward-pass through frozen CNN, save pool5 features to disk (~200 GB total). (4) Per class, train a binary SVM (cat vs not-cat, dog vs not-dog, …) on those cached features. (5) Per class, train a regressor predicting normalised offsets $(\Delta x,\Delta y,\Delta w,\Delta h)$ from proposal to GT. Test: proposals → warp → CNN → SVM scores + box refinement → NMS. The flaw cascade: CNN frozen by step 3, so SVMs in step 4 and regressors in step 5 can't shape what the CNN learns. Five disjoint training runs, none end-to-end — Fast R-CNN's RoI Pool is what made the whole pipeline a single optimiser.

AP worked example (the lecture's canonical trace). Five 'dog' detections sorted by score and 3 ground-truth dogs. Score 0.99 → TP (matches GT${}_1$). Score 0.95 → TP (matches GT${}_2$). Score 0.90 → FP (no unmatched GT with IoU $\ge 0.5$). Score 0.50 → FP. Score 0.10 → TP (matches GT${}_3$). Cumulative table: after each detection $(P,R)=(1.00,0.33),(1.00,0.67),(0.67,0.67),(0.50,0.67),(0.60,1.00)$. AP = area under the staircase. For this example AP = 0.86. Get AP = 1.0 only when every TP ranks above every FP and no GT is missed.

Examples

• RPN output arithmetic. Feature map $14\times 14$ with $k=9$ anchors per location. Total proposals = $14\cdot 14\cdot 9=1764$ candidate boxes per image. Each location outputs $9\cdot (2+4)=54$ numbers, so the RPN head produces $14\cdot 14\cdot 54=10584$ scalars per image before filtering by objectness + per-batch top-N proposals.
• Standard RPN anchor config (Faster R-CNN). Three scales $\{128^2,256^2,512^2\}$ pixels, three aspect ratios $\{1:1,1:2,2:1\}$ — nine total per location, covering most common object shapes. Anchors are at the receptive-field centres of the feature map.
• Per-class NMS trace. Three detections after the RPN: $A$ (car, score 0.9), $B$ (car, score 0.8, IoU with $A$ = 0.7), $C$ (person, score 0.85, IoU with $A$ = 0.6). Threshold $\tau =0.5$. Step 1: pick $A$ (highest car score) — keep; suppress $B$ (IoU > 0.5). Step 2: only $C$ remains in its class — keep. Final: $\{A,C\}$. KEY: $C$ is NOT suppressed by $A$ despite IoU 0.6 because NMS is applied PER CLASS — car and person are independent.
• COCO vs VOC mAP example. Same detector. mAP@0.5 = 0.77 (VOC-style). mAP@0.55 = 0.71, mAP@0.60 = 0.65, …, mAP@0.95 = 0.20. COCO mAP = average of those ten = ~0.40. Both numbers describe the same model; COCO is just stricter.
• PASCAL VOC 2007 detector trace. 20 classes. Run on 5 k test images: get ~50 k detections total. Sort by score across all detections per class. Per class: walk the sorted list, mark TP/FP at IoU $\ge 0.5$, build the PR curve, compute AP via 11-point interpolation. Average the 20 class APs → mAP. Faster R-CNN gets ~66.9 here.
• Speed evolution (one-line memorisation). R-CNN 47 s/img → Fast R-CNN 0.32 s (+ 2 s Selective Search outside) → Faster R-CNN 0.2 s → YOLO v1 22 ms (45 FPS) → Fast YOLO 6 ms (155 FPS).

Diagrams

• R-CNN → Fast → Faster evolution: per-region CNN forwards → shared backbone + RoI Pool → shared backbone + RPN. Annotate the bottleneck removed at each step (proposal cost, redundant convs, CPU Selective Search).
• RPN at one location: 9 anchors of varying scale and aspect ratio overlaid on the receptive field; two 1×1 conv heads emit objectness (binary) + box deltas (4 numbers) per anchor.
• RoI Pool diagram: a floating-point RoI projected on the feature map → quantised to integer cells → divided into a $7\times 7$ grid → max-pool inside each cell. Highlight the two rounding steps that cause misalignment.
• YOLO grid: the image divided into 7×7 = 49 cells; each cell's centre is marked; show one object whose centre falls inside one cell, with that cell predicting B = 2 candidate boxes.
• PR curve for the 5-detection AP example: a staircase from $(0.33,1.00)$ to $(1.00,0.6)$, with area under the curve shaded.
• NMS trace as a small table: rows = detections sorted by score, columns = (class, score, IoU with surviving boxes, kept?, suppressed-by).

Edge cases

• NMS in dense crowds. Two pedestrians walking shoulder-to-shoulder have boxes with IoU $\approx 0.8$. Hard NMS suppresses one as a duplicate even though both are real. Soft-NMS (linear or Gaussian decay) preserves both with reduced score; the lecture explicitly says of standard NMS: 'no good solution =('.
• Per-class vs global NMS. Applying NMS GLOBALLY across classes wrongly suppresses, e.g., a dog and a nearby person. Always partition by class first.
• Pure IoU loss for non-overlapping boxes. $\partial \text{IoU}/\partial \text{box}=0$ when $A\cap B=\varnothing$ — training stalls early because there's no gradient to pull the predicted box toward the GT. GIoU / DIoU / CIoU fix this.
• Small-object failure of vanilla detectors. YOLO v1 cell size is $448/7\approx 64$ px; objects smaller than ~32 px lose their centre information when downsampled. RPN's smallest anchor at the final feature level is typically $\ge 32$ px on the input image. Fix: FPN — predict on multiple feature levels so small objects are detected on the high-resolution P2 level.
• YOLO's 49-object cap. $7\times 7$ grid hard-limits the prediction to 49 objects. Crowds, flocks, swarms exceed this. v2 onwards reintroduced more grid cells and anchors.
• Anchor scale mismatch. If the smallest anchor at the final feature level is still larger than typical objects in your domain (e.g., aerial imagery with 8-px boats), the RPN will never match them and recall on small objects collapses.
• ImageNet detection misleading. ILSVRC 2014 has 1.1 objects/image — almost every image is a centred singleton. Models that score well there can fail on COCO (7.2 obj/img) where occlusion and crowding matter.

Common mistakes

• 'YOLO predicts B class distributions per cell.' WRONG — YOLO predicts ONE class distribution per cell, SHARED across the $B$ boxes. That's why YOLO struggles when multiple object types share a cell.
• **Confusing ${\lambda }_{\text{coord}}$ and ${\lambda }_{\text{noobj}}$.** ${\lambda }_{\text{coord}}=5$ UPWEIGHTS box-coordinate loss (localisation matters more). ${\lambda }_{\text{noobj}}=0.5$ DOWNWEIGHTS no-object confidence loss (so the abundant background cells don't drown out the few object cells). Mirror image, easy to swap.
• 'Cell containing the object' = 'cell overlapping the object'. WRONG — it's the cell whose centre POINT contains the object's CENTRE (not vice versa). The horse can span 20 cells; only the cell at the horse's geometric centre is responsible.
• Computing mAP from detections in raw order. Always sort by score FIRST. mAP is defined on the score-sorted PR curve.
• Applying NMS before splitting by class. Global NMS suppresses legitimate cross-class boxes. Always partition first.
• Saying 'IoU = 0.5 means 50% overlap'. Two equal squares can share only 1/3 each and still have IoU = 0.5. IoU is intersection / union, not a percentage of either side.
• Forgetting modal vs amodal. PASCAL VOC, COCO, KITTI all use MODAL boxes (visible part only). Amodal is a separate benchmark family.

Shortcuts

• Speed chain: R-CNN 47 s → Fast R-CNN 0.3 s → Faster R-CNN 0.2 s → YOLO v1 22 ms. Remember as 'forty-seven, thirty, twenty, twenty-two'.
• RPN numbers per location: 9 anchors, 54 outputs ($9\cdot 6$). 3 scales $\times$ 3 ratios.
• YOLO output: $7\times 7\times 30$ on PASCAL VOC. $B=2,C=20$.
• Loss coefficients: ${\lambda }_{\text{coord}}=5,{\lambda }_{\text{noobj}}=0.5$. Five loss terms total.
• COCO vs VOC mAP: VOC at 0.5 only. COCO averages over $\{0.5,0.55,\dots ,0.95\}$ — explains the smaller-looking numbers.
• Datasets: VOC 20 cls / 2.4 obj-per-img, ImageNet 200 cls / 1.1, COCO 80 cls / 7.2.
• Soft-NMS in one line: multiply suppressed scores by a decaying function of IoU instead of zeroing them.

Proofs / Algorithms

**GIoU $\in [-1,1]$.** Identical boxes: IoU = 1, $|C\setminus (A\cup B)|=0$, so GIoU = 1. Vanishingly small boxes far apart: IoU $\to 0$, $|A\cup B|\to 0$, $|C|\to$ a fixed large value (the smallest enclosing box), so $|C\setminus (A\cup B)|/|C|\to 1$ and GIoU $\to -1$. Hence GIoU $\in [-1,1]$.

IoU is not 'fractional overlap'. Counter-example: two unit squares overlapping by a $1/\sqrt{3}\times 1/\sqrt{3}$ region have $|A\cap B|=1/3$ and $|A\cup B|=2-1/3=5/3$, so IoU = $1/5\ne 1/3$. The overlapping fractions on each side and IoU differ unless you pick the union as denominator — which is what the metric does and human intuition does not.

Why anchor-relative offsets are easier to learn. Predicting raw $(x,y,w,h)$ for an object somewhere in ${\mathbb{R}}^4$ is high-variance. With anchor priors $(x_a,y_a,w_a,h_a)$, the regression target $(t_x=(x-x_a)/w_a,t_y=(y-y_a)/h_a,t_w=\log (w/w_a),t_h=\log (h/h_a))$ is approximately zero-mean and unit-variance — well-suited to L2/smooth-L1 regression. The $\log$ on the size makes the loss SCALE-INVARIANT (multiplying $w$ and $w_a$ by the same factor leaves $t_w$ unchanged).