YOLOv10改进策略【注意力机制篇】| CVPR2024 CAA上下文锚点注意力机制

最新推荐文章于 2024-10-08 20:36:49 发布

Limiiiing

最新推荐文章于 2024-10-08 20:36:49 发布

阅读量511

点赞数 17

分类专栏： YOLOv10改进专栏文章标签： YOLO 计算机视觉深度学习目标检测

本文链接：https://blog.csdn.net/qq_42591591/article/details/142583955

版权

YOLOv10改进专栏专栏收录该内容

14 篇文章 1 订阅

订阅专栏

一、本文介绍

本文记录的是基于CAA注意力模块的YOLOv10目标检测改进方法研究。在远程遥感图像或其他大尺度变化的图像中目标检测任务中，为准确提取其长距离上下文信息，需要解决大目标尺度变化和多样上下文信息时的不足的问题。CAA能够有效捕捉长距离依赖，并且参数量和计算量更少。

二、CAA原理

Poly Kernel Inception Network for Remote Sensing Detection

CAA（Context Anchor Attention）注意力的设计原理和优势如下：

2.1 原理

采用平均池化和1×1卷积来获取局部区域特征：对输入特征进行平均池化，然后通过1×1卷积得到局部区域特征。
使用深度可分离的条形卷积来近似标准大核深度可分离卷积：通过两个深度可分离的条形卷积来扩大感受野，并且这种设计基于两个考虑。首先，条形卷积是轻量级的，与传统的大核2D深度可分离卷积相比，使用几个1D深度可分离核可以达到类似的效果，同时参数减少了 $kb /2$ 。其次，条形卷积有助于识别和提取细长形状物体（如桥梁）的特征。
随着CAA模块所属的PKI块深度增加，增大条形卷积的核大小（ $kb = 11 + 2 \times l$ ），以增强PKINet建立长距离像素间关系的能力，同时由于条形深度可分离设计，不会显著增加计算成本。
最后，CAA模块产生一个注意力权重，用于增强PKI模块的输出特征。具体来说，通过Sigmoid函数确保注意力图在范围 $(0, 1)$ 内，然后通过元素点乘和元素求和操作来增强特征。

在这里插入图片描述

2.2 优势

有效捕捉长距离依赖：通过合适的核大小设置，能够更好地捕捉长距离像素间的依赖关系，相比于较小核大小的情况，能提升模型性能，因为较小核无法有效捕获长距离依赖，而较大核可以包含更多上下文信息。
轻量化：条形卷积的设计使得CAA模块具有轻量化的特点，减少了参数数量和计算量。
增强特征提取：当在PKINet的任何阶段使用CAA模块时，都能带来性能提升，当在所有阶段部署CAA模块时，性能增益达到 $1.03\%$ ，这表明CAA模块能够有效地增强模型对特征的提取能力。

论文：https://arxiv.org/pdf/2403.06258
源码：https://github.com/NUST-Machine-Intelligence-Laboratory/PKINet

三、CAA的实现代码

CAA模块的实现代码如下：

from mmcv.cnn import ConvModule
from mmengine.model import BaseModule

class CAA(BaseModule):
    """Context Anchor Attention"""
    def __init__(
            self,
            channels: int,
            h_kernel_size: int = 11,
            v_kernel_size: int = 11,
            norm_cfg: Optional[dict] = dict(type='BN', momentum=0.03, eps=0.001),
            act_cfg: Optional[dict] = dict(type='SiLU'),
            init_cfg: Optional[dict] = None,
    ):
        super().__init__(init_cfg)
        self.avg_pool = nn.AvgPool2d(7, 1, 3)
        self.conv1 = ConvModule(channels, channels, 1, 1, 0,
                                norm_cfg=norm_cfg, act_cfg=act_cfg)
        self.h_conv = ConvModule(channels, channels, (1, h_kernel_size), 1,
                                 (0, h_kernel_size // 2), groups=channels,
                                 norm_cfg=None, act_cfg=None)
        self.v_conv = ConvModule(channels, channels, (v_kernel_size, 1), 1,
                                 (v_kernel_size // 2, 0), groups=channels,
                                 norm_cfg=None, act_cfg=None)
        self.conv2 = ConvModule(channels, channels, 1, 1, 0,
                                norm_cfg=norm_cfg, act_cfg=act_cfg)
        self.act = nn.Sigmoid()

    def forward(self, x):
        attn_factor = self.act(self.conv2(self.v_conv(self.h_conv(self.conv1(self.avg_pool(x))))))
        return attn_factor

四、创新模块

4.1 改进点⭐

模块改进方法：
1️⃣ 加入CAA模块。CAA模块添加后如下：

在这里插入图片描述

注意❗：在5.2和5.3小节中需要声明的模块名称为：CAA。

2️⃣：加入基于CAA模块的C2f。利用CAA改进C2f模块，使模型能够更好地捕捉长距离像素间的依赖关系。

改进代码如下：

class C2f_CAA(nn.Module):
    """Faster Implementation of CSP Bottleneck with 2 convolutions."""

    def __init__(self, c1, c2, n=1, shortcut=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__()
        self.c = int(c2 * e)  # hidden channels
        self.cv1 = Conv(c1, 2 * self.c, 1, 1)
        self.cv2 = Conv((2 + n) * self.c, c2, 1)  # optional act=FReLU(c2)
        self.m = nn.ModuleList(Bottleneck(self.c, self.c, shortcut, g, k=((3, 3), (3, 3)), e=1.0) for _ in range(n))
        self.att = CAA(c2)

    def forward(self, x):
        """Forward pass through C2f layer."""
        y = list(self.cv1(x).chunk(2, 1))
        y.extend(m(y[-1]) for m in self.m)
        return self.att(self.cv2(torch.cat(y, 1)))

    def forward_split(self, x):
        """Forward pass using split() instead of chunk()."""
        y = list(self.cv1(x).split((self.c, self.c), 1))
        y.extend(m(y[-1]) for m in self.m)
        return self.att(self.cv2(torch.cat(y, 1)))

在这里插入图片描述

注意❗：在5.2和5.3小节中需要声明的模块名称为：C2f_CAA。

五、添加步骤

5.1 修改ultralytics/nn/modules/block.py

此处需要修改的文件是ultralytics/nn/modules/block.py

block.py中定义了网络结构的通用模块，我们想要加入新的模块就只需要将模块代码放到这个文件内即可。

将CAA和C2f_CAA模块代码添加到此文件下。

5.2 修改ultralytics/nn/modules/init.py

此处需要修改的文件是ultralytics/nn/modules/__init__.py

__init__.py文件中定义了所有模块的初始化，我们只需要将block.py中的新的模块命添加到对应的函数即可。

CAA和C2f_CAA在block.py中实现，所有要添加在from .block import：

from .block import (
    C1,
    C2,
    ...
    CAA,
    C2f_CAA
)

在这里插入图片描述

5.3 修改ultralytics/nn/modules/tasks.py

在tasks.py文件中，需要在两处位置添加各模块类名称。

首先：在函数声明中引入CAA和C2f_CAA

在这里插入图片描述

其次：在parse_model函数中注册CAA和C2f_CAA模块

在这里插入图片描述

六、yaml模型文件

6.1 模型改进版本⭐

此处以ultralytics/cfg/models/v10/yolov10m.yaml为例，在同目录下创建一个用于自己数据集训练的模型文件yolov10m-C2f_CAA.yaml。

将yolov10m.yaml中的内容复制到yolov10m-C2f_CAA.yaml文件下，修改nc数量等于自己数据中目标的数量。

📌 模型的修改方法是将骨干网络中的所有C2f模块替换成C2f_CAA模块。

# Ultralytics YOLO 🚀, AGPL-3.0 license
# YOLOv8 object detection model with P3-P5 outputs. For Usage examples see https://docs.ultralytics.com/tasks/detect

# Parameters
nc: 1 # number of classes
scales: # model compound scaling constants, i.e. 'model=yolov8n.yaml' will call yolov8.yaml with scale 'n'
  # [depth, width, max_channels]
  m: [0.67, 0.75, 768] # YOLOv8m summary: 295 layers, 25902640 parameters, 25902624 gradients,  79.3 GFLOPs

# 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_CAA, [128, True]]
  - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
  - [-1, 6, C2f_CAA, [256, True]]
  - [-1, 1, SCDown, [512, 3, 2]] # 5-P4/16
  - [-1, 6, C2f_CAA, [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, 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, 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)

六、成功运行结果

分别打印网络模型可以看到C2f_CAA已经加入到模型中，并可以进行训练了。

yolov10m-C2f_CAA：

                   from  n    params  module                                       arguments                     
  0                  -1  1      1392  ultralytics.nn.modules.conv.Conv             [3, 48, 3, 2]                 
  1                  -1  1     41664  ultralytics.nn.modules.conv.Conv             [48, 96, 3, 2]                
  2                  -1  2    172416  ultralytics.nn.modules.block.C2f_CAA         [96, 96, True]                
  3                  -1  1    166272  ultralytics.nn.modules.conv.Conv             [96, 192, 3, 2]               
  4                  -1  4   1353216  ultralytics.nn.modules.block.C2f_CAA         [192, 192, True]              
  5                  -1  1     78720  ultralytics.nn.modules.block.SCDown          [192, 384, 3, 2]              
  6                  -1  4   5360640  ultralytics.nn.modules.block.C2f_CAA         [384, 384, True]              
  7                  -1  1    228672  ultralytics.nn.modules.block.SCDown          [384, 576, 3, 2]              
  8                  -1  2   1689984  ultralytics.nn.modules.block.C2fCIB          [576, 576, 2, True]           
  9                  -1  1    831168  ultralytics.nn.modules.block.SPPF            [576, 576, 5]                 
 10                  -1  1   1253088  ultralytics.nn.modules.block.PSA             [576, 576]                    
 11                  -1  1         0  torch.nn.modules.upsampling.Upsample         [None, 2, 'nearest']          
 12             [-1, 6]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           
 13                  -1  2   1993728  ultralytics.nn.modules.block.C2f             [960, 384, 2]                 
 14                  -1  1         0  torch.nn.modules.upsampling.Upsample         [None, 2, 'nearest']          
 15             [-1, 4]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           
 16                  -1  2    517632  ultralytics.nn.modules.block.C2f             [576, 192, 2]                 
 17                  -1  1    332160  ultralytics.nn.modules.conv.Conv             [192, 192, 3, 2]              
 18            [-1, 13]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           
 19                  -1  2    831744  ultralytics.nn.modules.block.C2fCIB          [576, 384, 2, True]           
 20                  -1  1    152448  ultralytics.nn.modules.block.SCDown          [384, 384, 3, 2]              
 21            [-1, 10]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           
 22                  -1  2   1911168  ultralytics.nn.modules.block.C2fCIB          [960, 576, 2, True]           
 23        [16, 19, 22]  1   2282134  ultralytics.nn.modules.head.v10Detect        [1, [192, 384, 576]]          
YOLOv10m-C2f_CAA summary: 707 layers, 19198246 parameters, 19198230 gradients, 80.9 GFLOPs