YOLOv10

YOLOv10 is a real-time object detector from Tsinghua University.

• Paper: Wang, Chen, Liu, Chen, Lin, Han, Ding, YOLOv10: Real-Time End-to-End Object Detection, 2024, arXiv:2405.14458.
• Target: 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.
• Headline result: 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.

Because both heads score every candidate with the same functional form of $m(\alpha ,\beta )$, only scaled by $r$, sorting the candidates by $m_{o2m}$ or by $m_{o2o}$ produces the identical order when $r$ is constant across all candidates — so the single positive the o2o head trains on is guaranteed to be the same sample the o2m head would also rank first, rather than an arbitrary, potentially conflicting choice.

Loss

The paper defines no new loss for the heads: it defers to the task-aligned loss of TOOD/YOLOv8, so the total is the YOLOv8 detection loss applied to each head and summed with equal weight:

$\mathcal{L}={\mathcal{L}}_{o2m}+{\mathcal{L}}_{o2o},{\mathcal{L}}_{head}=7.5{\mathcal{L}}_{CIoU}+0.5{\mathcal{L}}_{cls}+1.5{\mathcal{L}}_{DFL}$

Each term (BCE with soft targets, CIoU weighted by $\hat{t}$, DFL) is defined in YOLOv8; the assigner is in Task-Aligned-Assignment. The heads differ only in the assigner’s top-$k$:

	o2m head	o2o head
top-$k$	10	1
$\alpha ,\beta$	0.5, 6.0	0.5, 6.0 ($r=1$)
positives per GT	up to 10	exactly 1
used at inference	no (needs NMS)	yes

Soft targets. For each GT the assigner computes $m=s\cdot p^{\alpha }\cdot {\mathrm{IoU}}^{\beta }$ over candidates and the classification target of a positive is $\hat{t}=m\cdot u^{\ast }/m^{\ast }$, where $u^{\ast }$ is the GT’s largest IoU among its positives and $m^{\ast }$ the largest $m$. The best positive therefore targets $u^{\ast }$, the others proportionally less. With top-1 the o2o head’s single positive always has $\hat{t}=u^{\ast }$. If two GTs pick the same anchor in the o2o head, it goes to the higher-IoU one and the other GT gets no positive that step.

Supervision gap. Regression targets of the two heads never conflict (matched predictions share the GT box, unmatched ones are ignored); the gap lies only in the classification targets. With $t_{o2o,i}=u^{\ast }$ and $t_{o2m,j}=u^{\ast }\cdot m_{o2m,j}/m_{o2m}^{\ast }\le u^{\ast }$ for $j\in \Omega$ (the o2m positives), the paper measures it as a 1-Wasserstein distance:

$A=t_{o2o,i}-\mathbb{I}(i\in \Omega )t_{o2m,i}+{\sum }_{k\in \Omega \setminus \{i\}}{t}_{o2m,k}$

$A$ shrinks as $t_{o2m,i}$ grows and is minimal when $i$ is the best o2m positive ($t_{o2m,i}=u^{\ast }$). The consistent metric ($m_{o2o}=m_{o2m}^r$) guarantees exactly that.

Implementation note (not in the paper, unverified here): the reference code is believed to detach the neck features fed to the o2o head, so only the o2m loss trains backbone and neck.

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)
• Assigner top-k: 10 (o2m head), 1 (o2o head); the two head losses are summed with equal weight
• 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

• All Articles
• Task-Aligned-Assignment — the assigner behind both YOLOv10 heads; the consistent matching metric is this metric raised to the power $r$, which is why the two rankings coincide.
• YOLOv8 — the baseline architecture YOLOv10 starts from (backbone, PAN neck, TAL assignment, DFL+CIoU losses); the differences are tabulated there.
• 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.