In modern computer vision, deep neural networks excel at processing high-resolution images in milliseconds. By leveraging the massive parallelism of GPUs and specialized hardware accelerators, modern backbones can execute billions of operations almost instantly. Yet, when these models are deployed in real-time systems—such as autonomous driving or robotics—they often hit an unexpected wall. The system stalls, not during the deep network's forward pass, but during a classical, hand-designed post-processing step: Non-Maximum Suppression (NMS).
As neural network backbones have become highly optimized, this post-processing phase has transformed from a minor cleanup step into a primary computational bottleneck. To understand why this happens and how researchers are fixing it, we must look at the fundamental mismatch between deep learning hardware and classical geometric algorithms.
The Sequential Bottleneck
Most traditional object detectors rely on a "one-to-many" training paradigm. During training, a single real-world object is associated with multiple candidate bounding boxes or anchor points. Consequently, during inference, the network outputs a dense flood of thousands of candidate predictions, many of which cluster redundantly around the same object.
To clean up this output, standard pipelines apply greedy NMS. The intuition behind greedy NMS is straightforward:
- Sort all candidate boxes by their classification confidence score.
- Select the box with the highest confidence and save it as a final prediction.
- Calculate the Intersection-over-Union (IoU) between this top box and all remaining boxes.
- Suppress (delete) any remaining boxes that overlap more than a certain threshold.
- Repeat the process for the next highest remaining box until the list is empty.
[Dense Predictions] ──> [Sort by Score] ──> [Select Top Box] ──> [Compute IoU & Suppress] ──> Loop
^ │
└────────────────────────────────────────────┘
While intuitive, this algorithm possesses a critical flaw: it is inherently sequential. Step $i$ cannot begin until step $i-1$ has finished filtering the box list. Because of this recursive dependency, greedy NMS has a worst-case quadratic time complexity ($O(N^2)$) relative to the number of candidate boxes.
As Jonathan Huang et al. demonstrated in an early comprehensive analysis of detector trade-offs, this sequential nature frequently forces post-processing to execute on the CPU. On embedded and edge AI platforms, as explored by Min-Kook Choi, this architectural split causes severe CPU stalling, effectively erasing the throughput gains achieved by expensive GPU hardware.
This vulnerability is not just an efficiency issue; it is also a security risk. Erh-Chung Chen et al. introduced the "Overload" attack, demonstrating that adversarial images can exploit this $O(N^2)$ complexity. By tricking a model into generating an excessive number of high-confidence, non-overlapping false positives, the attack exhausts edge device CPU resources, increasing post-processing latency by over 10 times and creating a computational Denial-of-Service.
To resolve this bottleneck, researchers have split into two main camps: those who seek to parallelize the suppression step, and those who seek to eliminate it entirely.
Strategy 1: Parallelizing the Suppression Step
If the core issue with NMS is its sequential loop, can we reformulate the geometry to compute overlaps simultaneously?
Fast NMS
Daniel Bolya et al. (YOLACT) introduced Fast NMS to unlock GPU acceleration. Instead of iteratively selecting and removing boxes, Fast NMS computes an all-to-all IoU matrix for the top $N$ candidate boxes concurrently.
Imagine a matrix where every cell $(i, j)$ represents the overlap between box $i$ and box $j$. If box $i$ and box $j$ overlap significantly, and box $i$ has a higher confidence score than box $j$, then box $j$ is marked for suppression. Because this matrix calculation can be mapped directly to standard tensor operations, it runs entirely on the GPU, drastically reducing inference latency with only a negligible impact on precision. Daniel Bolya et al. (YOLACT++) later extended this concept to handle dense multi-class environments where sequential overhead scales poorly.
Matrix NMS
Xinlong Wang et al. (SOLOv2) took parallelization further with Matrix NMS. Traditional NMS is binary: a box is either kept or killed. If a box overlaps slightly with two different high-confidence objects, a sequential algorithm might erroneously suppress it.
Matrix NMS replaces this rigid logic by calculating a score decay factor for every candidate mask simultaneously. It estimates the probability of a mask being suppressed by looking at its maximum overlap with all higher-scoring candidates. By treating suppression as a continuous, parallelizable matrix operation, Matrix NMS decreases scores across hundreds of candidates in a single step, removing the sequential bottleneck without sacrificing segmentation quality.
Sequential NMS: [Box A] ──(suppresses)──> [Box B] ──(suppresses)──> [Box C] (Step-by-step)
Matrix NMS: [Box A, Box B, Box C] ──> [Parallel IoU Matrix] ──> [Simultaneous Decay]
Graph and Pooling Alternatives
Other approaches reframe the grouping problem entirely. Yichun Shen et al. proposed the Confidence Propagation Cluster (CP-Cluster), which treats post-processing as a graph-based message-passing problem. Instead of merely discarding overlapping boxes, CP-Cluster allows true positives to propagate and enhance each other's confidence scores in parallel. Meanwhile, Tianyi Zhang et al. introduced PSRR-MaxpoolNMS, which replaces iterative sorting with a multi-step "Pyramid Shifted" max-pooling strategy on a grid, achieving up to a 6x speedup on CPUs by converting geometric sorting into localized pooling operations.
Strategy 2: Designing NMS-Free Architectures
While parallelizing NMS mitigates latency, it does not solve the root problem: the model is still forced to predict redundant outputs. A more radical solution is to design networks that inherently produce exactly one prediction per object, achieving a truly end-to-end pipeline.
Transformer-Based Set Prediction
The rise of the DEtection TRansformer (DETR) provided a natural path forward. Transformers treat object detection as a direct set-prediction problem, utilizing a fixed number of learnable object queries that interact via self-attention to claim unique objects in the scene.
Yian Zhao et al. developed RT-DETR, the first transformer-based object detector to achieve real-time performance. By optimizing the query selection process and streamlining the encoder architecture, RT-DETR matches or beats the accuracy of the popular YOLO series while completely eliminating NMS. This removes the non-deterministic latency spikes caused by geometric post-processing, making deployment across diverse hardware environments much more stable.
Consistent Dual Assignment in CNNs
Can we achieve NMS-free inference without the architectural overhead of a transformer? YOLOv10, designed by Ao Wang, proves that it is possible through a novel training strategy called consistent dual assignment.
Training Phase:
┌──> One-to-Many Head (Rich Supervision, uses NMS)
[Backbone Features]
└──> One-to-One Head (No NMS needed, optimized via consistent loss)
Inference Phase:
[Backbone Features] ──> One-to-One Head ──> [Final Predictions (NMS-Free)]
During training, YOLOv10 utilizes two prediction heads running in parallel:
- A traditional one-to-many head that assigns multiple predictions to one ground-truth object, providing rich supervisory signals that help the backbone learn robust features.
- A one-to-one head that forces a strict single-prediction match per object.
Crucially, the author introduces a consistent matching loss that aligns the optimization of both heads. During inference, the one-to-many head is simply discarded. The model runs entirely through the one-to-one head, outputting clean, non-redundant predictions directly from the network. This architecture achieves ultra-low latency because the post-processing step is reduced to zero.
Domain-Specific NMS Elimination
This push toward NMS-free architectures spans multiple computer vision domains:
- Image Segmentation: Jiangmiao Pang et al. developed K-Net, a framework that uses a set of learnable, content-aware kernels to iteratively segment pixels without relying on bounding boxes or NMS cleanup.
- 3D Object Detection: Yue Wang et al. introduced Object DGCNN, which models 3D bounding box generation as a set-prediction problem resolved via message passing on dynamic graphs.
- 3D Instance Segmentation: Shaoyu Chen et al. designed HAIS, a bottom-up framework that progressively aggregates point clouds into complete objects using dynamic bandwidths, bypassing the traditional group-and-refine cycles that slow down 3D pipelines.
- Scene Text Detection: Traditional text spotters rely on heavy CPU-bound morphological operations to group pixels into words. To bypass this, Guosheng Lin et al. proposed Markov Clustering Networks (MCN), which reframe text detection as a differentiable graph clustering problem, allowing real-time, arbitrary-shape text detection at 34 FPS without NMS.
Summary
The evolution of real-time vision has shifted the optimization frontier. When neural networks were slow, NMS latency was statistical noise. Today, with highly optimized backbones running on specialized hardware, the sequential nature of classical post-processing has become a glaring bottleneck.
Whether by mapping geometric suppression to parallel matrix operations or by redesigning loss functions to enforce one-to-one predictions, eliminating the NMS bottleneck represents a crucial step toward truly deterministic, low-latency, and secure real-time vision systems.
Key Foundational Work
BlitzNet: A Real-Time Deep Network for Scene Understanding (2017) — contributed 2 concept elements to this direction.
Speed/Accuracy Trade-Offs for Modern Convolutional Object Detectors (2017) — contributed 1 concept elements to this direction.
Learning Markov Clustering Networks for Scene Text Detection (2018) — contributed 1 concept elements to this direction.