学习资源站

YOLOv11改进-Conv篇-利用FasterBlock二次创新C3k2提出一种全新的结构（全网独家首发）

一、本文介绍

本文给大家带来的改进机制是利用FasterNet的FasterBlock改进特征提取网络，将其用来改进 ResNet网络 ，其旨在 提高计算速度而不牺牲准确性 ，特别是在视觉任务中。它通过一种称为 部分卷积（PConv） 的新技术来减少冗余计算和内存访问。这种方法使得FasterNet在多种设备上运行速度比其他网络快得多，同时在各种视觉任务中保持高准确率，同时本文的内容为我独家创新，全网仅此一份， 同时本文的改进机制参数量下降、计算量均有下降 。

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

二、FasterNet原理

论文地址： 官方论文地址

代码地址： 官方代码地址

2.1 FasterNet的基本原理

FasterNet 是一种高效的 神经网络 架构，旨在 提高计算速度而不牺牲准确性 ，特别是在视觉任务中。它通过一种称为 部分卷积（PConv） 的新技术来减少冗余计算和内存访问。这种方法使得FasterNet在多种设备上运行速度比其他网络快得多，同时在各种视觉任务中保持高准确率。例如，FasterNet在ImageNet-1k数据集上的表现超过了其他模型，如 MobileViT-XXS ，展现了其在速度和准确度方面的优势。

FasterNet的基本原理可以总结为以下几点：

1. 部分卷积（PConv）: FasterNet引入了部分卷积（PConv），这是一种新型的卷积方法，它通过只处理输入通道的一部分来减少计算量和内存访问。

2. 加速神经网络 : FasterNet利用PConv的优势，实现了在多种设备上比其他现有神经网络更快的运行速度，同时保持了较高的准确度。

下面为大家展示的是 FasterNet的整体架构 。

它包括四个层次化的阶段，每个阶段由一系列FasterNet块组成，并由嵌入或合并层开头。最后三层用于特征分类。在每个FasterNet块中，PConv层之后是两个点状卷积（PWConv）层。为了保持特征多样性并实现更低的延迟，仅在中间层之后放置了 归一化和激活层 。

2.2 部分卷积

部分卷积（PConv） 是一种 卷积神经网络 中的操作，旨在提高计算效率。它通过 只在输入特征图的一部分上执行卷积操作 ，而非传统卷积操作中的全面应用。这样，PConv可以减少不必要的计算和内存访问，因为它忽略了输入中认为是冗余的部分。这种方法特别适合在资源有限的设备上运行 深度学习 模型，因为它可以在不牺牲太多性能的情况下，显著降低计算需求。

下面我为大家展示了FasterNet中的 部分卷积（PConv）与传统卷积和深度卷积/分组卷积的比较 ：

PConv通过仅对输入通道的一小部分应用滤波器，同时保持其余通道不变，实现了快速和高效的特性提取。PConv的计算复杂度 （FLOPs） 低于常规卷积，但高于深度卷积/分组卷积，这样在减少计算资源的同时提高了运算性能。

2.3 加速神经网络

加速神经网络 主要通过优化计算路径、减少模型大小和复杂性、提高操作效率，以及使用高效的 硬件 实现等方式来降低模型的推理时间。这些方法包括

简化网络层 、 使用更快的激活函数 、 采用量化技术 将 浮点运算转换为整数运算 ，以及使用特殊的算法来减少内存访问次数等。通过这些策略，可以在不损害模型准确性的前提下，使神经网络能够更快地处理数据和做出预测。

三、FasterBlock的核心代码

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

  1. import torch
  2. import torch.nn as nn
  3. from timm.models.layers import DropPath
  5. __all__ = ['C3k2_FasterBlock']
  7. class Partial_conv3(nn.Module):
  8.     def __init__(self, dim, n_div, forward):
  9.         super().__init__()
  10.         self.dim_conv3 = dim // n_div
  11.         self.dim_untouched = dim - self.dim_conv3
  12.         self.partial_conv3 = nn.Conv2d(self.dim_conv3, self.dim_conv3, 3, 1, 1, bias=False)
  14.         if forward == 'slicing':
  15.             self.forward = self.forward_slicing
  16.         elif forward == 'split_cat':
  17.             self.forward = self.forward_split_cat
  18.         else:
  19.             raise NotImplementedError
  21.     def forward_slicing(self, x):
  22.         # only for inference
  23.         x = x.clone()  # !!! Keep the original input intact for the residual connection later
  24.         x[:, :self.dim_conv3, :, :] = self.partial_conv3(x[:, :self.dim_conv3, :, :])
  26.         return x
  28.     def forward_split_cat(self, x):
  29.         # for training/inference
  30.         x1, x2 = torch.split(x, [self.dim_conv3, self.dim_untouched], dim=1)
  31.         x1 = self.partial_conv3(x1)
  32.         x = torch.cat((x1, x2), 1)
  34.         return x
  37. def autopad(k, p=None, d=1):  # kernel, padding, dilation
  38.     """Pad to 'same' shape outputs."""
  39.     if d > 1:
  40.         k = d * (k - 1) + 1 if isinstance(k, int) else [d * (x - 1) + 1 for x in k]  # actual kernel-size
  41.     if p is None:
  42.         p = k // 2 if isinstance(k, int) else [x // 2 for x in k]  # auto-pad
  43.     return p
  46. class Conv(nn.Module):
  47.     """Standard convolution with args(ch_in, ch_out, kernel, stride, padding, groups, dilation, activation)."""
  48.     default_act = nn.SiLU()  # default activation
  50.     def __init__(self, c1, c2, k=1, s=1, p=None, g=1, d=1, act=True):
  51.         """Initialize Conv layer with given arguments including activation."""
  52.         super().__init__()
  53.         self.conv = nn.Conv2d(c1, c2, k, s, autopad(k, p, d), groups=g, dilation=d, bias=False)
  54.         self.bn = nn.BatchNorm2d(c2)
  55.         self.act = self.default_act if act is True else act if isinstance(act, nn.Module) else nn.Identity()
  57.     def forward(self, x):
  58.         """Apply convolution, batch normalization and activation to input tensor."""
  59.         return self.act(self.bn(self.conv(x)))
  61.     def forward_fuse(self, x):
  62.         """Perform transposed convolution of 2D data."""
  63.         return self.act(self.conv(x))
  66. class FasterBlock(nn.Module):
  68.     def __init__(self,
  69.                  inc,
  70.                  dim,
  71.                  n_div=4,
  72.                  mlp_ratio=2,
  73.                  drop_path=0.1,
  74.                  layer_scale_init_value=0.0,
  75.                  act_layer='RELU',
  76.                  norm_layer='BN',
  77.                  pconv_fw_type='split_cat'
  78.                  ):
  80.         super().__init__()
  81.         self.dim = dim
  82.         self.inc = inc
  83.         self.mlp_ratio = mlp_ratio
  84.         self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()
  85.         self.n_div = n_div
  87.         mlp_hidden_dim = int(dim * mlp_ratio)
  89.         mlp_layer = [
  90.             nn.Conv2d(dim, mlp_hidden_dim, 1, bias=False),
  91.             nn.BatchNorm2d(mlp_hidden_dim),
  92.             nn.ReLU(),
  93.             nn.Conv2d(mlp_hidden_dim, dim, 1, bias=False)
  94.         ]
  96.         self.mlp = nn.Sequential(*mlp_layer)
  98.         self.spatial_mixing = Partial_conv3(
  99.             dim,
  100.             n_div,
  101.             pconv_fw_type
  102.         )
  104.         if inc != dim:  # 在输入和输出不等时添加额外处理一步
  105.             self.firstConv = Conv(inc, dim, 1)
  107.         if layer_scale_init_value > 0:
  108.             self.layer_scale = nn.Parameter(layer_scale_init_value * torch.ones((dim)), requires_grad=True)
  109.             self.forward = self.forward_layer_scale
  110.         else:
  111.             self.forward = self.forward
  113.     def forward(self, x):
  114.         if self.inc != self.dim:
  115.             x = self.firstConv(x)
  116.         shortcut = x
  117.         x = self.spatial_mixing(x)
  118.         x = shortcut + self.drop_path(self.mlp(x))
  119.         return x
  121.     def forward_layer_scale(self, x):
  122.         if self.inc != self.dim:
  123.             x = self.firstConv(x)
  124.         shortcut = x
  125.         x = self.spatial_mixing(x)
  126.         x = shortcut + self.drop_path(
  127.             self.layer_scale.unsqueeze(-1).unsqueeze(-1) * self.mlp(x))
  128.         return x
  130. def autopad(k, p=None, d=1):  # kernel, padding, dilation
  131.     """Pad to 'same' shape outputs."""
  132.     if d > 1:
  133.         k = d * (k - 1) + 1 if isinstance(k, int) else [d * (x - 1) + 1 for x in k]  # actual kernel-size
  134.     if p is None:
  135.         p = k // 2 if isinstance(k, int) else [x // 2 for x in k]  # auto-pad
  136.     return p
  139. class Conv(nn.Module):
  140.     """Standard convolution with args(ch_in, ch_out, kernel, stride, padding, groups, dilation, activation)."""
  141.     default_act = nn.SiLU()  # default activation
  143.     def __init__(self, c1, c2, k=1, s=1, p=None, g=1, d=1, act=True):
  144.         """Initialize Conv layer with given arguments including activation."""
  145.         super().__init__()
  146.         self.conv = nn.Conv2d(c1, c2, k, s, autopad(k, p, d), groups=g, dilation=d, bias=False)
  147.         self.bn = nn.BatchNorm2d(c2)
  148.         self.act = self.default_act if act is True else act if isinstance(act, nn.Module) else nn.Identity()
  150.     def forward(self, x):
  151.         """Apply convolution, batch normalization and activation to input tensor."""
  152.         return self.act(self.bn(self.conv(x)))
  154.     def forward_fuse(self, x):
  155.         """Perform transposed convolution of 2D data."""
  156.         return self.act(self.conv(x))
  159. class Bottleneck(nn.Module):
  160.     """Standard bottleneck."""
  162.     def __init__(self, c1, c2, shortcut=True, g=1, k=(3, 3), e=0.5):
  163.         """Initializes a standard bottleneck module with optional shortcut connection and configurable parameters."""
  164.         super().__init__()
  165.         c_ = int(c2 * e)  # hidden channels
  166.         self.cv1 = Conv(c1, c_, k[0], 1)
  167.         self.cv2 = Conv(c_, c2, k[1], 1, g=g)
  168.         self.add = shortcut and c1 == c2
  170.     def forward(self, x):
  171.         """Applies the YOLO FPN to input data."""
  172.         return x + self.cv2(self.cv1(x)) if self.add else self.cv2(self.cv1(x))
  176. class C2f(nn.Module):
  177.     """Faster Implementation of CSP Bottleneck with 2 convolutions."""
  179.     def __init__(self, c1, c2, n=1, shortcut=False, g=1, e=0.5):
  180.         """Initializes a CSP bottleneck with 2 convolutions and n Bottleneck blocks for faster processing."""
  181.         super().__init__()
  182.         self.c = int(c2 * e)  # hidden channels
  183.         self.cv1 = Conv(c1, 2 * self.c, 1, 1)
  184.         self.cv2 = Conv((2 + n) * self.c, c2, 1)  # optional act=FReLU(c2)
  185.         self.m = nn.ModuleList(Bottleneck(self.c, self.c, shortcut, g, k=((3, 3), (3, 3)), e=1.0) for _ in range(n))
  187.     def forward(self, x):
  188.         """Forward pass through C2f layer."""
  189.         y = list(self.cv1(x).chunk(2, 1))
  190.         y.extend(m(y[-1]) for m in self.m)
  191.         return self.cv2(torch.cat(y, 1))
  193.     def forward_split(self, x):
  194.         """Forward pass using split() instead of chunk()."""
  195.         y = list(self.cv1(x).split((self.c, self.c), 1))
  196.         y.extend(m(y[-1]) for m in self.m)
  197.         return self.cv2(torch.cat(y, 1))
  199. class C3(nn.Module):
  200.     """CSP Bottleneck with 3 convolutions."""
  202.     def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5):
  203.         """Initialize the CSP Bottleneck with given channels, number, shortcut, groups, and expansion values."""
  204.         super().__init__()
  205.         c_ = int(c2 * e)  # hidden channels
  206.         self.cv1 = Conv(c1, c_, 1, 1)
  207.         self.cv2 = Conv(c1, c_, 1, 1)
  208.         self.cv3 = Conv(2 * c_, c2, 1)  # optional act=FReLU(c2)
  209.         self.m = nn.Sequential(*(Bottleneck(c_, c_, shortcut, g, k=((1, 1), (3, 3)), e=1.0) for _ in range(n)))
  211.     def forward(self, x):
  212.         """Forward pass through the CSP bottleneck with 2 convolutions."""
  213.         return self.cv3(torch.cat((self.m(self.cv1(x)), self.cv2(x)), 1))
  215. class C3k(C3):
  216.     """C3k is a CSP bottleneck module with customizable kernel sizes for feature extraction in neural networks."""
  218.     def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5, k=3):
  219.         """Initializes the C3k module with specified channels, number of layers, and configurations."""
  220.         super().__init__(c1, c2, n, shortcut, g, e)
  221.         c_ = int(c2 * e)  # hidden channels
  222.         # self.m = nn.Sequential(*(RepBottleneck(c_, c_, shortcut, g, k=(k, k), e=1.0) for _ in range(n)))
  223.         self.m = nn.Sequential(*(Bottleneck(c_, c_, shortcut, g, k=(k, k), e=1.0) for _ in range(n)))
  225. class C3k2_FasterBlock(C2f):
  226.     """Faster Implementation of CSP Bottleneck with 2 convolutions."""
  228.     def __init__(self, c1, c2, n=1, c3k=False, e=0.5, g=1, shortcut=True):
  229.         """Initializes the C3k2 module, a faster CSP Bottleneck with 2 convolutions and optional C3k blocks."""
  230.         super().__init__(c1, c2, n, shortcut, g, e)
  231.         self.m = nn.ModuleList(
  232.             C3k(self.c, self.c, 2, shortcut, g) if c3k else FasterBlock(self.c, self.c) for _ in range(n)
  233.         )
  234.         # 解析 c3k在主干和网络最后一个C3k2的时候设置True走的是C3k, 否则我们走的是MSBlock
  237. if __name__ == "__main__":
  238.     # Generating Sample image
  239.     image_size = (1, 64, 240, 240)
  240.     image = torch.rand(*image_size)
  242.     # Model
  243.     model = C3k2_FasterBlock(64, 64)
  245.     out = model(image)
  246.     print(out.size())

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

4.1 修改一

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

​

4.2 修改二

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

4.3 修改三

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

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

4.4 修改四

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

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

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

5.1 FasterBlock的yaml文件

此版本的训练信息：YOLO11-C3k2-FasterBlock summary: 330 layers, 2,548,347 parameters, 2,548,331 gradients, 6.2 GFLOPs

# 解析 c3k在主干和网络最后一个C3k2的时候设置True走的是C3k, 否则我们走的是 FasterBlock（也就是Neck的三个False时） 

  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_FasterBlock, [256, False, 0.25]]
  20.   - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
  21.   - [-1, 2, C3k2_FasterBlock, [512, False, 0.25]]
  22.   - [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
  23.   - [-1, 2, C3k2_FasterBlock, [512, True]]
  24.   - [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
  25.   - [-1, 2, C3k2_FasterBlock, [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_FasterBlock, [512, False]] # 13
  35.   - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  36.   - [[-1, 4], 1, Concat, [1]] # cat backbone P3
  37.   - [-1, 2, C3k2_FasterBlock, [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_FasterBlock, [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_FasterBlock, [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 FasterBlock的训练过程截图

五、本文总结

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