YOLOv11改进入门篇 | 手把手讲解改进模块如何实现高效涨点,以SimAM注意力模块为例

YOLOv11改进专栏
专栏收录该内容
¥99.90
¥299.90
227 篇文章

一、本文介绍

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


专栏目录:YOLOv11改进目录一览 | 涉及卷积层、轻量化、注意力、损失函数、Backbone、SPPF、Neck、检测头等全方位改进

专栏地址:YOLOv11改进专栏——以发表论文的角度,快速准确的找到有效涨点的创新点!


二、SimAM注意力原理

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

2.1、原理

  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^=wt​t+bt​和 x ^ i = w t x i + b t \hat{x}_{i}=w_{t}x_{i}+b_{t} x^i​=wt​xi​+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−(wt​xi​+bt​))2+(1−(wt​t+bt​))2+λwt2​。
  2. 推导能量函数的闭式解:
    • 通过对上述能量函数求解,得到关于 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​∑i​xi​和 σ 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​∑i​xi​和 σ ^ 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∗​获得。
  3. 注意力模块的特征细化:
    • 根据哺乳动物大脑中的注意力调制通常表现为对神经元响应的增益效应,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、优势

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

论文:https://proceedings.mlr.press/v139/yang21o/yang21o.pdf
源码:https://github.com/ZjjConan/SimAM

三、SimAM的实现代码

SimAM模块的实现代码如下:

import torch
import torch.nn as nn  

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) 

def autopad(k, p=None, d=1):
    """
    Pads kernel to 'same' output shape, adjusting for optional dilation; returns padding size.
    `k`: kernel, `p`: padding, `d`: dilation.
    """
    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):
        """Initializes a standard convolution layer with optional batch normalization and 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):
        """Applies a convolution followed by batch normalization and an activation function to the input tensor `x`."""
        return self.act(self.bn(self.conv(x)))
 
    def forward_fuse(self, x):
        """Applies a fused convolution and activation function to the input tensor `x`."""
        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 standard bottleneck module with optional shortcut connection and configurable parameters."""
        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):
        """Applies the YOLO FPN to input data."""
        return x + self.cv2(self.cv1(x)) if self.add else self.cv2(self.cv1(x))

class C3(nn.Module):
    """CSP Bottleneck with 3 convolutions."""

    def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5):
        """Initialize the CSP Bottleneck with given channels, number, shortcut, groups, and expansion values."""
        super().__init__()
        c_ = int(c2 * e)  # hidden channels
        self.cv1 = Conv(c1, c_, 1, 1)
        self.cv2 = Conv(c1, c_, 1, 1)
        self.cv3 = Conv(2 * c_, c2, 1)  # optional act=FReLU(c2)
        self.m = nn.Sequential(*(Bottleneck(c_, c_, shortcut, g, k=((1, 1), (3, 3)), e=1.0) for _ in range(n)))

    def forward(self, x):
        """Forward pass through the CSP bottleneck with 2 convolutions."""
        return self.cv3(torch.cat((self.m(self.cv1(x)), self.cv2(x)), 1))

class C3k(C3):
    """C3k is a CSP bottleneck module with customizable kernel sizes for feature extraction in neural networks."""

    def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5, k=3):
        """Initializes the C3k module with specified channels, number of layers, and configurations."""
        super().__init__(c1, c2, n, shortcut, g, e)
        c_ = int(c2 * e)  # hidden channels
        # self.m = nn.Sequential(*(RepBottleneck(c_, c_, shortcut, g, k=(k, k), e=1.0) for _ in range(n)))
        self.m = nn.Sequential(*(Bottleneck(c_, c_, shortcut, g, k=(k, k), e=1.0) for _ in range(n)))

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)))

class C3k2_SimAM(C2f_SimAM):
    """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)
        )



四、创新模块

4.1 改进点1

模块改进方法1️⃣:直接加入SimAM模块。(第五节讲解添加步骤)
SimAM模块添加后如下:

在这里插入图片描述

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

4.2 改进点2⭐

模块改进方法2️⃣:基于SimAM模块的C3k2。(第五节讲解添加步骤)

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

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

改进代码如下:

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

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)))

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

class C3k2_SimAM(C2f_SimAM):
    """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_SimAM。


五、添加步骤

5.1 修改一

① 在ultralytics/nn/目录下新建AddModules文件夹用于存放模块代码

② 在AddModules文件夹下新建SimAM.py,将第三节中的代码粘贴到此处

在这里插入图片描述

5.2 修改二

在AddModules文件夹下新建__init__.py(已有则不用新建),在文件内导入模块:from .SimAM import *

在这里插入图片描述

5.3 修改三

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

首先:导入模块

在这里插入图片描述

其次:在parse_model函数中注册SimAM,C3k2_SimAM模块

在这里插入图片描述

在这里插入图片描述


六、yaml模型文件

6.1 模型改进版本一

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

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

将yolov11m.yaml中的内容复制到yolov11m-SimAM.yaml文件下,修改nc数量等于自己数据中目标的数量。
在骨干网络中添加SimAM模块,只需要填入一个参数,通道数,和前一层通道数一致。还需要注意的是,由于PAN+FPN的颈部模型结构存在,层之间的匹配也要记得修改,维度要匹配上。

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

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

# 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, SimAM, [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/yolov11m.yaml为例,在同目录下创建一个用于自己数据集训练的模型文件yolov11m-C3k2_SimAM.yaml。

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

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

# 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_SimAM, [256, False, 0.25]]
  - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
  - [-1, 2, C3k2_SimAM, [512, False, 0.25]]
  - [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
  - [-1, 2, C3k2_SimAM, [512, True]]
  - [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
  - [-1, 2, C3k2_SimAM, [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)



七、成功运行结果

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

YOLOv11m-SimAM:

                   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         0  ultralytics.nn.modules.block.SimAM           [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-SimAM summary: 411 layers, 20,053,779 parameters, 20,053,763 gradients, 68.2 GFLOPs

YOLOv11m-C3k2_SimAM:

                   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     99328  ultralytics.nn.modules.block.C3k2_SimAM      [128, 256, False, 0.25]       
  3                  -1  1    590336  ultralytics.nn.modules.conv.Conv             [256, 256, 3, 2]              
  4                  -1  1    395264  ultralytics.nn.modules.block.C3k2_SimAM      [256, 512, False, 0.25]       
  5                  -1  1   2360320  ultralytics.nn.modules.conv.Conv             [512, 512, 3, 2]              
  6                  -1  1   1248000  ultralytics.nn.modules.block.C3k2_SimAM      [512, 512, True]              
  7                  -1  1   2360320  ultralytics.nn.modules.conv.Conv             [512, 512, 3, 2]              
  8                  -1  1   1248000  ultralytics.nn.modules.block.C3k2_SimAM      [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_SimAM summary: 331 layers, 19,726,867 parameters, 19,726,851 gradients, 66.4 GFLOPs
VIP SimAM:轻量级注意力机制,解锁卷积神经网络新潜力【原理讲解及代码!!!】 SimAM 是一种轻量级、无参数的卷积神经网络注意力机制,它通过计算特征图的局部自相似性来生成注意力权重,无需引入任何额外参数,即可有效提升 CNN 的性能。 开通可读全文·1.9w 阅读·47 点赞·166 收藏 阅读全文

相关推荐

YOLO算法改进指南:8.添加SimAM注意力机制 |无参数注意力模块

本文提出一种概念简单且非常有效的注意力模块。不同于现有的通道/空域注意力模块,该模块无需额外参数为特征图推导出3D注意力权值。具体来说,本文基于著名的神经科学理论提出优化能量函数以挖掘神经元的重要性。本文进一步针对该能量函数推导出一种快速解析解并表明:该解析解仅需不超过10行代码即可实现。该模块的另一个优势在于:大部分操作均基于所定义的能量函数选择,避免了过多的结构调整。最后,本文在不同的任务上对所提注意力模块的有效性、灵活性进行验证。

“365天深度学习训练营”报名进行中~ 5588

YOLOv11 改进入门篇 | 手把手讲解改进模块如何实现高效涨点,以 SimAM 注意力模块为例

本文详细介绍了如何在YOLOv11中集成SimAM无参数注意力模块实现性能提升。SimAM通过能量函数推导三维权重,无需额外参数和计算开销,可在Backbone、Neck或Head任意位置插入。文章提供了两种实现方案:直接插入SPPF后的即插即用法,以及改造C3k2模块的创新方法。消融实验显示该方法可带来0.6-1.1 mAP提升,且延迟增幅小于3%。文中包含完整的代码实现、yaml配置修改和训练参数建议,并强调了SimAM对特征响应集中和背景抑制的优化效果,为YOLO系列算法的改进提供了实用参考。

shrgegrb的博客 982

YOLOv10改进入门篇 | 手把手讲解改进模块如何实现高效涨点,以SimAM注意力模块为例

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

Limiiiing的博客 2543

YOLOv12改进入门篇 | 手把手讲解改进模块如何实现高效涨点,以SimAM注意力模块为例

本文记录的是。SimAM注意力模块通过优化能量函数来获得每个神经元的三维权重,而或增加计算复杂度。若是有轻量化需求的小伙伴,无参的注意力模块也许是一个不错的选择。

Limiiiing的博客 2915

YOLOv9改进入门篇 | 手把手讲解改进模块如何实现高效涨点,以SimAM注意力模块为例

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

Limiiiing的博客 2156

YOLOv8改进入门篇 | 手把手讲解改进模块如何实现高效涨点,以SimAM注意力模块为例

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

Limiiiing的博客 1852

YOLOv13改进入门篇 | 手把手讲解改进模块如何实现高效涨点,以SimAM注意力模块为例

本文记录的是基于SimAM注意力模块的YOLOv13目标检测方法研究。通过优化能量函数来获得每个神经元的三维权重,而无需引入额外的参数或增加计算复杂度。若是有轻量化需求的小伙伴,无参的注意力模块也许是一个不错的选择。是一种简单且无参数的注意力模块,主要用于卷积神经网络。​是该通道上除(t)以外所有神经元的均值和方差。 由于上述解是在单个通道上得到的,假设单个通道中的所有像素遵循相同的分布,那么可以对所有神经元计算一次均值和方差,并在该通道上重复使用,得到最小能量计算公式:et∗=4(σ^2+λ)(t−μ^)

Limiiiing的博客 1275

YOLOv11模型改进-注意力-引入简单无参数注意力模块SimAM 提升小目标和遮挡检测

基于视觉神经科学理论,为每个神经元定义能量函数通过最小化这个能量函数,找到目标神经元与其他神经元的线性可分性,从而确定神经元在视觉处理中的重要程度。2. 特征精炼部分:缩放算子应用:根据哺乳动物大脑中注意力调制表现为对神经元反应的增益效应,使用缩放算子进行特征精炼。具体来说,通过来实现,其中包含所有通道和空间维度的(即每个神经元的最小能量),函数用于限制中的过大值,以确保特征精炼的合理性。

qq_64693987的博客 4334

【YOLOv11改进- 注意力机制】YOLOv11+simAM: 基于YOLOv11的轻量级卷积注意力机制,线性复杂度,高效涨点;

SimAM:ASimple,Parameter-Free Attention Module for Convolutional Neural Networks 注意力机制的详细信息SimAM(Similarity - Aware Activation Module)注意力机制是一种新颖的注意力机制。它受到神经科学中空域抑制现象的启发,通过度量神经元之间的线性可分性来确定其重要性。

qq_41304809的博客 1517

【YOLOv11改进 - 注意力机制】SimAM:轻量级注意力机制,解锁卷积神经网络新潜力

【YOLOv11改进 - 注意力机制】SimAM:轻量级注意力机制,解锁卷积神经网络新潜力

专注于图像领域,主要研究内容包括计算机视觉和深度学习,特别是在图像分类、目标检测和图像生成等方面有深入的研究和实践经验。 2151

YOLOv11改进入门篇 | SimAM注意力模块助你轻松涨点!

YOLOv11作为YOLO系列的最新成员,在之前版本的基础上引入了新功能和改进,进一步提升了性能和灵活性。其核心改进包括引入C2PSA模块(跨阶段局部自注意),该模块将跨阶段局部网络和自注意机制的优势结合起来,使模型能够更有效地捕获跨多层网络的上下文信息。注意力机制的本质是让模型学会关注重要信息而忽略无关信息。通道注意力:关注哪些通道的特征更重要空间注意力:关注特征图中的哪些空间位置更重要混合注意力:同时考虑通道和空间维度的重要性SimAM的独特之处在于它是一种无参数。

QQ_778132974的博客 676

YOLOv11改进 | 注意力篇 | YOLOv11引入无参SimAM注意力机制

该模块的另一个优点是,大多数算子是根据定义的能量函数的解来选择的,避免了过多的结构调整工作。到此本文的正式分享内容就结束了,在这里给大家推荐我的YOLOv11改进有效涨点专栏,本专栏目前为新开的,后期我会根据各种前沿顶会进行论文复现,也会对一些老的改进机制进行补充,如果大家觉得本文帮助到你了,订阅本专栏,关注后续更多的更新~(4)基于解的操作符选择:SimAM中的大多数操作符都是基于能量函数的解来选择的,这避免了过多的结构调优工作。在SimAM.py文件里添加给出的SimAM代码。

tsg6698的博客 1553

「API取数」FDL获取金蝶云星空的单据数据

本文介绍了如何使用FDL实现金蝶云API取数以及如何有效应对复杂的API数据处理场景。

oOBubbleX的博客 2043

从仿真到实践:两级直接耦合放大电路的静态工作点协同调试指南

本文详细解析了两级直接耦合放大电路的静态工作点协同调试方法,从仿真到实践提供系统指南。重点介绍了Rc2电阻调整技巧、集电极电位测量方法及常见问题排查,帮助工程师解决各级静态工作点相互影响的难题,提升模拟电路设计效率。

weixin_29189373的博客 125

FPGA信号处理系列文章——分数倍插值抽取滤波器(一)

提示:文章写完后,目录可以自动生成,如何生成可参考右边的帮助文档 FPGA信号处理系列文章——分数倍插值抽取滤波器(一)前言信号流matlab模型频谱示意图分析总结 前言 变采样率滤波器不仅仅存在整数倍插值和整数倍抽取的情况,还会存在分数倍插值抽取的情况。那这种情况下要怎么处理呢 信号流 分数倍插值抽取滤波器的信号流是什么?信号先进行插值,再进行FIR滤波,最后进行抽取 matlab模型 %signal 定点化数据输入 coeff_val_fir = importdata('fir.coe'); si

gzy0506的博客 1万+

C语言关键字static的绝妙用途

为什么要说static妙,它确实是妙,在软件开发或者单片机开发过程中,大家总以为static就是一个静态变量,在变量类型的前面加上就自动清0了,还有就是加上static关键字的,不管是变量还是关键字,在局部变量中,变量仅限于局部可见,在全局区中,static变量或函数仅限于本文件可见,当然还有一个重要的特性被忽略了。。。。       就是static修饰的局部变量 它的数值 是上一次函数调用结

Bruce.yang的嵌入式之旅 5381

Spring AI 项目实战(十二):Spring Boot +AI + DeepSeek + 百度OCR 公司发票智能处理系统的技术实践(附完整源码)

本文介绍了基于百度OCR API与DeepSeek AI的发票智能处理系统,通过整合AI技术实现发票识别、信息提取和验证的全流程自动化。系统采用Spring Boot 3.2.0架构,结合百度OCR的高精度图像识别和DeepSeek的语义理解能力,显著提升了发票处理效率与准确率。关键技术包括多模型融合、智能错误纠正和自适应学习机制,实现了95%以上的识别准确率,将传统处理效率提升90%以上。该系统为数字化转型中的企业财务管理提供了智能化解决方案,具备高精度识别、实时处理、智能验证等核心优势。

博客 1628

IEC 61400-1:2019 附录 C 湍流模型全面解读

IEC 61400-1:2019 附录 C 全面解读

weixin_46713695的博客 475

【OpenFOAM】-olaFlow-算例10-wavemakerTank

采用 Flap和Piston两种方式的动网格进行造波

ou_no的博客 2172

AI使能的SVD算子:基于深度学习的矩阵分解方法

奇异值分解(Singular Value Decomposition, SVD)是线性代数中一种重要的矩阵分解方法,广泛应用于信号处理、数据降维、推荐系统等领域。传统SVD算法虽然精确,但在处理大规模矩阵时面临计算复杂度高、内存需求大等问题。本文提出了一种基于深度学习神经网络的SVD算子实现方法,完全摒弃传统数值算法,仅使用PyTorch框架构建的神经网络模型来完成大规模信道矩阵的SVD分解与还原。

huanghm88的专栏 1359

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

全球国家地区城市数据

MySQL全球国家地区城市数据报。。。。。。。。。。。。

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

上一篇: YOLOv11改进策略【注意力机制篇】| EMA注意力 即插即用模块,提高远距离建模依赖
下一篇: YOLOv10改进目录一览 | 涉及卷积层、轻量化、注意力、损失函数、Backbone、SPPF、Neck、检测头等全方位改进
Limiiiing
博客等级 码龄8年 2万+粉丝 1905原创
评论 31
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Limiiiing

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值
⌂ 换网址