【YOLOv5/v7改进系列】引入Slim Neck与GSConv

已于 2024-06-15 16:46:26 修改
阅读量1.1k 收藏 21
点赞数 35
分类专栏： YOLO改进指南 文章标签： YOLO 人工智能 目标检测 pytorch 深度学习 机器学习 dnn
于 2024-06-04 02:02:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84870184/article/details/139427295
版权
一、导言

GSConv旨在平衡模型的准确度与速度，针对自动驾驶车辆中目标检测任务设计。从类脑研究中得到的直观理解是，具有更多神经元的模型能够获得更强的非线性表达能力。但是，不容忽视的是生物大脑处理信息的强大能力和低能耗远远超过计算机。强大的模型不能仅仅通过无限制地增加模型参数的数量来构建。当前阶段，轻量化设计对于缓解高计算成本是有效的，这主要通过使用深度可分离卷积(DSC)操作来减少参数量和浮点运算次数(FLOPs)来实现，效果明显。

尽管如此，DSC的缺点也很明显：在计算过程中，输入图像的通道信息被分开处理。这种缺陷导致DSC在特征提取和融合能力上远低于标准卷积(SC)。标准卷积在整个输出上保持了通道间的相互作用，而DSC则是先进行深度卷积再进行逐点卷积，虽然降低了计算成本，但也牺牲了通道间的信息交互。

为了解决这一问题，研究者提出了GSConv，这是一种新的轻量级卷积技术，旨在减轻模型重量的同时保持准确性，实现了模型准确度和速度之间的良好平衡。GSConv通过混合使用标准卷积、DSC和通道混洗(shuffle)来工作，使DSC的输出尽可能接近标准卷积的结果，从而提高了特征表示能力。这种方法允许来自标准卷积的信息充分混合到DSC产生的信息中，同时避免了额外的计算开销。

此外，文章还提出了一种设计范式“slim-neck”，即仅在模型的“neck”部分使用GSConv，而非整个模型。在neck阶段，特征图已经过足够的压缩（通道维度达到最大，而宽度和高度维度减至最小），且转换变得适度。此时，利用GSConv处理拼接的特征图恰到好处，因为它可以减少冗余重复信息，无需进一步压缩，并且注意力模块如SPP和CA等可以更好地发挥作用。

GSConv与slim-neck的优势和劣势可以从几个方面来解释：

优点：

  1. 提高效率与准确性平衡：GSConv通过结合标准卷积(SC)、深度可分离卷积(DSC)以及通道混洗操作，能够在不显著增加计算成本的情况下，增强模型的非线性表达能力，从而在保持轻量化的同时提升检测精度。

  2. 增强特征提取与融合：与仅使用DSC相比，GSConv通过混入SC产生的信息，使得输出特征图更接近于使用SC的结果，提高了特征的提取与融合能力。这在处理小物体检测时尤为重要，有助于提高平均精度(mAP)。

  3. 针对性应用：特别是在“细颈”(slim-neck)设计范式中，GSConv被应用于模型的中间连接部分，即neck，这时特征图已经过初步处理，变得较为精简，且宽度和高度减小到最小，而通道数达到最大。此时使用GSConv能有效处理这些特征，避免冗余信息重复压缩，同时促进注意力机制如空间金字塔池化(SPP)和通道注意力(CA)模块更好地工作。

  4. 轻量化设计：GSConv的设计有助于减轻高计算成本，对于车载边缘计算平台而言，能够在满足实时检测需求的同时，保持模型的轻便性，这对于工业应用至关重要。

缺点：

  1. 模型复杂度：虽然GSConv提升了性能，但若在整个模型的所有阶段都使用GSConv，会导致网络层加深，增加数据流的阻力并显著增加推理时间。这可能对资源有限的设备构成挑战。

  2. 实现难度：文中提到，为了在不引入额外浮点运算的情况下完成混洗操作，需要采取特定策略，比如转置操作或线性操作。这些非标准操作可能在某些硬件设备上不受支持，增加了实现的复杂度。

  3. 设计与优化要求：有效利用GSConv要求对模型架构有深入理解并进行细致调整，以确保在特定层（如neck部分）应用GSConv能带来最大的效益，这可能需要额外的调优工作。

综上所述，GSConv通过创新的结构设计为轻量级目标检测模型提供了新的解决方案，尤其在自动驾驶领域，它能够帮助模型在保持高效运行的同时，提高对小目标的检测精度，但其应用也需考虑模型复杂度增加和实现上的局限性。

二、准备工作

首先在YOLOv5/v7的models文件夹下新建文件slimneck.py，导入如下代码

from models.common import *


class GSConv(nn.Module):
    # GSConv https://github.com/AlanLi1997/slim-neck-by-gsconv
    def __init__(self, c1, c2, k=1, s=1, g=1, act=True):
        super().__init__()
        c_ = c2 // 2
        self.cv1 = Conv(c1, c_, k, s, None, g, act)
        self.cv2 = Conv(c_, c_, 5, 1, None, c_, act)

    def forward(self, x):
        x1 = self.cv1(x)
        x2 = torch.cat((x1, self.cv2(x1)), 1)
        # shuffle
        b, n, h, w = x2.data.size()
        b_n = b * n // 2
        y = x2.reshape(b_n, 2, h * w)
        y = y.permute(1, 0, 2)
        y = y.reshape(2, -1, n // 2, h, w)
        return torch.cat((y[0], y[1]), 1)


class GSBottleneck(nn.Module):
    # GS Bottleneck https://github.com/AlanLi1997/slim-neck-by-gsconv
    def __init__(self, c1, c2, k=3, s=1):
        super().__init__()
        c_ = c2 // 2
        # for lighting
        self.conv_lighting = nn.Sequential(
            GSConv(c1, c_, 1, 1),
            GSConv(c_, c2, 1, 1, act=False))
        # for receptive field
        self.conv = nn.Sequential(
            GSConv(c1, c_, 3, 1),
            GSConv(c_, c2, 3, 1, act=False))
        self.shortcut = Conv(c1, c2, 3, 1, act=False)

    def forward(self, x):
        return self.conv_lighting(x) + self.shortcut(x)


class VoVGSCSP(nn.Module):
    # VoV-GSCSP https://github.com/AlanLi1997/slim-neck-by-gsconv
    def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5):
        super().__init__()
        c_ = int(c2 * e)
        self.cv1 = Conv(c1, c_, 1, 1)
        self.cv2 = Conv(2 * c_, c2, 1)
        self.m = nn.Sequential(*(GSBottleneck(c_, c_) for _ in range(n)))

    def forward(self, x):
        x1 = self.cv1(x)
        return self.cv2(torch.cat((self.m(x1), x1), dim=1))

其次在在YOLOv5/v7项目文件下的models/yolo.py中在文件首部添加代码

from models.slimneck import GSConv, VoVGSCSP

并搜索def parse_model(d, ch)

定位到如下行添加以下代码

GSConv, VoVGSCSP,

三、YOLOv7-tiny改进工作

完成二后，在YOLOv7项目文件下的models文件夹下创建新的文件yolov7-tiny-slimneck.yaml，导入如下代码。

# parameters
nc: 80  # number of classes
depth_multiple: 1.0  # model depth multiple
width_multiple: 1.0  # layer channel multiple

# anchors
anchors:
  - [10,13, 16,30, 33,23]  # P3/8
  - [30,61, 62,45, 59,119]  # P4/16
  - [116,90, 156,198, 373,326]  # P5/32

# yolov7-tiny backbone
backbone:
  # [from, number, module, args] c2, k=1, s=1, p=None, g=1, act=True
  [[-1, 1, Conv, [32, 3, 2, None, 1, nn.LeakyReLU(0.1)]],  # 0-P1/2  
  
   [-1, 1, Conv, [64, 3, 2, None, 1, nn.LeakyReLU(0.1)]],  # 1-P2/4    
   
   [-1, 1, Conv, [32, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-2, 1, Conv, [32, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-1, 1, Conv, [32, 3, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-1, 1, Conv, [32, 3, 1, None, 1, nn.LeakyReLU(0.1)]],
   [[-1, -2, -3, -4], 1, Concat, [1]],
   [-1, 1, Conv, [64, 1, 1, None, 1, nn.LeakyReLU(0.1)]],  # 7
   
   [-1, 1, MP, []],  # 8-P3/8
   [-1, 1, Conv, [64, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-2, 1, Conv, [64, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-1, 1, Conv, [64, 3, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-1, 1, Conv, [64, 3, 1, None, 1, nn.LeakyReLU(0.1)]],
   [[-1, -2, -3, -4], 1, Concat, [1]],
   [-1, 1, Conv, [128, 1, 1, None, 1, nn.LeakyReLU(0.1)]],  # 14
   
   [-1, 1, MP, []],  # 15-P4/16
   [-1, 1, Conv, [128, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-2, 1, Conv, [128, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-1, 1, Conv, [128, 3, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-1, 1, Conv, [128, 3, 1, None, 1, nn.LeakyReLU(0.1)]],
   [[-1, -2, -3, -4], 1, Concat, [1]],
   [-1, 1, Conv, [256, 1, 1, None, 1, nn.LeakyReLU(0.1)]],  # 21
   
   [-1, 1, MP, []],  # 22-P5/32
   [-1, 1, Conv, [256, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-2, 1, Conv, [256, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-1, 1, Conv, [256, 3, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-1, 1, Conv, [256, 3, 1, None, 1, nn.LeakyReLU(0.1)]],
   [[-1, -2, -3, -4], 1, Concat, [1]],
   [-1, 1, Conv, [512, 1, 1, None, 1, nn.LeakyReLU(0.1)]],  # 28
  ]

# yolov7-tiny head
head:
  [[-1, 1, Conv, [256, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-2, 1, Conv, [256, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-1, 1, SP, [5]],
   [-2, 1, SP, [9]],
   [-3, 1, SP, [13]],
   [[-1, -2, -3, -4], 1, Concat, [1]],
   [-1, 1, Conv, [256, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [[-1, -7], 1, Concat, [1]],
   [-1, 1, Conv, [256, 1, 1, None, 1, nn.LeakyReLU(0.1)]],  # 37
  
   [-1, 1, GSConv, [128, 1, 1]],
   [-1, 1, nn.Upsample, [None, 2, 'nearest']],
   [21, 1, GSConv, [128, 1, 1]], # route backbone P4
   [[-1, -2], 1, Concat, [1]],

   [-1, 1, VoVGSCSP, [128, 1, 1]],  # 42
  
   [-1, 1, GSConv, [64, 1, 1]],
   [-1, 1, nn.Upsample, [None, 2, 'nearest']],
   [14, 1, GSConv, [64, 1, 1]], # route backbone P3
   [[-1, -2], 1, Concat, [1]],

   [-1, 1, VoVGSCSP, [64, 1, 1]],  # 47
   
   [-1, 1, Conv, [128, 3, 2, None, 1, nn.LeakyReLU(0.1)]],
   [[-1, 42], 1, Concat, [1]],

   [-1, 1, VoVGSCSP, [128, 1, 1]],  # 50
   
   [-1, 1, Conv, [256, 3, 2, None, 1, nn.LeakyReLU(0.1)]],
   [[-1, 37], 1, Concat, [1]],

   [-1, 1, VoVGSCSP, [256, 1, 1]],  # 53
      
   [47, 1, Conv, [128, 3, 1, None, 1, nn.LeakyReLU(0.1)]],
   [50, 1, Conv, [256, 3, 1, None, 1, nn.LeakyReLU(0.1)]],
   [53, 1, Conv, [512, 3, 1, None, 1, nn.LeakyReLU(0.1)]],

   [[54, 55, 56], 1, IDetect, [nc, anchors]],   # Detect(P3, P4, P5)
  ]


                 from  n    params  module                                  arguments                     
  0                -1  1       928  models.common.Conv                      [3, 32, 3, 2, None, 1, LeakyReLU(negative_slope=0.1)]
  1                -1  1     18560  models.common.Conv                      [32, 64, 3, 2, None, 1, LeakyReLU(negative_slope=0.1)]
  2                -1  1      2112  models.common.Conv                      [64, 32, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
  3                -2  1      2112  models.common.Conv                      [64, 32, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
  4                -1  1      9280  models.common.Conv                      [32, 32, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
  5                -1  1      9280  models.common.Conv                      [32, 32, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
  6  [-1, -2, -3, -4]  1         0  models.common.Concat                    [1]                           
  7                -1  1      8320  models.common.Conv                      [128, 64, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
  8                -1  1         0  models.common.MP                        []                            
  9                -1  1      4224  models.common.Conv                      [64, 64, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 10                -2  1      4224  models.common.Conv                      [64, 64, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 11                -1  1     36992  models.common.Conv                      [64, 64, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 12                -1  1     36992  models.common.Conv                      [64, 64, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 13  [-1, -2, -3, -4]  1         0  models.common.Concat                    [1]                           
 14                -1  1     33024  models.common.Conv                      [256, 128, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 15                -1  1         0  models.common.MP                        []                            
 16                -1  1     16640  models.common.Conv                      [128, 128, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 17                -2  1     16640  models.common.Conv                      [128, 128, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 18                -1  1    147712  models.common.Conv                      [128, 128, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 19                -1  1    147712  models.common.Conv                      [128, 128, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 20  [-1, -2, -3, -4]  1         0  models.common.Concat                    [1]                           
 21                -1  1    131584  models.common.Conv                      [512, 256, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 22                -1  1         0  models.common.MP                        []                            
 23                -1  1     66048  models.common.Conv                      [256, 256, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 24                -2  1     66048  models.common.Conv                      [256, 256, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 25                -1  1    590336  models.common.Conv                      [256, 256, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 26                -1  1    590336  models.common.Conv                      [256, 256, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 27  [-1, -2, -3, -4]  1         0  models.common.Concat                    [1]                           
 28                -1  1    525312  models.common.Conv                      [1024, 512, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 29                -1  1    131584  models.common.Conv                      [512, 256, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 30                -2  1    131584  models.common.Conv                      [512, 256, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 31                -1  1         0  models.common.SP                        [5]                           
 32                -2  1         0  models.common.SP                        [9]                           
 33                -3  1         0  models.common.SP                        [13]                          
 34  [-1, -2, -3, -4]  1         0  models.common.Concat                    [1]                           
 35                -1  1    262656  models.common.Conv                      [1024, 256, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 36          [-1, -7]  1         0  models.common.Concat                    [1]                           
 37                -1  1    131584  models.common.Conv                      [512, 256, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 38                -1  1     18240  models.slimneck.GSConv                  [256, 128, 1, 1]              
 39                -1  1         0  torch.nn.modules.upsampling.Upsample    [None, 2, 'nearest']          
 40                21  1     18240  models.slimneck.GSConv                  [256, 128, 1, 1]              
 41          [-1, -2]  1         0  models.common.Concat                    [1]                           
 42                -1  1     93408  models.slimneck.VoVGSCSP                [256, 128, 1, 1]              
 43                -1  1      5024  models.slimneck.GSConv                  [128, 64, 1, 1]               
 44                -1  1         0  torch.nn.modules.upsampling.Upsample    [None, 2, 'nearest']          
 45                14  1      5024  models.slimneck.GSConv                  [128, 64, 1, 1]               
 46          [-1, -2]  1         0  models.common.Concat                    [1]                           
 47                -1  1     24176  models.slimneck.VoVGSCSP                [128, 64, 1, 1]               
 48                -1  1     73984  models.common.Conv                      [64, 128, 3, 2, None, 1, LeakyReLU(negative_slope=0.1)]
 49          [-1, 42]  1         0  models.common.Concat                    [1]                           
 50                -1  1     93408  models.slimneck.VoVGSCSP                [256, 128, 1, 1]              
 51                -1  1    295424  models.common.Conv                      [128, 256, 3, 2, None, 1, LeakyReLU(negative_slope=0.1)]
 52          [-1, 37]  1         0  models.common.Concat                    [1]                           
 53                -1  1    367040  models.slimneck.VoVGSCSP                [512, 256, 1, 1]              
 54                47  1     73984  models.common.Conv                      [64, 128, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 55                50  1    295424  models.common.Conv                      [128, 256, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 56                53  1   1180672  models.common.Conv                      [256, 512, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 57      [54, 55, 56]  1     17132  models.yolo.IDetect                     [1, [[10, 13, 16, 30, 33, 23], [30, 61, 62, 45, 59, 119], [116, 90, 156, 198, 373, 326]], [128, 256, 512]]

Model Summary: 411 layers, 5683004 parameters, 5683004 gradients, 12.2 GFLOPS

运行后若打印出如上文本代表改进成功。

四、YOLOv5s改进工作

完成二后，在YOLOv5项目文件下的models文件夹下创建新的文件yolov5s-slimneck.yaml，导入如下代码。

# Parameters
nc: 80  # number of classes
depth_multiple: 0.33  # model depth multiple
width_multiple: 0.50 # layer channel multiple
anchors:
  - [10,13, 16,30, 33,23]  # P3/8
  - [30,61, 62,45, 59,119]  # P4/16
  - [116,90, 156,198, 373,326]  # P5/32

# YOLOv5 v6.0 backbone
backbone:
  # [from, number, module, args]
  [[-1, 1, Conv, [64, 6, 2, 2]],  # 0-P1/2
   [-1, 1, Conv, [128, 3, 2]],  # 1-P2/4
   [-1, 3, C3, [128]],
   [-1, 1, Conv, [256, 3, 2]],  # 3-P3/8
   [-1, 6, C3, [256]],
   [-1, 1, Conv, [512, 3, 2]],  # 5-P4/16
   [-1, 9, C3, [512]],
   [-1, 1, Conv, [1024, 3, 2]],  # 7-P5/32
   [-1, 3, C3, [1024]],
   [-1, 1, SPPF, [1024, 5]],  # 9
  ]

# YOLOv5 v6.0 head
head:
  [[-1, 1, GSConv, [512, 1, 1]],
   [-1, 1, nn.Upsample, [None, 2, 'nearest']],
   [[-1, 6], 1, Concat, [1]],  # cat backbone P4
   [-1, 3, VoVGSCSP, [512]],  # 13

   [-1, 1, GSConv, [256, 1, 1]],
   [-1, 1, nn.Upsample, [None, 2, 'nearest']],
   [[-1, 4], 1, Concat, [1]],  # cat backbone P3
   [-1, 3, VoVGSCSP, [256]],  # 17 (P3/8-small)

   [-1, 1, GSConv, [256, 3, 2]],
   [[-1, 14], 1, Concat, [1]],  # cat head P4
   [-1, 3, VoVGSCSP, [512]],  # 20 (P4/16-medium)

   [-1, 1, GSConv, [512, 3, 2]],
   [[-1, 10], 1, Concat, [1]],  # cat head P5
   [-1, 3, VoVGSCSP, [1024]],  # 23 (P5/32-large)

   [[17, 20, 23], 1, Detect, [nc, anchors]],  # Detect(P3, P4, P5)
  ]


                 from  n    params  module                                  arguments                     
  0                -1  1      3520  models.common.Conv                      [3, 32, 6, 2, 2]              
  1                -1  1     18560  models.common.Conv                      [32, 64, 3, 2]                
  2                -1  1     18816  models.common.C3                        [64, 64, 1]                   
  3                -1  1     73984  models.common.Conv                      [64, 128, 3, 2]               
  4                -1  2    115712  models.common.C3                        [128, 128, 2]                 
  5                -1  1    295424  models.common.Conv                      [128, 256, 3, 2]              
  6                -1  3    625152  models.common.C3                        [256, 256, 3]                 
  7                -1  1   1180672  models.common.Conv                      [256, 512, 3, 2]              
  8                -1  1   1182720  models.common.C3                        [512, 512, 1]                 
  9                -1  1    656896  models.common.SPPF                      [512, 512, 5]                 
 10                -1  1     69248  models.slimneck.GSConv                  [512, 256, 1, 1]              
 11                -1  1         0  torch.nn.modules.upsampling.Upsample    [None, 2, 'nearest']          
 12           [-1, 6]  1         0  models.common.Concat                    [1]                           
 13                -1  1    367040  models.slimneck.VoVGSCSP                [512, 256]                    
 14                -1  1     18240  models.slimneck.GSConv                  [256, 128, 1, 1]              
 15                -1  1         0  torch.nn.modules.upsampling.Upsample    [None, 2, 'nearest']          
 16           [-1, 4]  1         0  models.common.Concat                    [1]                           
 17                -1  1     93408  models.slimneck.VoVGSCSP                [256, 128]                    
 18                -1  1     75584  models.slimneck.GSConv                  [128, 128, 3, 2]              
 19          [-1, 14]  1         0  models.common.Concat                    [1]                           
 20                -1  1    334272  models.slimneck.VoVGSCSP                [256, 256]                    
 21                -1  1    298624  models.slimneck.GSConv                  [256, 256, 3, 2]              
 22          [-1, 10]  1         0  models.common.Concat                    [1]                           
 23                -1  1   1323904  models.slimneck.VoVGSCSP                [512, 512]                    
 24      [17, 20, 23]  1     16182  models.yolo.Detect                      [1, [[10, 13, 16, 30, 33, 23], [30, 61, 62, 45, 59, 119], [116, 90, 156, 198, 373, 326]], [128, 256, 512]]

Model Summary: 410 layers, 6767958 parameters, 6767958 gradients, 14.7 GFLOPs

运行后若打印出如上文本代表改进成功。

五、YOLOv5n改进工作

完成二后，在YOLOv5项目文件下的models文件夹下创建新的文件yolov5n-slimneck.yaml，导入如下代码。

# Parameters
nc: 80  # number of classes
depth_multiple: 0.33  # model depth multiple
width_multiple: 0.25 # layer channel multiple
anchors:
  - [10,13, 16,30, 33,23]  # P3/8
  - [30,61, 62,45, 59,119]  # P4/16
  - [116,90, 156,198, 373,326]  # P5/32

# YOLOv5 v6.0 backbone
backbone:
  # [from, number, module, args]
  [[-1, 1, Conv, [64, 6, 2, 2]],  # 0-P1/2
   [-1, 1, Conv, [128, 3, 2]],  # 1-P2/4
   [-1, 3, C3, [128]],
   [-1, 1, Conv, [256, 3, 2]],  # 3-P3/8
   [-1, 6, C3, [256]],
   [-1, 1, Conv, [512, 3, 2]],  # 5-P4/16
   [-1, 9, C3, [512]],
   [-1, 1, Conv, [1024, 3, 2]],  # 7-P5/32
   [-1, 3, C3, [1024]],
   [-1, 1, SPPF, [1024, 5]],  # 9
  ]

# YOLOv5 v6.0 head
head:
  [[-1, 1, GSConv, [512, 1, 1]],
   [-1, 1, nn.Upsample, [None, 2, 'nearest']],
   [[-1, 6], 1, Concat, [1]],  # cat backbone P4
   [-1, 3, VoVGSCSP, [512]],  # 13

   [-1, 1, GSConv, [256, 1, 1]],
   [-1, 1, nn.Upsample, [None, 2, 'nearest']],
   [[-1, 4], 1, Concat, [1]],  # cat backbone P3
   [-1, 3, VoVGSCSP, [256]],  # 17 (P3/8-small)

   [-1, 1, GSConv, [256, 3, 2]],
   [[-1, 14], 1, Concat, [1]],  # cat head P4
   [-1, 3, VoVGSCSP, [512]],  # 20 (P4/16-medium)

   [-1, 1, GSConv, [512, 3, 2]],
   [[-1, 10], 1, Concat, [1]],  # cat head P5
   [-1, 3, VoVGSCSP, [1024]],  # 23 (P5/32-large)

   [[17, 20, 23], 1, Detect, [nc, anchors]],  # Detect(P3, P4, P5)
  ]


                 from  n    params  module                                  arguments                     
  0                -1  1      1760  models.common.Conv                      [3, 16, 6, 2, 2]              
  1                -1  1      4672  models.common.Conv                      [16, 32, 3, 2]                
  2                -1  1      4800  models.common.C3                        [32, 32, 1]                   
  3                -1  1     18560  models.common.Conv                      [32, 64, 3, 2]                
  4                -1  2     29184  models.common.C3                        [64, 64, 2]                   
  5                -1  1     73984  models.common.Conv                      [64, 128, 3, 2]               
  6                -1  3    156928  models.common.C3                        [128, 128, 3]                 
  7                -1  1    295424  models.common.Conv                      [128, 256, 3, 2]              
  8                -1  1    296448  models.common.C3                        [256, 256, 1]                 
  9                -1  1    164608  models.common.SPPF                      [256, 256, 5]                 
 10                -1  1     18240  models.slimneck.GSConv                  [256, 128, 1, 1]              
 11                -1  1         0  torch.nn.modules.upsampling.Upsample    [None, 2, 'nearest']          
 12           [-1, 6]  1         0  models.common.Concat                    [1]                           
 13                -1  1     93408  models.slimneck.VoVGSCSP                [256, 128]                    
 14                -1  1      5024  models.slimneck.GSConv                  [128, 64, 1, 1]               
 15                -1  1         0  torch.nn.modules.upsampling.Upsample    [None, 2, 'nearest']          
 16           [-1, 4]  1         0  models.common.Concat                    [1]                           
 17                -1  1     24176  models.slimneck.VoVGSCSP                [128, 64]                     
 18                -1  1     19360  models.slimneck.GSConv                  [64, 64, 3, 2]                
 19          [-1, 14]  1         0  models.common.Concat                    [1]                           
 20                -1  1     85216  models.slimneck.VoVGSCSP                [128, 128]                    
 21                -1  1     75584  models.slimneck.GSConv                  [128, 128, 3, 2]              
 22          [-1, 10]  1         0  models.common.Concat                    [1]                           
 23                -1  1    334272  models.slimneck.VoVGSCSP                [256, 256]                    
 24      [17, 20, 23]  1      8118  models.yolo.Detect                      [1, [[10, 13, 16, 30, 33, 23], [30, 61, 62, 45, 59, 119], [116, 90, 156, 198, 373, 326]], [64, 128, 256]]

Model Summary: 410 layers, 1709766 parameters, 1709766 gradients, 3.9 GFLOPs

运行后打印如上代码说明改进成功。

更多文章产出中，主打简洁和准确，欢迎关注我，共同探讨！

拿下Nahida
关注
  • 35
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
YOLOv7 | 添加GSConv，VoVGSCSP等多种卷积，有效提升目标检测效果，代码改进（超详细）
kay_545
03-16 3075
本实验引入了一种新的轻量级卷积方法 GSConv，使深度可分离卷积达到接近普通卷积的效果并且更加高效。设计了一次性聚合模块 VoV-GSCSP 来代替普通的瓶颈模块以加速推理。此外，我们还提供轻量化的细颈设计范例。在我们的实验中，与其他轻量级卷积方法相比，GSConv 显示出更好的性能。​。
改进YOLOv5/v7 | GSConv+Slim-neck 减轻模型的复杂度同时提升精度 | 附改进方式模板
YOLOv8项目贡献者
10-16 2万+
GSConv+Slim-Neck助力YOLOv5涨点
目标检测算法——YOLOv5/YOLOv7改进之GSConv+Slim Neck（优化成本）
加勒比海带66——【YOLO魔法搭配&论文投稿咨询】
10-27 1万+
目标检测算法——YOLOv5/YOLOv7改进之GSConv+Slim Neck，作者提出了一种新方法GSConv来减轻模型的复杂度并保持准确性。GSConv可以更好地平衡模型的准确性和速度。并且，提供了一种设计范式Slim Neck，以实现检测器更高的计算成本效益。实验过程中，与原始网络相比，改进方法获得了最优秀的检测结果。
YOLOv10全网最新创新点改进系列：融合GSConv+Slim Neck，双改进、双增强，替换特征融合层实现， 轻量化涨点改进策略，有效涨点神器！
weixin_51692073的博客
07-04 675
YOLOv10全网最新创新点改进系列：融合GSConv+Slim Neck，双改进、双增强，替换特征融合层实现， 轻量化涨点改进策略，有效涨点神器！
改进Yolov5 | 用 GSConv+Slim Neck 一步步把 Yolov5 提升到极致！！！
weixin_40920183的博客
06-23 2540
目标检测是计算机视觉中一项艰巨的下游任务。对于车载边缘计算平台，大模型很难达到实时检测的要求。而且，由大量深度可分离卷积层构建的轻量级模型无法达到足够的准确性。因此本文引入了一种新方法 GSConv 来减轻模型的复杂度并保持准确性。GSConv 可以更好地平衡模型的准确性和速度。并且，提供了一种设计范式，Slim-Neck，以实现检测器更高的计算成本效益。在实验中，与原始...
改进YOLOv5！GSConv+Slim Neck进一步提升YOLOv5性能！
阿木寺的博客
06-26 6470
点击下方卡片，关注“CVer”公众号AI/CV重磅干货，第一时间送达点击进入—>CV微信技术交流群转载自：集智书童Slim-neck by GSConv: A better design paradigm of detector architectures for autonomous vehicles论文：https://arxiv.org/abs/2206....
YOLOv5/v7/v8 的改进点合集导航页
YOLOv8项目贡献者
05-17 3万+
🚀🚀🚀YOLOv5/v7/v8 的改进点合集导航页🚀🚀🚀
手把手带你 YOLOv5/v7 添加注意力机制（并附上30多种顶会Attention原理图）2024/2/5更新
热门推荐
YOLOv8项目贡献者
04-27 17万+
YOLOv5/v7 添加注意力机制教程 2023/6/15更新🍀🍀🍀
GSconv和VoVGSCSP代码，用于嵌入改进yolov5/7/8
04-06
原论文https://arxiv.org/abs/2206.02424 基于论文复现GSconv和VoVGSCSP模块 可以即插即用改进yolov5/7/8 对小目标检测有明显涨点效果
基于YOLOv5模型改进
02-05
本项目聚焦于对YOLOv5模型的改进，以提高其性能和适应性。 一、YOLOv5基本结构 YOLOv5的核心设计理念是端到端的实时目标检测，它采用了单阶段检测方法，直接从输入图像中预测边界框和类别概率。YOLOv5模型由四个...
yolov5的各种改进尝试.zip
01-06
在"yolov5的各种改进尝试.zip"中，我们可以看到作者或研究者对YOLOv5模型进行了一系列的优化和改进尝试，以提高其性能和效率。 首先，我们来看看YOLOv5的基本结构。YOLOv5沿袭了YOLO系列的核心思想——一次预测，它...
yolov5+改进策略+案例分析+资源合集
05-30
Neck网络：目标检测网络在BackBone与最后的Head输出层之间往往会插入一些层，Yolov5中添加了FPN+PAN结构； Head输出层：输出层的锚框机制与YOLOv4相同，主要改进的是训练时的损失函数GIOU_Loss，以及预测框筛选的...
基于python与yolov5的车牌识别检测设计与实现
04-29
YOLOv5是YOLO系列的最新版本，改进了前几代的网络结构，提高了检测精度和速度。YOLOv5使用PyTorch框架构建，包含四个主要部分：输入层、Backbone（特征提取网络）、 Neck（特征融合结构）和Head（检测头）。在车牌...
【YOLOv10改进[Conv]】KAN系列 |使用KAGNConv改进C2f + 含全部代码和详细修改方式 + 手撕结构图
静谧、淡雅
07-19 37
【YOLOv10改进[Conv]】KAN系列 |使用KAGNConv改进C2f + 含全部代码和详细修改方式 + 手撕结构图
【yolov8】3、yolov8 环境安装 【GPU版】
最新发布
ladymorgana的博客
07-19 417
1、要求 1.1 什么是 CUDA 和 CUDNN 1.2 查看cuda版本的3种方法（`版本在10.2以上的可以忽略本章节`）： 1.3 没有找到NIVDIA图标，确认是否有英伟达显卡 2、pycharm下载安装 进入官网 3、yolov8 环境安装 【GPU版】 3.1 Yolov8 源码下载： Stage 1 ：解压后用pycharm打开 Stage 2 ：配置 python 解释器(anaconda) Stage 3 ：安装Yolov8的依赖环境 Stage 3-1 ：把 `requirements
YOLOV3翻译
smilejfy的博客
07-15 536
我们对 YOLO 进行了一些更新！我们在设计上做了一些小改动，使它变得更好。我们还训练了一个新的网络，它非常强大。在模型上，它比上次的大了一点，但更准确了，不过速度还是很快，不用担心。在 320×320 时，YOLOv3 以 28.2 mAP 在 22 毫秒内运行，与 SSD 一样精确，但速度快三倍。当我们使用旧的 0.5 IOU mAP 检测指标时，YOLOv3 的表现相当不错。
YOLOv8改进 | 检测头 | 融合渐进特征金字塔的检测头【AFPN3】
kay_545
07-15 840
yolov8改进，yolov8，AFPN检测头
yolov5/v7 引入 最新 bifusion neck | 附详细结构图
11-17
Yolov5/v7是一种目标检测模型，最新引入了bifusion neck结构。bifusion neck结构是一种用于提高目标检测性能的网络结构，它通过融合不同层级的特征图来实现更准确的目标检测和定位。具体来说，bifusion neck结构包括了两个重要部分：特征融合模块和多尺度特征融合模块。特征融合模块通过特征金字塔网络将不同层级的特征图进行融合，从而提高了模型对目标的检测能力。而多尺度特征融合模块则通过不同尺度上的特征图进行融合，使得模型可以更好地适应不同大小和比例的目标检测。 这个bifusion neck结构的引入使得Yolov5/v7模型在目标检测任务中取得了更好的性能表现，具有更高的检测精度和定位准确度。此外，该结构还在各种复杂场景下都表现出色，包括遮挡、光照不均等情况下的目标检测。总的来说，bifusion neck结构的引入极大地提升了Yolov5/v7模型的性能，使其成为当前目标检测领域的一款重要的模型。 下面是bifusion neck结构的详细结构图，能够更直观地展示这个网络结构的设计和实现方式。结合图中的详细说明，可以更好地理解bifusion neck结构在Yolov5/v7模型中的应用和作用。 （以下为详细结构图）

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值