YOLOv10论文解读——实时的端到端目标检测模型

heromps

已于 2024-05-31 23:04:55 修改

阅读量1.4k

点赞数 13

文章标签： YOLO 目标检测人工智能

于 2024-05-30 23:03:28 首次发布

本文链接：https://blog.csdn.net/heromps/article/details/139335845

版权

过去几年里，YOLOs因在计算成本和检测性能之间实现有效平衡而成为实时目标检测领域的主流范式。研究人员针对YOLOs的结构设计、优化目标、数据增强策略等进行了深入探索，并取得了显著进展。然而，对非极大值抑制（NMS）的后处理依赖阻碍了YOLOs的端到端部署，并对推理延迟产生负面影响。此外，YOLOs中各种组件的设计缺乏全面和彻底的审查，导致明显的计算冗余并限制了模型的性能。这导致次优的效率，以及性能提升的巨大潜力。在这项工作中，我们旨在从后处理和模型架构两个方面进一步推进YOLOs的性能-效率边界。为此，我们首先提出了用于YOLOs无NMS训练的持续双重分配，该方法同时带来了竞争性的性能和较低的推理延迟。此外，我们为YOLOs引入了全面的效率-准确性驱动模型设计策略。我们从效率和准确性两个角度全面优化了YOLOs的各个组件，这大大降低了计算开销并增强了模型能力。我们的努力成果是新一代YOLO系列，专为实时端到端目标检测而设计，名为YOLOv10。广泛的实验表明，YOLOv10在各种模型规模下均达到了最先进的性能和效率。例如，在COCO数据集上，我们的YOLOv10-S在相似AP下比RT-DETR-R18快1.8倍，同时参数和浮点运算量（FLOPs）减少了2.8倍。与YOLOv9-C相比，YOLOv10-B在相同性能下延迟减少了46%，参数减少了25%。

论文地址：YOLOv10: Real-Time End-to-End Object Detection点击即可跳转

官方代码：Github代码仓库点击即可跳转
在这里插入图片描述

1. 创新点

无NMS的一致双分配(consistent dual assignments)：

YOLOv10提出了一种通过双标签分配而不用非极大值抑制NMS的策略。这种方法结合了一对多和一对一分配策略的优势，提高了效率并保持了性能。

效率-精度驱动的模型设计(Holistic Efficiency-Accuracy Driven Model Design)：

轻量化分类头：在不显著影响性能的情况下，减少了计算开销。
空间-通道解耦下采样：解耦空间下采样和通道调整，优化计算成本。
基于秩的块设计：根据各阶段的内在秩适应块设计，减少冗余，提高效率。
大核卷积和部分自注意力PSA：在不显著增加计算成本的情况下，增强了感受野和全局建模能力。

2. 一致性分配策略（Consistent Dual Assignments）

YOLOv10引入了一种新的双分配策略，用于在训练期间同时利用一对多（one-to-many）和一对一（one-to-one）标签分配。这种方法在保持模型高效训练的同时，摆脱了推理过程中对非极大值抑制NMS的依赖。

双标签分配（Dual Label Assignments）

一对多分配：在训练期间，多个预测框被分配给一个真实物体标签。这种策略提供了丰富的监督信号，优化效果更好。
一对一分配：仅一个预测框被分配给一个真实物体标签，避免了NMS，但由于监督信号较弱，容易导致收敛速度慢和性能欠佳。
双头架构：模型在训练期间使用两个预测头，一个使用一对多分配，另一个使用一对一分配。这样，模型可以在训练期间利用一对多分配的丰富监督信号，而在推理期间则使用一对一分配的预测结果，从而实现无NMS的高效推理。

3. 一致匹配度量（Consistent Matching Metric）

为了在训练期间保持两个预测头的一致性，提出了一致匹配度量。通过调整匹配度量参数，使得一对一和一对多分配的监督信号一致，减少了训练期间的监督差距，提升了模型的预测质量。

整体效率-精度驱动的模型设计（Holistic Efficiency-Accuracy Driven Model Design）

YOLOv10在模型架构的各个方面进行了全面优化，旨在提升效率和精度。

3.1 效率驱动的模型设计

轻量化分类头（Lightweight Classification Head）

在YOLO系列中，分类头和回归头通常共享相同的架构，但分类任务的计算开销更大。为分类头采用轻量级的架构，包括两个3×3的深度可分离卷积（depthwise separable convolutions）和一个1×1卷积，以减少计算开销。

空间-通道解耦下采样（Spatial-Channel Decoupled Downsampling）

传统的下采样方法同时进行空间和通道的转换，计算成本较高。YOLOv10首先使用逐点卷积（pointwise convolution）调整通道维度，然后使用深度卷积（depthwise convolution）进行空间下采样。这样可以最大限度地保留信息，同时减少计算成本。

3.2 基于秩的块设计（Rank-Guided Block Design）

在YOLO模型中，各阶段通常使用相同的基本构建块，容易导致深层阶段的计算冗余。因此根据各阶段的内在秩（intrinsic rank）调整块设计，减少冗余，采用紧凑的反向块（Compact Inverted Block, CIB）设计，用深度卷积进行空间混合和逐点卷积进行通道混合，提高效率。
在这里插入图片描述

3.3 精度驱动的模型设计

大核卷积（Large-Kernel Convolution）

大核卷积的感受野较大，能够更好地捕捉图像中的全局信息。然而，直接在所有阶段使用大核卷积可能会导致小物体特征的污染，并增加高分辨率阶段的I/O开销和延迟。因此，在深层阶段使用大核深度卷积（如7×7）来扩大感受野，增强模型能力，同时使用结构重参数化技术（structural reparameterization）优化训练。

对于小模型规模（如YOLOv10-N/S），大核卷积的使用能够显著提升性能，而对于大模型规模（如YOLOv10-M），其天然较大的感受野使得大核卷积的效果不明显，因此仅在小模型中使用。

部分自注意力（Partial Self-Attention, PSA）

部分自注意力模块通过引入全局建模能力来提升模型性能，同时保持较低的计算开销。

自注意力（self-attention）在视觉任务中因其出色的全局建模能力而被广泛使用，但其计算复杂度和内存占用较高。本文引入PSA模块，通过将特征按通道分成两部分，仅对一部分应用多头自注意力（Multi-Head Self-Attention, MHSA），然后进行融合，增强全局建模能力，降低计算复杂度。

3.4 YOLOv10b.yaml文件

# Parameters
nc: 80 # number of classes
scales: # model compound scaling constants, i.e. 'model=yolov8n.yaml' will call yolov8.yaml with scale 'n'
  # [depth, width, max_channels]
  b: [0.67, 1.00, 512] 

# YOLOv8.0n backbone
backbone:
  # [from, repeats, module, args]
  - [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
  - [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
  - [-1, 3, C2f, [128, True]]
  - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
  - [-1, 6, C2f, [256, True]]
  - [-1, 1, SCDown, [512, 3, 2]] # 5-P4/16
  - [-1, 6, C2f, [512, True]]
  - [-1, 1, SCDown, [1024, 3, 2]] # 7-P5/32
  - [-1, 3, C2fCIB, [1024, True]]
  - [-1, 1, SPPF, [1024, 5]] # 9
  - [-1, 1, PSA, [1024]] # 10

# YOLOv8.0n head
head:
  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  - [[-1, 6], 1, Concat, [1]] # cat backbone P4
  - [-1, 3, C2fCIB, [512, True]] # 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, C2fCIB, [512, True]] # 19 (P4/16-medium)

  - [-1, 1, SCDown, [512, 3, 2]]
  - [[-1, 10], 1, Concat, [1]] # cat head P5
  - [-1, 3, C2fCIB, [1024, True]] # 22 (P5/32-large)

  - [[16, 19, 22], 1, v10Detect, [nc]] # Detect(P3, P4, P5)

3.5 YOLOv10中的PSA

引入YOLOv10中的一种高效的部分自注意力（PSA）模块设计，在1×1卷积后将特征均匀地分为两部分。我们只将一部分输入到由多头自注意力模块（MHSA）和前馈网络（FFN）组成的NPSA块中。然后，两部分通过1×1卷积连接并融合。

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, C, H, W = x.shape
        N = H * W
        qkv = self.qkv(x)
        q, k, v = qkv.view(B, self.num_heads, self.key_dim*2 + self.head_dim, 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, C, H, W) + self.pe(v.reshape(B, C, 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))

在这里插入图片描述

3.6 YOLOv10中的CIB

class CIB(nn.Module):
    """Standard bottleneck."""

    def __init__(self, c1, c2, shortcut=True, e=0.5, lk=False):
        """Initializes a bottleneck module with given input/output channels, shortcut option, group, kernels, and
        expansion.
        """
        super().__init__()
        c_ = int(c2 * e)  # hidden channels
        self.cv1 = nn.Sequential(
            Conv(c1, c1, 3, g=c1),
            Conv(c1, 2 * c_, 1),
            Conv(2 * c_, 2 * c_, 3, g=2 * c_) if not lk else RepVGGDW(2 * c_),
            Conv(2 * c_, c2, 1),
            Conv(c2, c2, 3, g=c2),
        )

        self.add = shortcut and c1 == c2

    def forward(self, x):
        """'forward()' applies the YOLO FPN to input data."""
        return x + self.cv1(x) if self.add else self.cv1(x)
        
class C2fCIB(C2f):
    """Faster Implementation of CSP Bottleneck with 2 convolutions."""

    def __init__(self, c1, c2, n=1, shortcut=False, lk=False, g=1, e=0.5):
        """Initialize CSP bottleneck layer with two convolutions with arguments ch_in, ch_out, number, shortcut, groups,
        expansion.
        """
        super().__init__(c1, c2, n, shortcut, g, e)
        self.m = nn.ModuleList(CIB(self.c, self.c, shortcut, e=1.0, lk=lk) for _ in range(n))

class RepVGGDW(torch.nn.Module):
    def __init__(self, ed) -> None:
        super().__init__()
        self.conv = Conv(ed, ed, 7, 1, 3, g=ed, act=False)
        self.conv1 = Conv(ed, ed, 3, 1, 1, g=ed, act=False)
        self.dim = ed
        self.act = nn.SiLU()
    
    def forward(self, x):
        return self.act(self.conv(x) + self.conv1(x))
    
    def forward_fuse(self, x):
        return self.act(self.conv(x))
 
    @torch.no_grad()
    def fuse(self):
        conv = fuse_conv_and_bn(self.conv.conv, self.conv.bn)
        conv1 = fuse_conv_and_bn(self.conv1.conv, self.conv1.bn)
        
        conv_w = conv.weight
        conv_b = conv.bias
        conv1_w = conv1.weight
        conv1_b = conv1.bias
        
        conv1_w = torch.nn.functional.pad(conv1_w, [2,2,2,2])
 
        final_conv_w = conv_w + conv1_w
        final_conv_b = conv_b + conv1_b
 
        conv.weight.data.copy_(final_conv_w)
        conv.bias.data.copy_(final_conv_b)
 
        self.conv = conv
        del self.conv1

CBI架构图下图：
在这里插入图片描述

4. 总结

YOLOv10引入了额外的one-to-one头部，通过双分配策略，在训练时提供更丰富的监督信息，而在推理时则利用one-to-one头部进行高效预测，从而无需NMS后处理。此外，YOLOv10从效率和准确性两个方面全面优化了YOLO的各个组件，包括轻量级分类头部、空间-通道解耦的下采样层、基于秩的模块设计等，以降低计算冗余并提升模型性能。

YOLOv10检测器的提出不仅为实时目标检测领域带来了新的突破，也展示了通过后处理和模型设计的联合优化，同时提升效率和精度的有效思路。YOLOv10检测器有望在自动驾驶、机器人导航、物体跟踪等实际应用中得到广泛应用，为实时目标检测任务带来更高的效率。

对于后处理，我们提出了用于NMS-free训练的一致双分配策略，实现了高效的端到端检测。在模型架构方面，我们引入了全面的效率和准确性驱动的模型设计策略，改善了性能和效率之间的权衡。这些创新带来了我们的YOLOv10，这是一个全新的实时端到端目标检测器。大量的实验结果表明，YOLOv10与其他先进检测器相比，在性能和延迟方面都取得了state-of-the-art的成果，充分展示了其优越性。