【YOLOv5/v7改进系列】改进池化层为SimSPPF

最新推荐文章于 2024-09-03 20:48:36 发布
最新推荐文章于 2024-09-03 20:48:36 发布
阅读量1.4k 收藏 13
点赞数 41
分类专栏： YOLO改进指南 文章标签： 目标检测 YOLO 人工智能 深度学习 计算机视觉 dnn
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84870184/article/details/140375859
版权
一、导言

SimSPPF（Simplified Spatial Pyramid Pooling with Fixed-size kernel）模块是在YOLOv6架构中引入的一个关键组件，它旨在优化原始SPPF（Spatial Pyramid Pooling Fixed-size）模块的效率。以下是SimSPPF的一些优点和可能存在的缺点：

优点:

  1. 效率提升: SimSPPF通过简化原有的SPPF结构，使用固定大小的池化核（通常是5x5），从而显著减少了计算量和内存消耗，这使得模型在推断阶段运行得更快。

  2. 感受野扩大: 尽管使用了较小的池化核，SimSPPF仍然能够有效地捕获多尺度特征，因为其设计允许在网络中整合不同层级的信息，这对于物体检测任务来说非常重要。

  3. 易于实现: 由于其设计上的简化，SimSPPF比原始的SPPF更容易在不同的硬件平台上实现和优化。

  4. 适应性: 在YOLOv6的不同变体中（如YOLOv6-N/S/M），SimSPPF可以根据模型的大小和特定需求进行调整，例如在较小的模型中使用SimCSPSPPF以进一步加速，而在较大的模型中使用SimSPPF以保持良好的精度。

缺点:

  1. 可能的信息损失: 通过使用固定大小的池化核，SimSPPF可能会牺牲一些大尺度的特征信息，这是由于较大尺寸的池化核能够捕捉到更大范围内的上下文信息。

  2. 精度折衷: 虽然效率提高了，但这种简化可能会影响模型在某些场景下的检测精度，特别是对于那些需要非常精细的多尺度分析的情况。

  3. 灵活性降低: 固定大小的池化核限制了SimSPPF的灵活性，因为它不能像可变大小的SPPF那样自适应地调整其感受野的大小。

  4. 泛化能力: 理论上讲，固定的池化核可能会限制模型处理各种尺度输入的能力，尽管实践中这种影响可能被其他网络组件所弥补。

总体而言，SimSPPF模块是YOLOv6设计中为了平衡速度和精度而做出的一种选择，它通过牺牲一定的复杂性和理论上的精度，换取了实际应用中的高效率和快速响应。

二、准备工作

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

import warnings

from models.common import *
# simsppf
# yolov6
class SimConv(nn.Module):
    '''Normal Conv with ReLU activation'''
    def __init__(self, in_channels, out_channels, kernel_size, stride, groups=1, bias=False):
        super().__init__()
        padding = kernel_size // 2
        self.conv = nn.Conv2d(
            in_channels,
            out_channels,
            kernel_size=kernel_size,
            stride=stride,
            padding=padding,
            groups=groups,
            bias=bias,
        )
        self.bn = nn.BatchNorm2d(out_channels)
        self.act = nn.ReLU()

    def forward(self, x):
        return self.act(self.bn(self.conv(x)))

    def forward_fuse(self, x):
        return self.act(self.conv(x))

class SimSPPF(nn.Module):
    '''Simplified SPPF with ReLU activation'''
    def __init__(self, in_channels, out_channels, kernel_size=5):
        super().__init__()
        c_ = in_channels // 2  # hidden channels
        self.cv1 = SimConv(in_channels, c_, 1, 1)
        self.cv2 = SimConv(c_ * 4, out_channels, 1, 1)
        self.m = nn.MaxPool2d(kernel_size=kernel_size, stride=1, padding=kernel_size // 2)

    def forward(self, x):
        x = self.cv1(x)
        with warnings.catch_warnings():
            warnings.simplefilter('ignore')
            y1 = self.m(x)
            y2 = self.m(y1)
            return self.cv2(torch.cat([x, y1, y2, self.m(y2)], 1))

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

from models.morepooling import *

并搜索def parse_model(d, ch)

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

SimSPPF,

三、YOLOv7-tiny改进工作

完成二后，在YOLOv7项目文件下的models文件夹下创建新的文件yolov7-tiny-simsppf.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, SimSPPF, [256]], # 29
  
   [-1, 1, Conv, [128, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-1, 1, nn.Upsample, [None, 2, 'nearest']],
   [21, 1, Conv, [128, 1, 1, None, 1, nn.LeakyReLU(0.1)]], # route backbone P4
   [[-1, -2], 1, Concat, [1]],
   
   [-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)]],  # 39
  
   [-1, 1, Conv, [64, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-1, 1, nn.Upsample, [None, 2, 'nearest']],
   [14, 1, Conv, [64, 1, 1, None, 1, nn.LeakyReLU(0.1)]], # route backbone P3
   [[-1, -2], 1, Concat, [1]],
   
   [-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)]],  # 49
   
   [-1, 1, Conv, [128, 3, 2, None, 1, nn.LeakyReLU(0.1)]],
   [[-1, 39], 1, Concat, [1]],
   
   [-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)]],  # 57
   
   [-1, 1, Conv, [256, 3, 2, None, 1, nn.LeakyReLU(0.1)]],
   [[-1, 29], 1, Concat, [1]],
   
   [-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)]],  # 65
      
   [49, 1, Conv, [128, 3, 1, None, 1, nn.LeakyReLU(0.1)]],
   [57, 1, Conv, [256, 3, 1, None, 1, nn.LeakyReLU(0.1)]],
   [65, 1, Conv, [512, 3, 1, None, 1, nn.LeakyReLU(0.1)]],

   [[66, 67, 68], 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    394240  models.morepooling.SimSPPF              [512, 256]                    
 30                -1  1     33024  models.common.Conv                      [256, 128, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 31                -1  1         0  torch.nn.modules.upsampling.Upsample    [None, 2, 'nearest']          
 32                21  1     33024  models.common.Conv                      [256, 128, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 33          [-1, -2]  1         0  models.common.Concat                    [1]                           
 34                -1  1     16512  models.common.Conv                      [256, 64, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 35                -2  1     16512  models.common.Conv                      [256, 64, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 36                -1  1     36992  models.common.Conv                      [64, 64, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 37                -1  1     36992  models.common.Conv                      [64, 64, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 38  [-1, -2, -3, -4]  1         0  models.common.Concat                    [1]                           
 39                -1  1     33024  models.common.Conv                      [256, 128, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 40                -1  1      8320  models.common.Conv                      [128, 64, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 41                -1  1         0  torch.nn.modules.upsampling.Upsample    [None, 2, 'nearest']          
 42                14  1      8320  models.common.Conv                      [128, 64, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 43          [-1, -2]  1         0  models.common.Concat                    [1]                           
 44                -1  1      4160  models.common.Conv                      [128, 32, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 45                -2  1      4160  models.common.Conv                      [128, 32, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 46                -1  1      9280  models.common.Conv                      [32, 32, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 47                -1  1      9280  models.common.Conv                      [32, 32, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 48  [-1, -2, -3, -4]  1         0  models.common.Concat                    [1]                           
 49                -1  1      8320  models.common.Conv                      [128, 64, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 50                -1  1     73984  models.common.Conv                      [64, 128, 3, 2, None, 1, LeakyReLU(negative_slope=0.1)]
 51          [-1, 39]  1         0  models.common.Concat                    [1]                           
 52                -1  1     16512  models.common.Conv                      [256, 64, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 53                -2  1     16512  models.common.Conv                      [256, 64, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 54                -1  1     36992  models.common.Conv                      [64, 64, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 55                -1  1     36992  models.common.Conv                      [64, 64, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 56  [-1, -2, -3, -4]  1         0  models.common.Concat                    [1]                           
 57                -1  1     33024  models.common.Conv                      [256, 128, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 58                -1  1    295424  models.common.Conv                      [128, 256, 3, 2, None, 1, LeakyReLU(negative_slope=0.1)]
 59          [-1, 29]  1         0  models.common.Concat                    [1]                           
 60                -1  1     65792  models.common.Conv                      [512, 128, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 61                -2  1     65792  models.common.Conv                      [512, 128, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 62                -1  1    147712  models.common.Conv                      [128, 128, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 63                -1  1    147712  models.common.Conv                      [128, 128, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 64  [-1, -2, -3, -4]  1         0  models.common.Concat                    [1]                           
 65                -1  1    131584  models.common.Conv                      [512, 256, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 66                49  1     73984  models.common.Conv                      [64, 128, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 67                57  1    295424  models.common.Conv                      [128, 256, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 68                65  1   1180672  models.common.Conv                      [256, 512, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 69      [66, 67, 68]  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: 249 layers, 5751820 parameters, 5751820 gradients, 13.0 GFLOPS

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

四、YOLOv5s改进工作

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

# Parameters
nc: 1  # 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, SimSPPF, [1024]],
  ]

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

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

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

   [-1, 1, Conv, [512, 3, 2]],
   [[-1, 10], 1, Concat, [1]],  # cat head P5
   [-1, 3, C3, [1024, False]],  # 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.morepooling.SimSPPF              [512, 512, 5]                 
 10                -1  1    131584  models.common.Conv                      [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    361984  models.common.C3                        [512, 256, 1, False]          
 14                -1  1     33024  models.common.Conv                      [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     90880  models.common.C3                        [256, 128, 1, False]          
 18                -1  1    147712  models.common.Conv                      [128, 128, 3, 2]              
 19          [-1, 14]  1         0  models.common.Concat                    [1]                           
 20                -1  1    296448  models.common.C3                        [256, 256, 1, False]          
 21                -1  1    590336  models.common.Conv                      [256, 256, 3, 2]              
 22          [-1, 10]  1         0  models.common.Concat                    [1]                           
 23                -1  1   1182720  models.common.C3                        [512, 512, 1, False]          
 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: 270 layers, 7022326 parameters, 7022326 gradients, 15.9 GFLOPs
五、YOLOv5n改进工作

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

# Parameters
nc: 1  # 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, SimSPPF, [1024]],
  ]

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

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

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

   [-1, 1, Conv, [512, 3, 2]],
   [[-1, 10], 1, Concat, [1]],  # cat head P5
   [-1, 3, C3, [1024, False]],  # 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.morepooling.SimSPPF              [256, 256, 5]                 
 10                -1  1     33024  models.common.Conv                      [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     90880  models.common.C3                        [256, 128, 1, False]          
 14                -1  1      8320  models.common.Conv                      [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     22912  models.common.C3                        [128, 64, 1, False]           
 18                -1  1     36992  models.common.Conv                      [64, 64, 3, 2]                
 19          [-1, 14]  1         0  models.common.Concat                    [1]                           
 20                -1  1     74496  models.common.C3                        [128, 128, 1, False]          
 21                -1  1    147712  models.common.Conv                      [128, 128, 3, 2]              
 22          [-1, 10]  1         0  models.common.Concat                    [1]                           
 23                -1  1    296448  models.common.C3                        [256, 256, 1, False]          
 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: 270 layers, 1765270 parameters, 1765270 gradients, 4.2 GFLOPs
六、代码解释

simsppf又称为“简单的”sppf.

定义了两个深度学习模块：SimConv 和 SimSPPF。它们是YOLOv6检测模型中的一部分，旨在简化网络结构和提高效率。

SimConv

这是一个简化版的卷积块，它包含一个卷积层、批量归一化（Batch Normalization）和ReLU激活函数。相比于标准的卷积块，这里没有使用更复杂的激活函数如SiLU或Leaky ReLU，而是选择了计算成本较低的ReLU。

优点:

  • 简单性: 使用ReLU减少了计算复杂度，加速训练过程。
  • 可融合性: 提供了forward_fuse方法，允许在网络优化过程中融合BN和卷积操作，进一步加速推理速度。

缺点:

  • 表达能力: 相比于更复杂的激活函数，ReLU可能在某些任务上限制了网络的表达能力。
  • 梯度消失问题: 虽然ReLU解决了传统sigmoid和tanh函数的梯度消失问题，但在输入为负数时其梯度为零，这仍然可能导致部分神经元“死亡”。
SimSPPF

这是对空间金字塔池化（Spatial Pyramid Pooling, SPP）模块的简化版本，通常用于增强特征的尺度不变性。这个模块使用多个最大池化层来捕获不同尺度的信息，并通过1x1卷积进行通道数调整。

优点:

  • 尺度不变性: 多尺度的最大池化有助于模型捕捉到不同大小的目标信息。
  • 参数效率: 使用了较少的参数量，同时保持了SPP模块的大部分功能。
  • 灵活性: 可以通过改变kernel_size参数来适应不同的输入尺寸或特征图需求。

缺点:

  • 计算资源: 尽管进行了简化，SPPF仍然涉及多次最大池化操作，这可能会增加计算负担，尤其是在高分辨率图像上。
  • 信息损失: 最大池化操作可能会导致一些空间细节的丢失，这可能会影响最终的检测精度。

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

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

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

拿下Nahida
关注
专栏目录
yolo：空间金字塔simsppf和sppf的区别
qq_41413211的博客
04-27 1245
差别在卷积层中的激活函数，sppf是silu， simsppf是relu，单个模块提速了18%yolov5的sppf。
YOLOv5算法进阶改进（7）— 将主干网络SPPF更换为SimSPPF / SPP-CSPC / SPPF-CSPC
突然好想你
12-02 2118
本节课就教大家如何将主干网络中的SPPF更换为SimSPPF / SPP-CSPC / SPPF-CSPC，希望大家学习之后能够有所收获！~🌈
【YOLOv7改进系列】简化YOLOv7-tiny池化层，便于引入改进的池化层
2401_84870184的博客
06-08 1266
相比YOLOv5/v7，除了YOLOv5n外，YOLOv7tiny的参数量较小，效果往往也相较YOLOv5n高上不少，又近来博主打算改进yolov7-tiny文件，但苦于其池化层部位是直接写在yaml中的，修改极为不便，因此对池化层做简化处理。本次修改的目标是将yaml中池化层的代码修改为单层代码形式来代表，便于以后做替换、改进工作，因此，需要保证改进前后的参数量、GFLOPS相同。此外，可能有小伙伴会疑问，为何博主不推荐把所有部位都简化？这是因为某些修改常常会修改于1x1的卷积，而不修改3x3的卷积。
SPP/SPPF/Focal Module
最新发布
NewBaiChen的博客
09-03 934
这意味着输入的特征图的尺寸必须是固定的，以确保展平后的向量长度是确定的。具体来说，SPP 模块在特征图上应用多个不同大小的池化窗口（例如 1×1、2×2、4×4），将这些池化操作的结果拼接在一起，从而获得一个固定长度的特征向量。因此，全连接层对输入的尺寸有严格要求。· 第一个全连接层的输入维度必须与前一层展平后的特征向量的长度一致，这就要求前面的卷积和池化层的输出特征图尺寸必须经过计算或预定义，以确保能够正确展平。不同尺度的池化操作捕捉了特征图中的不同层次的空间信息，从而保留了图像的局部和全局特征。
yolov6中的SimSPPF
猫猫与橙子的博客
07-12 3512
空间金字塔池化SPP，SPPF和SimSPPF
【YOLOv5/v7改进系列】改进池化层为SPP、SPPF、SPPCSPC
2401_84870184的博客
06-08 2142
池化层（Pooling Layer）是卷积神经网络（Convolutional Neural Networks, CNNs）中的一个重要组成部分，主要用于减少输入数据的空间尺寸（例如，图像的宽度和高度），同时保持其最重要的信息。这一过程称为下采样（downsampling）或者降维。池化操作通过提取特征图（feature maps）的摘要信息来实现，这些摘要信息通常是原特征的统计量，如最大值、平均值或其他聚合方式的结果。
特征融合篇 | YOLOv8改进之将主干网络SPPF更换为SimSPPF / SPP-CSPC / SPPF-CSPC
突然好想你
03-23 632
SimSPPF是YOLOv6中提出的一种改进的空间金字塔池化方法，它是SPPF的升级版。SimSPPF通过在不同尺度上使用不同大小的池化核来提取特征，从而提高了检测器的性能。本节课就教大家如何将主干网络中的SPPF更换为SimSPPF / SPP-CSPC / SPPF-CSPC，希望大家学习之后能够有所收获！~🌈
YOLOv5、YOLOv8改进：空间金字塔池化 SPPF改为 SimSPPF / ASPP / RFB / SPPCSPC / SPPFCSPC
weixin_45303602的博客
09-23 9375
空间金字塔池化（Spatial Pyramid Pooling，SPP）是一种用于解决输入尺寸不同的图像在深度学习中常见的问题的技术。它通过将不同尺寸的感受野划分成不同的层级，并对每个层级内的特征进行池化操作，从而能够对任意大小的输入图像进行固定长度的特征表示。
手把手带你 YOLOv5/v7 添加注意力机制（并附上30多种顶会Attention原理图）2024/2/5更新
热门推荐
YOLOv8项目贡献者
04-27 18万+
YOLOv5/v7 添加注意力机制教程 2023/6/15更新🍀🍀🍀
《YOLOv5/v7改进实战专栏》专栏介绍 & 专栏目录 《提供 YOLOv5-Magic 私域代码框架》
YOLOv8项目贡献者
05-19 2万+
全网最经典的教程🚀🚀🚀
改进YOLOv5/v7 | 用于低分辨率图像和小物体的新 CNN 模块SPD-Conv
YOLOv8项目贡献者
08-18 2万+
用于低分辨率图像和小物体的新 CNN 模块SPD-Conv
空间金字塔池化改进 SPP / SPPF / SimSPPF / ASPP / RFB / SPPCSPC / SPPFCSPC / SPPELAN
YOLOv8项目贡献者
08-15 12万+
汇总一些SPP结构
改进YOLOv5/v7 | GSConv+Slim-neck 减轻模型的复杂度同时提升精度 | 附改进方式模板
YOLOv8项目贡献者
10-16 2万+
GSConv+Slim-Neck助力YOLOv5涨点
YOLOv7代码修改
Ggggm_28的博客
02-27 292
YOLOv7修改代码报错
YOLOv5改进实战 | 空间金字塔池化改进（一）之SimSPPF篇
w94ghz的博客
10-11 1289
SPP、SPPF 、 SimSPPF 、 ASPP、 SPPCSPC详解
@bangbang的博客
07-18 1万+
模块是在《ECCV2018:Receptive Field Block Net for Accurate and Fast Object Detection》一文中提出的，该文的出发点是模拟人类视觉的感受野从而加强网络的特征提取能力，在结构。为每个采样率提取的特征在单独的分支中进一步处理，并融合以生成最终的结果。这个是Yolov5作者基于SPP提出的，速度较SPP快很多（2.5倍），所以叫做。ASPP 是在DeepLab中提出来的，在后续的。层，加入深度可分离卷积等，但基本的思路还是没变。
改进YOLOv7算法蝴蝶识别检测源码教程
实力派，无需多言！
11-01 577
并在 V100 上，30 FPS 的情况下达到实时目标检测器的最高精度 56.8% AP。YOLOv7 是在 MS COCO 数据集上从头开始训练的，不使用任何其他数据集或预训练权重。
YOLOv7改进主干结构系列：结合丰富的梯度流信息模块，来自YOLOv8的核心模块
包括YOLOv5、YOLOv7、YOLOv8等模型改进
01-15 7070
结合丰富的梯度流信息C2f模块，打造新的检测器
YOLOv8修改特征金字塔（替换SPPF模块）
qq_43471945的博客
10-30 4197
修改特征金字塔模块，即SPPF模块是YOLOv8改进中非常常见的一个改进点。 以下将介绍如何在yolov8中修改SPPF模型。
yolov5/v7/v8 改进首发最新pwconv核心结构
05-01
YOLOV5/V7/V8是一种常用的目标检测算法，由于其高效的运行速度和准确率而备受关注。最近，该算法的开发者进行了改进并首发了最新的PWConv核心结构。PWConv是Pointwise Convolutional的缩写，又称为1x1卷积层，它能够将通道维度降至最低，从而减少模型的计算量。 在改进的YOLOV5/V7/V8算法中，PWConv核心结构被应用于卷积层中。这种卷积层可以使用通道数较少的1x1卷积操作来减少计算量，同时能够更好地保留信息。这是因为，在卷积中使用更少的通道数会降低信息的丢失率，从而提高模型的准确率。 此外，改进的算法还应用了一种自适应L2正则化方法，该方法可以自动地调整正则化强度，从而使得模型更加稳定和鲁棒。 综上所述，改进的YOLOV5/V7/V8算法通过应用PWConv核心结构和自适应L2正则化方法，可以在减少计算量的同时提高模型的准确率。这对于需要高效、准确检测目标的实际应用场景非常有价值，例如自动驾驶和智能监控等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值