Non-Maximum Suppression

Our detector has several plausible rectangles around one seed. Each is a slightly different guess about its boundary. If Botie counts every rectangle, he reports more seeds than the tray contains.

We need a rule for deciding which candidates are competing explanations of the same object. A common starting point is to keep the highest-scoring candidate and remove lower-scoring candidates that overlap it too much. Let's follow that procedure carefully, because the order matters.

A high score does not tell us whether two boxes duplicate one object. Change scores or the overlap threshold and watch which candidate gets to remove the overlapping alternatives.

Each candidate has a rectangle and a score. Sorting the scores produces indices into the box array. Preserve that mapping so the highest score still refers to its own rectangle.

We will process candidates from greatest score to least. To make the teaching examples reproducible, tied scores use the lower original index first. Production libraries may use a different tie rule, including differences across devices.

Scores = [0.7, 0.9, 0.8]
Descending-score indices = [1, 2, 0]

The score threshold for discarding weak candidates and the overlap threshold for removing duplicates are different controls.

Remove the highest-scoring available index from the waiting list and append it to the kept list. Compute its IoU with each remaining candidate. Suppress a remaining candidate when that IoU is strictly greater than the chosen threshold.

Here, equality stays. Both the inequality and coordinate convention must match the implementation you intend to use.

Overlap threshold = 0.5
IoU = 0.7 → suppress
IoU = 0.5 → keep available
IoU = 0.2 → keep available

Suppressing means removing a candidate from consideration. We do not merge its coordinates with the retained box.

After keeping the highest-scoring box, remove its sufficiently overlapping alternatives. Then choose the highest score among the boxes still waiting. Removed boxes take no further part in the decisions.

Suppose A overlaps B, and B overlaps C, but A does not overlap C enough to suppress it. Keeping A removes B while leaving C eligible. If the removed B were allowed to suppress C too, we would be running a different algorithm.

Waiting: A, B, C
Keep A; suppress B
Waiting: C
Keep C

This procedure can still discard a real nearby object. The overlap heuristic cannot perfectly resolve crowded scenes.

The examples in this lesson concern one class: seeds. In a class-aware detector, suppression is normally applied separately within each class. Otherwise, a high-scoring box for one class might erase a valid overlapping box for another.

Some applications deliberately use class-agnostic suppression. State the intended policy and evaluate its errors rather than assuming one choice fits every detector.

A class ID is not a geometric coordinate. Keep it alongside the box and score when filtering or gathering detections.

import numpy as np
boxes = np.array([[0.,0.,4.,4.], [0.5,0.,4.5,4.], [7.,0.,9.,2.]])
def iou(a, b):
    overlap = np.maximum(0, np.minimum(a[2:], b[2:]) - np.maximum(a[:2], b[:2]))
    intersection = np.prod(overlap)
    union = np.prod(a[2:] - a[:2]) + np.prod(b[2:] - b[:2]) - intersection
    return intersection / union
overlaps = np.array([iou(boxes[0], box) for box in boxes[1:]])
print(np.round(overlaps, 4).tolist())
print((overlaps <= 0.5).tolist())

[0.7778, 0.0]
[False, True]

The workshop divides the work into score ordering, greedy suppression, and gathering retained boxes. The suppression component performs the loop we just traced. In Python, implement that loop yourself to see how the waiting list changes.

This step cleans up supplied detections. It does not train a detector, repair inaccurate coordinates, or prove that each kept rectangle contains a real seed. Review the retained boxes against the photograph and labelled examples.

order = indices sorted by descending score
kept = []
while order is not empty:
    current = remove first index
    append current to kept
    retain only indices whose IoU with current <= threshold
return boxes at kept indices

A higher overlap threshold suppresses fewer candidates under this procedure. It may preserve close objects while also retaining more duplicates.

Three proposals can form an overlap chain: A overlaps B, B overlaps C, but A and C can both describe separate objects. After keeping A and removing B, compare C with the boxes actually kept.

Deleting every box that overlaps any higher-scored box implements a different operation. The waiting list is state: each greedy choice changes which candidates are allowed to influence the remaining decisions.

import numpy as np
overlap = np.array([[1., .6, .2], [.6, 1., .6], [.2, .6, 1.]])
waiting = [0,1,2]
kept = []
while waiting:
    current = waiting.pop(0)
    kept.append(current)
    waiting = [j for j in waiting if overlap[current,j] <= .5]
print(kept)

[0, 2]

Two real seeds may overlap in the photograph. A strict suppression threshold can erase one legitimate detection; a loose threshold can retain several copies of the same seed. NMS cannot resolve that ambiguity from overlap alone.

Evaluate the retained detections on crowded scenes as well as isolated objects. Inspect missed objects and duplicate counts separately. A score-decay method or a detector trained for the setting may help, but changing postprocessing cannot create evidence that the original candidates lack.