YOLOv10改进策略【注意力机制篇】| MCAttention 多尺度交叉轴注意力

Limiiiing

于 2024-10-09 09:23:20 发布

阅读量431

点赞数 9

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

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

版权

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

15 篇文章 1 订阅

订阅专栏

一、本文介绍

本文记录的是基于MCA注意力模块的YOLOv10目标检测改进方法研究。普通的轴向注意力难以实现长距离交互，不利于捕获分割任务中所需的空间结构或形状，而MCA注意力模块通过构建了两个并行轴向注意力之间的交互，更有效地利用多尺度特征和全局上下文，在改进YOLOv10的过程中，能够契合目标形态，更有效的获取目标的全局信息。

二、MCANet原理

MCANet：基于多尺度交叉轴关注的医学图像分割

MCANet（Medical Image Segmentation with Multi - Scale Cross - Axis Attention）是一种用于医学图像分割的网络，其核心组件是多尺度交叉轴注意力（Multi - Scale Cross - Axis Attention，MCA）。

2.1 MCA的原理：

回顾轴向注意力：
- 轴向注意力将自注意力分解为两个部分，分别负责沿水平或垂直维度计算自注意力，基于此，Axial - DeepLab可沿水平和垂直方向依次聚合特征，使捕获全局信息成为可能。
- 轴向注意力比自注意力更高效，计算复杂度从 $\times HW)$ 降低到 $\times (H + W))$ 。
- 但在许多医学图像分割任务中，数据集相对较小，轴向注意力难以实现长距离交互，不利于捕获分割任务中所需的空间结构或形状。
多尺度交叉轴注意力：
- MCA结构分为两个并行分支，分别计算水平和垂直轴向注意力，每个分支由三个不同核大小的1D卷积组成，用于沿一个空间维度编码多尺度上下文信息，随后通过交叉轴注意力沿另一个空间维度聚合特征。
- 以顶部分支为例，给定特征图 $F$ （编码器最后三个阶段特征图的组合），使用三个并行的1D卷积对其进行编码，输出通过求和融合并送入一个 $1\times1$ 卷积，公式为 $F_{x} = Conv_{1\times1}\left(\sum_{i = 0}^{2}Conv1D_{i}^{x}(Norm(F))\right)$ ，其中 $Conv1D_{i}^{x}(\cdot)$ 表示沿 $x$ 轴维度的1D卷积， $Norm(\cdot)$ 是层归一化， $F_{x}$ 是输出。对于1D卷积的核大小，设置为 $1\times7$ 、 $1\times11$ 和 $1\times21$ 。底部分支的输出 $F_{y}$ 可通过类似方式得到。
- 对于顶部分支的 $F_{x}$ ，将其送入 $y$ 轴注意力，为更好地利用来自两个空间方向的多尺度卷积特征，计算 $F_{x}$ 和 $F_{y}$ 之间的交叉注意力，具体将 $F_{x}$ 作为键和值矩阵， $F_{y}$ 作为查询矩阵，计算过程为 $F_{T} = MHCA_{y}(F_{y}, F_{x}, F_{x})$ ，其中 $MHCA_{y}(\cdot, \cdot, \cdot)$ 表示沿 $x$ 轴的多头交叉注意力。底部分支以类似方式编码沿 $y$ 轴方向的上下文，即 $F_{B} = MHCA_{x}(F_{x}, F_{y}, F_{y})$ ，其中 $MHCA_{x}(\cdot, \cdot, \cdot)$ 表示沿 $y$ 轴的多头交叉注意力。
- MCA的输出为 $F_{out} = Conv_{1\times1}(F_{T}) + Conv_{1\times1}(F_{B}) + F$ 。

在这里插入图片描述

2.2 MCA的优势：

引入轻量级多尺度卷积：处理病变区域或器官各种大小和形状的有效方式。
创新的注意力机制：与大多数以前的工作不同，MCA不直接应用轴向注意力来捕获全局上下文，而是构建两个并行轴向注意力之间的交互，更有效地利用多尺度特征和全局上下文。
解码器轻量级：微小型号的模型参数数量仅为 $0.14 M$ ，更适合实际应用场景。

论文：https://arxiv.org/pdf/2312.08866v1
源码：https://github.com/haoshao-nku/medical_seg

三、MCA的实现代码

MCA模块的实现代码如下：

class StdPool(nn.Module) :
    def __init__(self):
        super(StdPool, self).__init__()
    def forward (self, x):
        b, c, _, _ = x.size()
        std = x.view(b, c, -1).std(dim=2, keepdim=True)
        std = std.reshape(b, c, 1, 1)
        return std
        
class MCAGate (nn.Module):
    def __init__(self, k_size, pool_types=['avg', 'std']):
 
        super(MCAGate, self).__init__()
        self.pools = nn.ModuleList([])
        for pool_type in pool_types:
            if pool_type == 'avg':
                self.pools.append(nn.AdaptiveAvgPool2d(1))
            elif pool_type == 'max':
                self.pools.append(nn.AdaptiveMaxPool2d(1))
            elif pool_type == 'std':
                self.pools.append(StdPool())
            else:
                raise NotImplementedError
 
        self.conv = nn.Conv2d(1, 1, kernel_size=(1, k_size),  stride=1, padding=(0, (k_size - 1) // 2), bias=False)
        self.sigmoid = nn.Sigmoid()
        self.weight = nn.Parameter(torch.rand(2))
 
    def forward(self, x):
        feats = [pool(x) for pool in self.pools]
 
        if len(feats) == 1:
            out = feats[0]
        elif len(feats) == 2:
            weight = torch.sigmoid(self.weight)
            out = 1/2*(feats[0] + feats[1]) + weight[0] * feats[0] + weight[1] * feats[1]
        else:
            assert False, "特征提取异常"
 
        out = out.permute(0, 3, 2, 1).contiguous()
        out = self.conv(out)
        out = out.permute(0, 3, 2, 1).contiguous()
 
        out = self.sigmoid(out)
        out = out.expand_as(x)
 
        return x * out
 
class MCA(nn.Module):
    def __init__(self, channel, no_spatial=False): 
        """Constructs a MCA module.
        Args:
            inp: Number of channels of the input feature maps
            no_spatial: whether to build channel dimension interactions
        """
        super(MCA, self).__init__()
        lambd = 1.5
        gamma = 1
        temp = round(abs((math.log2(channel) - gamma) / lambd))
        kernel = temp if temp % 2 else temp - 1
 
        self.h_cw = MCAGate(3)
        self.w_hc = MCAGate(3)
        self.no_spatial = no_spatial
        if not no_spatial:
            self.c_hw = MCAGate(kernel)
 
    def forward(self, x):
        x_h = x.permute(0, 2, 1, 3).contiguous()
        x_h = self.h_cw(x_h)
        x_h = x_h.permute(0, 2, 1, 3).contiguous() 
 
        x_w = x.permute(0, 3, 2, 1).contiguous()
        x_w = self.w_hc(x_w)
        x_w = x_w.permute(0, 3, 2, 1).contiguous() 
 
        if not self.no_spatial:   
            x_c = self.c_hw(x)
            x_out = 1 / 3 * (x_c + x_h + x_w)
        else:
            x_out = 1 / 2 * (x_h + x_w)
 
        return x_out

四、添加步骤

4.1 改进点1

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

在这里插入图片描述

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

4.2 改进点2⭐

模块改进方法2️⃣：基于MCA模块的C2f。

相较方法一中的直接插入注意力模块，利用注意力模块对卷积等其他模块进行改进，其新颖程度会更高一些，训练精度可能会表现的更高。

第二种改进方法是对YOLOv10中的C2f模块进行改进，MCA注意力模块通过构建了两个并行轴向注意力之间的交互，更有效地利用多尺度特征和全局上下文，在加入到C2f模块后，能够更加契合目标形态，更有效的获取目标的全局信息。

改进代码如下：

class MCARepNCSPELAN4(nn.Module):
    # csp-elan
    def __init__(self, c1, c2, c3, c4, c5=1):  # ch_in, ch_out, number, shortcut, groups, expansion
        super().__init__()
        self.c = c3//2
        self.cv1 = Conv(c1, c3, 1, 1)
        self.cv2 = nn.Sequential(RepNCSP(c3//2, c4, c5), MCA(c4))
        self.cv3 = nn.Sequential(RepNCSP(c4, c4, c5), MCA(c4))
        self.cv4 = Conv(c3+(2*c4), c2, 1, 1)

    def forward(self, x):
        y = list(self.cv1(x).chunk(2, 1))
        y.extend((m(y[-1])) for m in [self.cv2, self.cv3])
        return self.cv4(torch.cat(y, 1))

    def forward_split(self, x):
        y = list(self.cv1(x).split((self.c, self.c), 1))
        y.extend(m(y[-1]) for m in [self.cv2, self.cv3])
        return self.cv4(torch.cat(y, 1))

在这里插入图片描述

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

五、添加步骤

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

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

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

将MCA和C2f_MCA模块代码添加到此文件下。

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

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

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

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

from .block import (
    C1,
    C2,
    ...
    MCA,
    C2f_MCA
)

在这里插入图片描述

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

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

首先：在函数声明中引入MCA和C2f_MCA

在这里插入图片描述

其次：在parse_model函数中注册MCA和C2f_MCA模块

在这里插入图片描述

六、yaml模型文件

6.1 模型改进版本一

在代码配置完成后，配置模型的YAML文件。

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

将yolov10m.yaml中的内容复制到yolov10m-MCA.yaml文件下，修改nc数量等于自己数据中目标的数量。
在骨干网络中添加MCA模块，只需要填入一个参数，通道数。

# 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, [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, MCA, [1024]]
  - [-1, 1, SPPF, [1024, 5]] # 10
  - [-1, 1, PSA, [1024]] # 11

# YOLOv8.0n head
head:
  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  - [[-1, 6], 1, Concat, [1]] # cat backbone P4
  - [-1, 3, C2f, [512]] # 14

  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  - [[-1, 4], 1, Concat, [1]] # cat backbone P3
  - [-1, 3, C2f, [256]] # 17 (P3/8-small)

  - [-1, 1, Conv, [256, 3, 2]]
  - [[-1, 14], 1, Concat, [1]] # cat head P4
  - [-1, 3, C2fCIB, [512, True]] # 20 (P4/16-medium)

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

  - [[17, 20, 23], 1, v10Detect, [nc]] # Detect(P3, P4, P5)

6.2 模型改进版本二⭐

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

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

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

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

七、成功运行结果

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

YOLOv10m-MCA：

                  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    111360  ultralytics.nn.modules.block.C2f             [96, 96, 2, True]             
  3                  -1  1    166272  ultralytics.nn.modules.conv.Conv             [96, 192, 3, 2]               
  4                  -1  4    813312  ultralytics.nn.modules.block.C2f             [192, 192, 4, True]           
  5                  -1  1     78720  ultralytics.nn.modules.block.SCDown          [192, 384, 3, 2]              
  6                  -1  4   3248640  ultralytics.nn.modules.block.C2f             [384, 384, 4, 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        10  ultralytics.nn.modules.block.MCA             [576, 576]                    
 10                  -1  1    831168  ultralytics.nn.modules.block.SPPF            [576, 576, 5]                 
 11                  -1  1   1253088  ultralytics.nn.modules.block.PSA             [576, 576]                    
 12                  -1  1         0  torch.nn.modules.upsampling.Upsample         [None, 2, 'nearest']          
 13             [-1, 6]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           
 14                  -1  2   1993728  ultralytics.nn.modules.block.C2f             [960, 384, 2]                 
 15                  -1  1         0  torch.nn.modules.upsampling.Upsample         [None, 2, 'nearest']          
 16             [-1, 4]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           
 17                  -1  2    517632  ultralytics.nn.modules.block.C2f             [576, 192, 2]                 
 18                  -1  1    332160  ultralytics.nn.modules.conv.Conv             [192, 192, 3, 2]              
 19            [-1, 14]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           
 20                  -1  2    831744  ultralytics.nn.modules.block.C2fCIB          [576, 384, 2, True]           
 21                  -1  1    152448  ultralytics.nn.modules.block.SCDown          [384, 384, 3, 2]              
 22            [-1, 11]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           
 23                  -1  2   1911168  ultralytics.nn.modules.block.C2fCIB          [960, 576, 2, True]           
 24        [17, 20, 23]  1   2282134  ultralytics.nn.modules.head.v10Detect        [1, [192, 384, 576]]          
YOLOv10m-MCA summary: 511 layers, 16485296 parameters, 16485280 gradients, 64.0 GFLOPs

YOLOv10m-C2f_MCA：

                   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    130206  ultralytics.nn.modules.block.C2f_MCA         [96, 96, True]                
  3                  -1  1    166272  ultralytics.nn.modules.conv.Conv             [96, 192, 3, 2]               
  4                  -1  4   1036860  ultralytics.nn.modules.block.C2f_MCA         [192, 192, True]              
  5                  -1  1     78720  ultralytics.nn.modules.block.SCDown          [192, 384, 3, 2]              
  6                  -1  4   4138052  ultralytics.nn.modules.block.C2f_MCA         [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_MCA summary: 747 layers, 17617092 parameters, 17617076 gradients, 70.8 GFLOPs