【YOLOv5/v7改进系列】替换骨干网络为ShuffleNetv2

最新推荐文章于 2024-05-25 18:24:07 发布
最新推荐文章于 2024-05-25 18:24:07 发布
阅读量557 收藏 20
点赞数 32
分类专栏： YOLO改进指南 文章标签： YOLO 目标检测 计算机视觉 人工智能 机器学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84870184/article/details/138824684
版权

一、导言

《ShuffleNet V2: Practical Guidelines for Efficient CNN Architecture Design》提出了一种新的卷积神经网络（CNN）架构设计方法，并给出了一系列实用的设计指南，旨在提高模型在实际应用中的效率。其优点主要体现在以下几个方面：

  1. 直接性能指标评估：传统的CNN设计往往侧重于计算复杂度（如FLOPs）这一间接指标，而该研究主张在目标平台上直接评估模型的速度等直接性能指标。这考虑到了内存访问成本和平台特性等其他因素，从而提供了更贴近实际应用场景的性能评估方式。

  2. 实用性设计原则：通过一系列控制实验，文章得出了几条高效网络设计的实用原则，比如平衡卷积、注意分组卷积的成本、减少网络碎片化以及限制逐元素运算等，这些原则对实际设计轻量化、高效率网络具有重要指导意义。

  3. ShuffleNet V2架构：基于上述设计原则，论文介绍了一个新架构——ShuffleNet V2，该架构不仅优化了特征重用模式，类似于DenseNet在保持高精度的同时提高了效率，而且在速度与精度权衡上达到了当时最优。

  4. 详实的实验验证：作者在ImageNet 2012分类数据集上进行了广泛的消融实验，比较了不同复杂度级别的ShuffleNet V2与其他知名网络架构（如ShuffleNet V1、MobileNet V2、Xception、DenseNet）的性能。实验结果全面展示了ShuffleNet V2在速度与精度上的优越性，并通过各种配置的比较，验证了所提设计原则的有效性。

  5. 对实际问题的洞察：研究揭示了在不同任务（如图像分类与对象检测）中，网络表现排名的变化，特别是指出扩大感受野对检测任务的重要性，并据此提出了ShuffleNet V2*变体，通过增加少量FLOPs进一步提升了准确性，为未来工作指明了方向。

  6. 跨平台考虑：文档不仅关注GPU上的性能，还考虑了ARM平台的表现，显示了不同设计选择对不同硬件环境的影响，增强了设计的通用性和实用性。

综上所述，这篇文档通过提供一套面向实践的CNN设计原则和一个高效的网络架构ShuffleNet V2，对推动深度学习模型设计领域的发展做出了重要贡献，尤其是在追求高效、轻量化模型设计方面。

二、准备工作

首先在YOLOv5/v7项目文件下的models文件夹下创建新的文件shufflenetv2.py

导入如下代码

from models.common import *


def channel_shuffle(x, groups):
    batchsize, num_channels, height, width = x.data.size()
    channels_per_group = num_channels // groups

    # reshape
    x = x.view(batchsize, groups,
               channels_per_group, height, width)

    x = torch.transpose(x, 1, 2).contiguous()

    # flatten
    x = x.view(batchsize, -1, height, width)

    return x


class conv_bn_relu_maxpool(nn.Module):
    def __init__(self, c1, c2):  # ch_in, ch_out
        super(conv_bn_relu_maxpool, self).__init__()
        self.conv = nn.Sequential(
            nn.Conv2d(c1, c2, kernel_size=3, stride=2, padding=1, bias=False),
            nn.BatchNorm2d(c2),
            nn.ReLU(inplace=True),
        )
        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)

    def forward(self, x):
        return self.maxpool(self.conv(x))


class Shuffle_Block(nn.Module):
    def __init__(self, inp, oup, stride):
        super(Shuffle_Block, self).__init__()

        if not (1 <= stride <= 3):
            raise ValueError('illegal stride value')
        self.stride = stride

        branch_features = oup // 2
        assert (self.stride != 1) or (inp == branch_features << 1)

        if self.stride > 1:
            self.branch1 = nn.Sequential(
                self.depthwise_conv(inp, inp, kernel_size=3, stride=self.stride, padding=1),
                nn.BatchNorm2d(inp),
                nn.Conv2d(inp, branch_features, kernel_size=1, stride=1, padding=0, bias=False),
                nn.BatchNorm2d(branch_features),
                nn.ReLU(inplace=True),
            )

        self.branch2 = nn.Sequential(
            nn.Conv2d(inp if (self.stride > 1) else branch_features,
                      branch_features, kernel_size=1, stride=1, padding=0, bias=False),
            nn.BatchNorm2d(branch_features),
            nn.ReLU(inplace=True),
            self.depthwise_conv(branch_features, branch_features, kernel_size=3, stride=self.stride, padding=1),
            nn.BatchNorm2d(branch_features),
            nn.Conv2d(branch_features, branch_features, kernel_size=1, stride=1, padding=0, bias=False),
            nn.BatchNorm2d(branch_features),
            nn.ReLU(inplace=True),
        )

    @staticmethod
    def depthwise_conv(i, o, kernel_size, stride=1, padding=0, bias=False):
        return nn.Conv2d(i, o, kernel_size, stride, padding, bias=bias, groups=i)

    def forward(self, x):
        if self.stride == 1:
            x1, x2 = x.chunk(2, dim=1)  # 按照维度1进行split
            out = torch.cat((x1, self.branch2(x2)), dim=1)
        else:
            out = torch.cat((self.branch1(x), self.branch2(x)), dim=1)

        out = channel_shuffle(out, 2)

        return out

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

from models.shufflenetv2 import *

并搜索def parse_model(d, ch)

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

conv_bn_relu_maxpool, Shuffle_Block,  # ShuffleNetv2

三、YOLOv7-tiny改进工作

完成二后，在YOLOv5项目文件下的models文件夹下创建新的文件yolov7-tiny-shufflenetv2.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]
  # Shuffle_Block: [out, stride]
  [[ -1, 1, conv_bn_relu_maxpool, [ 32 ] ], # 0-P2/4
   [ -1, 1, Shuffle_Block, [ 128, 2 ] ],  # 1-P3/8
   [ -1, 3, Shuffle_Block, [ 128, 1 ] ],  # 2
   [ -1, 1, Shuffle_Block, [ 256, 2 ] ],  # 3-P4/16
   [ -1, 7, Shuffle_Block, [ 256, 1 ] ],  # 4
   [ -1, 1, Shuffle_Block, [ 512, 2 ] ],  # 5-P5/32
   [ -1, 3, Shuffle_Block, [ 512, 1 ] ],  # 6
  ]

# 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-15

   [-1, 1, Conv, [128, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-1, 1, nn.Upsample, [None, 2, 'nearest']],
   [4, 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)]],  # 47-25

   [-1, 1, Conv, [64, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-1, 1, nn.Upsample, [None, 2, 'nearest']],
   [2, 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)]],  # 57-35

   [-1, 1, Conv, [128, 3, 2, None, 1, nn.LeakyReLU(0.1)]],
   [[-1, 25], 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)]],  # 65-43

   [-1, 1, Conv, [256, 3, 2, None, 1, nn.LeakyReLU(0.1)]],
   [[-1, 15], 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)]],  # 73-51

   [35, 1, Conv, [128, 3, 1, None, 1, nn.LeakyReLU(0.1)]],
   [43, 1, Conv, [256, 3, 1, None, 1, nn.LeakyReLU(0.1)]],
   [51, 1, Conv, [512, 3, 1, None, 1, nn.LeakyReLU(0.1)]],

   [[52,53,54], 1, IDetect, [nc, anchors]],   # Detect(P3, P4, P5)
  ]


                 from  n    params  module                                  arguments                     
  0                -1  1       928  models.shufflenetv2.conv_bn_relu_maxpool[3, 32]                       
  1                -1  1      9632  models.shufflenetv2.Shuffle_Block       [32, 128, 2]                  
  2                -1  3     27456  models.shufflenetv2.Shuffle_Block       [128, 128, 1]                 
  3                -1  1     52736  models.shufflenetv2.Shuffle_Block       [128, 256, 2]                 
  4                -1  7    242816  models.shufflenetv2.Shuffle_Block       [256, 256, 1]                 
  5                -1  1    203776  models.shufflenetv2.Shuffle_Block       [256, 512, 2]                 
  6                -1  3    404736  models.shufflenetv2.Shuffle_Block       [512, 512, 1]                 
  7                -1  1    131584  models.common.Conv                      [512, 256, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
  8                -2  1    131584  models.common.Conv                      [512, 256, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
  9                -1  1         0  models.common.SP                        [5]                           
 10                -2  1         0  models.common.SP                        [9]                           
 11                -3  1         0  models.common.SP                        [13]                          
 12  [-1, -2, -3, -4]  1         0  models.common.Concat                    [1]                           
 13                -1  1    262656  models.common.Conv                      [1024, 256, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 14          [-1, -7]  1         0  models.common.Concat                    [1]                           
 15                -1  1    131584  models.common.Conv                      [512, 256, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 16                -1  1     33024  models.common.Conv                      [256, 128, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 17                -1  1         0  torch.nn.modules.upsampling.Upsample    [None, 2, 'nearest']          
 18                 4  1     33024  models.common.Conv                      [256, 128, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 19          [-1, -2]  1         0  models.common.Concat                    [1]                           
 20                -1  1     16512  models.common.Conv                      [256, 64, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 21                -2  1     16512  models.common.Conv                      [256, 64, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 22                -1  1     36992  models.common.Conv                      [64, 64, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 23                -1  1     36992  models.common.Conv                      [64, 64, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 24  [-1, -2, -3, -4]  1         0  models.common.Concat                    [1]                           
 25                -1  1     33024  models.common.Conv                      [256, 128, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 26                -1  1      8320  models.common.Conv                      [128, 64, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 27                -1  1         0  torch.nn.modules.upsampling.Upsample    [None, 2, 'nearest']          
 28                 2  1      8320  models.common.Conv                      [128, 64, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 29          [-1, -2]  1         0  models.common.Concat                    [1]                           
 30                -1  1      4160  models.common.Conv                      [128, 32, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 31                -2  1      4160  models.common.Conv                      [128, 32, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 32                -1  1      9280  models.common.Conv                      [32, 32, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 33                -1  1      9280  models.common.Conv                      [32, 32, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 34  [-1, -2, -3, -4]  1         0  models.common.Concat                    [1]                           
 35                -1  1      8320  models.common.Conv                      [128, 64, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 36                -1  1     73984  models.common.Conv                      [64, 128, 3, 2, None, 1, LeakyReLU(negative_slope=0.1)]
 37          [-1, 25]  1         0  models.common.Concat                    [1]                           
 38                -1  1     16512  models.common.Conv                      [256, 64, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 39                -2  1     16512  models.common.Conv                      [256, 64, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 40                -1  1     36992  models.common.Conv                      [64, 64, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 41                -1  1     36992  models.common.Conv                      [64, 64, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 42  [-1, -2, -3, -4]  1         0  models.common.Concat                    [1]                           
 43                -1  1     33024  models.common.Conv                      [256, 128, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 44                -1  1    295424  models.common.Conv                      [128, 256, 3, 2, None, 1, LeakyReLU(negative_slope=0.1)]
 45          [-1, 15]  1         0  models.common.Concat                    [1]                           
 46                -1  1     65792  models.common.Conv                      [512, 128, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 47                -2  1     65792  models.common.Conv                      [512, 128, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 48                -1  1    147712  models.common.Conv                      [128, 128, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 49                -1  1    147712  models.common.Conv                      [128, 128, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 50  [-1, -2, -3, -4]  1         0  models.common.Concat                    [1]                           
 51                -1  1    131584  models.common.Conv                      [512, 256, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 52                35  1     73984  models.common.Conv                      [64, 128, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 53                43  1    295424  models.common.Conv                      [128, 256, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 54                51  1   1180672  models.common.Conv                      [256, 512, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 55      [52, 53, 54]  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: 352 layers, 4492652 parameters, 4492652 gradients, 8.5 GFLOPS

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

四、YOLOv5s改进工作

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

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
# custom backbone
backbone:
  # [from, number, module, args]
  [[-1, 1, conv_bn_relu_maxpool, [32]], # 0-P2/4
   [-1, 1, Shuffle_Block, [128, 2]],  # 1-P3/8
   [-1, 3, Shuffle_Block, [128, 1]],  # 2
   [-1, 1, Shuffle_Block, [256, 2]],  # 3-P4/16
   [-1, 7, Shuffle_Block, [256, 1]],  # 4
   [-1, 1, Shuffle_Block, [512, 2]],  # 5-P5/32
   [-1, 3, Shuffle_Block, [512, 1]],  # 6
  ]

# YOLOv5 head
head:
  [[-1, 1, Conv, [512, 1, 1]],                        # 7
   [-1, 1, nn.Upsample, [None, 2, 'nearest']],        # 8
   [[-1, 4], 1, Concat, [1]],  # cat backbone P4      # 9
   [-1, 1, C3, [512, False]],                         # 10

   [-1, 1, Conv, [256, 1, 1]],                       # 11
   [-1, 1, nn.Upsample, [None, 2, 'nearest']],       # 12
   [[-1, 2], 1, Concat, [1]],  # cat backbone P3     # 13
   [-1, 1, C3, [256, False]],  # 14 (P3/8-small)     # 14

   [-1, 1, Conv, [128, 3, 2]],                      # 15
   [[-1, 11], 1, Concat, [1]],  # cat head P4       # 16
   [-1, 1, C3, [256, False]],  # 17 (P4/16-medium)  # 17

   [-1, 1, Conv, [256, 3, 2]],                      # 18
   [[-1, 7], 1, Concat, [1]],  # cat head P5        # 19
   [-1, 1, C3, [512, False]],  # 20 (P5/32-large)   # 20

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


                 from  n    params  module                                  arguments                     
  0                -1  1       232  models.shufflenetv2.conv_bn_relu_maxpool[3, 8]                        
  1                -1  1       872  models.shufflenetv2.Shuffle_Block       [8, 32, 2]                    
  2                -1  1       752  models.shufflenetv2.Shuffle_Block       [32, 32, 1]                   
  3                -1  1      3968  models.shufflenetv2.Shuffle_Block       [32, 64, 2]                   
  4                -1  2      5056  models.shufflenetv2.Shuffle_Block       [64, 64, 1]                   
  5                -1  1     14080  models.shufflenetv2.Shuffle_Block       [64, 128, 2]                  
  6                -1  1      9152  models.shufflenetv2.Shuffle_Block       [128, 128, 1]                 
  7                -1  1     16640  models.common.Conv                      [128, 128, 1, 1]              
  8                -1  1         0  torch.nn.modules.upsampling.Upsample    [None, 2, 'nearest']          
  9           [-1, 4]  1         0  models.common.Concat                    [1]                           
 10                -1  1     82688  models.common.C3                        [192, 128, 1, False]          
 11                -1  1      8320  models.common.Conv                      [128, 64, 1, 1]               
 12                -1  1         0  torch.nn.modules.upsampling.Upsample    [None, 2, 'nearest']          
 13           [-1, 2]  1         0  models.common.Concat                    [1]                           
 14                -1  1     20864  models.common.C3                        [96, 64, 1, False]            
 15                -1  1     18496  models.common.Conv                      [64, 32, 3, 2]                
 16          [-1, 11]  1         0  models.common.Concat                    [1]                           
 17                -1  1     20864  models.common.C3                        [96, 64, 1, False]            
 18                -1  1     36992  models.common.Conv                      [64, 64, 3, 2]                
 19           [-1, 7]  1         0  models.common.Concat                    [1]                           
 20                -1  1     82688  models.common.C3                        [192, 128, 1, False]          
 21      [14, 17, 20]  1      4662  models.yolo.Detect                      [1, [[10, 13, 16, 30, 33, 23], [30, 61, 62, 45, 59, 119], [116, 90, 156, 198, 373, 326]], [64, 64, 128]]

Model Summary: 216 layers, 326326 parameters, 326326 gradients, 1.0 GFLOPs

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

五、YOLOv5n改进工作

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

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
# custom backbone
backbone:
  # [from, number, module, args]
  [[-1, 1, conv_bn_relu_maxpool, [32]], # 0-P2/4
   [-1, 1, Shuffle_Block, [128, 2]],  # 1-P3/8
   [-1, 3, Shuffle_Block, [128, 1]],  # 2
   [-1, 1, Shuffle_Block, [256, 2]],  # 3-P4/16
   [-1, 7, Shuffle_Block, [256, 1]],  # 4
   [-1, 1, Shuffle_Block, [512, 2]],  # 5-P5/32
   [-1, 3, Shuffle_Block, [512, 1]],  # 6
  ]

# YOLOv5 head
head:
  [[-1, 1, Conv, [512, 1, 1]],                        # 7
   [-1, 1, nn.Upsample, [None, 2, 'nearest']],        # 8
   [[-1, 4], 1, Concat, [1]],  # cat backbone P4      # 9
   [-1, 1, C3, [512, False]],                         # 10

   [-1, 1, Conv, [256, 1, 1]],                       # 11
   [-1, 1, nn.Upsample, [None, 2, 'nearest']],       # 12
   [[-1, 2], 1, Concat, [1]],  # cat backbone P3     # 13
   [-1, 1, C3, [256, False]],  # 14 (P3/8-small)     # 14

   [-1, 1, Conv, [128, 3, 2]],                      # 15
   [[-1, 11], 1, Concat, [1]],  # cat head P4       # 16
   [-1, 1, C3, [256, False]],  # 17 (P4/16-medium)  # 17

   [-1, 1, Conv, [256, 3, 2]],                      # 18
   [[-1, 7], 1, Concat, [1]],  # cat head P5        # 19
   [-1, 1, C3, [512, False]],  # 20 (P5/32-large)   # 20

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


                 from  n    params  module                                  arguments                     
  0                -1  1       464  models.shufflenetv2.conv_bn_relu_maxpool[3, 16]                       
  1                -1  1      2768  models.shufflenetv2.Shuffle_Block       [16, 64, 2]                   
  2                -1  1      2528  models.shufflenetv2.Shuffle_Block       [64, 64, 1]                   
  3                -1  1     14080  models.shufflenetv2.Shuffle_Block       [64, 128, 2]                  
  4                -1  2     18304  models.shufflenetv2.Shuffle_Block       [128, 128, 1]                 
  5                -1  1     52736  models.shufflenetv2.Shuffle_Block       [128, 256, 2]                 
  6                -1  1     34688  models.shufflenetv2.Shuffle_Block       [256, 256, 1]                 
  7                -1  1     66048  models.common.Conv                      [256, 256, 1, 1]              
  8                -1  1         0  torch.nn.modules.upsampling.Upsample    [None, 2, 'nearest']          
  9           [-1, 4]  1         0  models.common.Concat                    [1]                           
 10                -1  1    329216  models.common.C3                        [384, 256, 1, False]          
 11                -1  1     33024  models.common.Conv                      [256, 128, 1, 1]              
 12                -1  1         0  torch.nn.modules.upsampling.Upsample    [None, 2, 'nearest']          
 13           [-1, 2]  1         0  models.common.Concat                    [1]                           
 14                -1  1     82688  models.common.C3                        [192, 128, 1, False]          
 15                -1  1     73856  models.common.Conv                      [128, 64, 3, 2]               
 16          [-1, 11]  1         0  models.common.Concat                    [1]                           
 17                -1  1     82688  models.common.C3                        [192, 128, 1, False]          
 18                -1  1    147712  models.common.Conv                      [128, 128, 3, 2]              
 19           [-1, 7]  1         0  models.common.Concat                    [1]                           
 20                -1  1    329216  models.common.C3                        [384, 256, 1, False]          
 21      [14, 17, 20]  1      9270  models.yolo.Detect                      [1, [[10, 13, 16, 30, 33, 23], [30, 61, 62, 45, 59, 119], [116, 90, 156, 198, 373, 326]], [128, 128, 256]]

Model Summary: 216 layers, 1279286 parameters, 1279286 gradients, 3.7 GFLOPs

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

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

拿下Nahida
关注
  • 32
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
主干网络篇 | YOLOv5/v7 更换骨干网络之 GhostNet | 从廉价的操作中生成更多的特征图
YOLOv8项目贡献者
01-02 1万+
YOLOv5/v7 更换骨干网络之 GhostNet
主干网络篇 | YOLOv5/v7 更换骨干网络之 PP-LCNet | 轻量级CPU卷积神经网络
YOLOv8项目贡献者
01-02 8938
YOLOv5/v7 更换骨干网络之 PP-LCNet
主干网络篇 | YOLOv5/v7 更换骨干网络之 MobileNetV3 | 基于神经网络搜索的轻量级网络
YOLOv8项目贡献者
01-02 1万+
YOLOv5 框架引入 Google 轻量化网络 MobileNet V3
[YOLOv7/YOLOv5系列算法改进NO.11]主干网络C3替换为轻量化网络MobileNetV3
m0_70388905的博客
07-04 2万+
​前 言：作为当前先进的深度学习目标检测算法YOLOv5，已经集合了大量的trick，但是还是有提高和改进的空间，针对具体应用场景下的检测难点，可以不同的改进方法。此后的系列文章，将重点对YOLOv5的如何改进进行详细的介绍，目的是为了给那些搞科研的同学需要创新点或者搞工程项目的朋友需要达到更好的效果提供自己的微薄帮助和参考。解决问题：YOLOv5主干特征提取网络采用C3结构，带来较大的参数量，检测速度较慢，应用受限。.........
YOLOv5/v7 引入 YOLOv8 的 C2f 模块
YOLOv8项目贡献者
01-23 1万+
基于快速、准确和易于使用的设计理念，使其成为
主干网络篇 | YOLOv5/v7 更换主干网络之 SwinTransformer | Vision Transformer using Shifted Windows
YOLOv8项目贡献者
04-13 5614
YOLOv5/v7 更换主干网络之 SwinTransformer
改进YOLO系列 | YOLOv5/v7 更换骨干网络之 ConvNeXt
YOLOv8项目贡献者
01-17 5205
YOLOv5 更换骨干网络之 ConvNeXt
改进YOLOv5/YOLOv7——魔改YOLOv5/YOLOv7提升检测精度（涨点必备）
热门推荐
加勒比海带66——【YOLO魔法搭配&论文投稿咨询】
04-10 5万+
🎄🎄魔改YOLOv5/YOLOv7目标检测算法——各位小伙伴可根据自身研究方向及专业领域自主搭配各类创新新颖且行之有效的网络结构，以此实现论文实验高效涨点。主要包括主干网络改进、轻量化网络、注意力机制、检测头部改进、空间金字塔池化、损失函数及NMS改进、视觉顶会创新点改进以及算法训练相关项目等等。
目标检测算法——YOLOv5/YOLOv7改进|结合轻量型网络ShuffleNetV2
加勒比海带66——【YOLO魔法搭配&论文投稿咨询】
04-09 1万+
将YOLOv5算法与轻量级网络ShuffleNetV2相结合，在保证模型检测精度基本不变的情况下，大大降低计算量FLOPS，并明显提高网络推理速度！！！
yolov5/v7 车牌数据集
11-17
yolov5/v7 车牌数据集
可用于YOLOv5/v6/v7/v8训练的农作物杂草数据集
10-21
可用于YOLOv5/v6/v7/v8训练的农作物杂草数据集
真实场景下煤矸石目标检测数据集，可直接用于YOLOv5/v6/v7/v8训练
03-18
数据集类别：0代表煤炭（coal），1代表矸石（gangue），2代表煤炭和矸石的混合物（coal and gangue） 所有数据都有对应的标签，可直接提供给YOLO网络进行训练，数据集已划分好。 煤炭mAP@.5：0.896 矸石mAP@.5：0....
基于yolov5的戴口罩检测系统
06-02
yolov5口罩检测，数据集训练结果，包含训练好的权重文件和各种训练曲线图，保存在runs/train文件夹中，附有代码和检测结果以及测试数据集，类别为戴口罩：face_mask 和不戴口罩。
基于YOLOv5-v7用于SpireVision SDK训练（源码+说明文档）.rar
04-15
1、资源内容：基于YOLOv5-v7用于SpireVision SDK训练（完整源码+说明文档+数据）.rar 2、代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 3、适用对象：计算机，电子信息工程、数学等专业的...
番外篇 | YOLOv8改进之更换主干网络MobileNetv3 + 添加CA注意力机制
突然好想你
05-21 367
MobileNetv3是一种轻量级网络，采用了深度可分离卷积等轻量化技术，具有较小的模型参数量和计算复杂度，适合在计算能力较弱的设备上运行。本节课就让我们结合论文来对YOLOv8进行组合改进（更换主干网络MobileNetv3 + 添加CA注意力机制），希望同学们学完本节课可以有所启迪！🌈
番外篇 | YOLOv8改进之在C2f中引入多元分支模块DiverseBranchBlock | 涨点必备
突然好想你
05-22 401
Diverse Branch Block (DBB) 是一种用于增强卷积神经网络性能的结构重新参数化技术。基本原理在于增加卷积层的复杂性，通过引入不同尺寸和结构的卷积分支来丰富网络的特征表示能力。🌈
特征融合篇 | YOLOv8改进之引入轻量级跨尺度特征融合模块CCFM | 源自RT-DETR
突然好想你
05-23 95
CCFM即为跨尺度特征融合模块。这个模块的作用是将不同尺度的特征通过融合操作整合起来，以增强模型对于尺度变化的适应性和对小尺度对象的检测能力。CCFM可以有效地整合细节特征和上下文信息，从而提高模型的整体性能。🌈
【深度学习】yolov8 seg实例分割训练，交通灯
最新发布
q742971636的博客
05-25 399
类别0：类别1： 类别2：类别3：类别4： 类别5： 类别6：类别7：删除没有标签json的图： 将圆形标签json转为txt yolo seg 多边形标签： 转移到新的数据集文件夹： 三、训练yolov8 seg train.py 训练开启： 训练结束：对摄像头实时画面进行分割：下载所有资料： 帮助：
yolov5/v7 更换主干网络之 shufflenetv2
05-01
目前，YOLOv5/v7作为一款非常流行的目标检测算法，主要采用的是骨干网络为CSPDarknet53，这个骨干网络的主要特点是结构简单、运算速度快以及参数较少，因此被广泛应用。但是，这个骨干网络在一些性能方面上却存在着一些不足之处，比如说网络深度不够，并且存在一定的准确率瓶颈等等。 针对这些问题，YOLOv5/v7的开发团队提出了更换骨干网络的方案，将原来的CSPDarknet53替换为ShuffleNetV2。ShuffleNetV2是一种轻量级的卷积神经网络，它采用了一种新颖的“分组卷积（Group Convolution）”的思想，将输入特征图分成几个小组，每个小组内部自己卷积，最后再将结果整合在一起。这种设计可以大大减少卷积操作的计算量，提升模型的整体计算速度，同时也不会降低网络的性能表现。 总的来说，将ShuffleNetV2作为YOLOv5/v7的新骨干网络，能够有效地提高模型的计算速度，同时也更加稳定可靠，有着一定的实际应用价值。虽然目前更换骨干网络的工作还处于研究阶段，但是相对于原有的骨干网络而言，ShuffleNetV2无疑是更加先进、更加适合当前研究的网络结构。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值