学习资源站

YOLOv11改进-融合改进篇-华为VanillaNet配合HSFPN助力yolov11有效涨点（教你如何融合创新点）

一、本文介绍

本文给大家带来的最新改进机制是 华为VanillaNet主干 配合 HSFPN 实现融合涨点，这个主干是一种注重极简主义和效率的 神经网络 我也将其进行了实验， 其中的HSFPN其是一种为白细胞检测设计的网络结构，主要用于解决白细胞数据集中的 多尺度 挑战。它的基本原理包括两个关键部分： 特征选择模块 和 特征融合模块， 在本文的下面均会有讲解，这个结构是非常新颖的。其可以起到 特征选择 的作用，我将其融合在一起，大家可以复制过去在其基础上配合我的 损失函数 ，然后再加一个检测头如果在你的数据上有涨点效果大家就可以开始撰写论文了。我发的改进机制已经有多名读者在Qq私聊我已经有涨点效果了，均有记录证明！ 欢迎大家订阅本专栏，本专栏每周更新3-5篇最新机制，更有包含我所有改进的文件和交流群提供给大家。

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

二、手把手教你添加华为VanillaNet主干

2.1 VanillaNet核心代码 

  1. # Copyright (C) 2023. Huawei Technologies Co., Ltd. All rights reserved.
  3. # This program is free software; you can redistribute it and/or modify it under the terms of the MIT License.
  5. # This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MIT License for more details.
  7. import torch
  8. import torch.nn as nn
  9. from timm.layers import weight_init
  11. __all__ = ['vanillanet_5', 'vanillanet_6', 'vanillanet_7', 'vanillanet_8', 'vanillanet_9', 'vanillanet_10',
  12.            'vanillanet_11', 'vanillanet_12', 'vanillanet_13', 'vanillanet_13_x1_5', 'vanillanet_13_x1_5_ada_pool']
  15. class activation(nn.ReLU):
  16.     def __init__(self, dim, act_num=3, deploy=False):
  17.         super(activation, self).__init__()
  18.         self.deploy = deploy
  19.         self.weight = torch.nn.Parameter(torch.randn(dim, 1, act_num * 2 + 1, act_num * 2 + 1))
  20.         self.bias = None
  21.         self.bn = nn.BatchNorm2d(dim, eps=1e-6)
  22.         self.dim = dim
  23.         self.act_num = act_num
  24.         weight_init.trunc_normal_(self.weight, std=.02)
  26.     def forward(self, x):
  27.         if self.deploy:
  28.             return torch.nn.functional.conv2d(
  29.                 super(activation, self).forward(x),
  30.                 self.weight, self.bias, padding=(self.act_num * 2 + 1) // 2, groups=self.dim)
  31.         else:
  32.             return self.bn(torch.nn.functional.conv2d(
  33.                 super(activation, self).forward(x),
  34.                 self.weight, padding=self.act_num, groups=self.dim))
  36.     def _fuse_bn_tensor(self, weight, bn):
  37.         kernel = weight
  38.         running_mean = bn.running_mean
  39.         running_var = bn.running_var
  40.         gamma = bn.weight
  41.         beta = bn.bias
  42.         eps = bn.eps
  43.         std = (running_var + eps).sqrt()
  44.         t = (gamma / std).reshape(-1, 1, 1, 1)
  45.         return kernel * t, beta + (0 - running_mean) * gamma / std
  47.     def switch_to_deploy(self):
  48.         if not self.deploy:
  49.             kernel, bias = self._fuse_bn_tensor(self.weight, self.bn)
  50.             self.weight.data = kernel
  51.             self.bias = torch.nn.Parameter(torch.zeros(self.dim))
  52.             self.bias.data = bias
  53.             self.__delattr__('bn')
  54.             self.deploy = True
  57. class Block(nn.Module):
  58.     def __init__(self, dim, dim_out, act_num=3, stride=2, deploy=False, ada_pool=None):
  59.         super().__init__()
  60.         self.act_learn = 1
  61.         self.deploy = deploy
  62.         if self.deploy:
  63.             self.conv = nn.Conv2d(dim, dim_out, kernel_size=1)
  64.         else:
  65.             self.conv1 = nn.Sequential(
  66.                 nn.Conv2d(dim, dim, kernel_size=1),
  67.                 nn.BatchNorm2d(dim, eps=1e-6),
  68.             )
  69.             self.conv2 = nn.Sequential(
  70.                 nn.Conv2d(dim, dim_out, kernel_size=1),
  71.                 nn.BatchNorm2d(dim_out, eps=1e-6)
  72.             )
  74.         if not ada_pool:
  75.             self.pool = nn.Identity() if stride == 1 else nn.MaxPool2d(stride)
  76.         else:
  77.             self.pool = nn.Identity() if stride == 1 else nn.AdaptiveMaxPool2d((ada_pool, ada_pool))
  79.         self.act = activation(dim_out, act_num)
  81.     def forward(self, x):
  82.         if self.deploy:
  83.             x = self.conv(x)
  84.         else:
  85.             x = self.conv1(x)
  86.             x = torch.nn.functional.leaky_relu(x, self.act_learn)
  87.             x = self.conv2(x)
  89.         x = self.pool(x)
  90.         x = self.act(x)
  91.         return x
  93.     def _fuse_bn_tensor(self, conv, bn):
  94.         kernel = conv.weight
  95.         bias = conv.bias
  96.         running_mean = bn.running_mean
  97.         running_var = bn.running_var
  98.         gamma = bn.weight
  99.         beta = bn.bias
  100.         eps = bn.eps
  101.         std = (running_var + eps).sqrt()
  102.         t = (gamma / std).reshape(-1, 1, 1, 1)
  103.         return kernel * t, beta + (bias - running_mean) * gamma / std
  105.     def switch_to_deploy(self):
  106.         if not self.deploy:
  107.             kernel, bias = self._fuse_bn_tensor(self.conv1[0], self.conv1[1])
  108.             self.conv1[0].weight.data = kernel
  109.             self.conv1[0].bias.data = bias
  110.             # kernel, bias = self.conv2[0].weight.data, self.conv2[0].bias.data
  111.             kernel, bias = self._fuse_bn_tensor(self.conv2[0], self.conv2[1])
  112.             self.conv = self.conv2[0]
  113.             self.conv.weight.data = torch.matmul(kernel.transpose(1, 3),
  114.                                                  self.conv1[0].weight.data.squeeze(3).squeeze(2)).transpose(1, 3)
  115.             self.conv.bias.data = bias + (self.conv1[0].bias.data.view(1, -1, 1, 1) * kernel).sum(3).sum(2).sum(1)
  116.             self.__delattr__('conv1')
  117.             self.__delattr__('conv2')
  118.             self.act.switch_to_deploy()
  119.             self.deploy = True
  122. class VanillaNet(nn.Module):
  123.     def __init__(self, in_chans=3, num_classes=1000, dims=[96, 192, 384, 768],
  124.                  drop_rate=0, act_num=3, strides=[2, 2, 2, 1], deploy=False, ada_pool=None, **kwargs):
  125.         super().__init__()
  126.         self.deploy = deploy
  127.         if self.deploy:
  128.             self.stem = nn.Sequential(
  129.                 nn.Conv2d(in_chans, dims[0], kernel_size=4, stride=4),
  130.                 activation(dims[0], act_num)
  131.             )
  132.         else:
  133.             self.stem1 = nn.Sequential(
  134.                 nn.Conv2d(in_chans, dims[0], kernel_size=4, stride=4),
  135.                 nn.BatchNorm2d(dims[0], eps=1e-6),
  136.             )
  137.             self.stem2 = nn.Sequential(
  138.                 nn.Conv2d(dims[0], dims[0], kernel_size=1, stride=1),
  139.                 nn.BatchNorm2d(dims[0], eps=1e-6),
  140.                 activation(dims[0], act_num)
  141.             )
  143.         self.act_learn = 1
  145.         self.stages = nn.ModuleList()
  146.         for i in range(len(strides)):
  147.             if not ada_pool:
  148.                 stage = Block(dim=dims[i], dim_out=dims[i + 1], act_num=act_num, stride=strides[i], deploy=deploy)
  149.             else:
  150.                 stage = Block(dim=dims[i], dim_out=dims[i + 1], act_num=act_num, stride=strides[i], deploy=deploy,
  151.                               ada_pool=ada_pool[i])
  152.             self.stages.append(stage)
  153.         self.depth = len(strides)
  155.         self.apply(self._init_weights)
  156.         self.width_list = [i.size(1) for i in self.forward(torch.randn(1, 3, 640, 640))]
  158.     def _init_weights(self, m):
  159.         if isinstance(m, (nn.Conv2d, nn.Linear)):
  160.             weight_init.trunc_normal_(m.weight, std=.02)
  161.             nn.init.constant_(m.bias, 0)
  163.     def change_act(self, m):
  164.         for i in range(self.depth):
  165.             self.stages[i].act_learn = m
  166.         self.act_learn = m
  168.     def forward(self, x):
  169.         unique_tensors = {}
  170.         if self.deploy:
  171.             x = self.stem(x)
  172.         else:
  173.             x = self.stem1(x)
  174.             x = torch.nn.functional.leaky_relu(x, self.act_learn)
  175.             x = self.stem2(x)
  176.         width, height = x.shape[2], x.shape[3]
  177.         unique_tensors[(width, height)] = x
  178.         for i in range(self.depth):
  179.             x = self.stages[i](x)
  180.             width, height = x.shape[2], x.shape[3]
  181.             unique_tensors[(width, height)] = x
  182.         result_list = list(unique_tensors.values())[-4:]
  183.         return result_list
  185.     def _fuse_bn_tensor(self, conv, bn):
  186.         kernel = conv.weight
  187.         bias = conv.bias
  188.         running_mean = bn.running_mean
  189.         running_var = bn.running_var
  190.         gamma = bn.weight
  191.         beta = bn.bias
  192.         eps = bn.eps
  193.         std = (running_var + eps).sqrt()
  194.         t = (gamma / std).reshape(-1, 1, 1, 1)
  195.         return kernel * t, beta + (bias - running_mean) * gamma / std
  197.     def switch_to_deploy(self):
  198.         if not self.deploy:
  199.             self.stem2[2].switch_to_deploy()
  200.             kernel, bias = self._fuse_bn_tensor(self.stem1[0], self.stem1[1])
  201.             self.stem1[0].weight.data = kernel
  202.             self.stem1[0].bias.data = bias
  203.             kernel, bias = self._fuse_bn_tensor(self.stem2[0], self.stem2[1])
  204.             self.stem1[0].weight.data = torch.einsum('oi,icjk->ocjk', kernel.squeeze(3).squeeze(2),
  205.                                                      self.stem1[0].weight.data)
  206.             self.stem1[0].bias.data = bias + (self.stem1[0].bias.data.view(1, -1, 1, 1) * kernel).sum(3).sum(2).sum(1)
  207.             self.stem = torch.nn.Sequential(*[self.stem1[0], self.stem2[2]])
  208.             self.__delattr__('stem1')
  209.             self.__delattr__('stem2')
  211.             for i in range(self.depth):
  212.                 self.stages[i].switch_to_deploy()
  214.             self.deploy = True
  217. def vanillanet_5(pretrained=False, in_22k=False, **kwargs):
  218.     model = VanillaNet(dims=[128 * 4, 256 * 4, 512 * 4, 1024 * 4], strides=[2, 2, 2], **kwargs)
  219.     return model
  222. def vanillanet_6(pretrained=False, in_22k=False, **kwargs):
  223.     model = VanillaNet(dims=[128 * 4, 256 * 4, 512 * 4, 1024 * 4, 1024 * 4], strides=[2, 2, 2, 1], **kwargs)
  224.     return model
  227. def vanillanet_7(pretrained=False, in_22k=False, **kwargs):
  228.     model = VanillaNet(dims=[128 * 4, 128 * 4, 256 * 4, 512 * 4, 1024 * 4, 1024 * 4], strides=[1, 2, 2, 2, 1], **kwargs)
  229.     return model
  232. def vanillanet_8(pretrained=False, in_22k=False, **kwargs):
  233.     model = VanillaNet(dims=[128 * 4, 128 * 4, 256 * 4, 512 * 4, 512 * 4, 1024 * 4, 1024 * 4],
  234.                        strides=[1, 2, 2, 1, 2, 1], **kwargs)
  235.     return model
  238. def vanillanet_9(pretrained=False, in_22k=False, **kwargs):
  239.     model = VanillaNet(dims=[128 * 4, 128 * 4, 256 * 4, 512 * 4, 512 * 4, 512 * 4, 1024 * 4, 1024 * 4],
  240.                        strides=[1, 2, 2, 1, 1, 2, 1], **kwargs)
  241.     return model
  244. def vanillanet_10(pretrained=False, in_22k=False, **kwargs):
  245.     model = VanillaNet(
  246.         dims=[128 * 4, 128 * 4, 256 * 4, 512 * 4, 512 * 4, 512 * 4, 512 * 4, 1024 * 4, 1024 * 4],
  247.         strides=[1, 2, 2, 1, 1, 1, 2, 1],
  248.         **kwargs)
  249.     return model
  252. def vanillanet_11(pretrained=False, in_22k=False, **kwargs):
  253.     model = VanillaNet(
  254.         dims=[128 * 4, 128 * 4, 256 * 4, 512 * 4, 512 * 4, 512 * 4, 512 * 4, 512 * 4, 1024 * 4, 1024 * 4],
  255.         strides=[1, 2, 2, 1, 1, 1, 1, 2, 1],
  256.         **kwargs)
  257.     return model
  260. def vanillanet_12(pretrained=False, in_22k=False, **kwargs):
  261.     model = VanillaNet(
  262.         dims=[128 * 4, 128 * 4, 256 * 4, 512 * 4, 512 * 4, 512 * 4, 512 * 4, 512 * 4, 512 * 4, 1024 * 4, 1024 * 4],
  263.         strides=[1, 2, 2, 1, 1, 1, 1, 1, 2, 1],
  264.         **kwargs)
  265.     return model
  268. def vanillanet_13(pretrained=False, in_22k=False, **kwargs):
  269.     model = VanillaNet(
  270.         dims=[128 * 4, 128 * 4, 256 * 4, 512 * 4, 512 * 4, 512 * 4, 512 * 4, 512 * 4, 512 * 4, 512 * 4, 1024 * 4,
  271.               1024 * 4],
  272.         strides=[1, 2, 2, 1, 1, 1, 1, 1, 1, 2, 1],
  273.         **kwargs)
  274.     return model
  277. def vanillanet_13_x1_5(pretrained=False, in_22k=False, **kwargs):
  278.     model = VanillaNet(
  279.         dims=[128 * 6, 128 * 6, 256 * 6, 512 * 6, 512 * 6, 512 * 6, 512 * 6, 512 * 6, 512 * 6, 512 * 6, 1024 * 6,
  280.               1024 * 6],
  281.         strides=[1, 2, 2, 1, 1, 1, 1, 1, 1, 2, 1],
  282.         **kwargs)
  283.     return model
  286. def vanillanet_13_x1_5_ada_pool(pretrained=False, in_22k=False, **kwargs):
  287.     model = VanillaNet(
  288.         dims=[128 * 6, 128 * 6, 256 * 6, 512 * 6, 512 * 6, 512 * 6, 512 * 6, 512 * 6, 512 * 6, 512 * 6, 1024 * 6,
  289.               1024 * 6],
  290.         strides=[1, 2, 2, 1, 1, 1, 1, 1, 1, 2, 1],
  291.         ada_pool=[0, 38, 19, 0, 0, 0, 0, 0, 0, 10, 0],
  292.         **kwargs)
  293.     return model

2.2 修改教程

2.2.1 修改一

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

2.2.2 修改二

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

2.2.3 修改三

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

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

2.2.4 修改四

添加如下两行代码！！！

​

2.2.5 修改五

找到七百多行大概把具体看图片，按照图片来修改就行，添加红框内的部分，注意没有()只是函数名。 

  1.         elif m in {自行添加对应的模型即可，下面都是一样的}:
  2.             m = m(*args)
  3.             c2 = m.width_list  # 返回通道列表
  4.             backbone = True

2.2.6 修改六

下面的两个红框内都是需要改动的。

​ 

  1.         if isinstance(c2, list):
  2.             m_ = m
  3.             m_.backbone = True
  4.         else:
  5.             m_ = nn.Sequential(*(m(*args) for _ in range(n))) if n > 1 else m(*args)  # module
  6.             t = str(m)[8:-2].replace('__main__.', '')  # module type
  9.         m.np = sum(x.numel() for x in m_.parameters())  # number params
  10.         m_.i, m_.f, m_.type = i + 4 if backbone else i, f, t  # attach index, 'from' index, type

2.2.7 修改七

如下的也需要修改，全部按照我的来。

​

代码如下把原先的代码替换了即可。 

  1.         if verbose:
  2.             LOGGER.info(f'{i:>3}{str(f):>20}{n_:>3}{m.np:10.0f}  {t:<45}{str(args):<30}')  # print
  4.         save.extend(x % (i + 4 if backbone else i) for x in ([f] if isinstance(f, int) else f) if x != -1)  # append to savelist
  5.         layers.append(m_)
  6.         if i == 0:
  7.             ch = []
  8.         if isinstance(c2, list):
  9.             ch.extend(c2)
  10.             if len(c2) != 5:
  11.                 ch.insert(0, 0)
  12.         else:
  13.             ch.append(c2)

2.2.8 修改八

修改七和前面的都不太一样，需要修改前向传播中的一个部分， 已经离开了parse_model方法了。

可以在图片中开代码行数，没有离开task.py文件都是同一个文件。 同时这个部分有好几个前向传播都很相似，大家不要看错了， 是70多行左右的！！！，同时我后面提供了代码，大家直接复制粘贴即可，有时间我针对这里会出一个视频。

​

代码如下-> 

  1.     def _predict_once(self, x, profile=False, visualize=False):
  2.         """
  3.         Perform a forward pass through the network.
  5.         Args:
  6.             x (torch.Tensor): The input tensor to the model.
  7.             profile (bool):  Print the computation time of each layer if True, defaults to False.
  8.             visualize (bool): Save the feature maps of the model if True, defaults to False.
  10.         Returns:
  11.             (torch.Tensor): The last output of the model.
  12.         """
  13.         y, dt = [], []  # outputs
  14.         for m in self.model:
  15.             if m.f != -1:  # if not from previous layer
  16.                 x = y[m.f] if isinstance(m.f, int) else [x if j == -1 else y[j] for j in m.f]  # from earlier layers
  17.             if profile:
  18.                 self._profile_one_layer(m, x, dt)
  19.             if hasattr(m, 'backbone'):
  20.                 x = m(x)
  21.                 if len(x) != 5: # 0 - 5
  22.                     x.insert(0, None)
  23.                 for index, i in enumerate(x):
  24.                     if index in self.save:
  25.                         y.append(i)
  26.                     else:
  27.                         y.append(None)
  28.                 x = x[-1] # 最后一个输出传给下一层
  29.             else:
  30.                 x = m(x)  # run
  31.                 y.append(x if m.i in self.save else None)  # save output
  32.             if visualize:
  33.                 feature_visualization(x, m.type, m.i, save_dir=visualize)
  34.         return x

到这里就完成了修改部分，但是这里面细节很多，大家千万要注意不要替换多余的代码，导致报错，也不要拉下任何一部，都会导致运行失败，而且报错很难排查！！！很难排查！！！

注意！！！ 额外的修改！

关注我的其实都知道，我大部分的修改都是一样的，这个网络需要额外的修改一步，就是s一个参数，将下面的s改为640！！！即可完美运行！！

修改八

我们找到如下文件'ultralytics/utils/torch_utils.py'按照如下的图片进行修改，否则容易打印不出来计算量。

​

注意事项！！！

如果大家在验证的时候报错形状不匹配的错误可以固定 验证集 的图片尺寸，方法如下 ->

找到下面这个文件ultralytics/ models /yolo/detect/train.py然后其中有一个类是DetectionTrainer class中的build_dataset函数中的一个参数rect=mode == 'val'改为rect=False

三、HSFPN的核心代码 

  1. import torch
  2. import torch.nn as nn
  3. import torch.nn.functional as F
  6. __all__ = ['CA', 'multiply', 'Add']
  9. class Add(nn.Module):
  10.     # Concatenate a list of tensors along dimension
  11.     def __init__(self, ch=256):
  12.         super().__init__()
  14.     def forward(self, x):
  15.         input1, input2 = x[0], x[1]
  16.         x = input1 + input2
  17.         return x
  20. class multiply(nn.Module):
  21.     def __init__(self):
  22.         super().__init__()
  24.     def forward(self, x):
  25.         x = x[0] * x[1]
  26.         return x
  28. class CA(nn.Module):
  29.     def __init__(self, in_planes, ratio = 4, flag=True):
  30.         super(CA, self).__init__()
  31.         self.avg_pool = nn.AdaptiveAvgPool2d(1)
  32.         self.max_pool = nn.AdaptiveMaxPool2d(1)
  34.         self.conv1 = nn.Conv2d(in_planes, in_planes // ratio, 1, bias=False)
  35.         self.relu = nn.ReLU()
  36.         self.conv2 = nn.Conv2d(in_planes // ratio, in_planes, 1, bias=False)
  37.         self.flag = flag
  38.         self.sigmoid = nn.Sigmoid()
  40.         nn.init.xavier_uniform_(self.conv1.weight)
  41.         nn.init.xavier_uniform_(self.conv2.weight)
  43.     def forward(self, x):
  44.         avg_out = self.conv2(self.relu(self.conv1(self.avg_pool(x))))
  45.         max_out = self.conv2(self.relu(self.conv1(self.max_pool(x))))
  46.         out = avg_out + max_out
  47.         out = self.sigmoid(out) * x if self.flag else self.sigmoid(out)
  48.         return out
  52. class FeatureSelectionModule(nn.Module):
  53.     def __init__(self, in_chan, out_chan):
  54.         super(FeatureSelectionModule, self).__init__()
  55.         self.conv_atten = nn.Conv2d(in_chan, in_chan, kernel_size=1)
  56.         self.group_norm1 = nn.GroupNorm(32, in_chan)
  57.         self.sigmoid = nn.Sigmoid()
  58.         self.conv = nn.Conv2d(in_chan, out_chan, kernel_size=1)
  59.         self.group_norm2 = nn.GroupNorm(32, out_chan)
  60.         nn.init.xavier_uniform_(self.conv_atten.weight)
  61.         nn.init.xavier_uniform_(self.conv.weight)
  63.     def forward(self, x):
  64.         atten = self.sigmoid(self.group_norm1(self.conv_atten(F.avg_pool2d(x, x.size()[2:]))))
  65.         feat = torch.mul(x, atten)
  66.         x = x + feat
  67.         feat = self.group_norm2(self.conv(x))
  68.         return feat
  71. if __name__ == "__main__":
  72.     # Generating Sample image
  73.     image_size = (1, 64, 240, 240)
  74.     image = torch.rand(*image_size)
  76.     # Model
  77.     mobilenet_v3 = FeatureSelectionModule(64, 64)
  79.     out = mobilenet_v3(image)
  80.     print(out.size())

四、手把手教你添加HS-FPN

4.1 修改一

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

​

​

​

4.2 修改二

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

​​​

4.3 修改三

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

​​​

4.4 修改四

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

​

4.5 修改五

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

​ 

  1.         elif m in {'此处添加大家修改的对应机制即可'}:
  2.             c2 = ch[f]
  3.             args = [c2, *args]
  1.         elif m is multiply:
  2.             c2 = ch[f[0]]
  3.         elif m is Add:
  4.             c2 = ch[f[-1]]

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

五、融合后的yaml文件

5.1 yaml文件

训练信息：YOLO11-vanillanet-HSFPN summary: 265 layers, 3,128,418 parameters, 3,128,402 gradients, 12.8 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. # 下面 [-1, 1, vanillanet_5, [0.25]] 参数位置的0.25是通道放缩的系数, YOLOv11N是0.25 YOLOv11S是0.5 YOLOv11M是1. YOLOv11l是1 YOLOv11是1.5大家根据自己训练的YOLO版本设定即可.
  15. # 本文支持版本有 vanillanet_5, vanillanet_6, vanillanet_7, vanillanet_8, vanillanet_9, vanillanet_10, vanillanet_11, vanillanet_12, vanillanet_13, vanillanet_13_x1_5, vanillanet_13_x1_5_ada_pool
  16. # YOLO11n backbone
  17. backbone:
  18.   # [from, repeats, module, args]
  19.   - [-1, 1, vanillanet_5, [0.25]] # 0-4 P1/2 这里是四层大家不要被yaml文件限制住了思维，不会画图进群看视频.
  20.   - [-1, 1, SPPF, [1024, 5]] # 5
  21.   - [-1, 2, C2PSA, [1024]] # 6
  23. # YOLO11n head
  24. head:
  25.   - [-1, 1, CA, []] # 11
  26.   - [-1, 1, nn.Conv2d, [256, 1]] # 12
  27.   - [-1, 2, C3k2, [256, False]] # 13 P5
  29.   - [3, 1, CA, []]
  30.   - [-1, 1, nn.Conv2d, [256, 1]]  # 15
  32.   - [8, 1, nn.ConvTranspose2d, [256, 3, 2, 1, 1]] # 16
  33.   - [-1, 1, CA, [4, False]]
  34.   - [[-1, 11], 1, multiply, []] # 18
  35.   - [[-1, 12], 1, Add, []] # 19
  36.   - [-1, 2, C3k2, [256, False]] # 20 P4
  38.   - [2, 1, CA, []] # 21
  39.   - [-1, 1, nn.Conv2d, [256, 1]] # 22
  41.   - [12, 1, nn.ConvTranspose2d, [256, 3, 2, 1, 1]] # 23
  42.   - [-1, 1, CA, [4, False]] # 24
  43.   - [[-1, 18], 1, multiply, []] # 25
  44.   - [[-1, 19], 1, Add, []] # 26
  45.   - [-1, 2, C3k2, [256, True]] # 27 P3
  47.   - [[23, 16, 9], 1, Detect, [nc]] # Det

5.2 运行文件

可以复制我的运行文件进行运行， 

  1. import warnings
  3. warnings.filterwarnings('ignore')
  4. from ultralytics import YOLO
  6. if __name__ == '__main__':
  7.     model = YOLO("替换你的yaml文件地址")
  8.     # model.load('yolov8n.pt')  # 不建议大家加载初始化权重尤其这种替换主干和Neck的改进机制
  9.     model.train(data=r'你的数据集的地址',
  10.                 cache=False,
  11.                 imgsz=640,
  12.                 epochs=150,
  13.                 batch=4,
  14.                 close_mosaic=0,
  15.                 workers=0,
  16.                 device=0,
  17.                 optimizer='SGD'
  18.     amp = False,
  19.     )

5.3 运行记录

五、本文总结

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