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

一、本文介绍

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

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

目录

一、本文介绍

二、FasterNet原理

2.1 FasterNet的基本原理

2.2 部分卷积

2.3 加速神经网络

三、FasterBlock的核心代码

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

4.1 修改一

4.2 修改二

4.3 修改三

4.4 修改四

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

5.1 FasterBlock的yaml文件

5.2 训练代码

5.3 FasterBlock的训练过程截图

五、本文总结

二、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
  4.  
  5. __all__ = ['C3k2_FasterBlock']
  6.  
  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)
  13.  
  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
  20.  
  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, :, :])
  25.  
  26.         return x
  27.  
  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)
  33.  
  34.         return x
  35.  
  36.  
  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
  44.  
  45.  
  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
  49.  
  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()
  56.  
  57.     def forward(self, x):
  58.         """Apply convolution, batch normalization and activation to input tensor."""
  59.         return self.act(self.bn(self.conv(x)))
  60.  
  61.     def forward_fuse(self, x):
  62.         """Perform transposed convolution of 2D data."""
  63.         return self.act(self.conv(x))
  64.  
  65.  
  66. class FasterBlock(nn.Module):
  67.  
  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.                  ):
  79.  
  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
  86.  
  87.         mlp_hidden_dim = int(dim * mlp_ratio)
  88.  
  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.         ]
  95.  
  96.         self.mlp = nn.Sequential(*mlp_layer)
  97.  
  98.         self.spatial_mixing = Partial_conv3(
  99.             dim,
  100.             n_div,
  101.             pconv_fw_type
  102.         )
  103.  
  104.         if inc != dim:  # 在输入和输出不等时添加额外处理一步
  105.             self.firstConv = Conv(inc, dim, 1)
  106.  
  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
  112.  
  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
  120.  
  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
  129.  
  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
  137.  
  138.  
  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
  142.  
  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()
  149.  
  150.     def forward(self, x):
  151.         """Apply convolution, batch normalization and activation to input tensor."""
  152.         return self.act(self.bn(self.conv(x)))
  153.  
  154.     def forward_fuse(self, x):
  155.         """Perform transposed convolution of 2D data."""
  156.         return self.act(self.conv(x))
  157.  
  158.  
  159. class Bottleneck(nn.Module):
  160.     """Standard bottleneck."""
  161.  
  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
  169.  
  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))
  173.  
  174.  
  175.  
  176. class C2f(nn.Module):
  177.     """Faster Implementation of CSP Bottleneck with 2 convolutions."""
  178.  
  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))
  186.  
  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))
  192.  
  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))
  198.  
  199. class C3(nn.Module):
  200.     """CSP Bottleneck with 3 convolutions."""
  201.  
  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)))
  210.  
  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))
  214.  
  215. class C3k(C3):
  216.     """C3k is a CSP bottleneck module with customizable kernel sizes for feature extraction in neural networks."""
  217.  
  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)))
  224.  
  225. class C3k2_FasterBlock(C2f):
  226.     """Faster Implementation of CSP Bottleneck with 2 convolutions."""
  227.  
  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
  235.  
  236.  
  237. if __name__ == "__main__":
  238.     # Generating Sample image
  239.     image_size = (1, 64, 240, 240)
  240.     image = torch.rand(*image_size)
  241.  
  242.     # Model
  243.     model = C3k2_FasterBlock(64, 64)
  244.  
  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
  3.  
  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
  13.  
  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
  28.  
  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
  34.  
  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)
  38.  
  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)
  42.  
  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)
  46.  
  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
  4.  
  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分，后期我会根据各种最新的前沿顶会进行论文复现，也会对一些老的改进机制进行补充，如果大家觉得本文帮助到你了，订阅本专栏，关注后续更多的更新~