学习资源站

YOLOv11改进-卷积_Conv篇-利用DualConv二次创新C3k2提出一种轻量化结构（全网独家首发创新）

一、本文介绍

本文给大家带来的改进机制是利用DualConv改进C3k2提出一种更加 轻量化 的C3k2， DualConv 是一种创新的 卷积网络 结构，旨在构建轻量级的深度 神经网络 。它通过结合 3×3和1×1的卷积核 处理相同的输入特征映射通道，优化了信息处理和特征提取。DualConv利用 组卷积技术高效排列卷积滤波器 ，大大降低了计算成本和参数数量。我们将其用于C3k2的创新上能够大幅度的降低参数，还能够提升精度。

在开始之前给大家推荐一下我的专栏， 本专栏每周更新3-10篇最新前沿机制 | 包括二次创新全网无重复，以及融合改进(大家拿到之后添加另外一个改进机制在你的数据集上实现涨点即可撰写论文)，还有各种前沿顶会改进机制 |，更有包含我所有附赠的文件（文件内集成我所有的改进机制全部注册完毕可以直接运行）和交流群和视频讲解提供给大家。

欢迎大家订阅我的专栏一起学习YOLO！

二、DualConv原理

论文地址： 官方论文地址

代码地址：

2.2  DualConv的基本原理

DualConv 是一种创新的卷积网络结构，旨在构建 轻量级 的深度神经网络。它通过结合 3×3和1×1的卷积核 处理相同的输入特征映射通道，优化了信息处理和特征提取。DualConv利用 组卷积技术高效排列卷积滤波器 ，大大降低了计算成本和参数数量。这种结构可以广泛应用于各种 卷积神经网络 （CNN） 模型 ，如VGG-16、ResNet-50等，适用于图像分类、目标检测和语义分割任务。

DualConv的 基本原理 可以总结如下：

1. 结合3×3和1×1卷积核： DualConv使用3×3和1×1的卷积核同时处理相同的输入特征映射通道，结合了两者的优点。

2. 利用组卷积技术： 它通过组卷积技术高效地安排卷积滤波器，减少了计算成本和参数数量。

2.3 结合3×3和1×1卷积核

DualConv结构中 结合3×3和1×1卷积核 的设计理念是为了 融合这两种卷积核的优点 ：3×3卷积核在进行特征提取时可以捕获更多的空间信息，而1×1卷积核则可以在不增加过多参数和计算复杂度的前提下，进行特征通道之间的交互和信息整合。

下图是 DualConv结构的可视化 ，它展示了如何结合3×3和1×1的卷积核:

在DualConv中，3×3卷积核被用于提取特征图的空间特征，而1×1卷积核则被用来整合这些特征，并减少模型的参数。

每个组内的卷积核都分别处理一部分输入通道，然后输出合并，从而在不同的特征图通道间实现信息的高效流动和整合。这种结构设计不仅保持了网络深度和表征能力，还降低了计算复杂度和模型大小，使其适用于资源受限的环境。

2.3 组卷积技术

DualConv运用 组卷积技术 ，这是一种有效的参数和计算量减少策略。在组卷积中， 输入和输出特征图被分成多个组 ，每组的卷积滤波器仅处理对应的输入特征图的一部分，这减少了模型的复杂度。DualConv利用这一技术来进一步降低计算成本，因为它允许组内的不同卷积核（如3×3和1×1）并行处理同一组输入通道，优化了信息流和特征提取效率，同时保持了网络的表征能力。

下面这幅图展示了 DualConv的结构布局 ：

图中描绘了 3×3和1×1卷积核在输入特征映射通道上的并行布局 。 具体来说，这种布局利用了组卷积技术将卷积核分组，并在同一组内并行使用不同尺寸的卷积核。这样的设计有助于同时利用大尺寸卷积核的空间特征提取能力和小尺寸卷积核的计算效率，从而在保持准确性的同时减少模型的参数数量和计算成本。

三、DualConv核心代码 

  1. import torch
  2. import torch.nn as nn
  4. __all__ = ['C2f_Dual']
  7. def autopad(k, p=None, d=1):  # kernel, padding, dilation
  8.     """Pad to 'same' shape outputs."""
  9.     if d > 1:
  10.         k = d * (k - 1) + 1 if isinstance(k, int) else [d * (x - 1) + 1 for x in k]  # actual kernel-size
  11.     if p is None:
  12.         p = k // 2 if isinstance(k, int) else [x // 2 for x in k]  # auto-pad
  13.     return p
  16. class Conv(nn.Module):
  17.     """Standard convolution with args(ch_in, ch_out, kernel, stride, padding, groups, dilation, activation)."""
  18.     default_act = nn.SiLU()  # default activation
  20.     def __init__(self, c1, c2, k=1, s=1, p=None, g=1, d=1, act=True):
  21.         """Initialize Conv layer with given arguments including activation."""
  22.         super().__init__()
  23.         self.conv = nn.Conv2d(c1, c2, k, s, autopad(k, p, d), groups=g, dilation=d, bias=False)
  24.         self.bn = nn.BatchNorm2d(c2)
  25.         self.act = self.default_act if act is True else act if isinstance(act, nn.Module) else nn.Identity()
  27.     def forward(self, x):
  28.         """Apply convolution, batch normalization and activation to input tensor."""
  29.         return self.act(self.bn(self.conv(x)))
  31.     def forward_fuse(self, x):
  32.         """Perform transposed convolution of 2D data."""
  33.         return self.act(self.conv(x))
  38. class DualConv(nn.Module):
  39.     def __init__(self, in_channels, out_channels, stride=1, g=4):
  40.         """
  41.         Initialize the DualConv class.
  42.         :param input_channels: the number of input channels
  43.         :param output_channels: the number of output channels
  44.         :param stride: convolution stride
  45.         :param g: the value of G used in DualConv
  46.         """
  47.         super(DualConv, self).__init__()
  48.         # Group Convolution
  49.         self.gc = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1, groups=g, bias=False)
  50.         # Pointwise Convolution
  51.         self.pwc = nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=stride, bias=False)
  53.     def forward(self, input_data):
  54.         """
  55.         Define how DualConv processes the input images or input feature maps.
  56.         :param input_data: input images or input feature maps
  57.         :return: return output feature maps
  58.         """
  59.         return self.gc(input_data) + self.pwc(input_data)
  62. class Bottleneck(nn.Module):
  63.     # Standard bottleneck with DCN
  64.     def __init__(self, c1, c2, shortcut=True, g=1, k=(3, 3), e=0.5):  # ch_in, ch_out, shortcut, groups, kernels, expand
  65.         super().__init__()
  66.         c_ = int(c2 * e)  # hidden channels
  68.         self.cv1 = Conv(c1, c_, k[0], 1)
  69.         self.cv2 = DualConv(c2, c_)
  70.         self.add = shortcut and c1 == c2
  72.     def forward(self, x):
  73.         return x + self.cv2(self.cv1(x)) if self.add else self.cv2(self.cv1(x))
  76. class C2f_Dual(nn.Module):
  77.     # CSP Bottleneck with 2 convolutions
  78.     def __init__(self, c1, c2, n=1, shortcut=False, g=1, e=0.5):  # ch_in, ch_out, number, shortcut, groups, expansion
  79.         super().__init__()
  80.         self.c = int(c2 * e)  # hidden channels
  81.         self.cv1 = Conv(c1, 2 * self.c, 1, 1)
  82.         self.cv2 = Conv((2 + n) * self.c, c2, 1)  # optional act=FReLU(c2)
  83.         self.m = nn.ModuleList(Bottleneck(self.c, self.c, shortcut, g, k=(3, 3), e=1.0) for _ in range(n))
  85.     def forward(self, x):
  86.         y = list(self.cv1(x).split((self.c, self.c), 1))
  87.         y.extend(m(y[-1]) for m in self.m)
  88.         return self.cv2(torch.cat(y, 1))
  91. if __name__ == "__main__":
  92.     # Generating Sample image
  93.     image_size = (1, 64, 224, 224)
  94.     image = torch.rand(*image_size)
  96.     # Model
  97.     model = C2f_Dual(64, 64)
  99.     out = model(image)
  100.     print(out.size())

四、C3k2DUALConv的添加方式

这个添加方式和之前的变了一下，以后的添加方法都按照这个来了，是为了和群内的文件适配。

4.1 修改一

第一还是建立文件，我们找到如下 ultralytics /nn/modules文件夹下建立一个目录名字呢就是'Addmodules'文件夹( 用群内的文件的话已经有了无需新建) ！然后在其内部建立一个新的py文件将核心代码复制粘贴进去即可。

4.2 修改二

第二步我们在该目录下创建一个新的py文件名字为'__init__.py'( 用群内的文件的话已经有了无需新建) ，然后在其内部导入我们的检测头如下图所示。

4.3 修改三

第三步我门中到如下文件'ultralytics/nn/tasks.py'进行导入和注册我们的模块( 用群内的文件的话已经有了无需重新导入直接开始第四步即可) ！

从今天开始以后的教程就都统一成这个样子了，因为我默认大家用了我群内的文件来进行修改！！

4.4 修改四

按照我的添加在parse_model里添加即可。

到此就修改完成了，大家可以复制下面的yaml文件运行。

五、C3k2DUALConv的yaml文件和运行记录

5.1 C3k2DUALConv的yaml文件一

此版本训练信息：YOLO11-C3k2-DualConv-1 summary: 320 layers, 2,564,123 parameters, 2,564,107 gradients, 6.3 GFLOPs 

  1. # Ultralytics YOLO 🚀, AGPL-3.0 license
  2. # YOLOv10 object detection model. For Usage examples see https://docs.ultralytics.com/tasks/detect
  4. # Parameters
  5. nc: 80 # number of classes
  6. scales: # model compound scaling constants, i.e. 'model=yolov10n.yaml' will call yolov10.yaml with scale 'n'
  7.   # [depth, width, max_channels]
  8.   n: [0.33, 0.25, 1024]
  10. backbone:
  11.   # [from, repeats, module, args]
  12.   - [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
  13.   - [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
  14.   - [-1, 3, C2f_Dual, [128, True]]
  15.   - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
  16.   - [-1, 6, C2f_Dual, [256, True]]
  17.   - [-1, 1, SCDown, [512, 3, 2]] # 5-P4/16
  18.   - [-1, 6, C2f_Dual, [512, True]]
  19.   - [-1, 1, SCDown, [1024, 3, 2]] # 7-P5/32
  20.   - [-1, 3, C2f_Dual, [1024, True]]
  21.   - [-1, 1, SPPF, [1024, 5]] # 9
  22.   - [-1, 1, PSA, [1024]] # 10
  24. # YOLOv10.0n head
  25. head:
  26.   - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  27.   - [[-1, 6], 1, Concat, [1]] # cat backbone P4
  28.   - [-1, 3, C2f_Dual, [512]] # 13
  30.   - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  31.   - [[-1, 4], 1, Concat, [1]] # cat backbone P3
  32.   - [-1, 3, C2f_Dual, [256]] # 16 (P3/8-small)
  34.   - [-1, 1, Conv, [256, 3, 2]]
  35.   - [[-1, 13], 1, Concat, [1]] # cat head P4
  36.   - [-1, 3, C2f_Dual, [512]] # 19 (P4/16-medium)
  38.   - [-1, 1, SCDown, [512, 3, 2]]
  39.   - [[-1, 10], 1, Concat, [1]] # cat head P5
  40.   - [-1, 3, C2fCIB, [1024, True, True]] # 22 (P5/32-large)
  42.   - [[16, 19, 22], 1, v10Detect, [nc]] # Detect(P3, P4, P5)

5.2 C3k2DUALConv的yaml文件二

此版本训练信息：YOLO11-C3k2-DualConv-2 summary: 320 layers, 2,488,091 parameters, 2,488,075 gradients, 6.4 GFLOPs 

  1. # Ultralytics YOLO 🚀, AGPL-3.0 license
  2. # YOLO11 object detection model with P3-P5 outputs. For Usage examples see https://docs.ultralytics.com/tasks/detect
  4. # Parameters
  5. nc: 80 # number of classes
  6. scales: # model compound scaling constants, i.e. 'model=yolo11n.yaml' will call yolo11.yaml with scale 'n'
  7.   # [depth, width, max_channels]
  8.   n: [0.50, 0.25, 1024] # summary: 319 layers, 2624080 parameters, 2624064 gradients, 6.6 GFLOPs
  9.   s: [0.50, 0.50, 1024] # summary: 319 layers, 9458752 parameters, 9458736 gradients, 21.7 GFLOPs
  10.   m: [0.50, 1.00, 512] # summary: 409 layers, 20114688 parameters, 20114672 gradients, 68.5 GFLOPs
  11.   l: [1.00, 1.00, 512] # summary: 631 layers, 25372160 parameters, 25372144 gradients, 87.6 GFLOPs
  12.   x: [1.00, 1.50, 512] # summary: 631 layers, 56966176 parameters, 56966160 gradients, 196.0 GFLOPs
  14. # YOLO11n backbone
  15. backbone:
  16.   # [from, repeats, module, args]
  17.   - [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
  18.   - [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
  19.   - [-1, 2, C3k2_DualConv2, [256, False, 0.25]]
  20.   - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
  21.   - [-1, 2, C3k2_DualConv2, [512, False, 0.25]]
  22.   - [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
  23.   - [-1, 2, C3k2_DualConv2, [512, True]]
  24.   - [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
  25.   - [-1, 2, C3k2_DualConv2, [1024, True]]
  26.   - [-1, 1, SPPF, [1024, 5]] # 9
  27.   - [-1, 2, C2PSA, [1024]] # 10
  29. # YOLO11n head
  30. head:
  31.   - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  32.   - [[-1, 6], 1, Concat, [1]] # cat backbone P4
  33.   - [-1, 2, C3k2_DualConv2, [512, False]] # 13
  35.   - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  36.   - [[-1, 4], 1, Concat, [1]] # cat backbone P3
  37.   - [-1, 2, C3k2_DualConv2, [256, False]] # 16 (P3/8-small)
  39.   - [-1, 1, Conv, [256, 3, 2]]
  40.   - [[-1, 13], 1, Concat, [1]] # cat head P4
  41.   - [-1, 2, C3k2_DualConv2, [512, False]] # 19 (P4/16-medium)
  43.   - [-1, 1, Conv, [512, 3, 2]]
  44.   - [[-1, 10], 1, Concat, [1]] # cat head P5
  45.   - [-1, 2, C3k2_DualConv2, [1024, True]] # 22 (P5/32-large)
  47.   - [[16, 19, 22], 1, Detect, [nc]] # Detect(P3, P4, P5)

5.3 C3k2DUALConv的训练过程截图

5.4 训练代码 

  1. import warnings
  2. warnings.filterwarnings('ignore')
  3. from ultralytics import YOLO
  5. if __name__ == '__main__':
  6.     model = YOLO('模型yaml文件地址')
  7.     # 如何切换模型版本, 上面的ymal文件可以改为 yolov8s.yaml就是使用的v8s,
  8.     # 类似某个改进的yaml文件名称为yolov8-XXX.yaml那么如果想使用其它版本就把上面的名称改为yolov8l-XXX.yaml即可（改的是上面YOLO中间的名字不是配置文件的）！
  9.     # model.load('yolov8n.pt') # 是否加载预训练权重,科研不建议大家加载否则很难提升精度
  10.     model.train(data=r"填写你数据集yaml文件地址",
  11.                 # 如果大家任务是其它的'ultralytics/cfg/default.yaml'找到这里修改task可以改成detect, segment, classify, pose
  12.                 cache=False,
  13.                 imgsz=640,
  14.                 epochs=150,
  15.                 single_cls=False,  # 是否是单类别检测
  16.                 batch=4,
  17.                 close_mosaic=0,
  18.                 workers=0,
  19.                 device='0',
  20.                 optimizer='SGD', # using SGD
  21.                 # resume=True, # 这里是填写True
  22.                 amp=False,  # 如果出现训练损失为Nan可以关闭amp
  23.                 project='runs/train',
  24.                 name='exp',
  25.                 )

五、本文总结

到此本文的正式分享内容就结束了，在这里给大家推荐我的YOLOv11改进有效涨点专栏，本专栏目前为新开的平均质量分98分，后期我会根据各种最新的前沿顶会进行论文复现，也会对一些老的改进机制进行补充，如果大家觉得本文帮助到你了，订阅本专栏，关注后续更多的更新~