（12）YOLOv10算法基本原理

原创最新推荐文章于 2026-06-30 11:06:11 发布 3.2k 阅读 AI写同款

收录于

YOLO

AI莫大猫

码龄2年墨衍会员 · AI 创作全网分发

270粉丝20篇原创

关注

yolov--10--目标检测模型的参数评估指标详解、概念解析 Yolov-1-TX2上用YOLOv3训练自己数据集的流程(VOC2007-TX2-GPU) Yolov--2--一文全面了解深度学习性能优化加速引擎---TensorRT Yolov--3--TensorRT中yolov3性能优化加速（基于caffe） yolov-5-目标检测：YOLOv2算法原理详解 yolov--8--Tensorflow实现YOLO v3 yolov--9--Y... 阅读详情

AI摘要

本文介绍了清华大学开源的YOLOv10，包括不同型号以满足多样场景。阐述其主要贡献，如一致双重分配策略、一致匹配度量。指出YOLOv10针对的依赖NMS、计算冗余、小目标检测挑战等问题，介绍其改进点及效果，还回顾了往期YOLO相关教程。

一、YOLOv10的介绍

目前，由清华大学开源的最新的 YOLOv10，包括从n到x各种型号的模型，其中 YOLOv10n 最小，YOLOv10x 最大，以满足

不同应用场景。

二、YOLOv10的主要贡献

一致的双重分配策略（Consistent Dual Assignments）：YOLOv10提出了一种新的训练策略，用于无需非极大值抑制（NMS）的YOLO训练。这种策略结合了一对一（one-to-one）和多对一（one-to-many）的标签分配方式，以提供丰富的训练监督信号，并在推理时保持高效率。

在传统的YOLO系列模型中，通常采用多对一的标签分配策略，即一个真实目标对应多个正样本（anchor boxes）。这种方法虽然能够提供丰富的监督信号，有助于模型性能的提升，但需要依赖非极大值抑制（NMS）来进行后处理，这限制了模型的端到端部署，并增加了推理延迟。

为了解决这个问题，YOLOv10引入了双重标签匹配策略，它包括两个部分：一对多（one-to-many）和一对一（one-to-one）的头部（head）。在训练期间，两个头部一起被优化，其中一对多头部提供丰富的监督信号，而一对一头部则用于标签分配。这样，模型在训练时可以利用一对多头部的丰富监督，而在推理时则只使用一对一头部进行预测，从而避免了NMS的使用。

一致匹配度量（Consistent matching metric）

为了使一对一头部在训练和推理时与一对多头部保持一致，YOLOv10提出了一致匹配度量。这个度量标准使用了一个统一的匹配度量公式，它考虑了分类得分p、预测框与真实框之间的IoU（Intersection over Union）以及空间先验s。通过调整这个匹配度量的参数α和β，可以使得一对一头部的预测与一对多头部的预测更加一致，从而提高模型的推理性能。具体来说，一致匹配度量的公式为：

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

其中，p 是分类得分，\hat{b}和b分别表示预测框和真实框，s 表示空间先验，\alpha和\beta是平衡分类和定位任务影响的超参数。

一致匹配度量是YOLOv10中的一个重要创新，它通过统一的匹配度量标准，优化了一对一和一对多标签分配策略之间的协调性，减少了训练过程中的监督差距，并提高了模型的端到端性能。

在YOLOv10的训练配置中，双重标签分配策略是通过配置文件来实现的。这部分代码定义了模型的头部结构，包括上采样、连接和检测层的配置。以下是配置文件中的一段示例代码：

head:
  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  - [[-1, 6], 1, Concat, [1]] # cat backbone P4
  - [-1, 3, C2f, [512]] # 13
  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  - [[-1, 4], 1, Concat, [1]] # cat backbone P3
  - [-1, 3, C2f, [256]] # 16 (P3/8-small)
  - [-1, 1, Conv, [256, 3, 2]]
  - [[-1, 13], 1, Concat, [1]] # cat head P4
  - [-1, 3, C2f, [512]] # 19 (P4/16-medium)
  - [-1, 1, SCDown, [512, 3, 2]]
  - [[-1, 10], 1, Concat, [1]] # cat head P5
  - [-1, 3, C2fCIB, [1024, True, True]] # 22 (P5/32-large)
  - [[16, 19, 22], 1, v10Detect, [nc]] # Detect(P3, P4, P5)

三、YOLOv10针对的问题

依赖于非极大值抑制（NMS）：当前YOLO模型依赖于NMS进行后处理，这阻碍了YOLO模型的端到端部署，并增加了推理过程的延迟。
计算冗余：YOLO模型中各个组件的设计缺乏全面和彻底的检查，导致了显著的计算冗余，限制了模型的能力，从而导致效率不佳，并有很大的性能提升潜力。
小目标检测挑战：尽管YOLOv10通过多尺度特征融合技术在小目标检测方面取得了进步，但在极端情况下，如非常小的目标或密集排列的目标，其检测精度仍存在一定的局限性。

四、YOLOv10的改进点：

一致匹配度量（Consistent Matching Metric）：为了减少一对一和多对一头之间的监督差距，YOLOv10引入了一致匹配度量，使得两个头（branch）在训练时能够更加协调。
轻量级分类头（Lightweight Classification Head）：YOLOv10设计了一个轻量级的分类头，以减少分类任务的计算开销，同时保持性能。
空间-通道解耦下采样（Spatial-Channel Decoupled Downsampling）：YOLOv10提出了一种新的下采样方法，将空间缩减和通道增加操作分开进行，以提高信息保留率和性能。
等级引导的块设计（Rank-Guided Block Design）：YOLOv10利用内在秩分析来确定模型中哪些阶段存在冗余，并用更紧凑的架构设计替换这些阶段的基本构建块，以提高效率。
Compact Inverted Block (CIB)：CIB 被引入作为 YOLOv10 中的基本构建块，用于提高模型的效率。CIB 结构利用深度卷积（depthwise convolutions）进行空间混合，以及成本效益高的逐点卷积（pointwise convolutions）进行通道混合。
大核卷积（Large-Kernel Convolution）：YOLOv10在深层阶段使用大核深度卷积来扩大感受野并增强模型能力。YOLOv10在CIB中使用了大核卷积，具体来说，将CIB中的第二个3×3深度卷积的核大小增加到7×7，同时采用结构重参数化技术引入另一个3×3深度卷积分支，以缓解优化问题，而无需推理开销。

部分自注意力模块（Partial Self-Attention, PSA）：为了在保持低成本的同时增强模型性能，YOLOv10提出了一种有效的部分自注意力模块设计。

部分自注意力模块 (PSA) 实现YOLOv10在关键区域引入了部分自注意力模块，以下是PSA模块的实现代码：

class Attention(nn.Module):
    def __init__(self, dim, num_heads=8, attn_ratio=0.5):
        super().__init__()
        self.num_heads = num_heads
        self.head_dim = dim // num_heads
        self.key_dim = int(self.head_dim * attn_ratio)
        self.scale = self.key_dim ** -0.5
        nh_kd = nh_kd = self.key_dim * num_heads
        h = dim + nh_kd * 2
        self.qkv = Conv(dim, h, 1, act=False)
        self.proj = Conv(dim, dim, 1, act=False)
        self.pe = Conv(dim, dim, 3, 1, g=dim, act=False)

    def forward(self, x):
        B, _, H, W = x.shape
        N = H * W
        qkv = self.qkv(x)
        q, k, v = qkv.view(B, self.num_heads, -1, N).split([self.key_dim, self.key_dim, self.head_dim], dim=2)
        attn = (q.transpose(-2, -1) @ k) * self.scale
        attn = attn.softmax(dim=-1)
        x = (v @ attn.transpose(-2, -1)).view(B, -1, H, W) + self.pe(v.reshape(B, -1, H, W))
        x = self.proj(x)
        return x

class PSA(nn.Module):
    def __init__(self, c1, c2, e=0.5):
        super().__init__()
        assert(c1 == c2)
        self.c = int(c1 * e)
        self.cv1 = Conv(c1, 2 * self.c, 1, 1)
        self.cv2 = Conv(2 * self.c, c1, 1)
        self.attn = Attention(self.c, attn_ratio=0.5, num_heads=self.c // 64)
        self.ffn = nn.Sequential(
            Conv(self.c, self.c*2, 1),
            Conv(self.c*2, self.c, 1, act=False)
        )

    def forward(self, x):
        a, b = self.cv1(x).split((self.c, self.c), dim=1)
        b = b + self.attn(b)
        b = b + self.ffn(b)
        return self.cv2(torch.cat((a, b), 1))