RT-DETR改进策略【卷积层】| CVPR-2020 Strip Pooling 空间池化模块 处理不规则形状的对象 含二次创新
一、本文介绍
本文记录的是
利用
Strip Pooling
模块优化
RT-DETR
的目标检测网络模型
。
Strip Pooling
结合了
长而窄的卷积核
形状在一个空间维度上的
长程关系捕捉能力
和在另一个空间维度上的
局部细节捕捉能力
，有效地处理复杂的场景信息。这一机制通过采用
1
×
N
1×N
1
×
N
或
N
×
1
N×1
N
×
1
的池化核形状来适应不同的图像特征，
提
高模型对目标形状和分布的适应性
。在场景解析网络中，
Strip Pooling
可以被用于提升对具有
长程带状结构
或
离散分布目标
的解析能力，特别是在复杂场景或不同对象布局条件下效果更好。
二、Strip Pooling 介绍
2.1 设计出发点
- 解决传统空间池化局限性 ：传统空间池化通常采用 固定形状 的 N × N N×N N × N 核，在 处理具有不规则形状的对象 或现实场景中广泛存在的各向异性上下文时存在局限性。
例如，在一些情况下，目标对象可能具有长程带状结构（如草地）或离散分布（如柱子），使用大的方形池化窗口无法很好地解决问题，因为它不可避免地会包含来自无关区域的污染信息。
-
更有效地捕获长程依赖
：为了更有效地捕获长程依赖，作者提出利用
空间池化
来
扩大卷积神经网络（CNNs）的感受野
并收集有用的上下文信息，从而提出了
Strip Pooling的概念。
2.2 原理
-
数学定义
- 标准空间平均池化 ：对于二维输入张量 x ∈ R H × W x\in\mathbb{R}^{H×W} x ∈ R H × W ，平均池化层需要一个池化的空间范围 ( h × w ) (h×w) ( h × w ) 。当 h h h 整除 H H H 且 w w w 整除 W W W 时，池化后的输出 y y y 是一个二维张量，高度为 H o = H h H_{o}=\frac{H}{h} H o = h H ，宽度为 W o = W w W_{o}=\frac{W}{w} W o = w W ，其计算公式为： y i o , j o = 1 h × w ∑ 0 ≤ i < h ∑ 0 ≤ j < w x i o × h + i , j o × w + j y_{i_{o},j_{o}}=\frac{1}{h×w}\sum_{0\leq i<h}\sum_{0\leq j<w}x_{i_{o}×h+i,j_{o}×w+j} y i o , j o = h × w 1 0 ≤ i < h ∑ 0 ≤ j < w ∑ x i o × h + i , j o × w + j 其中 0 ≤ i o < H o 0\leq i_{o}<H_{o} 0 ≤ i o < H o 且 0 ≤ j o < W o 0\leq j_{o}<W_{o} 0 ≤ j o < W o ，每个 y y y 的空间位置对应一个大小为 h × w h×w h × w 的池化窗口。
-
Strip Pooling
：对于二维张量
x
∈
R
H
×
W
x\in\mathbb{R}^{H×W}
x
∈
R
H
×
W
，在
Strip Pooling中，需要一个池化的空间范围为 ( H , 1 ) (H,1) ( H , 1 ) 或 ( 1 , W ) (1,W) ( 1 , W ) 。水平Strip Pooling后的输出 y h ∈ R H y^{h}\in\mathbb{R}^{H} y h ∈ R H 计算公式为： y i h = 1 W ∑ 0 ≤ j < W x i , j y_{i}^{h}=\frac{1}{W}\sum_{0\leq j<W}x_{i,j} y i h = W 1 0 ≤ j < W ∑ x i , j 垂直Strip Pooling后的输出 y v ∈ R W y^{v}\in\mathbb{R}^{W} y v ∈ R W 计算公式为： y j v = 1 H ∑ 0 ≤ i < H x i , j y_{j}^{v}=\frac{1}{H}\sum_{0\leq i<H}x_{i,j} y j v = H 1 0 ≤ i < H ∑ x i , j
- 长程依赖和局部细节捕捉 ：通过 长而窄 的核形状，能够在离散分布的区域之间建立 长程依赖 ，并对 带状形状 的区域进行编码。同时，由于在另一个维度上保持窄核形状，也能够专注于 捕捉局部细节 。
2.3 结构
2.3.1 Strip Pooling Module (SPM)
整体结构
：
如图所示，输入张量
x
∈
R
C
×
H
×
W
x\in\mathbb{R}^{C×H×W}
x
∈
R
C
×
H
×
W
首先被送入两个并行路径，每个路径包含一个
水平
或
垂直
Strip Pooling层
，后面跟着一个核大小为3的
1D卷积层
用于调制当前位置及其邻域特征，得到
y
h
∈
R
C
×
H
y^{h}\in\mathbb{R}^{C×H}
y
h
∈
R
C
×
H
和
y
v
∈
R
C
×
W
y^{v}\in\mathbb{R}^{C×W}
y
v
∈
R
C
×
W
。
然后将 y h y^{h} y h 和 y v y^{v} y v 组合得到 y ∈ R C × H × W y\in\mathbb{R}^{C×H×W} y ∈ R C × H × W （ y c , i , j = y c , i h + y c , j v y_{c,i,j}=y_{c,i}^{h}+y_{c,j}^{v} y c , i , j = y c , i h + y c , j v ）。
最后输出 z ∈ R C × H × W z\in\mathbb{R}^{C×H×W} z ∈ R C × H × W ，计算方式为 z = S c a l e ( x , σ ( f ( y ) ) ) z = Scale(x,\sigma(f(y))) z = S c a l e ( x , σ ( f ( y ))) ，其中 S c a l e ( , ) Scale(,) S c a l e ( , ) 是元素级乘法， σ \sigma σ 是sigmoid函数， f f f 是一个1×1卷积。
- 路径连接 ：在这个过程中， 输出张量的每个位置都可以与输入张量的多个位置建立关系 。例如，输出张量中由黑色框界定的正方形与具有相同水平或垂直坐标的所有位置相连。
2.3.2 Mixed Pooling Module (MPM)
整体结构 ：由两个子模块组成， 用于同时捕获不同位置之间的短程和长程依赖 。
对于长程依赖，采用
水平
和
垂直
Strip Pooling
操作；对于短程依赖，采用一个轻量级的金字塔池化子模块，它有两个空间池化层，后面跟着卷积层用于多尺度特征提取，还有一个
2D卷积层
用于保留原始空间信息，池化后的
特征图bin
大小分别为
20×20
和
12×12
，三个子路径通过
求和
组合。
然后将两个子模块嵌套到具有
瓶颈结构
的
残差块
中，在每个子模块之前，先使用一个
1×1卷积层
进行
通道缩减
，两个子模块的输出连接在一起后再送入另一个
1×1卷积层
进行
通道扩展
。
- 模块嵌套 ：基于上述两个子模块，将它们嵌套到具有瓶颈结构的残差块中进行参数减少和模块化设计。
2.4 优势
-
与全局平均池化相比
-
避免不必要连接
：
Strip Pooling考虑 长而窄 的范围，而不是整个特征图，避免了在相距较远的位置之间建立大多数不必要的连接。 -
注意力机制优势
：与基于注意力的模块相比，
SPM是轻量级的，可以很容易地嵌入到任何构建块中，以提高 捕获长程空间依赖和利用通道间依赖的能力 。
-
避免不必要连接
：
-
与金字塔池化模块相比
-
更强大和适应性更强
：所提出的
MPM是一种模块化设计，可以很容易地以顺序方式使用，以扩展长程依赖收集子模块的作用。在相同的骨干网络下，只有两个MPMs（参数约为原始PPM的1/3）的网络性能甚至优于PSPNet。
-
更强大和适应性更强
：所提出的
论文： https://arxiv.org/abs/2003.13328
源码： https://github.com/houqb/SPNet
三、Strip Pooling的实现代码
Strip Pooling
及其改进的实现代码如下：
import torch
from torch import nn
import torch.nn.functional as F
class StripPooling(nn.Module):
def __init__(self, in_channels, pool_size= (20, 12), norm_layer=nn.BatchNorm2d, up_kwargs={'mode': 'bilinear', 'align_corners': True}):
super(StripPooling, self).__init__()
self.pool1 = nn.AdaptiveAvgPool2d(pool_size[0])
self.pool2 = nn.AdaptiveAvgPool2d(pool_size[1])
self.pool3 = nn.AdaptiveAvgPool2d((1, None))
self.pool4 = nn.AdaptiveAvgPool2d((None, 1))
inter_channels = int(in_channels/4)
self.conv1_1 = nn.Sequential(nn.Conv2d(in_channels, inter_channels, 1, bias=False),
norm_layer(inter_channels),
nn.ReLU(True))
self.conv1_2 = nn.Sequential(nn.Conv2d(in_channels, inter_channels, 1, bias=False),
norm_layer(inter_channels),
nn.ReLU(True))
self.conv2_0 = nn.Sequential(nn.Conv2d(inter_channels, inter_channels, 3, 1, 1, bias=False),
norm_layer(inter_channels))
self.conv2_1 = nn.Sequential(nn.Conv2d(inter_channels, inter_channels, 3, 1, 1, bias=False),
norm_layer(inter_channels))
self.conv2_2 = nn.Sequential(nn.Conv2d(inter_channels, inter_channels, 3, 1, 1, bias=False),
norm_layer(inter_channels))
self.conv2_3 = nn.Sequential(nn.Conv2d(inter_channels, inter_channels, (1, 3), 1, (0, 1), bias=False),
norm_layer(inter_channels))
self.conv2_4 = nn.Sequential(nn.Conv2d(inter_channels, inter_channels, (3, 1), 1, (1, 0), bias=False),
norm_layer(inter_channels))
self.conv2_5 = nn.Sequential(nn.Conv2d(inter_channels, inter_channels, 3, 1, 1, bias=False),
norm_layer(inter_channels),
nn.ReLU(True))
self.conv2_6 = nn.Sequential(nn.Conv2d(inter_channels, inter_channels, 3, 1, 1, bias=False),
norm_layer(inter_channels),
nn.ReLU(True))
self.conv3 = nn.Sequential(nn.Conv2d(inter_channels*2, in_channels, 1, bias=False),
norm_layer(in_channels))
# bilinear interpolate options
self._up_kwargs = up_kwargs
def forward(self, x):
_, _, h, w = x.size()
x1 = self.conv1_1(x)
x2 = self.conv1_2(x)
x2_1 = self.conv2_0(x1)
x2_2 = F.interpolate(self.conv2_1(self.pool1(x1)), (h, w), **self._up_kwargs)
x2_3 = F.interpolate(self.conv2_2(self.pool2(x1)), (h, w), **self._up_kwargs)
x2_4 = F.interpolate(self.conv2_3(self.pool3(x2)), (h, w), **self._up_kwargs)
x2_5 = F.interpolate(self.conv2_4(self.pool4(x2)), (h, w), **self._up_kwargs)
x1 = self.conv2_5(F.relu_(x2_1 + x2_2 + x2_3))
x2 = self.conv2_6(F.relu_(x2_5 + x2_4))
out = self.conv3(torch.cat([x1, x2], dim=1))
return F.relu_(x + out)
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 ResNetBlock(nn.Module):
"""ResNet block with standard convolution layers."""
def __init__(self, c1, c2, s=1, e=4):
"""Initialize convolution with given parameters."""
super().__init__()
c3 = e * c2
self.cv1 = Conv(c1, c2, k=1, s=1, act=True)
self.cv2 = Conv(c2, c2, k=3, s=s, p=1, act=True)
self.cv3 = Conv(c2, c3, k=1, act=False)
self.cv4 = StripPooling(c2, (20, 12), nn.BatchNorm2d, {'mode': 'bilinear', 'align_corners': True})
self.shortcut = nn.Sequential(Conv(c1, c3, k=1, s=s, act=False)) if s != 1 or c1 != c3 else nn.Identity()
def forward(self, x):
"""Forward pass through the ResNet block."""
return F.relu(self.cv3(self.cv4(self.cv2(self.cv1(x)))) + self.shortcut(x))
class ResNetLayer_StripPooling(nn.Module):
"""ResNet layer with multiple ResNet blocks."""
def __init__(self, c1, c2, s=1, is_first=False, n=1, e=4):
"""Initializes the ResNetLayer given arguments."""
super().__init__()
self.is_first = is_first
if self.is_first:
self.layer = nn.Sequential(
Conv(c1, c2, k=7, s=2, p=3, act=True), nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
)
else:
blocks = [ResNetBlock(c1, c2, s, e=e)]
blocks.extend([ResNetBlock(e * c2, c2, 1, e=e) for _ in range(n - 1)])
self.layer = nn.Sequential(*blocks)
def forward(self, x):
"""Forward pass through the ResNet layer."""
return self.layer(x)
四、创新模块
4.1 改进点1⭐
模块改进方法
：直接加入
StripPooling模块
（
第五节讲解添加步骤
）。
StripPooling模块
添加后如下：
4.2 改进点2⭐
模块改进方法
：基于
StripPooling模块
的
ResNetLayer
（
第五节讲解添加步骤
）。
第二种改进方法是对
RT-DETR
中的
ResNetLayer模块
进行改进，并将
StripPooling
在加入到
ResNetLayer
模块中。
改进代码如下：
对
ResNetBlock
模块进行改进，加入
StripPooling模块
，并将
ResNetLayer
重命名为
ResNetLayer_StripPooling
。
class ResNetBlock(nn.Module):
"""ResNet block with standard convolution layers."""
def __init__(self, c1, c2, s=1, e=4):
"""Initialize convolution with given parameters."""
super().__init__()
c3 = e * c2
self.cv1 = Conv(c1, c2, k=1, s=1, act=True)
self.cv2 = Conv(c2, c2, k=3, s=s, p=1, act=True)
self.cv3 = Conv(c2, c3, k=1, act=False)
self.cv4 = StripPooling(c2, (20, 12), nn.BatchNorm2d, {'mode': 'bilinear', 'align_corners': True})
self.shortcut = nn.Sequential(Conv(c1, c3, k=1, s=s, act=False)) if s != 1 or c1 != c3 else nn.Identity()
def forward(self, x):
"""Forward pass through the ResNet block."""
return F.relu(self.cv3(self.cv4(self.cv2(self.cv1(x)))) + self.shortcut(x))
class ResNetLayer_StripPooling(nn.Module):
"""ResNet layer with multiple ResNet blocks."""
def __init__(self, c1, c2, s=1, is_first=False, n=1, e=4):
"""Initializes the ResNetLayer given arguments."""
super().__init__()
self.is_first = is_first
if self.is_first:
self.layer = nn.Sequential(
Conv(c1, c2, k=7, s=2, p=3, act=True), nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
)
else:
blocks = [ResNetBlock(c1, c2, s, e=e)]
blocks.extend([ResNetBlock(e * c2, c2, 1, e=e) for _ in range(n - 1)])
self.layer = nn.Sequential(*blocks)
def forward(self, x):
"""Forward pass through the ResNet layer."""
return self.layer(x)
注意❗：在
第五小节
中需要声明的模块名称为：
ResNetLayer_StripPooling
。
五、添加步骤
5.1 修改一
① 在
ultralytics/nn/
目录下新建
AddModules
文件夹用于存放模块代码
② 在
AddModules
文件夹下新建
StripPooling.py
，将
第三节
中的代码粘贴到此处
5.2 修改二
在
AddModules
文件夹下新建
__init__.py
（已有则不用新建），在文件内导入模块：
from .StripPooling import *
5.3 修改三
在
ultralytics/nn/modules/tasks.py
文件中，需要在两处位置添加各模块类名称。
首先：导入模块
其次：在
parse_model函数
中注册
ResNetLayer_StripPooling
模块
最后：在
parse_model函数
中添加如下代码
elif m in {StripPooling}:
args = [ch[f]]
六、yaml模型文件
6.1 模型改进版本1⭐
此处以
ultralytics/cfg/models/rt-detr/rtdetr-l.yaml
为例，在同目录下创建一个用于自己数据集训练的模型文件
rtdetr-l-StripPooling.yaml
。
将
rtdetr-l.yaml
中的内容复制到
rtdetr-l-StripPooling.yaml
文件下，修改
nc
数量等于自己数据中目标的数量。
📌 模型的修改方法是在
骨干网络
中添加
StripPooling模块
。
# 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, 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, StripPooling, []]
- [-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)
6.2 模型改进版本2⭐
此处以
ultralytics/cfg/models/rt-detr/rtdetr-resnet50.yaml
为例，在同目录下创建一个用于自己数据集训练的模型文件
rtdetr-ResNetLayer_StripPooling.yaml
。
将
rtdetr-resnet50.yaml
中的内容复制到
rtdetr-ResNetLayer_StripPooling.yaml
文件下，修改
nc
数量等于自己数据中目标的数量。
📌 模型的修改方法是将
骨干网络
中的
ResNetLayer模块
替换成
ResNetLayer_StripPooling模块
。
# Ultralytics YOLO 🚀, AGPL-3.0 license
# RT-DETR-ResNet50 object detection model with P3-P5 outputs.
# 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, ResNetLayer_StripPooling, [3, 64, 1, True, 1]] # 0
- [-1, 1, ResNetLayer_StripPooling, [64, 64, 1, False, 3]] # 1
- [-1, 1, ResNetLayer_StripPooling, [256, 128, 2, False, 4]] # 2
- [-1, 1, ResNetLayer_StripPooling, [512, 256, 2, False, 6]] # 3
- [-1, 1, ResNetLayer_StripPooling, [1024, 512, 2, False, 3]] # 4
head:
- [-1, 1, Conv, [256, 1, 1, None, 1, 1, False]] # 5
- [-1, 1, AIFI, [1024, 8]]
- [-1, 1, Conv, [256, 1, 1]] # 7
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
- [3, 1, Conv, [256, 1, 1, None, 1, 1, False]] # 9
- [[-2, -1], 1, Concat, [1]]
- [-1, 3, RepC3, [256]] # 11
- [-1, 1, Conv, [256, 1, 1]] # 12
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
- [2, 1, Conv, [256, 1, 1, None, 1, 1, False]] # 14
- [[-2, -1], 1, Concat, [1]] # cat backbone P4
- [-1, 3, RepC3, [256]] # X3 (16), fpn_blocks.1
- [-1, 1, Conv, [256, 3, 2]] # 17, downsample_convs.0
- [[-1, 12], 1, Concat, [1]] # cat Y4
- [-1, 3, RepC3, [256]] # F4 (19), pan_blocks.0
- [-1, 1, Conv, [256, 3, 2]] # 20, downsample_convs.1
- [[-1, 7], 1, Concat, [1]] # cat Y5
- [-1, 3, RepC3, [256]] # F5 (22), pan_blocks.1
- [[16, 19, 22], 1, RTDETRDecoder, [nc]] # Detect(P3, P4, P5)
七、成功运行结果
打印网络模型可以看到
StripPooling
和
C2fCIB_SP
已经加入到模型中，并可以进行训练了。
rtdetr-l-StripPooling ：
rtdetr-l-StripPooling summary: 709 layers, 32,294,467 parameters, 32,294,467 gradients, 107.8 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 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 276096 ultralytics.nn.AddModules.StripPooling.StripPooling[256]
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-StripPooling summary: 709 layers, 32,294,467 parameters, 32,294,467 gradients, 107.8 GFLOPs
rtdetr-ResNetLayer_StripPooling ：
rtdetr-ResNetLayer_StripPooling summary: 1,217 layers, 48,052,995 parameters, 48,052,995 gradients, 140.5 GFLOPs
from n params module arguments
0 -1 1 9536 ultralytics.nn.AddModules.StripPooling.ResNetLayer_StripPooling[3, 64, 1, True, 1]
1 -1 1 268512 ultralytics.nn.AddModules.StripPooling.ResNetLayer_StripPooling[64, 64, 1, False, 3]
2 -1 1 1497344 ultralytics.nn.AddModules.StripPooling.ResNetLayer_StripPooling[256, 128, 2, False, 4]
3 -1 1 8754944 ultralytics.nn.AddModules.StripPooling.ResNetLayer_StripPooling[512, 256, 2, False, 6]
4 -1 1 18267904 ultralytics.nn.AddModules.StripPooling.ResNetLayer_StripPooling[1024, 512, 2, False, 3]
5 -1 1 524800 ultralytics.nn.modules.conv.Conv [2048, 256, 1, 1, None, 1, 1, False]
6 -1 1 789760 ultralytics.nn.modules.transformer.AIFI [256, 1024, 8]
7 -1 1 66048 ultralytics.nn.modules.conv.Conv [256, 256, 1, 1]
8 -1 1 0 torch.nn.modules.upsampling.Upsample [None, 2, 'nearest']
9 3 1 262656 ultralytics.nn.modules.conv.Conv [1024, 256, 1, 1, None, 1, 1, False]
10 [-2, -1] 1 0 ultralytics.nn.modules.conv.Concat [1]
11 -1 3 2232320 ultralytics.nn.modules.block.RepC3 [512, 256, 3]
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 2 1 131584 ultralytics.nn.modules.conv.Conv [512, 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 590336 ultralytics.nn.modules.conv.Conv [256, 256, 3, 2]
18 [-1, 12] 1 0 ultralytics.nn.modules.conv.Concat [1]
19 -1 3 2232320 ultralytics.nn.modules.block.RepC3 [512, 256, 3]
20 -1 1 590336 ultralytics.nn.modules.conv.Conv [256, 256, 3, 2]
21 [-1, 7] 1 0 ultralytics.nn.modules.conv.Concat [1]
22 -1 3 2232320 ultralytics.nn.modules.block.RepC3 [512, 256, 3]
23 [16, 19, 22] 1 7303907 ultralytics.nn.modules.head.RTDETRDecoder [1, [256, 256, 256]]
rtdetr-ResNetLayer_StripPooling summary: 1,217 layers, 48,052,995 parameters, 48,052,995 gradients, 140.5 GFLOPs