学习资源站

YOLOv11改进-Conv_卷积篇-利用MobileNetV4的UIB模块二次创新C3k2适配yolov11扩展率（全网独家首发，轻量化）

YOLOv11改进 | Conv/卷积篇 | 利用MobileNetV4的UIB模块二次创新C3k2适配yolov11扩展率（全网独家首发，轻量化）

一、本文介绍

本文给大家带来的最新改进机制是利用 MobileNetV4 的 UIB模块二次创新C3k2 ，其中UIB模块来自 2024.5月发布的 MobileNetV4网络，其是一种高度优化的 神经网络 架构，专为 移动设备 设计。它最新的改动总结主要有两点 ， 采用了通用反向瓶颈（UIB，也就是本文利用的结构） 和针对移动 加速器 优化的 Mobile MQA注意力模块 （一种全新的注意力机制）。我将其用于C3k2的二次创新在V11n上参数量为250W），计算量为6.0GFLOPs，非常适用于想要轻量化网络模型的读者来使用， 同时本文结构为本专栏独家创新 。

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

二、原理介绍

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

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

MobileNetV4 是MobileNet系列的最新版本，专为移动设备设计，引入了多种新颖且高效的架构组件。其中最关键的是通用反转瓶颈（UIB），它结合了以前模型如MobileNetV2的反转瓶颈和新元素，例如ConvNext块和视觉变换器（ViT）中的前馈网络。这种结构允许在不过度复杂化架构搜索过程的情况下，适应性地并有效地扩展模型到各种平台。

此外，MobileNetV4还包括一种名为Mobile MQA的新型注意力机制，该机制通过优化算术运算与内存访问的比率，显著提高了移动加速器上的推理速度，这是移动 性能 的关键因素。该架构通过精细的神经 网络架构 搜索（NAS）和新颖的蒸馏技术进一步优化，使得MobileNetV4能够在多种硬件平台上达到最优性能，包括移动CPU、DSP、GPU和特定的加速器，如Apple的Neural Engine和Google的Pixel EdgeTPU。

此外，MobileNetV4还引入了改进的NAS策略，通过粗粒度和细粒度搜索相结合的方法，显著提高搜索效率并改善模型质量。通过这种方法，MobileNetV4能够实现大多数情况下的Pareto最优性能，这意味着在不同设备上都能达到效率和准确性的最佳平衡。

最后，通过一种新的蒸馏技术，MobileNetV4进一步提高了准确性，其混合型大模型在ImageNet-1K数据集上达到了87%的顶级准确率，同时在Pixel 8 EdgeTPU上的运行时间仅为3.8毫秒。这些特性使MobileNetV4成为适用于移动环境中高效视觉任务的理想选择。

主要思想提取和总结：

1. 通用反转瓶颈（UIB），本文利用的机制:

MobileNetV4引入了一种名为通用反转瓶颈（UIB）的新架构组件。UIB是一个灵活的架构单元，融合了反转瓶颈（IB）、ConvNext、前馈网络（FFN），以及新颖的额外深度（ExtraDW）变体。

2. Mobile MQA注意力机制:

为了优化移动加速器的性能，MobileNetV4设计了一个特殊的注意力模块，名为Mobile MQA。这一模块针对移动设备的计算和存储限制进行了优化，提供了高达39%的推理速度提升。

3. 优化的神经架构搜索（NAS）配方:

通过改进的NAS配方，MobileNetV4能够更高效地搜索和优化网络架构，这有助于发现适合特定 硬件 的最优模型配置。

4. 模型蒸馏技术:

引入了一种新的蒸馏技术，用以提高模型的准确性。通过这种技术，MNv4-Hybrid-Large模型在ImageNet-1K上达到了87%的准确率，并且在Pixel 8 EdgeTPU上的运行时间仅为3.8毫秒。

个人总结： MobileNetV4是一个专为移动设备设计的高效 深度学习 模型。它通过整合多种先进技术，如通用反转瓶颈（UIB）、针对移动设备优化的注意力机制（Mobile MQA），以及先进的架构搜索方法（NAS），实现了在不同硬件上的高效运行。这些技术的融合不仅大幅提升了模型的运行速度，还显著提高了准确率。特别是，它的一个变体模型在标准图像识别测试中取得了87%的准确率，运行速度极快。

三、核心代码

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

  1. import torch.nn as nn
  2. from typing import Optional
  3. import torch
  5. __all__ = ['C2f_UIB']
  8. def make_divisible(
  9.         value: float,
  10.         divisor: int,
  11.         min_value: Optional[float] = None,
  12.         round_down_protect: bool = True,
  13. ) -> int:
  14.     """
  15.     This function is copied from here
  16.     "https://github.com/tensorflow/models/blob/master/official/vision/modeling/layers/nn_layers.py"
  18.     This is to ensure that all layers have channels that are divisible by 8.
  20.     Args:
  21.         value: A `float` of original value.
  22.         divisor: An `int` of the divisor that need to be checked upon.
  23.         min_value: A `float` of  minimum value threshold.
  24.         round_down_protect: A `bool` indicating whether round down more than 10%
  25.         will be allowed.
  27.     Returns:
  28.         The adjusted value in `int` that is divisible against divisor.
  29.     """
  30.     if min_value is None:
  31.         min_value = divisor
  32.     new_value = max(min_value, int(value + divisor / 2) // divisor * divisor)
  33.     # Make sure that round down does not go down by more than 10%.
  34.     if round_down_protect and new_value < 0.9 * value:
  35.         new_value += divisor
  36.     return int(new_value)
  38. def conv_2d(inp, oup, kernel_size=3, stride=1, groups=1, bias=False, norm=True, act=True):
  39.     conv = nn.Sequential()
  40.     padding = (kernel_size - 1) // 2
  41.     conv.add_module('conv', nn.Conv2d(inp, oup, kernel_size, stride, padding, bias=bias, groups=groups))
  42.     if norm:
  43.         conv.add_module('BatchNorm2d', nn.BatchNorm2d(oup))
  44.     if act:
  45.         conv.add_module('Activation', nn.ReLU6())
  46.     return conv
  48. class UniversalInvertedBottleneckBlock(nn.Module):
  49.     def __init__(self,
  50.                  inp,
  51.                  oup,
  52.                  start_dw_kernel_size=3,
  53.                  middle_dw_kernel_size=3,
  54.                  middle_dw_downsample=1,
  55.                  stride=1,
  56.                  expand_ratio=1
  57.                  ):
  58.         """An inverted bottleneck block with optional depthwises.
  59.         Referenced from here https://github.com/tensorflow/models/blob/master/official/vision/modeling/layers/nn_blocks.py
  60.         """
  61.         super().__init__()
  62.         # Starting depthwise conv.
  63.         self.start_dw_kernel_size = start_dw_kernel_size
  64.         if self.start_dw_kernel_size:
  65.             stride_ = stride if not middle_dw_downsample else 1
  66.             self._start_dw_ = conv_2d(inp, inp, kernel_size=start_dw_kernel_size, stride=stride_, groups=inp, act=False)
  67.         # Expansion with 1x1 convs.
  68.         expand_filters = make_divisible(inp * expand_ratio, 8)
  69.         self._expand_conv = conv_2d(inp, expand_filters, kernel_size=1)
  70.         # Middle depthwise conv.
  71.         self.middle_dw_kernel_size = middle_dw_kernel_size
  72.         if self.middle_dw_kernel_size:
  73.             stride_ = stride if middle_dw_downsample else 1
  74.             self._middle_dw = conv_2d(expand_filters, expand_filters, kernel_size=middle_dw_kernel_size, stride=stride_,
  75.                                       groups=expand_filters)
  76.         # Projection with 1x1 convs.
  77.         self._proj_conv = conv_2d(expand_filters, oup, kernel_size=1, stride=1, act=False)
  79.         # Ending depthwise conv.
  80.         # this not used
  81.         # _end_dw_kernel_size = 0
  82.         # self._end_dw = conv_2d(oup, oup, kernel_size=_end_dw_kernel_size, stride=stride, groups=inp, act=False)
  84.     def forward(self, x):
  85.         if self.start_dw_kernel_size:
  86.             x = self._start_dw_(x)
  87.             # print("_start_dw_", x.shape)
  88.         x = self._expand_conv(x)
  89.         # print("_expand_conv", x.shape)
  90.         if self.middle_dw_kernel_size:
  91.             x = self._middle_dw(x)
  92.             # print("_middle_dw", x.shape)
  93.         x = self._proj_conv(x)
  94.         # print("_proj_conv", x.shape)
  95.         return x
  98. def autopad(k, p=None, d=1):  # kernel, padding, dilation
  99.     """Pad to 'same' shape outputs."""
  100.     if d > 1:
  101.         k = d * (k - 1) + 1 if isinstance(k, int) else [d * (x - 1) + 1 for x in k]  # actual kernel-size
  102.     if p is None:
  103.         p = k // 2 if isinstance(k, int) else [x // 2 for x in k]  # auto-pad
  104.     return p
  107. class Conv(nn.Module):
  108.     """Standard convolution with args(ch_in, ch_out, kernel, stride, padding, groups, dilation, activation)."""
  109.     default_act = nn.SiLU()  # default activation
  111.     def __init__(self, c1, c2, k=1, s=1, p=None, g=1, d=1, act=True):
  112.         """Initialize Conv layer with given arguments including activation."""
  113.         super().__init__()
  114.         self.conv = nn.Conv2d(c1, c2, k, s, autopad(k, p, d), groups=g, dilation=d, bias=False)
  115.         self.bn = nn.BatchNorm2d(c2)
  116.         self.act = self.default_act if act is True else act if isinstance(act, nn.Module) else nn.Identity()
  118.     def forward(self, x):
  119.         """Apply convolution, batch normalization and activation to input tensor."""
  120.         return self.act(self.bn(self.conv(x)))
  122.     def forward_fuse(self, x):
  123.         """Perform transposed convolution of 2D data."""
  124.         return self.act(self.conv(x))
  129. class C2f_UIB(nn.Module):
  130.     """Faster Implementation of CSP Bottleneck with 2 convolutions."""
  131.     def __init__(self, c1, c2, n=1, shortcut=False, g=1, e=0.5):
  132.         """Initialize CSP bottleneck layer with two convolutions with arguments ch_in, ch_out, number, shortcut, groups,
  133.         expansion.
  134.         """
  135.         super().__init__()
  136.         self.c = int(c2 * e)  # hidden channels
  137.         self.cv1 = Conv(c1, 2 * self.c, 1, 1)
  138.         self.cv2 = Conv((2 + n) * self.c, c2, 1)  # optional act=FReLU(c2)
  139.         self.m = nn.ModuleList(UniversalInvertedBottleneckBlock(self.c, self.c) for _ in range(n))
  141.     def forward(self, x):
  142.         """Forward pass through C2f layer."""
  143.         x = self.cv1(x)
  144.         x = x.chunk(2, 1)
  145.         y = list(x)
  146.         # y = list(self.cv1(x).chunk(2, 1))
  147.         y.extend(m(y[-1]) for m in self.m)
  148.         return self.cv2(torch.cat(y, 1))
  150.     def forward_split(self, x):
  151.         """Forward pass using split() instead of chunk()."""
  152.         y = list(self.cv1(x).split((self.c, self.c), 1))
  153.         y.extend(m(y[-1]) for m in self.m)
  154.         return self.cv2(torch.cat(y, 1))
  157. if __name__ == '__main__':
  158.     x = torch.randn(1, 32, 16, 16)
  159.     model = C2f_UIB(32, 32)
  160.     print(model(x).shape)

四、添加教程

4.1 修改一

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

​

4.2 修改二

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

4.3 修改三

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

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

​

4.4 修改四

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

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

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

5.1 C3k2UIB的yaml文件

训练信息： YOLO11-C3k2-UIB summary: 360 layers, 2,509,858 parameters, 2,509,842 gradients, 6.0 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_UIB, [256, False, 0.25]]
  20.   - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
  21.   - [-1, 2, C3k2_UIB, [512, False, 0.25]]
  22.   - [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
  23.   - [-1, 2, C3k2_UIB, [512, True]]
  24.   - [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
  25.   - [-1, 2, C3k2_UIB, [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_UIB, [512, False]] # 13
  35.   - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  36.   - [[-1, 4], 1, Concat, [1]] # cat backbone P3
  37.   - [-1, 2, C3k2_UIB, [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_UIB, [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_UIB, [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 C3k2UIB的训练过程截图

五、本文总结

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