One-stage vs. two-stage detectors (YOLO vs. Faster R-CNN)

Six candidate boxes, one shared ground truth per box. Toggle between scoring every box in a single pass and scoring them through a cheap filter followed by a careful second look — watch which boxes get flagged as detected change.

A one-stage detector (e.g. YOLO) evaluates every candidate box exactly once, in a single dense pass — fast, but every score shares whatever precision that one pass can afford. A two-stage detector (e.g. Faster R-CNN) runs a cheap region proposal pass over every box first, then spends a second, expensive classifier only on the boxes that clear a proposal threshold:

• $N$ — the total number of candidate boxes considered.
• $K$ — the number of boxes that survive the proposal filter and reach the expensive second pass ($K \le N$).
• $c_{\text{full}}$, $c_{\text{proposal}}$, $c_{\text{refine}}$ — the compute cost of one one-stage evaluation, one cheap proposal, and one expensive refine, respectively.

1. One-stage pays a flat cost for every box, once

   There's no filtering step — every one of the $N$ boxes gets the same single, cheap-per-box evaluation.

2. Two-stage trades one expensive pass for two cheaper ones

   Even though $c_{\text{refine}} \gg c_{\text{full}}$ per box, only $K$ boxes ever reach it — but when $K$ isn't small enough, or $c_{\text{refine}}$ is large enough, the total can still exceed one-stage's flat cost.

3. The extra pass buys precision the coarse pass didn't have

   A box near the decision boundary can flip its final call depending on how much refinement it got — that's the accuracy two-stage is paying its extra compute for.

The same six boxes, scored both ways side by side, plus the total compute each pipeline actually spent getting there. One box's final call depends on which pipeline scored it.

Six boxes with true objectness confidence $0.92, 0.77, 0.47, 0.18, 0.84, 0.56$ (boxes A–F), a detection threshold of $0.5$:

1. One-stage rounds every box onto a coarse 0.1 grid

   Box C's true confidence $0.47$ rounds to $0.5$ — right at the threshold, so one-stage calls it detected.

2. Two-stage's proposal pass is coarser still, but only decides pass/fail

   On a $0.25$ grid, $0.47$ rounds to $0.5$ too, clearing the $\ge0.5$ proposal threshold — so box C proceeds to the expensive second pass with its exact confidence, $0.47$, restored.

3. The refine pass flips the call

   $0.47 < 0.5$: two-stage calls box C not detected. One-stage and two-stage disagree on this one box — everywhere else, both pipelines agree.

4. But two-stage still cost more overall

   Rounding every box's confidence to the nearest $0.25$-grid value to check the $\geq0.5$ proposal threshold:

   • A: $0.92\to1.0$, passes
   • B: $0.77\to0.75$, passes
   • C: $0.47\to0.5$, passes
   • D: $0.18\to0.25$, fails
   • E: $0.84\to0.75$, passes
   • F: $0.56\to0.5$, passes

   Five of six boxes clear it, so $K=5$. One-stage: $6$ boxes $\times\,1 = 6$ cost units. Two-stage: $6\times0.2 + 5\times3 = 1.2+15=16.2$ — over $2.5\times$ the compute, entirely to correct one boundary case.