YOLOv11改进策略【注意力机制篇】| EMA 即插即用模块，提高远距离建模依赖

Limiiiing

已于 2024-10-11 11:09:59 修改

阅读量231

点赞数 13

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

于 2024-10-11 10:45:55 首次发布

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

版权

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

19 篇文章 7 订阅

订阅专栏

一、本文介绍

本文记录的是基于EMA模块的YOLOv11目标检测改进方法研究。EMA认为跨维度交互有助于通道或空间注意力预测，并且解决了现有注意力机制在提取深度视觉表示时可能带来的维度缩减问题。在改进YOLOv11的过程中能够为高级特征图产生更好的像素级注意力，能够建模长程依赖并嵌入精确的位置信息。

二、EMA原理

Efficient Multi-Scale Attention Module with Cross-Spatial Learning

EMA（Efficient Multi - Scale Attention）注意力模块的设计的原理和优势如下：

2.1 EMA原理

2.1.1 Coordinate Attention（CA）

CA通过全局平均池化操作建模跨通道信息，将原始输入张量分解为两个并行的1D特征编码向量，嵌入空间位置信息到通道注意力图中，以增强特征聚合。但CA忽略了整个空间位置间交互的重要性，且1x1卷积核的有限感受野不利于建模局部跨通道交互和利用上下文信息。

2.1.2 Multi - Scale Attention（EMA）模块

特征分组：对于输入特征图 $\in \mathbb{R}^{C \times H \times W}$ ，EMA将其在通道维度方向上划分为 $G$ 个子特征 $[X_{0}, X_{1}, \ldots, X_{G - 1}]$ ， $X_{i} \in \mathbb{R}^{C / G \times H \times W}$ ，假设学习到的注意力权重描述符将用于增强每个子特征中感兴趣区域的特征表示。
并行子网络：EMA采用三个并行路线来提取分组特征图的注意力权重描述符，其中两个在1x1分支，第三个在3x3分支。在1x1分支中，通过两个1D全局平均池化操作分别沿两个空间方向编码通道信息，并将G组重塑和置换到批处理维度，使两个编码特征共享无维度缩减的1x1卷积。在3x3分支中，通过一个3x3卷积捕获多尺度特征表示。这样，EMA不仅编码了通道间信息来调整不同通道的重要性，还将精确的空间结构信息保留到通道中。
跨空间学习：引入两个张量，分别是1x1分支和3x3分支的输出。利用2D全局平均池化在1x1分支的输出中编码全局空间信息，并在通道特征的联合激活机制前将另一个分支的输出转换为对应维度形状。通过矩阵点积操作得到第一个空间注意力图，再类似地得到第二个空间注意力图。最后，每个组内的输出特征图通过两个生成的空间注意力权重值的聚合计算得到，捕获像素级成对关系并突出所有像素的全局上下文。

在这里插入图片描述

2.2 特点

建立多尺度并行子网络：采用并行子结构，避免了更多的顺序处理和大深度，有利于有效建立短程和长程依赖，以获得更好的性能。
避免维度缩减：仅选取CA模块中1x1卷积的共享组件，避免了在卷积操作中进行通道维度缩减，从而更有效地学习有效的通道描述。
融合跨空间信息：通过跨空间学习方法，融合了不同尺度的上下文信息，使CNN能够为高级特征图产生更好的像素级注意力，能够建模长程依赖并嵌入精确的位置信息。
高效且有效：与其他注意力方法（如CBAM、NAM、SA、ECA和CA）相比，EMA不仅在性能上取得了更好的结果，而且在所需参数方面更高效。在多个数据集（如CIFAR - 100、ImageNet - 1k、COCO和VisDrone2019）上的实验表明，EMA在图像分类和对象检测任务中都具有优势，模型复杂度相对较小，且在不同的基准模型（如ResNet50/101和MobileNetV2）上集成时均能有效提升性能。

论文：https://doi.org/10.1016/j.neunet.2024.106314
源码：https://github.com/Lose-Code/UBRFC-Net

三、EMA的实现代码

EMA模块的实现代码如下：

import torch
from torch import nn


class EMA(nn.Module):
    def __init__(self, channels, c2=None, factor=32):
        super(EMA, self).__init__()
        self.groups = factor
        assert channels // self.groups > 0
        self.softmax = nn.Softmax(-1)
        self.agp = nn.AdaptiveAvgPool2d((1, 1))
        self.pool_h = nn.AdaptiveAvgPool2d((None, 1))
        self.pool_w = nn.AdaptiveAvgPool2d((1, None))
        self.gn = nn.GroupNorm(channels // self.groups, channels // self.groups)
        self.conv1x1 = nn.Conv2d(channels // self.groups, channels // self.groups, kernel_size=1, stride=1, padding=0)
        self.conv3x3 = nn.Conv2d(channels // self.groups, channels // self.groups, kernel_size=3, stride=1, padding=1)

    def forward(self, x):
        b, c, h, w = x.size()
        group_x = x.reshape(b * self.groups, -1, h, w)  # b*g,c//g,h,w
        x_h = self.pool_h(group_x)
        x_w = self.pool_w(group_x).permute(0, 1, 3, 2)
        hw = self.conv1x1(torch.cat([x_h, x_w], dim=2))
        x_h, x_w = torch.split(hw, [h, w], dim=2)
        x1 = self.gn(group_x * x_h.sigmoid() * x_w.permute(0, 1, 3, 2).sigmoid())
        x2 = self.conv3x3(group_x)
        x11 = self.softmax(self.agp(x1).reshape(b * self.groups, -1, 1).permute(0, 2, 1))
        x12 = x2.reshape(b * self.groups, c // self.groups, -1)  # b*g, c//g, hw
        x21 = self.softmax(self.agp(x2).reshape(b * self.groups, -1, 1).permute(0, 2, 1))
        x22 = x1.reshape(b * self.groups, c // self.groups, -1)  # b*g, c//g, hw
        weights = (torch.matmul(x11, x12) + torch.matmul(x21, x22)).reshape(b * self.groups, 1, h, w)
        return (group_x * weights.sigmoid()).reshape(b, c, h, w)

四、创新模块

4.1 改进点1

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

在这里插入图片描述

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

4.2 改进点2⭐

模块改进方法2️⃣：基于EMA模块的C3k2。

📌 第二种改进方法是对YOLOv11中的C3k2模块进行改进，在C2f提取特征后，利用EMA注意力模块跨空间学习方法，融合了不同尺度的上下文信息，再加入到C3k2模块中后，使模型能够为高级特征图产生更好的像素级注意力，并在局部聚合的过程中加入短程和长程依赖，来嵌入精确的位置信息以获得更好的性能。

改进代码如下：

首先添加如下代码改进C2f模块，并重命名为C2f_EMA

class C2f_EMA(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 = EMA(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)))

在这里插入图片描述
再添加如下代码让C3k2继承于C2f_EMA，并重命名为C3k2_NAM

class C3k2_EMA(C2f_EMA):
    """Faster Implementation of CSP Bottleneck with 2 convolutions."""

    def __init__(self, c1, c2, n=1, c3k=False, e=0.5, g=1, shortcut=True):
        """Initializes the C3k2 module, a faster CSP Bottleneck with 2 convolutions and optional C3k blocks."""
        super().__init__(c1, c2, n, shortcut, g, e)
        self.m = nn.ModuleList(
            C3k(self.c, self.c, 2, shortcut, g) if c3k else Bottleneck(self.c, self.c, shortcut, g) for _ in range(n)
        )

在这里插入图片描述

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

五、添加步骤

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

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

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

将EMA和C3k2_EMA模块代码添加到此文件下。

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

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

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

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

from .block import (
    C1,
    C2,
    ...
    EMA,
    C3k2_EMA
)

在这里插入图片描述

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

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

首先：在函数声明中引入EMA和C3k2_EMA

在这里插入图片描述

其次：在parse_model函数中注册EMA和C3k2_EMA模块

在这里插入图片描述

六、yaml模型文件

6.1 模型改进版本一

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

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

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

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

# yolo task=detect mode=train model=yolov11m.yaml data=data.yaml device=0 epochs=300 batch=16 imgsz=640 workers=10

# Parameters
nc: 1 # 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, EMA, [1024]]
  - [-1, 1, SPPF, [1024, 5]] # 9
  - [-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)

6.2 模型改进版本二⭐

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

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

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

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

# yolo task=detect mode=train model=yolov11m.yaml data=data.yaml device=0 epochs=300 batch=16 imgsz=640 workers=10

# Parameters
nc: 1 # 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_EMA, [256, False, 0.25]]
  - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
  - [-1, 2, C3k2_EMA, [512, False, 0.25]]
  - [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
  - [-1, 2, C3k2_EMA, [512, True]]
  - [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
  - [-1, 2, C3k2_EMA, [1024, True]]
  - [-1, 1, SPPF, [1024, 5]] # 9
  - [-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, 13], 1, Concat, [1]] # cat head P4
  - [-1, 2, C3k2, [512, False]] # 19 (P4/16-medium)

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

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

六、成功运行结果

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

YOLOv11m-EMA：

                   from  n    params  module                                       arguments                     
  0                  -1  1      1856  ultralytics.nn.modules.conv.Conv             [3, 64, 3, 2]                 
  1                  -1  1     73984  ultralytics.nn.modules.conv.Conv             [64, 128, 3, 2]               
  2                  -1  1    111872  ultralytics.nn.modules.block.C3k2            [128, 256, 1, True, 0.25]     
  3                  -1  1    590336  ultralytics.nn.modules.conv.Conv             [256, 256, 3, 2]              
  4                  -1  1    444928  ultralytics.nn.modules.block.C3k2            [256, 512, 1, True, 0.25]     
  5                  -1  1   2360320  ultralytics.nn.modules.conv.Conv             [512, 512, 3, 2]              
  6                  -1  1   1380352  ultralytics.nn.modules.block.C3k2            [512, 512, 1, True]           
  7                  -1  1   2360320  ultralytics.nn.modules.conv.Conv             [512, 512, 3, 2]              
  8                  -1  1   1380352  ultralytics.nn.modules.block.C3k2            [512, 512, 1, True]           
  9                  -1  1      2624  ultralytics.nn.modules.block.EMA             [512, 512]                    
 10                  -1  1    656896  ultralytics.nn.modules.block.SPPF            [512, 512, 5]                 
 11                  -1  1    990976  ultralytics.nn.modules.block.C2PSA           [512, 512, 1]                 
 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  1   1642496  ultralytics.nn.modules.block.C3k2            [1024, 512, 1, True]          
 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  1    542720  ultralytics.nn.modules.block.C3k2            [1024, 256, 1, True]          
 18                  -1  1    590336  ultralytics.nn.modules.conv.Conv             [256, 256, 3, 2]              
 19            [-1, 14]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           
 20                  -1  1   1511424  ultralytics.nn.modules.block.C3k2            [768, 512, 1, True]           
 21                  -1  1   2360320  ultralytics.nn.modules.conv.Conv             [512, 512, 3, 2]              
 22            [-1, 11]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           
 23                  -1  1   1642496  ultralytics.nn.modules.block.C3k2            [1024, 512, 1, True]          
 24        [17, 20, 23]  1   1411795  ultralytics.nn.modules.head.Detect           [1, [256, 512, 512]]          
YOLOv11m-EMA summary: 417 layers, 20,056,403 parameters, 20,056,387 gradients, 68.3 GFLOPs

YOLOv11m-C3k2_EMA：

                   from  n    params  module                                       arguments                     
  0                  -1  1      1856  ultralytics.nn.modules.conv.Conv             [3, 64, 3, 2]                 
  1                  -1  1     73984  ultralytics.nn.modules.conv.Conv             [64, 128, 3, 2]               
  2                  -1  1    100000  ultralytics.nn.modules.block.C3k2_EMA        [128, 256, False, 0.25]       
  3                  -1  1    590336  ultralytics.nn.modules.conv.Conv             [256, 256, 3, 2]              
  4                  -1  1    397888  ultralytics.nn.modules.block.C3k2_EMA        [256, 512, False, 0.25]       
  5                  -1  1   2360320  ultralytics.nn.modules.conv.Conv             [512, 512, 3, 2]              
  6                  -1  1   1250624  ultralytics.nn.modules.block.C3k2_EMA        [512, 512, True]              
  7                  -1  1   2360320  ultralytics.nn.modules.conv.Conv             [512, 512, 3, 2]              
  8                  -1  1   1250624  ultralytics.nn.modules.block.C3k2_EMA        [512, 512, True]              
  9                  -1  1    656896  ultralytics.nn.modules.block.SPPF            [512, 512, 5]                 
 10                  -1  1    990976  ultralytics.nn.modules.block.C2PSA           [512, 512, 1]                 
 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  1   1642496  ultralytics.nn.modules.block.C3k2            [1024, 512, 1, True]          
 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  1    542720  ultralytics.nn.modules.block.C3k2            [1024, 256, 1, True]          
 17                  -1  1    590336  ultralytics.nn.modules.conv.Conv             [256, 256, 3, 2]              
 18            [-1, 13]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           
 19                  -1  1   1511424  ultralytics.nn.modules.block.C3k2            [768, 512, 1, True]           
 20                  -1  1   2360320  ultralytics.nn.modules.conv.Conv             [512, 512, 3, 2]              
 21            [-1, 10]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           
 22                  -1  1   1642496  ultralytics.nn.modules.block.C3k2            [1024, 512, 1, True]          
 23        [16, 19, 22]  1   1411795  ultralytics.nn.modules.head.Detect           [1, [256, 512, 512]]          
YOLOv11m-C3k2_EMA summary: 355 layers, 19,735,411 parameters, 19,735,395 gradients, 68.8 GFLOPs