学习资源站

YOLOv11改进-Conv篇-利用CVPR2024-DynamicConv提出的GhostModule辅助C3k2进行特征融合（全网独家首发）

一、本文介绍

本文给大家带来的改进机制是 CVPR2024 的改进机制 DynamicConv 其是CVPR2024的最新改进机制，这个论文中介绍了一个名为ParameterNet的新型 设计原则 ， 它旨在在大规模视觉预训练模型中增加参数数量，同时尽量不增加浮点运算（FLOPs） ，所以本文的DynamicConv被提出来了，使得网络在保持低 FLOPs 的同时增加参数量，在其提出的时候它也提出了一个新的模块hostModule，我用其魔改C3k2从而达到创新的目的，从而允许这些网络从大规模视觉预训练中获益（本文的机制可以轻量化网络模型）。

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

二、原理介绍

官方论文地址： 官方论文地址点击此处即可跳转

官方代码地址： 官方代码地址点击此处即可跳转

动态卷积（Dynamic Convolution）是《DynamicConv.pdf》中提出的一种关键技术，旨在增加网络的参数量而几乎不增加额外的浮点运算（FLOPs）。以下是关于动态卷积的主要信息和原理：

主要原理：

1. 动态卷积的定义：
动态卷积通过对每个输入样本动态选择或组合不同的卷积核（称为"experts"），来处理输入数据。这种方法可以视为是对传统卷积操作的扩展，它允许网络根据输入的不同自适应地调整其参数。

2. 参数和计算的动态化：
在动态卷积中，不是为所有输入使用固定的卷积核，而是有多个卷积核（或参数集），并且根据输入的特性动态选择使用哪个核。
这种选择通过一个学习得到的 函数 （例如，使用多层感知机（MLP）和softmax函数）来动态生成控制各个卷积核贡献的权重。

3. 计算过程：
给定输入特征 X ，和一组卷积核 W_1, W_2, ..., W_M ，每个核对应一个专家。
每个专家的贡献由一个动态系数 \alpha_i \alpha_i 控制，这些系数是针对每个输入样本动态生成的。
输出 Y 是所有动态选定的卷积核操作的加权和： Y = \sum_{i=1}^M \alpha_i (X * W_i)
其中 * 表示卷积操作， \alpha_i 是通过一个小型网络（如MLP）动态计算得出的，这个小网络的输入是全局平均池化后的特征。

动态卷积的优点：

  • 参数效率高：通过共享和动态组合卷积核，动态卷积可以在增加极少的计算成本的情况下显著增加模型的参数量。
  • 适应性强：由于卷积核是针对每个输入动态选择的，这种方法可以更好地适应不同的输入特征，理论上可以提高模型的泛化能力。
  • 资源使用优化：动态卷积允许模型在资源有限的环境中（如移动设备）部署更复杂的网络结构，而不会显著增加计算负担。

动态卷积的设计思想突破了传统卷积网络结构的限制，通过动态调整和优化计算资源的使用，实现了在低FLOPs条件下提升网络 性能 的目标，这对于需要在计算资源受限的设备上运行高效 AI 模型的应用场景尤为重要。

三、核心代码

核心代码的使用方式看章节四！ 

  1. """
  2. An implementation of GhostNet Model as defined in:
  3. GhostNet: More Features from Cheap Operations. https://arxiv.org/abs/1911.11907
  4. The train script of the model is similar to that of MobileNetV3
  5. Original model: https://github.com/huawei-noah/CV-backbones/tree/master/ghostnet_pytorch
  6. """
  7. import math
  8. from functools import partial
  9. import torch
  10. import torch.nn as nn
  11. import torch.nn.functional as F
  12. from timm.layers import drop_path, SqueezeExcite
  13. from timm.models.layers import CondConv2d, hard_sigmoid, DropPath
  15. __all__ = ['C3k2_GhostModule']
  17. _SE_LAYER = partial(SqueezeExcite, gate_fn=hard_sigmoid, divisor=4)
  20. class DynamicConv(nn.Module):
  21.     """ Dynamic Conv layer
  22.     """
  24.     def __init__(self, in_features, out_features, kernel_size=1, stride=1, padding='', dilation=1,
  25.                  groups=1, bias=False, num_experts=4):
  26.         super().__init__()
  27.         self.routing = nn.Linear(in_features, num_experts)
  28.         self.cond_conv = CondConv2d(in_features, out_features, kernel_size, stride, padding, dilation,
  29.                                     groups, bias, num_experts)
  31.     def forward(self, x):
  32.         pooled_inputs = F.adaptive_avg_pool2d(x, 1).flatten(1)  # CondConv routing
  33.         routing_weights = torch.sigmoid(self.routing(pooled_inputs))
  34.         x = self.cond_conv(x, routing_weights)
  35.         return x
  38. class ConvBnAct(nn.Module):
  39.     """ Conv + Norm Layer + Activation w/ optional skip connection
  40.     """
  42.     def __init__(
  43.             self, in_chs, out_chs, kernel_size, stride=1, dilation=1, pad_type='',
  44.             skip=False, act_layer=nn.ReLU, norm_layer=nn.BatchNorm2d, drop_path_rate=0., num_experts=4):
  45.         super(ConvBnAct, self).__init__()
  46.         self.has_residual = skip and stride == 1 and in_chs == out_chs
  47.         self.drop_path_rate = drop_path_rate
  48.         # self.conv = create_conv2d(in_chs, out_chs, kernel_size, stride=stride, dilation=dilation, padding=pad_type)
  49.         self.conv = DynamicConv(in_chs, out_chs, kernel_size, stride, dilation=dilation, padding=pad_type,
  50.                                 num_experts=num_experts)
  51.         self.bn1 = norm_layer(out_chs)
  52.         self.act1 = act_layer()
  54.     def feature_info(self, location):
  55.         if location == 'expansion':  # output of conv after act, same as block coutput
  56.             info = dict(module='act1', hook_type='forward', num_chs=self.conv.out_channels)
  57.         else:  # location == 'bottleneck', block output
  58.             info = dict(module='', hook_type='', num_chs=self.conv.out_channels)
  59.         return info
  61.     def forward(self, x):
  62.         shortcut = x
  63.         x = self.conv(x)
  64.         x = self.bn1(x)
  65.         x = self.act1(x)
  66.         if self.has_residual:
  67.             if self.drop_path_rate > 0.:
  68.                 x = drop_path(x, self.drop_path_rate, self.training)
  69.             x += shortcut
  70.         return x
  73. class GhostModule(nn.Module):
  74.     def __init__(self, inp, oup, kernel_size=1, ratio=2, dw_size=3, stride=1, act_layer=nn.ReLU, num_experts=4):
  75.         super(GhostModule, self).__init__()
  76.         self.oup = oup
  77.         init_channels = math.ceil(oup / ratio)
  78.         new_channels = init_channels * (ratio - 1)
  80.         self.primary_conv = nn.Sequential(
  81.             DynamicConv(inp, init_channels, kernel_size, stride, kernel_size // 2, bias=False, num_experts=num_experts),
  82.             nn.BatchNorm2d(init_channels),
  83.             act_layer() if act_layer is not None else nn.Sequential(),
  84.         )
  86.         self.cheap_operation = nn.Sequential(
  87.             DynamicConv(init_channels, new_channels, dw_size, 1, dw_size // 2, groups=init_channels, bias=False,
  88.                         num_experts=num_experts),
  89.             nn.BatchNorm2d(new_channels),
  90.             act_layer() if act_layer is not None else nn.Sequential(),
  91.         )
  93.     def forward(self, x):
  94.         x1 = self.primary_conv(x)
  95.         x2 = self.cheap_operation(x1)
  96.         out = torch.cat([x1, x2], dim=1)
  97.         return out[:, :self.oup, :, :]
  100. class GhostBottleneck(nn.Module):
  101.     """ Ghost bottleneck w/ optional SE"""
  103.     def __init__(self, in_chs, out_chs, dw_kernel_size=3,
  104.                  stride=1, act_layer=nn.ReLU, se_ratio=0., drop_path=0., num_experts=4):
  105.         super(GhostBottleneck, self).__init__()
  106.         has_se = se_ratio is not None and se_ratio > 0.
  107.         self.stride = stride
  108.         mid_chs = in_chs * 2
  109.         # Point-wise expansion
  110.         self.ghost1 = GhostModule(in_chs, mid_chs, act_layer=act_layer, num_experts=num_experts)
  112.         # Depth-wise convolution
  113.         if self.stride > 1:
  114.             self.conv_dw = nn.Conv2d(
  115.                 mid_chs, mid_chs, dw_kernel_size, stride=stride,
  116.                 padding=(dw_kernel_size - 1) // 2, groups=mid_chs, bias=False)
  117.             self.bn_dw = nn.BatchNorm2d(mid_chs)
  118.         else:
  119.             self.conv_dw = None
  120.             self.bn_dw = None
  122.         # Squeeze-and-excitation
  123.         self.se = _SE_LAYER(mid_chs, se_ratio=se_ratio,
  124.                             act_layer=act_layer if act_layer is not nn.GELU else nn.ReLU) if has_se else None
  126.         # Point-wise linear projection
  127.         self.ghost2 = GhostModule(mid_chs, out_chs, act_layer=None, num_experts=num_experts)
  129.         # shortcut
  130.         if in_chs == out_chs and self.stride == 1:
  131.             self.shortcut = nn.Sequential()
  132.         else:
  133.             self.shortcut = nn.Sequential(
  134.                 DynamicConv(
  135.                     in_chs, in_chs, dw_kernel_size, stride=stride,
  136.                     padding=(dw_kernel_size - 1) // 2, groups=in_chs, bias=False, num_experts=num_experts),
  137.                 nn.BatchNorm2d(in_chs),
  138.                 DynamicConv(in_chs, out_chs, 1, stride=1, padding=0, bias=False, num_experts=num_experts),
  139.                 nn.BatchNorm2d(out_chs),
  140.             )
  142.         self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()
  144.     def forward(self, x):
  145.         shortcut = x
  147.         # 1st ghost bottleneck
  148.         x = self.ghost1(x)
  150.         # Depth-wise convolution
  151.         if self.conv_dw is not None:
  152.             x = self.conv_dw(x)
  153.             x = self.bn_dw(x)
  155.         # Squeeze-and-excitation
  156.         if self.se is not None:
  157.             x = self.se(x)
  159.         # 2nd ghost bottleneck
  160.         x = self.ghost2(x)
  162.         x = self.shortcut(shortcut) + self.drop_path(x)
  163.         return x
  165. class Bottleneck(nn.Module):
  166.     """Standard bottleneck."""
  168.     def __init__(self, c1, c2, shortcut=True, g=1, k=(3, 3), e=0.5):
  169.         """Initializes a standard bottleneck module with optional shortcut connection and configurable parameters."""
  170.         super().__init__()
  171.         c_ = int(c2 * e)  # hidden channels
  172.         self.cv1 = Conv(c1, c_, k[0], 1)
  173.         self.cv2 = Conv(c_, c2, k[1], 1, g=g)
  174.         self.add = shortcut and c1 == c2
  176.     def forward(self, x):
  177.         """Applies the YOLO FPN to input data."""
  178.         return x + self.cv2(self.cv1(x)) if self.add else self.cv2(self.cv1(x))
  181. def autopad(k, p=None, d=1):  # kernel, padding, dilation
  182.     """Pad to 'same' shape outputs."""
  183.     if d > 1:
  184.         k = d * (k - 1) + 1 if isinstance(k, int) else [d * (x - 1) + 1 for x in k]  # actual kernel-size
  185.     if p is None:
  186.         p = k // 2 if isinstance(k, int) else [x // 2 for x in k]  # auto-pad
  187.     return p
  191. class Conv(nn.Module):
  192.     """Standard convolution with args(ch_in, ch_out, kernel, stride, padding, groups, dilation, activation)."""
  193.     default_act = nn.SiLU()  # default activation
  195.     def __init__(self, c1, c2, k=1, s=1, p=None, g=1, d=1, act=True):
  196.         """Initialize Conv layer with given arguments including activation."""
  197.         super().__init__()
  198.         self.conv = nn.Conv2d(c1, c2, k, s, autopad(k, p, d), groups=g, dilation=d, bias=False)
  199.         self.bn = nn.BatchNorm2d(c2)
  200.         self.act = self.default_act if act is True else act if isinstance(act, nn.Module) else nn.Identity()
  202.     def forward(self, x):
  203.         """Apply convolution, batch normalization and activation to input tensor."""
  204.         return self.act(self.bn(self.conv(x)))
  206.     def forward_fuse(self, x):
  207.         """Perform transposed convolution of 2D data."""
  208.         return self.act(self.conv(x))
  211. class C2f(nn.Module):
  212.     """Faster Implementation of CSP Bottleneck with 2 convolutions."""
  214.     def __init__(self, c1, c2, n=1, shortcut=False, g=1, e=0.5):
  215.         """Initializes a CSP bottleneck with 2 convolutions and n Bottleneck blocks for faster processing."""
  216.         super().__init__()
  217.         self.c = int(c2 * e)  # hidden channels
  218.         self.cv1 = Conv(c1, 2 * self.c, 1, 1)
  219.         self.cv2 = Conv((2 + n) * self.c, c2, 1)  # optional act=FReLU(c2)
  220.         self.m = nn.ModuleList(Bottleneck(self.c, self.c, shortcut, g, k=((3, 3), (3, 3)), e=1.0) for _ in range(n))
  222.     def forward(self, x):
  223.         """Forward pass through C2f layer."""
  224.         y = list(self.cv1(x).chunk(2, 1))
  225.         y.extend(m(y[-1]) for m in self.m)
  226.         return self.cv2(torch.cat(y, 1))
  228.     def forward_split(self, x):
  229.         """Forward pass using split() instead of chunk()."""
  230.         y = list(self.cv1(x).split((self.c, self.c), 1))
  231.         y.extend(m(y[-1]) for m in self.m)
  232.         return self.cv2(torch.cat(y, 1))
  234. class C3(nn.Module):
  235.     """CSP Bottleneck with 3 convolutions."""
  237.     def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5):
  238.         """Initialize the CSP Bottleneck with given channels, number, shortcut, groups, and expansion values."""
  239.         super().__init__()
  240.         c_ = int(c2 * e)  # hidden channels
  241.         self.cv1 = Conv(c1, c_, 1, 1)
  242.         self.cv2 = Conv(c1, c_, 1, 1)
  243.         self.cv3 = Conv(2 * c_, c2, 1)  # optional act=FReLU(c2)
  244.         self.m = nn.Sequential(*(Bottleneck(c_, c_, shortcut, g, k=((1, 1), (3, 3)), e=1.0) for _ in range(n)))
  246.     def forward(self, x):
  247.         """Forward pass through the CSP bottleneck with 2 convolutions."""
  248.         return self.cv3(torch.cat((self.m(self.cv1(x)), self.cv2(x)), 1))
  250. class C3k(C3):
  251.     """C3k is a CSP bottleneck module with customizable kernel sizes for feature extraction in neural networks."""
  253.     def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5, k=3):
  254.         """Initializes the C3k module with specified channels, number of layers, and configurations."""
  255.         super().__init__(c1, c2, n, shortcut, g, e)
  256.         c_ = int(c2 * e)  # hidden channels
  257.         # self.m = nn.Sequential(*(RepBottleneck(c_, c_, shortcut, g, k=(k, k), e=1.0) for _ in range(n)))
  258.         self.m = nn.Sequential(*(Bottleneck(c_, c_, shortcut, g, k=(k, k), e=1.0) for _ in range(n)))
  260. class C3k2_GhostModule(C2f):
  261.     """Faster Implementation of CSP Bottleneck with 2 convolutions."""
  263.     def __init__(self, c1, c2, n=1, c3k=False, e=0.5, g=1, shortcut=True):
  264.         """Initializes the C3k2 module, a faster CSP Bottleneck with 2 convolutions and optional C3k blocks."""
  265.         super().__init__(c1, c2, n, shortcut, g, e)
  266.         self.m = nn.ModuleList(
  267.             C3k(self.c, self.c, 2, shortcut, g) if c3k else GhostBottleneck(self.c, self.c) for _ in range(n)
  268.         )  # c3k = True用C3k提取特征, False 时用GhostBottleneck融合特征
  270. if __name__ == "__main__":
  271.     # Generating Sample image
  272.     image_size = (1, 64, 224, 224)
  273.     image = torch.rand(*image_size)
  275.     # Model
  276.     model = C3k2_GhostModule(64, 64)
  278.     out = model(image)
  279.     print(out.size())

四、手把手教你添加GhostModule机制

4.1 修改一

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

​

4.2 修改二

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

4.3 修改三

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

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

​

4.4 修改四

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

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

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

5.1 GhostModule的yaml文件

此版本的训练信息：YOLO11-C3k2-GhostModule summary: 430 layers, 2,599,899 parameters, 2,599,883 gradients, 5.9 GFLOPs

版本信息： 

# c3k = True用C3k提取特征, False 时用GhostBottleneck融合特征
  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_GhostModule, [256, False, 0.25]]
  20.   - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
  21.   - [-1, 2, C3k2_GhostModule, [512, False, 0.25]]
  22.   - [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
  23.   - [-1, 2, C3k2_GhostModule, [512, True]]
  24.   - [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
  25.   - [-1, 2, C3k2_GhostModule, [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_GhostModule, [512, False]] # 13
  35.   - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  36.   - [[-1, 4], 1, Concat, [1]] # cat backbone P3
  37.   - [-1, 2, C3k2_GhostModule, [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_GhostModule, [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_GhostModule, [1024, True]] # 22 (P5/32-large)
  47.   - [[16, 19, 22], 1, Detect, [nc]] # Detect(P3, P4, P5)

5.2 训练代码

大家可以创建一个py文件将我给的代码复制粘贴进去，配置好自己的文件路径即可运行。 

  1. import warnings
  2. warnings.filterwarnings('ignore')
  3. from ultralytics import YOLO
  5. if __name__ == '__main__':
  6.     model = YOLO('ultralytics/cfg/models/v8/yolov8-C2f-FasterBlock.yaml')
  7.     # model.load('yolov8n.pt') # loading pretrain weights
  8.     model.train(data=r'替换数据集yaml文件地址',
  9.                 # 如果大家任务是其它的'ultralytics/cfg/default.yaml'找到这里修改task可以改成detect, segment, classify, pose
  10.                 cache=False,
  11.                 imgsz=640,
  12.                 epochs=150,
  13.                 single_cls=False,  # 是否是单类别检测
  14.                 batch=4,
  15.                 close_mosaic=10,
  16.                 workers=0,
  17.                 device='0',
  18.                 optimizer='SGD', # using SGD
  19.                 # resume='', # 如过想续训就设置last.pt的地址
  20.                 amp=False,  # 如果出现训练损失为Nan可以关闭amp
  21.                 project='runs/train',
  22.                 name='exp',
  23.                 )

5.3 GhostModule的训练过程截图

五、本文总结

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