YOLOv10改进策略【注意力机制篇】| GAM全局注意力机制：保留信息以增强通道与空间的相互作用

一、本文介绍

本文记录的是基于GAM注意力模块的YOLOv10目标检测改进方法研究。GAM注意力模块通过3D排列和重新设计的子模块，能够在通道和空间方面保留信息，避免了先前方法中由于信息减少和维度分离而导致的全局空间-通道交互丢失的问题。本文利用GAM改进YOLOv10，以增强模型的跨维度交互能力。

文章目录

一、本文介绍
二、GAM注意力原理
- 2.1、设计原理
- 2.2、优势
三、GAM的实现代码
四、添加步骤
- 4.1 改进点1
- 4.2 改进点2⭐
五、添加步骤
- 5.1 修改ultralytics/nn/modules/block.py
- 5.2 修改ultralytics/nn/modules/__init__.py
- 5.3 修改ultralytics/nn/modules/tasks.py
六、yaml模型文件
- 6.1 模型改进版本一
- 6.2 模型改进版本二⭐
七、成功运行结果

二、GAM注意力原理

全局注意力机制：保留信息以增强通道与空间的相互作用

GAM（Global Attention Mechanism）是一种全局注意力机制，其设计目的是减少信息减少并放大全局维度交互特征，以增强深度神经网络的性能。

2.1、设计原理

整体结构：采用了来自CBAM的顺序通道 - 空间注意力机制，并重新设计了子模块。给定输入特征图 $F_{1} \in \mathbb{R}^{C ×H ×W}$ ，中间状态 $F_{2}$ 和输出 $F_{3}$ 的定义为：
- $F_{2}=M_{c}\left(F_{1}\right) \otimes F_{1}$
- $F_{3}=M_{s}\left(F_{2}\right) \otimes F_{2}$
  其中 $M_{c}$ 和 $M_{s}$ 分别是通道和空间注意力图， $\otimes$ 表示元素级乘法。
通道注意力子模块：使用3D排列来保留跨三个维度的信息，然后通过两层MLP（多层感知机）放大跨维度的通道 - 空间依赖性。（MLP是具有压缩比 $r$ 的编码器 - 解码器结构，与BAM相同。）
空间注意力子模块：为了关注空间信息，使用两个卷积层进行空间信息融合，并使用与通道注意力子模块相同的压缩比 $r$ （与BAM相同）。同时，由于最大池化会减少信息并产生负面影响，所以移除了池化以进一步保留特征图。为了防止参数显著增加，在ResNet50中采用了具有通道打乱的组卷积。

在这里插入图片描述

2.2、优势

保留信息：通过3D排列和重新设计的子模块，GAM能够在通道和空间方面保留信息，避免了先前方法中由于信息减少和维度分离而导致的全局空间 - 通道交互的丢失。
放大交互：能够放大“全局”跨维度交互，捕获所有三个维度（通道、空间宽度和空间高度）上的重要特征，从而增强了跨维度的交互能力。
性能提升：在CIFAR - 100和ImageNet - 1K数据集上的评估表明，GAM稳定地优于其他几种近期的注意力机制，无论是在ResNet还是轻量级MobileNet上，都能提高性能。例如，在ImageNet - 1K数据集上，对于ResNet18，GAM以更少的参数和更高的效率优于ABN。

论文：https://arxiv.org/pdf/2112.05561v1
源码：https://github.com/dengbuqi/GAM_Pytorch/blob/main/CAM.py

三、GAM的实现代码

GAM模块的实现代码如下：

class GAMAttention(nn.Module):

    def __init__(self, c1, c2, group=True, rate=4):
        super(GAMAttention, self).__init__()

        self.channel_attention = nn.Sequential(
            nn.Linear(c1, int(c1 / rate)),
            nn.ReLU(inplace=True),
            nn.Linear(int(c1 / rate), c1),
        )
        self.spatial_attention = nn.Sequential(
            (
                nn.Conv2d(c1, c1 // rate, kernel_size=7, padding=3, groups=rate)
                if group
                else nn.Conv2d(c1, int(c1 / rate), kernel_size=7, padding=3)
            ),
            nn.BatchNorm2d(int(c1 / rate)),
            nn.ReLU(inplace=True),
            (
                nn.Conv2d(c1 // rate, c2, kernel_size=7, padding=3, groups=rate)
                if group
                else nn.Conv2d(int(c1 / rate), c2, kernel_size=7, padding=3)
            ),
            nn.BatchNorm2d(c2),
        )

    def forward(self, x):
        b, c, h, w = x.shape
        x_permute = x.permute(0, 2, 3, 1).view(b, -1, c)
        x_att_permute = self.channel_attention(x_permute).view(b, h, w, c)
        x_channel_att = x_att_permute.permute(0, 3, 1, 2)
        x = x * x_channel_att

        x_spatial_att = self.spatial_attention(x).sigmoid()
        x_spatial_att = channel_shuffle(x_spatial_att, 4)  # last shuffle
        out = x * x_spatial_att
        return out


def channel_shuffle(x, groups=2):  ##shuffle channel
    # RESHAPE----->transpose------->Flatten
    B, C, H, W = x.size()
    out = x.view(B, groups, C // groups, H, W).permute(0, 2, 1, 3, 4).contiguous()
    out = out.view(B, C, H, W)
    return out

四、添加步骤

4.1 改进点1

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

在这里插入图片描述

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

4.2 改进点2⭐

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

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

第二种改进方法是对YOLOv10中的C2f模块进行改进。GAM 模块能够捕捉通道、空间宽度和空间高度等多个维度的重要特征，加强了跨维度的交互，在将其添加到C2f模块中有助于在分流过程中更好地分配注意力，减少无关信息的干扰，提高特征质量。

改进代码如下：

class C2f_GAM(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 = GAMAttention(c1, 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_GAM。

五、添加步骤

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

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

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

将GAMAttention和C2f_GAM模块代码添加到此文件下。

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

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

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

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

from .block import (
    C1,
    C2,
    ...
    GAMAttention,
    C2f_GAM
)

在这里插入图片描述

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

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

首先：在函数声明中引入GAMAttention和C2f_GAM

在这里插入图片描述

其次：在parse_model函数中注册GAMAttention和C2f_GAM模块

在这里插入图片描述

六、yaml模型文件

6.1 模型改进版本一

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

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

将yolov10m.yaml中的内容复制到yolov10m-GAM.yaml文件下，修改nc数量等于自己数据中目标的数量。
在骨干网络中添加GAMAttention模块，即下方代码中的第45行，只需要填入一个参数，通道数，和前一层通道数一致。

📌 GAM 模块能够放大全局维度交互特征，放在此处的目的是有助于更好地捕捉和保留重要的信息，从而增强骨干网络对特征的提取能力。

# 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, GAMAttention, [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_GAM.yaml。

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

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

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

七、成功运行结果

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

YOLOv10m-GAM：

                   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   2200896  ultralytics.nn.modules.block.GAMAttention    [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-GAM summary: 509 layers, 18686182 parameters, 18686166 gradients, 65.7 GFLOPs

YOLOv10m-C2f_GAM：

                   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    253248  ultralytics.nn.modules.block.C2f_GAM         [96, 96, True]                
  3                  -1  1    166272  ultralytics.nn.modules.conv.Conv             [96, 192, 3, 2]               
  4                  -1  4   2017536  ultralytics.nn.modules.block.C2f_GAM         [192, 192, True]              
  5                  -1  1     78720  ultralytics.nn.modules.block.SCDown          [192, 384, 3, 2]              
  6                  -1  4   8053248  ultralytics.nn.modules.block.C2f_GAM         [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_GAM summary: 667 layers, 22636006 parameters, 22635990 gradients, 102.1 GFLOPs