YOLO11改进|注意力机制篇| 引入SpatialGroupEnhance注意力机制

在这里插入图片描述

- 一、【 SpatialGroupEnhance】注意力机制
- - 1.1【 SpatialGroupEnhance】注意力介绍
  - 1.2【SpatialGroupEnhance】核心代码
- 二、添加【SpatialGroupEnhance】注意力机制
- - 2.1STEP1
  - 2.2STEP2
  - 2.3STEP3
  - 2.4STEP4
- 三、yaml文件与运行
- - 3.1yaml文件
  - 3.2运行成功截图

一、【 SpatialGroupEnhance】注意力机制

1.1【 SpatialGroupEnhance】注意力介绍

在这里插入图片描述

下图是【SpatialGroupEnhance】的结构图，让我们简单分析一下运行过程和优势

处理过程分析：

输入特征图：
输入的特征图大小为 𝐶×𝐻×𝑊，其中 𝐶是通道数，𝐻和 𝑊
分别是特征图的高度和宽度。图片中展示了从图像输入到特征图处理的整个过程。
全局平均池化：
特征图首先经过 Global Average Pooling（全局平均池化）操作，这一步将输入特征图沿空间维度（高度和宽度）进行池化，得到一个形状为 𝐶×1×1的全局特征向量。这个向量可以看作是整个特征图的全局描述，提取了通道维度上的全局信息。
特征加权生成：
全局池化的特征向量 𝑔 经过一系列处理，用来生成每个通道的注意力权重。该过程包括了以下几个步骤：
归一化：通过某种形式的归一化操作（例如 Batch Normalization 或 Layer Normalization），对特征进行标准化处理。
逐像素点积：然后通过点积操作来计算每个通道上的注意力权重，从而使每个通道得到独立的响应权重。
Sigmoid 激活：为了保证加权系数在 0 到 1 之间，输出通过 Sigmoid 激活函数，将权重映射到标准化范围内。
通道注意力生成：
通过上述步骤生成的权重 𝛼被应用于原始的特征图 𝑋上。这个过程通过对每个通道进行重新加权，增强了那些对当前任务重要的特征，抑制了噪声或不相关的信息。
特征更新：
特征图通过全局上下文信息的调制，得到更新后的特征图 𝑋^ 。这使得模型能够更好地捕捉到全局的上下文信息，同时保留了空间上的细节。

优势分析：

全局上下文信息的有效捕捉：
通过全局平均池化，模型可以获得整个输入特征图的全局表示。这种全局上下文信息在特征重新加权时起到关键作用，尤其是在图像分类、检测等任务中，能够帮助模型识别出全局结构上的特征，提高对图像整体内容的理解。
通道间的依赖建模：
模块通过生成特征图每个通道的注意力权重，增强了通道间的依赖性。这意味着模型能够自动为重要的特征分配更多的权重，而减少对无关特征的依赖，从而使得模型更加鲁棒。
计算效率高：
与传统的自注意力机制（如 Transformer 中的多头自注意力）相比，这种全局注意力机制计算复杂度较低。因为池化后的向量尺寸显著减小，使得后续的计算（如归一化、点积、Sigmoid）代价很小，适合大规模特征图的处理。
轻量化且易于集成：
该模块结构简单，依赖基本的卷积、池化和激活操作，易于集成到现有的卷积神经网络中，如 ResNet、VGG 等。它不会大幅增加模型的参数量，因此能够在不明显增加计算资源的情况下，提升模型的表现。
动态自适应特征增强：
该模块能够根据输入特征的内容，自适应地调整每个通道的权重。这意味着它可以根据不同输入动态调节网络的响应能力，使得模型在各种复杂场景下都能具有较强的适应性。

1.2【SpatialGroupEnhance】核心代码

import numpy as np
import torch
from torch import nn
from torch.nn import init
 
 
class SpatialGroupEnhance(nn.Module):
    def __init__(self, groups=8):
        super().__init__()
        self.groups = groups
        self.avg_pool = nn.AdaptiveAvgPool2d(1)
        self.weight = nn.Parameter(torch.zeros(1, groups, 1, 1))
        self.bias = nn.Parameter(torch.zeros(1, groups, 1, 1))
        self.sig = nn.Sigmoid()
        self.init_weights()
 
    def init_weights(self):
        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                init.kaiming_normal_(m.weight, mode='fan_out')
                if m.bias is not None:
                    init.constant_(m.bias, 0)
            elif isinstance(m, nn.BatchNorm2d):
                init.constant_(m.weight, 1)
                init.constant_(m.bias, 0)
            elif isinstance(m, nn.Linear):
                init.normal_(m.weight, std=0.001)
                if m.bias is not None:
                    init.constant_(m.bias, 0)
 
    def forward(self, x):
        b, c, h, w = x.shape
        x = x.view(b * self.groups, -1, h, w)  # bs*g,dim//g,h,w
        xn = x * self.avg_pool(x)  # bs*g,dim//g,h,w
        xn = xn.sum(dim=1, keepdim=True)  # bs*g,1,h,w
        t = xn.view(b * self.groups, -1)  # bs*g,h*w
 
        t = t - t.mean(dim=1, keepdim=True)  # bs*g,h*w
        std = t.std(dim=1, keepdim=True) + 1e-5
        t = t / std  # bs*g,h*w
        t = t.view(b, self.groups, h, w)  # bs,g,h*w
 
        t = t * self.weight + self.bias  # bs,g,h*w
        t = t.view(b * self.groups, 1, h, w)  # bs*g,1,h*w
        x = x * self.sig(t)
        x = x.view(b, c, h, w)
        return x
 
 
def autopad(k, p=None, d=1):  # kernel, padding, dilation
    """Pad to 'same' shape outputs."""
    if d > 1:
        k = d * (k - 1) + 1 if isinstance(k, int) else [d * (x - 1) + 1 for x in k]  # actual kernel-size
    if p is None:
        p = k // 2 if isinstance(k, int) else [x // 2 for x in k]  # auto-pad
    return p
 
 
class Conv(nn.Module):
    """Standard convolution with args(ch_in, ch_out, kernel, stride, padding, groups, dilation, activation)."""
    default_act = nn.SiLU()  # default activation
 
    def __init__(self, c1, c2, k=1, s=1, p=None, g=1, d=1, act=True):
        """Initialize Conv layer with given arguments including activation."""
        super().__init__()
        self.conv = nn.Conv2d(c1, c2, k, s, autopad(k, p, d), groups=g, dilation=d, bias=False)
        self.bn = nn.BatchNorm2d(c2)
        self.act = self.default_act if act is True else act if isinstance(act, nn.Module) else nn.Identity()
 
    def forward(self, x):
        """Apply convolution, batch normalization and activation to input tensor."""
        return self.act(self.bn(self.conv(x)))
 
    def forward_fuse(self, x):
        """Perform transposed convolution of 2D data."""
        return self.act(self.conv(x))
 
 
class Bottleneck(nn.Module):
    """Standard bottleneck."""
 
    def __init__(self, c1, c2, shortcut=True, g=1, k=(3, 3), e=0.5):
        """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 = Conv(c1, c_, k[0], 1)
        self.cv2 = Conv(c_, c2, k[1], 1, g=g)
        self.add = shortcut and c1 == c2
 
    def forward(self, x):
        """'forward()' applies the YOLO FPN to input data."""
        return x + self.cv2(self.cv1(x)) if self.add else self.cv2(self.cv1(x))
 
 
class C2f(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))
 
    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.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.cv2(torch.cat(y, 1))
 
 
class C2f_SGE(nn.Module):
    def __init__(self, c1, c2, n=1, shortcut=False, g=1, e=0.5, groups=8):
        """Initialize CSP bottleneck layer with two convolutions and SpatialGroupEnhance."""
        super().__init__()
        self.c2f = C2f(c1, c2, n, shortcut, g, e)
        self.sge = SpatialGroupEnhance(groups)
 
    def forward(self, x):
        """Forward pass through C2f layer and then SpatialGroupEnhance."""
        x = self.c2f(x)
        x = self.sge(x)
        return x
 
 
if __name__ == '__main__':
    input = torch.randn(50, 512, 7, 7)
    c2f_sge = C2f_SGE(c1=512, c2=512, n=1, shortcut=False, g=1, e=0.5, groups=8)
    output = c2f_sge(input)
    print(output.shape)

二、添加【SpatialGroupEnhance】注意力机制

2.1STEP1

首先找到ultralytics/nn文件路径下新建一个Add-module的python文件包【这里注意一定是python文件包，新建后会自动生成_init_.py】，如果已经跟着我的教程建立过一次了可以省略此步骤，随后新建一个SpatialGroupEnhance.py文件并将上文中提到的注意力机制的代码全部粘贴到此文件中，如下图所示在这里插入图片描述

2.2STEP2

在STEP1中新建的_init_.py文件中导入增加改进模块的代码包如下图所示在这里插入图片描述

2.3STEP3

找到ultralytics/nn文件夹中的task.py文件，在其中按照下图添加在这里插入图片描述

2.4STEP4

定位到ultralytics/nn文件夹中的task.py文件中的def parse_model(d, ch, verbose=True): # model_dict, input_channels(3)函数添加如图代码,【如果不好定位可以直接ctrl+f搜索定位】

在这里插入图片描述

三、yaml文件与运行

3.1yaml文件

以下是添加【SpatialGroupEnhance】注意力机制在Backbone中的yaml文件，大家可以注释自行调节，效果以自己的数据集结果为准

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

# Parameters
nc: 80 # number of classes
scales: # model compound scaling constants, i.e. 'model=yolo11n.yaml' will call yolo11.yaml with scale 'n'
  # [depth, width, max_channels]
  n: [0.50, 0.25, 1024] # summary: 319 layers, 2624080 parameters, 2624064 gradients, 6.6 GFLOPs
  s: [0.50, 0.50, 1024] # summary: 319 layers, 9458752 parameters, 9458736 gradients, 21.7 GFLOPs
  m: [0.50, 1.00, 512] # summary: 409 layers, 20114688 parameters, 20114672 gradients, 68.5 GFLOPs
  l: [1.00, 1.00, 512] # summary: 631 layers, 25372160 parameters, 25372144 gradients, 87.6 GFLOPs
  x: [1.00, 1.50, 512] # summary: 631 layers, 56966176 parameters, 56966160 gradients, 196.0 GFLOPs

# YOLO11n 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, 2, C3k2, [256, False, 0.25]]
  - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
  - [-1, 2, C3k2, [512, False, 0.25]]
  - [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
  - [-1, 2, C3k2, [512, True]]
  - [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
  - [-1, 2, C3k2, [1024, True]]
  - [-1, 1, SPPF, [1024, 5]] # 9
  - [-1,1,SpatialGroupEnhance,[]]
  - [-1, 2, C2PSA, [1024]] # 10

# YOLO11n head
head:
  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  - [[-1, 6], 1, Concat, [1]] # cat backbone P4
  - [-1, 2, C3k2, [512, False]] # 13

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


  - [-1, 1, Conv, [256, 3, 2]]
  - [[-1, 14], 1, Concat, [1]] # cat head P4
  - [-1, 2, C3k2, [512, False]] # 19 (P4/16-medium)

  - [-1, 1, Conv, [512, 3, 2]]
  - [[-1, 11], 1, Concat, [1]] # cat head P5
  - [-1, 2, C3k2, [1024, True]] # 22 (P5/32-large)

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