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

一、本文介绍

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

二、SimAM注意力原理

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

2.1、原理

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

在这里插入图片描述

2.2、优势

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

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

三、SimAM的实现代码

SimAM模块 的实现代码如下：

import torch
import torch.nn as nn

from ultralytics.nn.modules.conv import LightConv

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):  # 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 HGBlock_SimAM(nn.Module):
    """
    HG_Block of PPHGNetV2 with 2 convolutions and LightConv.

    https://github.com/PaddlePaddle/PaddleDetection/blob/develop/ppdet/modeling/backbones/hgnet_v2.py
    """

    def __init__(self, c1, cm, c2, k=3, n=6, lightconv=False, shortcut=False, act=nn.ReLU()):
        """Initializes a CSP Bottleneck with 1 convolution using specified input and output channels."""
        super().__init__()
        block = LightConv if lightconv else Conv
        self.m = nn.ModuleList(block(c1 if i == 0 else cm, cm, k=k, act=act) for i in range(n))
        self.sc = Conv(c1 + n * cm, c2 // 2, 1, 1, act=act)  # squeeze conv
        self.ec = Conv(c2 // 2, c2, 1, 1, act=act)  # excitation conv
        self.add = shortcut and c1 == c2
        self.cv = SimAM(c2)
        
    def forward(self, x):
        """Forward pass of a PPHGNetV2 backbone layer."""
        y = [x]
        y.extend(m(y[-1]) for m in self.m)
        y = self.cv(self.ec(self.sc(torch.cat(y, 1))))
        return y + x if self.add else y

四、创新模块

4.1 改进点1

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

在这里插入图片描述

注意❗：需要声明的模块名称为： SimAM 。

4.2 改进点2⭐

模块改进方法 2️⃣：基于 SimAM模块 的 HGBlock 。（ 第五节讲解添加步骤 ）

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

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

改进代码如下：

class HGBlock_SimAM(nn.Module):
    """
    HG_Block of PPHGNetV2 with 2 convolutions and LightConv.

    https://github.com/PaddlePaddle/PaddleDetection/blob/develop/ppdet/modeling/backbones/hgnet_v2.py
    """

    def __init__(self, c1, cm, c2, k=3, n=6, lightconv=False, shortcut=False, act=nn.ReLU()):
        """Initializes a CSP Bottleneck with 1 convolution using specified input and output channels."""
        super().__init__()
        block = LightConv if lightconv else Conv
        self.m = nn.ModuleList(block(c1 if i == 0 else cm, cm, k=k, act=act) for i in range(n))
        self.sc = Conv(c1 + n * cm, c2 // 2, 1, 1, act=act)  # squeeze conv
        self.ec = Conv(c2 // 2, c2, 1, 1, act=act)  # excitation conv
        self.add = shortcut and c1 == c2
        self.cv = SimAM(c2)
        
    def forward(self, x):
        """Forward pass of a PPHGNetV2 backbone layer."""
        y = [x]
        y.extend(m(y[-1]) for m in self.m)
        y = self.cv(self.ec(self.sc(torch.cat(y, 1))))
        return y + x if self.add else y

在这里插入图片描述

注意❗：需要声明的模块名称为： HGBlock_SimAM 。

五、添加步骤

5.1 修改一

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

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

在这里插入图片描述

5.2 修改二

在 AddModules 文件夹下新建 __init__.py （已有则不用新建），在文件内导入模块： from .SimAM import *

在这里插入图片描述

5.3 修改三

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

首先：导入模块

在这里插入图片描述

其次：在 parse_model函数 中注册 SimAM , HGBlock_SimAM 模块

在这里插入图片描述

六、yaml模型文件

6.1 模型改进版本一

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

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

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

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

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

# Ultralytics YOLO 🚀, AGPL-3.0 license
# RT-DETR-l object detection model with P3-P5 outputs. For details see https://docs.ultralytics.com/models/rtdetr

# Parameters
nc: 1 # number of classes
scales: # model compound scaling constants, i.e. 'model=yolov8n-cls.yaml' will call yolov8-cls.yaml with scale 'n'
  # [depth, width, max_channels]
  l: [1.00, 1.00, 1024]

backbone:
  # [from, repeats, module, args]
  - [-1, 1, HGStem, [32, 48]] # 0-P2/4
  - [-1, 6, HGBlock, [48, 128, 3]] # stage 1

  - [-1, 1, DWConv, [128, 3, 2, 1, False]] # 2-P3/8
  - [-1, 6, HGBlock, [96, 512, 3]] # stage 2

  - [-1, 1, DWConv, [512, 3, 2, 1, False]] # 4-P4/16
  - [-1, 6, HGBlock, [192, 1024, 5, True, False]] # cm, c2, k, light, shortcut
  - [-1, 6, HGBlock, [192, 1024, 5, True, True]]
  - [-1, 6, HGBlock, [192, 1024, 5, True, True]] # stage 3

  - [-1, 1, DWConv, [1024, 3, 2, 1, False]] # 8-P5/32
  - [-1, 1, SimAM, [1024]] # stage 4
  - [-1, 6, HGBlock, [384, 2048, 5, True, False]] # stage 4

head:
  - [-1, 1, Conv, [256, 1, 1, None, 1, 1, False]] # 10 input_proj.2
  - [-1, 1, AIFI, [1024, 8]]
  - [-1, 1, Conv, [256, 1, 1]] # 12, Y5, lateral_convs.0

  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  - [7, 1, Conv, [256, 1, 1, None, 1, 1, False]] # 14 input_proj.1
  - [[-2, -1], 1, Concat, [1]]
  - [-1, 3, RepC3, [256]] # 16, fpn_blocks.0
  - [-1, 1, Conv, [256, 1, 1]] # 17, Y4, lateral_convs.1

  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  - [3, 1, Conv, [256, 1, 1, None, 1, 1, False]] # 19 input_proj.0
  - [[-2, -1], 1, Concat, [1]] # cat backbone P4
  - [-1, 3, RepC3, [256]] # X3 (21), fpn_blocks.1

  - [-1, 1, Conv, [256, 3, 2]] # 22, downsample_convs.0
  - [[-1, 18], 1, Concat, [1]] # cat Y4
  - [-1, 3, RepC3, [256]] # F4 (24), pan_blocks.0

  - [-1, 1, Conv, [256, 3, 2]] # 25, downsample_convs.1
  - [[-1, 13], 1, Concat, [1]] # cat Y5
  - [-1, 3, RepC3, [256]] # F5 (27), pan_blocks.1

  - [[22, 25, 28], 1, RTDETRDecoder, [nc]] # Detect(P3, P4, P5)

6.2 模型改进版本二⭐

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

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

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

# Ultralytics YOLO 🚀, AGPL-3.0 license
# RT-DETR-l object detection model with P3-P5 outputs. For details see https://docs.ultralytics.com/models/rtdetr

# Parameters
nc: 1 # number of classes
scales: # model compound scaling constants, i.e. 'model=yolov8n-cls.yaml' will call yolov8-cls.yaml with scale 'n'
  # [depth, width, max_channels]
  l: [1.00, 1.00, 1024]

backbone:
  # [from, repeats, module, args]
  - [-1, 1, HGStem, [32, 48]] # 0-P2/4
  - [-1, 6, HGBlock, [48, 128, 3]] # stage 1

  - [-1, 1, DWConv, [128, 3, 2, 1, False]] # 2-P3/8
  - [-1, 6, HGBlock, [96, 512, 3]] # stage 2

  - [-1, 1, DWConv, [512, 3, 2, 1, False]] # 4-P4/16
  - [-1, 6, HGBlock_SimAM, [192, 1024, 5, True, False]] # cm, c2, k, light, shortcut
  - [-1, 6, HGBlock_SimAM, [192, 1024, 5, True, True]]
  - [-1, 6, HGBlock_SimAM, [192, 1024, 5, True, True]] # stage 3

  - [-1, 1, DWConv, [1024, 3, 2, 1, False]] # 8-P5/32
  - [-1, 6, HGBlock, [384, 2048, 5, True, False]] # stage 4

head:
  - [-1, 1, Conv, [256, 1, 1, None, 1, 1, False]] # 10 input_proj.2
  - [-1, 1, AIFI, [1024, 8]]
  - [-1, 1, Conv, [256, 1, 1]] # 12, Y5, lateral_convs.0

  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  - [7, 1, Conv, [256, 1, 1, None, 1, 1, False]] # 14 input_proj.1
  - [[-2, -1], 1, Concat, [1]]
  - [-1, 3, RepC3, [256]] # 16, fpn_blocks.0
  - [-1, 1, Conv, [256, 1, 1]] # 17, Y4, lateral_convs.1

  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  - [3, 1, Conv, [256, 1, 1, None, 1, 1, False]] # 19 input_proj.0
  - [[-2, -1], 1, Concat, [1]] # cat backbone P4
  - [-1, 3, RepC3, [256]] # X3 (21), fpn_blocks.1

  - [-1, 1, Conv, [256, 3, 2]] # 22, downsample_convs.0
  - [[-1, 17], 1, Concat, [1]] # cat Y4
  - [-1, 3, RepC3, [256]] # F4 (24), pan_blocks.0

  - [-1, 1, Conv, [256, 3, 2]] # 25, downsample_convs.1
  - [[-1, 12], 1, Concat, [1]] # cat Y5
  - [-1, 3, RepC3, [256]] # F5 (27), pan_blocks.1

  - [[21, 24, 27], 1, RTDETRDecoder, [nc]] # Detect(P3, P4, P5)

七、成功运行结果

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

rtdetr-l-SimAM ：

rtdetr-l-SimAM summary: 683 layers, 32,808,131 parameters, 32,808,131 gradients, 108.0 GFLOPs

                   from  n    params  module                                       arguments                     
  0                  -1  1     25248  ultralytics.nn.modules.block.HGStem          [3, 32, 48]                   
  1                  -1  6    155072  ultralytics.nn.modules.block.HGBlock         [48, 48, 128, 3, 6]           
  2                  -1  1      1408  ultralytics.nn.modules.conv.DWConv           [128, 128, 3, 2, 1, False]    
  3                  -1  6    839296  ultralytics.nn.modules.block.HGBlock         [128, 96, 512, 3, 6]          
  4                  -1  1      5632  ultralytics.nn.modules.conv.DWConv           [512, 512, 3, 2, 1, False]    
  5                  -1  6   1695360  ultralytics.nn.modules.block.HGBlock         [512, 192, 1024, 5, 6, True, False]
  6                  -1  6   2055808  ultralytics.nn.modules.block.HGBlock         [1024, 192, 1024, 5, 6, True, True]
  7                  -1  6   2055808  ultralytics.nn.modules.block.HGBlock         [1024, 192, 1024, 5, 6, True, True]
  8                  -1  1     11264  ultralytics.nn.modules.conv.DWConv           [1024, 1024, 3, 2, 1, False]  
  9                  -1  1         0  ultralytics.nn.AddModules.SimAM.SimAM        [1024, 1024]                  
 10                  -1  6   6708480  ultralytics.nn.modules.block.HGBlock         [1024, 384, 2048, 5, 6, True, False]
 11                  -1  1    524800  ultralytics.nn.modules.conv.Conv             [2048, 256, 1, 1, None, 1, 1, False]
 12                  -1  1    789760  ultralytics.nn.modules.transformer.AIFI      [256, 1024, 8]                
 13                  -1  1     66048  ultralytics.nn.modules.conv.Conv             [256, 256, 1, 1]              
 14                  -1  1         0  torch.nn.modules.upsampling.Upsample         [None, 2, 'nearest']          
 15                   7  1    262656  ultralytics.nn.modules.conv.Conv             [1024, 256, 1, 1, None, 1, 1, False]
 16            [-2, -1]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           
 17                  -1  3   2232320  ultralytics.nn.modules.block.RepC3           [512, 256, 3]                 
 18                  -1  1     66048  ultralytics.nn.modules.conv.Conv             [256, 256, 1, 1]              
 19                  -1  1         0  torch.nn.modules.upsampling.Upsample         [None, 2, 'nearest']          
 20                   3  1    131584  ultralytics.nn.modules.conv.Conv             [512, 256, 1, 1, None, 1, 1, False]
 21            [-2, -1]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           
 22                  -1  3   2232320  ultralytics.nn.modules.block.RepC3           [512, 256, 3]                 
 23                  -1  1    590336  ultralytics.nn.modules.conv.Conv             [256, 256, 3, 2]              
 24            [-1, 18]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           
 25                  -1  3   2232320  ultralytics.nn.modules.block.RepC3           [512, 256, 3]                 
 26                  -1  1    590336  ultralytics.nn.modules.conv.Conv             [256, 256, 3, 2]              
 27            [-1, 13]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           
 28                  -1  3   2232320  ultralytics.nn.modules.block.RepC3           [512, 256, 3]                 
 29        [22, 25, 28]  1   7303907  ultralytics.nn.modules.head.RTDETRDecoder    [1, [256, 256, 256]]          
rtdetr-l-SimAM summary: 683 layers, 32,808,131 parameters, 32,808,131 gradients, 108.0 GFLOPs

rtdetr-l-HGBlock_SimAM ：

rtdetr-l-HGBlock_SimAM summary: 688 layers, 32,808,131 parameters, 32,808,131 gradients, 108.0 GFLOPs

                   from  n    params  module                                       arguments                     
  0                  -1  1     25248  ultralytics.nn.modules.block.HGStem          [3, 32, 48]                   
  1                  -1  6    155072  ultralytics.nn.modules.block.HGBlock         [48, 48, 128, 3, 6]           
  2                  -1  1      1408  ultralytics.nn.modules.conv.DWConv           [128, 128, 3, 2, 1, False]    
  3                  -1  6    839296  ultralytics.nn.modules.block.HGBlock         [128, 96, 512, 3, 6]          
  4                  -1  1      5632  ultralytics.nn.modules.conv.DWConv           [512, 512, 3, 2, 1, False]    
  5                  -1  6   1695360  ultralytics.nn.AddModules.SimAM.HGBlock_SimAM[512, 192, 1024, 5, 6, True, False]
  6                  -1  6   2055808  ultralytics.nn.AddModules.SimAM.HGBlock_SimAM[1024, 192, 1024, 5, 6, True, True]
  7                  -1  6   2055808  ultralytics.nn.AddModules.SimAM.HGBlock_SimAM[1024, 192, 1024, 5, 6, True, True]
  8                  -1  1     11264  ultralytics.nn.modules.conv.DWConv           [1024, 1024, 3, 2, 1, False]  
  9                  -1  6   6708480  ultralytics.nn.modules.block.HGBlock         [1024, 384, 2048, 5, 6, True, False]
 10                  -1  1    524800  ultralytics.nn.modules.conv.Conv             [2048, 256, 1, 1, None, 1, 1, False]
 11                  -1  1    789760  ultralytics.nn.modules.transformer.AIFI      [256, 1024, 8]                
 12                  -1  1     66048  ultralytics.nn.modules.conv.Conv             [256, 256, 1, 1]              
 13                  -1  1         0  torch.nn.modules.upsampling.Upsample         [None, 2, 'nearest']          
 14                   7  1    262656  ultralytics.nn.modules.conv.Conv             [1024, 256, 1, 1, None, 1, 1, False]
 15            [-2, -1]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           
 16                  -1  3   2232320  ultralytics.nn.modules.block.RepC3           [512, 256, 3]                 
 17                  -1  1     66048  ultralytics.nn.modules.conv.Conv             [256, 256, 1, 1]              
 18                  -1  1         0  torch.nn.modules.upsampling.Upsample         [None, 2, 'nearest']          
 19                   3  1    131584  ultralytics.nn.modules.conv.Conv             [512, 256, 1, 1, None, 1, 1, False]
 20            [-2, -1]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           
 21                  -1  3   2232320  ultralytics.nn.modules.block.RepC3           [512, 256, 3]                 
 22                  -1  1    590336  ultralytics.nn.modules.conv.Conv             [256, 256, 3, 2]              
 23            [-1, 17]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           
 24                  -1  3   2232320  ultralytics.nn.modules.block.RepC3           [512, 256, 3]                 
 25                  -1  1    590336  ultralytics.nn.modules.conv.Conv             [256, 256, 3, 2]              
 26            [-1, 12]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           
 27                  -1  3   2232320  ultralytics.nn.modules.block.RepC3           [512, 256, 3]                 
 28        [21, 24, 27]  1   7303907  ultralytics.nn.modules.head.RTDETRDecoder    [1, [256, 256, 256]]          
rtdetr-l-HGBlock_SimAM summary: 688 layers, 32,808,131 parameters, 32,808,131 gradients, 108.0 GFLOPs

学习资源站

RT-DETR改进入门篇手把手讲解改进模块如何实现高效涨点，以SimAM注意力模块为例-

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

一、本文介绍

二、SimAM注意力原理

2.1、原理

2.2、优势

三、SimAM的实现代码

四、创新模块

4.1 改进点1

4.2 改进点2⭐

五、添加步骤

5.1 修改一

5.2 修改二

5.3 修改三

六、yaml模型文件

6.1 模型改进版本一

6.2 模型改进版本二⭐

七、成功运行结果