YOLOv10

YOLOv10 is a real-time object detector introduced by Tsinghua University in YOLOv10: Real-Time End-to-End Object Detection (Wang, Chen, Liu, Chen, Lin, Han, Ding; 2024, arXiv:2405.14458). It targets two long-standing weaknesses of the YOLO family: reliance on non-maximum suppression (NMS) post-processing, and architectural redundancy inherited from years of incremental design choices. The result is a family of models (N/S/M/B/L/X) that are both NMS-free and more computationally efficient than prior YOLOs, while matching or exceeding their accuracy.

Motivation

Classic YOLO detectors use one-to-many label assignment during training (each ground-truth object matches many candidate predictions), which gives rich supervision but requires NMS at inference to remove duplicate boxes. NMS is sensitive to its hyperparameters (confidence/IoU thresholds) and adds latency, preventing true end-to-end deployment — a problem DETR-style detectors solved by using one-to-one bipartite matching (see DETR), but at the cost of slow convergence and, for pure transformer DETR variants, deployment complexity.

Separately, YOLO architectures had not been holistically re-examined for computational redundancy: components like the classification head, downsampling layers, and basic building blocks were designed once and reused across scales without questioning whether they were the efficient choice.

YOLOv10 addresses both problems simultaneously: NMS-free training via consistent dual assignments, and a holistic efficiency-accuracy driven architecture redesign.

NMS-free training: consistent dual assignments

Dual label assignments

YOLOv10 equips the model with two prediction heads during training:

• A one-to-many (o2m) head — the conventional YOLO head, retained with its original architecture and optimization objective, providing rich supervisory signal.
• A one-to-one (o2o) head — an additional head that receives only a single positive sample per ground-truth object (using top-1 selection, which performs on par with Hungarian matching but with less training overhead).

Both heads are trained jointly, so the backbone and neck benefit from the dense supervision of the o2m branch. At inference, only the o2o head is used, so no NMS is needed and there is no extra inference cost.

Consistent matching metric

Both heads use the same form of matching-quality metric:

$m(\alpha ,\beta )=s\cdot p^{\alpha }\cdot \mathrm{IoU}(\hat{b},b{)}^{\beta }$

where $p$ is the classification score, $\mathrm{IoU}(\hat{b},b)$ measures box overlap between prediction $\hat{b}$ and ground truth $b$, $s$ is a spatial prior (whether the anchor point falls inside the object), and $\alpha$, $\beta$ balance the classification vs. localization terms.

If the o2o and o2m heads use inconsistent $(\alpha ,\beta )$ pairs, the best sample for one head may not be the best for the other, creating a supervision gap between the two branches (formalized in the paper via a 1-Wasserstein distance argument). YOLOv10 resolves this by setting the o2o metric as a scaled version of the o2m metric:

${\alpha }_{o2o}=r\cdot {\alpha }_{o2m},{\beta }_{o2o}=r\cdot {\beta }_{o2m}$

with $r=1$ by default. This makes the top-ranked one-to-many sample also the top one-to-one sample, harmonizing the two branches without extra hyperparameter tuning.

Holistic efficiency-accuracy driven model design

Efficiency components

1. Lightweight classification head — analysis showed the classification head in prior YOLOs (e.g. YOLOv8) has disproportionately higher FLOPs/parameters than the regression head, yet contributes less to accuracy. YOLOv10 replaces it with two depthwise-separable 3×3 convolutions followed by a 1×1 convolution, cutting cost with negligible accuracy loss.
2. Spatial-channel decoupled downsampling — instead of a single stride-2 3×3 convolution that simultaneously halves spatial resolution and doubles channels (expensive: O(9/2 · HWC²)), YOLOv10 first uses a pointwise convolution to expand channels, then a depthwise convolution to downsample spatially, reducing both cost and information loss.
3. Rank-guided block design — using the intrinsic (numerical) rank of each stage’s last convolution as a redundancy signal, stages with low rank (more redundancy, typically deeper/larger stages) are replaced with a Compact Inverted Block (CIB): cheap depthwise convolutions for spatial mixing plus pointwise convolutions for channel mixing. An algorithm greedily replaces blocks stage-by-stage (sorted by ascending rank) as long as accuracy doesn’t regress.

Accuracy components

1. Large-kernel convolution — the second depthwise convolution inside CIB is enlarged from 3×3 to 7×7 to expand the receptive field, applied only to small model scales (where receptive field is more of a bottleneck) and only at deep stages, with a reparameterizable 3×3 branch during training to ease optimization (removed at inference for zero extra cost).
2. Partial Self-Attention (PSA) — to add global representation learning cheaply, features are split in half after a 1×1 convolution; only one half is passed through a multi-head self-attention (MHSA) + FFN block (with reduced query/key dimensions and BatchNorm instead of LayerNorm for inference speed), then the two halves are concatenated and fused with a 1×1 convolution. PSA is applied only after the lowest-resolution stage to avoid the quadratic cost of full self-attention.

Architecture summary

YOLOv10 uses YOLOv8 as its baseline (backbone/PAN neck), replacing its head with the dual o2o/o2m heads and applying the efficiency/accuracy redesign to backbone and neck blocks. Model scales are N, S, M, B, L, X, with YOLOv10-B derived from YOLOv10-M by increasing its width scale factor.

Training hyperparameters

As reported in the paper (Appendix A.1, Table 14), all models are trained from scratch on COCO across all scales (N/S/M/B/L/X) with the same schedule:

• Optimizer: SGD
• Epochs: 500
• Momentum: 0.937
• Weight decay: 5×10⁻⁴
• Warm-up epochs: 3, warm-up momentum: 0.8, warm-up bias learning rate: 0.1
• Initial learning rate: 1×10⁻²
• Final learning rate: 1×10⁻⁴
• Learning rate schedule: linear decay
• Loss gains: box loss 7.5, class loss 0.5, DFL (distribution focal loss) 1.5
• Data augmentation: HSV saturation 0.7, HSV value 0.4, HSV hue 0.015, translation 0.1, scale 0.5 (N/S) or 0.9 (M/B/L/X)
• Mosaic augmentation: 1.0 (all scales)
• Mixup augmentation: 0.0 (N/S), 0.1 (M/B), 0.15 (L/X)
• Copy-paste augmentation: 0.0 (N/S), 0.1 (M/B), 0.3 (L/X)
• Close-mosaic epochs (mosaic disabled for the last N epochs): 10
• Hardware: 8× NVIDIA RTX 3090 GPUs
• Consistent matching metric default: r = 1 (i.e. α_o2o = α_o2m = 0.5, β_o2o = β_o2m = 6.0, following YOLOv8’s TAL defaults)
• PSA: applied after the SPPF module, FFN expansion factor 2, N_PSA = 1 block
• CIB: inverted bottleneck expansion ratio of 2
• Large-kernel convolution: kernel size 7×7, applied only to N/S scales

Latency is measured on a T4 GPU with TensorRT FP16.

Results

On COCO, compared to its YOLOv8 baseline, YOLOv10 achieves AP improvements of 1.2/1.4/0.5/0.3/0.5% (N/S/M/L/X) with 28–57% fewer parameters and 23–38% less computation, and 37–70% lower latency, depending on scale. Notable comparisons:

• YOLOv10-S / X are 1.8× / 1.3× faster than RT-DETR-R18 / R101 at similar accuracy, with far fewer parameters.
• YOLOv10-B has 46% lower latency than YOLOv9-C at the same performance.
• YOLOv10-L / X outperform YOLOv8-L / X by 0.3 / 0.5 AP with 1.8× / 2.3× fewer parameters.

Ablations confirm each component’s contribution: NMS-free training with consistent dual assignments alone cuts YOLOv10-S latency by 4.63 ms while holding accuracy; efficiency-driven design further removes 11.8M parameters and 20.8 GFLOPs from YOLOv10-M; accuracy-driven design (large-kernel conv + PSA) adds 1.8 / 0.7 AP to S / M for only ~0.2 ms latency overhead.

Limitations

• The one-to-one (NMS-free) head still trails the original one-to-many + NMS pipeline by up to 1.0 AP on the smallest models (N/S), a gap the authors note as future work to close.
• The paper does not explore large-scale pretraining (e.g. on Objects365) due to compute constraints.

See also

• INDEX
• DETR — the transformer-based end-to-end detector that established one-to-one set prediction as an alternative to NMS-based pipelines; YOLOv10 imports this idea into the CNN-based YOLO lineage while keeping real-time efficiency.