YOLOv10改进策略【注意力机制篇】| 引入SimAM注意力模块（一个简单的，无参数的卷积神经网络注意模块，含二次创新）

一、本文介绍

本文记录的是基于SimAM注意力模块的YOLOv10目标检测方法研究。SimAM注意力模块通过优化能量函数来获得每个神经元的三维权重，而无需引入额外的参数或增加计算复杂度。若是有轻量化需求的小伙伴，无参的注意力模块也许是一个不错的选择。

文章目录

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

二、SimAM注意力原理

SimAM（A Simple, Parameter-Free Attention Module for Convolutional Neural Networks）是一种简单且无参数的注意力模块，主要用于卷积神经网络。

2.1、原理

基于神经科学理论定义能量函数 ：
- 在视觉神经科学中，最具信息量的神经元通常是那些与周围神经元具有不同激发模式的神经元。并且，一个活跃的神经元可能会抑制周围神经元的活动，这种现象被称为空间抑制。
- 基于此，SimAM为每个神经元定义了如下能量函数 ： e t ( w t , b t , y , x i ) = ( y t − t ^ ) 2 + 1 M − 1 ∑ i = 1 M − 1 ( y o − x ^ i ) 2 e_{t}\left(w_{t}, b_{t}, y, x_{i}\right)=\left(y_{t}-\hat{t}\right)^{2}+\frac{1}{M - 1} \sum_{i = 1}^{M - 1}\left(y_{o}-\hat{x}{i}\right)^{2} et(wt,bt,y,xi)=(yt−t^)2+M−11∑i=1M−1(yo−x^i)2，其中 t ^ = w t t + b t \hat{t}=w{t}t + b_{t} t^=wtt+bt和 x ^ i = w t x i + b t \hat{x}{i}=w{t}x_{i}+b_{t} x^i=wtxi+bt是线性变换， t t t和 x i x_{i} xi是输入特征 X ∈ R C × H × W X\in R^{C\times H\times W} X∈RC×H×W单个通道中的目标神经元和其他神经元。 i i i是空间维度上的索引， M = H × W M = H\times W M=H×W是该通道上的神经元数量。 w t w_{t} wt和 b t b_{t} bt是线性变换的权重和偏置。
- 为了简化计算，采用二进制标签（即 1 和 -1）用于 y t y_{t} yt和 y o y_{o} yo，并添加一个正则项，最终的能量函数为：
  e t ( w t , b t , y , x i ) = 1 M − 1 ∑ i = 1 M − 1 ( − 1 − ( w t x i + b t ) ) 2 + ( 1 − ( w t t + b t ) ) 2 + λ w t 2 e_{t}\left(w_{t}, b_{t}, y, x_{i}\right)=\frac{1}{M - 1} \sum_{i = 1}^{M - 1}\left(-1-\left(w_{t}x_{i}+b_{t}\right)\right)^{2}+\left(1-\left(w_{t}t+b_{t}\right)\right)^{2}+\lambda w_{t}^{2} et(wt,bt,y,xi)=M−11∑i=1M−1(−1−(wtxi+bt))2+(1−(wtt+bt))2+λwt2。
推导能量函数的闭式解 ：
- 通过对上述能量函数求解，得到关于 w t w_{t} wt和 b t b_{t} bt的闭式解为： w t = − 2 ( t − μ t ) ( t − μ t ) 2 + 2 σ t 2 + 2 λ w_{t}=-\frac{2\left(t-\mu_{t}\right)}{\left(t-\mu_{t}\right)^{2}+2\sigma_{t}^{2}+2\lambda} wt=−(t−μt)2+2σt2+2λ2(t−μt)， b t = − 1 2 ( t + μ t ) w t b_{t}=-\frac{1}{2}\left(t+\mu_{t}\right)w_{t} bt=−21(t+μt)wt。其中 μ t = 1 M − 1 ∑ i x i \mu_{t}=\frac{1}{M - 1}\sum_{i}x_{i} μt=M−11∑ixi和 σ t = 1 M − 1 ∑ i ( x i − μ t ) 2 \sigma_{t}=\sqrt{\frac{1}{M - 1}\sum_{i}\left(x_{i}-\mu_{t}\right)^{2}} σt=M−11∑i(xi−μt)2 是该通道上除(t)以外所有神经元的均值和方差。
- 由于上述解是在单个通道上得到的，假设单个通道中的所有像素遵循相同的分布，那么可以对所有神经元计算一次均值和方差，并在该通道上重复使用，得到最小能量计算公式： e t ∗ = 4 ( σ ^ 2 + λ ) ( t − μ ^ ) 2 + 2 σ ^ 2 + 2 λ e_{t}^{*}=\frac{4\left(\hat{\sigma}^{2}+\lambda\right)}{(t-\hat{\mu})^{2}+2\hat{\sigma}^{2}+2\lambda} et∗=(t−μ^)2+2σ^2+2λ4(σ^2+λ)，其中 μ ^ = 1 M ∑ i x i \hat{\mu}=\frac{1}{M}\sum_{i}x_{i} μ^=M1∑ixi和 σ ^ 2 = 1 M ∑ i ( x i − μ ^ ) 2 \hat{\sigma}^{2}=\frac{1}{M}\sum_{i}\left(x_{i}-\hat{\mu}\right)^{2} σ^2=M1∑i(xi−μ^)2。
- 能量 e t ∗ e_{t}^{*} et∗越低，神经元 t t t与周围神经元的区别就越大，在视觉处理中就越重要。因此，每个神经元的重要性可以通过 1 / e t ∗ 1/e_{t}^{*} 1/et∗获得。
注意力模块的特征细化 ：
- 根据哺乳动物大脑中的注意力调制通常表现为对神经元响应的增益效应，SimAM使用缩放运算符而不是加法来进行特征细化。整个模块的细化阶段公式为： X ~ = sigmoid ( 1 E ) ⊙ X \tilde{X}=\text{sigmoid}\left(\frac{1}{E}\right)\odot X X~=sigmoid(E1)⊙X，其 E E E是所有通道和空间维度上的 e t ∗ e_{t}^{*} et∗的集合， sigmoid \text{sigmoid} sigmoid函数用于限制 E E E中的值过大，它是一个单调函数，不会影响每个神经元的相对重要性。

2.2、优势

全三维注意力权重 ：
- 与现有的注意力模块不同，SimAM可以直接推断出全三维注意力权重，同时考虑空间和通道维度，而不是只沿通道或空间维度生成一维或二维权重。这使得网络能够学习到更具判别性的特征，更好地捕捉图像中的有价值线索，与图像标签更加一致。
基于神经科学理论，可解释性强 ：
- SimAM基于神经科学理论设计，其实现注意力的方式是估计单个神经元的重要性，这种方法来源于对哺乳动物大脑中视觉处理机制的理解，具有较强的可解释性 。相比其他大多基于启发式方法计算注意力权重的模块，SimAM更加科学合理。
参数自由 ：
- SimAM通过推导能量函数的闭式解，实现了无需向原始网络添加额外参数的特性。这在实际应用中具有很大的优势，轻量化，不会增加模型的复杂度和计算负担，同时能够有效地提升各种卷积神经网络在不同视觉任务中的表现。

论文：https://proceedings.mlr.press/v139/yang21o/yang21o.pdf

源码：https://github.com/ZjjConan/SimAM

三、SimAM的实现代码

SimAM模块的实现代码如下：

python 复制代码

class SimAM(torch.nn.Module):
    def __init__(self, channels = None,out_channels = None, e_lambda = 1e-4):
        super(SimAM, self).__init__()
        self.activaton = nn.Sigmoid()
        self.e_lambda = e_lambda

    def __repr__(self):
        s = self.__class__.__name__ + '('
        s += ('lambda=%f)' % self.e_lambda)
        return s

    @staticmethod
    def get_module_name():
        return "simam"

    def forward(self, x):
        b, c, h, w = x.size()
        n = w * h - 1
        x_minus_mu_square = (x - x.mean(dim=[2,3], keepdim=True)).pow(2)
        y = x_minus_mu_square / (4 * (x_minus_mu_square.sum(dim=[2,3], keepdim=True) / n + self.e_lambda)) + 0.5

        return x * self.activaton(y)

四、创新模块

4.1 改进点1

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

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

4.2 改进点2⭐

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

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

第二种改进方法是对YOLOv10中的C2f模块进行改进。此处的改进方法是在C2f模块的输出结果中，利用SimAM将分流融合后的特征信息再一次利用注意力加权，且使用SimAM注意力模块不会增加模型参数。

改进代码如下：

python 复制代码

class C2f_SimAM(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 = SimAM(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_SimAM。

五、添加步骤

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

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

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

将SimAM和C2f_SimAM模块代码添加到此文件下。

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

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

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

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

python 复制代码

from .block import (
    C1,
    C2,
    ...
    SimAM,
    C2f_SimAM
)

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

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

首先：在函数声明中引入SimAM和C2f_SimAM

其次：在parse_model函数中注册SimAM和C2f_SimAM模块

六、yaml模型文件

6.1 模型改进版本一

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

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

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

在骨干网络的最后一层添加SimAM模块，只需要填入一个参数，通道数，和前一层通道数一致。还需要注意的是，由于PAN+FPN的颈部模型结构存在，层之间的匹配也要记得修改，维度要匹配上。

📌 放在此处的目的是让网络能够学习到更深层的语义信息，因为此时特征图尺寸小，包含全局信息。若是希望网络能够更加关注局部信息，可尝试将注意力模块添加到网络的浅层。

📌 当然由于其即插即用的特性，加在哪里都是可以的，但是想要真的有效，还需要根据模型结构，数据集特性等多方面因素，多做实验进行验证。

python 复制代码

# 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, SimAM, [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_SimAM.yaml。

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

📌 模型的修改方法是将骨干网络 中的所有C2f模块替换成C2f_SimAM模块，使模型可以更早地聚焦于重要信息，避免在初始阶段引入过多无关或冗余特征，并且不同层之间的特征传递更加协调和有针对性，进一步加强模型性能。

python 复制代码

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

七、成功运行结果

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

YOLOv10m-SimAM：

                   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         0  ultralytics.nn.modules.block.SimAM           [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-SimAM summary: 500 layers, 16485286 parameters, 16485270 gradients, 64.0 GFLOPs

YOLOv10m-C2f_SimAM：

                   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    130176  ultralytics.nn.modules.block.C2f_SimAM       [96, 96, True]                
  3                  -1  1    166272  ultralytics.nn.modules.conv.Conv             [96, 192, 3, 2]               
  4                  -1  4   1036800  ultralytics.nn.modules.block.C2f_SimAM       [192, 192, True]              
  5                  -1  1     78720  ultralytics.nn.modules.block.SCDown          [192, 384, 3, 2]              
  6                  -1  4   4137984  ultralytics.nn.modules.block.C2f_SimAM       [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_SimAM summary: 577 layers, 17616934 parameters, 17616918 gradients, 70.7 GFLOPs