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

已于 2024-06-06 21:46:02 修改
阅读量1.3k 收藏 31
点赞数 40
分类专栏： YOLO改进指南 文章标签： YOLO 目标检测 计算机视觉 人工智能 机器学习 深度学习
于 2024-05-13 11:59:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84870184/article/details/138764091
版权

一、导言

PP-LCNet是一种专为Intel CPU设计的轻量级卷积神经网络，旨在提升在多任务上的性能表现。该网络通过结合MKLDNN加速策略，优化了在CPU上的推理速度，同时保持了模型的准确性。论文中提出了一系列技术改进措施，在几乎不增加延迟的前提下提高了网络的准确度，使得PP-LCNet在分类任务上显著超越了以往具有相同推理时间的网络结构，并且在对象检测、语义分割等计算机视觉下游任务上也展现出优越性能。

PP-LCNet基于MobileNetV1的深度可分离卷积（DepthSepConv）作为基本构建模块，这种模块不含捷径操作，避免了如concat或elementwise-add这类会降低推理速度的操作，而且已被Intel CPU加速库深入优化，其推理速度超越了其他轻量级网络结构。通过堆叠这些模块形成了一个基础网络(BaseNet)，并结合一些现有技术进一步发展成更强大的网络——PP-LCNet。

研究中探索的提升准确度而不增加延迟的方法包括使用更好的激活函数（例如h-swish）、引入大尺寸卷积核、添加Squeeze-and-Excitation(SE)模块以及调整最后的1x1卷积层并采用dropout策略。实验结果显示，这些技术的累积应用显著提升了模型的准确率，同时保持了较快的推理速度。

在不同任务上的评估结果表明，PP-LCNet在COCO数据集上的目标检测任务中，与MobileNetV3相比，以更低的延迟实现了更高的mAP值；在Cityscapes数据集的语义分割任务中，PP-LCNet-0.5x不仅提高了mIoU指标，还大幅降低了推理时间。

该网络利用MKLDNN加速策略，在保持低延迟的同时，显著提高了轻量级模型在多种任务上的性能。主要优点总结如下：

  1. 高性能与低延迟并重：PP-LCNet在不增加推理时间的前提下，通过一系列技术改进提升了网络的准确性，超越了同类网络结构在分类任务上的表现，并且在计算机视觉下游任务，如目标检测、语义分割等方面也展现出了优越性能。

  2. 针对CPU优化设计：考虑到MKLDNN在Intel CPU上的限制，研究重新思考了适用于Intel CPU的轻量化模型设计元素，解决了如何在不增加延迟的情况下增强特征表示能力、提高轻量模型准确性的关键问题，并探索了有效结合不同轻量化设计策略的方法。

  3. 综合策略提升精度与速度平衡：论文总结了一系列在不增加推理时间前提下提高精度的方法，并展示了如何组合这些方法以获得更好的精度-速度平衡。提出了设计轻量级CNN的一般规则，为基于CPU构建CNN的研究人员提供了新思路。

  4. 影响与启示：PP-LCNet不仅在多个视觉任务上显示了强大的性能，还缩小了神经架构搜索(NAS)的搜索空间，为快速获取轻量级模型提供了可能。未来工作将探索利用NAS进一步获得更快、更强大的模型。

  5. 实验验证与实现细节：研究通过广泛实验验证了方法的有效性，并公开了基于PaddlePaddle框架实现的代码及预训练模型，便于其他研究人员复现和进一步研究。

         论文地址：PP-LCNet论文地址

         代码地址：PP-LCNet代码地址

二、准备工作

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

导入如下代码

from models.common import *

NET_CONFIG = {
    "blocks2":
    # k, in_c, out_c, s, use_se
        [[3, 16, 32, 1, False]],
    "blocks3": [[3, 32, 64, 2, False], [3, 64, 64, 1, False]],
    "blocks4": [[3, 64, 128, 2, False], [3, 128, 128, 1, False]],
    "blocks5": [[3, 128, 256, 2, False], [5, 256, 256, 1, False],
                [5, 256, 256, 1, False], [5, 256, 256, 1, False],
                [5, 256, 256, 1, False], [5, 256, 256, 1, False]],
    "blocks6": [[5, 256, 512, 2, True], [5, 512, 512, 1, True]]
}
BLOCK_LIST = ["blocks2", "blocks3", "blocks4", "blocks5", "blocks6"]


def make_divisible_LC(v, divisor=8, min_value=None):
    if min_value is None:
        min_value = divisor
    new_v = max(min_value, int(v + divisor / 2) // divisor * divisor)
    if new_v < 0.9 * v:
        new_v += divisor
    return new_v


class HardSwish(nn.Module):
    def __init__(self, inplace=True):
        super(HardSwish, self).__init__()
        self.relu6 = nn.ReLU6(inplace=inplace)

    def forward(self, x):
        return x * self.relu6(x + 3) / 6


class HardSigmoid(nn.Module):
    def __init__(self, inplace=True):
        super(HardSigmoid, self).__init__()
        self.relu6 = nn.ReLU6(inplace=inplace)

    def forward(self, x):
        return (self.relu6(x + 3)) / 6


class SELayer(nn.Module):
    def __init__(self, channel, reduction=16):
        super(SELayer, self).__init__()
        self.avgpool = nn.AdaptiveAvgPool2d(1)
        self.fc = nn.Sequential(
            nn.Linear(channel, channel // reduction, bias=False),
            nn.ReLU(inplace=True),
            nn.Linear(channel // reduction, channel, bias=False),
            HardSigmoid()
        )

    def forward(self, x):
        b, c, h, w = x.size()
        y = self.avgpool(x).view(b, c)
        y = self.fc(y).view(b, c, 1, 1)
        return x * y.expand_as(x)


class DepthwiseSeparable(nn.Module):
    def __init__(self, inp, oup, dw_size, stride, use_se=False):
        super(DepthwiseSeparable, self).__init__()
        self.use_se = use_se
        self.stride = stride
        self.inp = inp
        self.oup = oup
        self.dw_size = dw_size
        self.dw_sp = nn.Sequential(
            nn.Conv2d(self.inp, self.inp, kernel_size=self.dw_size, stride=self.stride,
                      padding=autopad(self.dw_size, None), groups=self.inp, bias=False),
            nn.BatchNorm2d(self.inp),
            HardSwish(),

            nn.Conv2d(self.inp, self.oup, kernel_size=1, stride=1, padding=0, bias=False),
            nn.BatchNorm2d(self.oup),
            HardSwish(),
        )
        self.se = SELayer(self.oup)

    def forward(self, x):
        x = self.dw_sp(x)
        if self.use_se:
            x = self.se(x)
        return x


class PPLC_Conv(nn.Module):
    def __init__(self, scale):
        super(PPLC_Conv, self).__init__()
        self.scale = scale
        self.conv = nn.Conv2d(3, out_channels=make_divisible_LC(16 * self.scale),
                              kernel_size=3, stride=2, padding=1, bias=False)

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


class PPLC_Block(nn.Module):
    def __init__(self, scale, block_num):
        super(PPLC_Block, self).__init__()
        self.scale = scale
        self.block_num = BLOCK_LIST[block_num]
        self.block = nn.Sequential(*[
            DepthwiseSeparable(inp=make_divisible_LC(in_c * self.scale),
                               oup=make_divisible_LC(out_c * self.scale),
                               dw_size=k, stride=s, use_se=use_se)
            for i, (k, in_c, out_c, s, use_se) in enumerate(NET_CONFIG[self.block_num])
        ])

    def forward(self, x):
        return self.block(x)

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

from models.pplcnet import *

并搜索def parse_model(d, ch)

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

        elif m is PPLC_Conv:
            c2 = args[0]
            args = args[1:]
        elif m is PPLC_Block:
            c2 = args[0]
            args = args[1:]

三、YOLOv7-tiny改进工作

完成二后，在YOLOv5项目文件下的models文件夹下创建新的文件yolov7-tiny-pplcnet.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

# YOLOv5 backbone
backbone:
  [[-1, 1, PPLC_Conv, [16, 1]],#0
   [-1, 1, PPLC_Block, [32, 1, 0]],
   [-1, 1, PPLC_Block, [64, 1, 1]],
   [-1, 1, PPLC_Block, [128, 1, 2]],
   [-1, 1, PPLC_Block, [256, 1, 3]],
   [-1, 1, PPLC_Block, [512, 1, 4]],#5
  ]

# 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)]],  # 14

   [-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)]],  # 24

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

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

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

   [34, 1, Conv, [128, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [42, 1, Conv, [256, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [50, 1, Conv, [512, 1, 1, None, 1, nn.LeakyReLU(0.1)]],

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


                 from  n    params  module                                  arguments                     
  0                -1  1       432  models.pplcnet.PPLC_Conv                [1]                           
  1                -1  1       880  models.pplcnet.PPLC_Block               [1, 0]                        
  2                -1  1      8480  models.pplcnet.PPLC_Block               [1, 1]                        
  3                -1  1     31296  models.pplcnet.PPLC_Block               [1, 2]                        
  4                -1  1    448640  models.pplcnet.PPLC_Block               [1, 3]                        
  5                -1  1    481536  models.pplcnet.PPLC_Block               [1, 4]                        
  6                -1  1    131584  models.common.Conv                      [512, 256, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
  7                -2  1    131584  models.common.Conv                      [512, 256, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
  8                -1  1         0  models.common.SP                        [5]                           
  9                -2  1         0  models.common.SP                        [9]                           
 10                -3  1         0  models.common.SP                        [13]                          
 11  [-1, -2, -3, -4]  1         0  models.common.Concat                    [1]                           
 12                -1  1    262656  models.common.Conv                      [1024, 256, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 13          [-1, -7]  1         0  models.common.Concat                    [1]                           
 14                -1  1    131584  models.common.Conv                      [512, 256, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 15                -1  1     33024  models.common.Conv                      [256, 128, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 16                -1  1         0  torch.nn.modules.upsampling.Upsample    [None, 2, 'nearest']          
 17                 4  1     33024  models.common.Conv                      [256, 128, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 18          [-1, -2]  1         0  models.common.Concat                    [1]                           
 19                -1  1     16512  models.common.Conv                      [256, 64, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 20                -2  1     16512  models.common.Conv                      [256, 64, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 21                -1  1     36992  models.common.Conv                      [64, 64, 3, 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, -2, -3, -4]  1         0  models.common.Concat                    [1]                           
 24                -1  1     33024  models.common.Conv                      [256, 128, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 25                -1  1      8320  models.common.Conv                      [128, 64, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 26                -1  1         0  torch.nn.modules.upsampling.Upsample    [None, 2, 'nearest']          
 27                 3  1      8320  models.common.Conv                      [128, 64, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 28          [-1, -2]  1         0  models.common.Concat                    [1]                           
 29                -1  1      4160  models.common.Conv                      [128, 32, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 30                -2  1      4160  models.common.Conv                      [128, 32, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 31                -1  1      9280  models.common.Conv                      [32, 32, 3, 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, -2, -3, -4]  1         0  models.common.Concat                    [1]                           
 34                -1  1      8320  models.common.Conv                      [128, 64, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 35                -1  1     73984  models.common.Conv                      [64, 128, 3, 2, None, 1, LeakyReLU(negative_slope=0.1)]
 36          [-1, 24]  1         0  models.common.Concat                    [1]                           
 37                -1  1     16512  models.common.Conv                      [256, 64, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 38                -2  1     16512  models.common.Conv                      [256, 64, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 39                -1  1     36992  models.common.Conv                      [64, 64, 3, 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, -2, -3, -4]  1         0  models.common.Concat                    [1]                           
 42                -1  1     33024  models.common.Conv                      [256, 128, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 43                -1  1    295424  models.common.Conv                      [128, 256, 3, 2, None, 1, LeakyReLU(negative_slope=0.1)]
 44          [-1, 14]  1         0  models.common.Concat                    [1]                           
 45                -1  1     65792  models.common.Conv                      [512, 128, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 46                -2  1     65792  models.common.Conv                      [512, 128, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 47                -1  1    147712  models.common.Conv                      [128, 128, 3, 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, -2, -3, -4]  1         0  models.common.Concat                    [1]                           
 50                -1  1    131584  models.common.Conv                      [512, 256, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 51                34  1      8448  models.common.Conv                      [64, 128, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 52                42  1     33280  models.common.Conv                      [128, 256, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 53                50  1    132096  models.common.Conv                      [256, 512, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 54      [51, 52, 53]  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, 3145580 parameters, 3145580 gradients, 6.2 GFLOPS

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

四、YOLOv5s改进工作

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

# YOLOv5 🚀 by Ultralytics, GPL-3.0 license

# 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 backbone
backbone:
  [[-1, 1, PPLC_Conv, [16, 1]],
   [-1, 1, PPLC_Block, [32, 1, 0]],
   [-1, 1, PPLC_Block, [64, 1, 1]],
   [-1, 1, PPLC_Block, [128, 1, 2]],
   [-1, 1, PPLC_Block, [256, 1, 3]],
   [-1, 1, PPLC_Block, [512, 1, 4]],
  ]

# YOLOv5 head
head:
  [[-1, 1, Conv, [512, 1, 1]],
   [-1, 1, nn.Upsample, [None, 2, 'nearest']],
   [[-1, 4], 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, 3], 1, Concat, [1]],  # cat backbone P3
   [-1, 3, C3, [256, False]],  # 17 (P3/8-small)

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

   [-1, 1, Conv, [512, 3, 2]],
   [[-1, 6], 1, Concat, [1]],  # cat head P5
   [-1, 3, C3, [1024, False]],  # 23 (P5/32-large)

   [[13, 16, 19], 1, Detect, [nc, anchors]],  # Detect(P3, P4, P5)
  ]



                 from  n    params  module                                  arguments                     
  0                -1  1       432  models.pplcnet.PPLC_Conv                [1]                           
  1                -1  1       880  models.pplcnet.PPLC_Block               [1, 0]                        
  2                -1  1      8480  models.pplcnet.PPLC_Block               [1, 1]                        
  3                -1  1     31296  models.pplcnet.PPLC_Block               [1, 2]                        
  4                -1  1    448640  models.pplcnet.PPLC_Block               [1, 3]                        
  5                -1  1    481536  models.pplcnet.PPLC_Block               [1, 4]                        
  6                -1  1    131584  models.common.Conv                      [512, 256, 1, 1]              
  7                -1  1         0  torch.nn.modules.upsampling.Upsample    [None, 2, 'nearest']          
  8           [-1, 4]  1         0  models.common.Concat                    [1]                           
  9                -1  1    361984  models.common.C3                        [512, 256, 1, False]          
 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, 3]  1         0  models.common.Concat                    [1]                           
 13                -1  1     90880  models.common.C3                        [256, 128, 1, False]          
 14                -1  1    147712  models.common.Conv                      [128, 128, 3, 2]              
 15          [-1, 10]  1         0  models.common.Concat                    [1]                           
 16                -1  1    296448  models.common.C3                        [256, 256, 1, False]          
 17                -1  1    590336  models.common.Conv                      [256, 256, 3, 2]              
 18           [-1, 6]  1         0  models.common.Concat                    [1]                           
 19                -1  1   1182720  models.common.C3                        [512, 512, 1, False]          
 20      [13, 16, 19]  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: 367 layers, 3822134 parameters, 3822134 gradients, 8.2 GFLOPs

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

五、YOLOv5n改进工作

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

# YOLOv5 🚀 by Ultralytics, GPL-3.0 license

# 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 backbone
backbone:
  [[-1, 1, PPLC_Conv, [16, 1]],
   [-1, 1, PPLC_Block, [32, 1, 0]],
   [-1, 1, PPLC_Block, [64, 1, 1]],
   [-1, 1, PPLC_Block, [128, 1, 2]],
   [-1, 1, PPLC_Block, [256, 1, 3]],
   [-1, 1, PPLC_Block, [512, 1, 4]],
  ]

# YOLOv5 head
head:
  [[-1, 1, Conv, [512, 1, 1]],
   [-1, 1, nn.Upsample, [None, 2, 'nearest']],
   [[-1, 4], 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, 3], 1, Concat, [1]],  # cat backbone P3
   [-1, 3, C3, [256, False]],  # 17 (P3/8-small)

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

   [-1, 1, Conv, [512, 3, 2]],
   [[-1, 6], 1, Concat, [1]],  # cat head P5
   [-1, 3, C3, [1024, False]],  # 23 (P5/32-large)

   [[13, 16, 19], 1, Detect, [nc, anchors]],  # Detect(P3, P4, P5)
  ]



                 from  n    params  module                                  arguments                     
  0                -1  1       432  models.pplcnet.PPLC_Conv                [1]                           
  1                -1  1       880  models.pplcnet.PPLC_Block               [1, 0]                        
  2                -1  1      8480  models.pplcnet.PPLC_Block               [1, 1]                        
  3                -1  1     31296  models.pplcnet.PPLC_Block               [1, 2]                        
  4                -1  1    448640  models.pplcnet.PPLC_Block               [1, 3]                        
  5                -1  1    481536  models.pplcnet.PPLC_Block               [1, 4]                        
  6                -1  1     65792  models.common.Conv                      [512, 128, 1, 1]              
  7                -1  1         0  torch.nn.modules.upsampling.Upsample    [None, 2, 'nearest']          
  8           [-1, 4]  1         0  models.common.Concat                    [1]                           
  9                -1  1    107264  models.common.C3                        [384, 128, 1, False]          
 10                -1  1      8320  models.common.Conv                      [128, 64, 1, 1]               
 11                -1  1         0  torch.nn.modules.upsampling.Upsample    [None, 2, 'nearest']          
 12           [-1, 3]  1         0  models.common.Concat                    [1]                           
 13                -1  1     27008  models.common.C3                        [192, 64, 1, False]           
 14                -1  1     36992  models.common.Conv                      [64, 64, 3, 2]                
 15          [-1, 10]  1         0  models.common.Concat                    [1]                           
 16                -1  1     74496  models.common.C3                        [128, 128, 1, False]          
 17                -1  1    147712  models.common.Conv                      [128, 128, 3, 2]              
 18           [-1, 6]  1         0  models.common.Concat                    [1]                           
 19                -1  1    296448  models.common.C3                        [256, 256, 1, False]          
 20      [13, 16, 19]  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: 367 layers, 1743414 parameters, 1743414 gradients, 4.2 GFLOPs

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

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

拿下Nahida
关注
  • 40
    点赞
  • 踩
  • 31
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
主干网络篇 | YOLOv5/v7 更换骨干网络之 EfficientNet | 卷积神经网络模型缩放的再思考
YOLOv8项目贡献者
01-02 6295
YOLOv5/v7 更换骨干网络之 EfficientNet-B0
PP-LCNet-YoloV5
m0_46179553的博客
10-10 3799
背景简介 前段时间看到了百度新出的一篇论文，提出了一种基于MKLDNN加速策略的轻量级CPU网络，即PP-LCNet，它提高了轻量级模型在多任务上的性能,对于计算机视觉的下游任务，如目标检测、语义分割等，也有很好的表现。以下是论文链接和开源的基于PaddlePaddle的实现。 arXiv: https://arxiv.org/pdf/2109.15099.pdf code: https://github.com/PaddlePaddle/PaddleClas 论文很短，模型结构也十分简洁，没有特别创新的部
YOLOv5改进 | 主干网络 | 用EfficientNet卷积替换backbone【教程+代码 】
kay_545
05-21 1435
YOLOv5改进，优化，efficientnet
【YOLOv5/v7改进系列】替换骨干网络为VanillaNet
2401_84870184的博客
05-12 941
yolov7-tiny、yolov5n/s替换骨干网络为华为诺亚方舟实验室和悉尼大学的研究人员合作完成VanillaNet
YOLO V5更换主干网络ShuffleNet v2
leiye1997的博客
08-03 553
self.depthwise_conv(branch_features, branch_features, kernel_size=3, stride=self.stride, padding=1),##加的。# self.depthwise_conv(inp, inp, kernel_size=3, stride=1, padding=1),###加的。###############----- ShuffleNetV2主干网络-----#######最后运行train.py 就可以啦！
yolov5修改骨干网络-使用自己搭建的网络-以efficientnetv2为例
小白不白
12-15 5923
efficientnet则是通过NAS搜索，同时增加width、depth以及resolution，使网络结构达到最优。下表为EfficientNet-B0的网络框架（B1-B7就是在B0的基础上修改Resolution，Channels以及Layers），可以看出网络总共分成了9个Stage。第一个Stage是一个卷积核大小为3x3，stride为2的普通卷积层（包含BN和Swish激活函数）；
更换骨干网
地推
10-17 764
第一种PP YOLO技术是用Resnet50-vd-dcn ConvNet骨干替换YOLOv3 Darknet53骨干。Resnet是一个更流行的骨干，它的执行优化了更多的框架，并且其参数少于Darknet53。通过交换此骨干可以看到mAP的改进，这对PP YOLO来说是一个巨大的胜利。 ...
百度发文，pp-LCnet网络，pp-PicoDet算法，pp-shitu应用
05-01
PP-LCNet是一种针对CPU设备及加速库MKLDNN定制的骨干网络。它可以在不增加推理时间的情况下提高网络准确性。通过改进，PP-LCNet在相同的分类推理时间下，准确率可以大大超过以前的网络结构。 PP-LCNet的主要贡献是...
YOLOV5的多主干网络（backbone）实现.zip
03-05
# 复现TPH-YOLOv5 # 支持的backbone为Ghostnet、Shufflenetv2、Mobilenetv3Small、EagleEye、EfficientNetLite-0、PP-LCNet-1x、SwinTrans-YOLOv5
基于改进 YOLOv8 的轻量化小麦病害检测方法
最新发布
07-05
首先，使用 PP-LCNet 模型替换 YOLOv8 网络结构的骨干网络，并在骨干网络层引入深度可分离 卷积（depthwise separable convolution， DepthSepConv）结构，减少模型参数量，提升模型检测性能；其次，在颈部网 络...
UPS-GCNet:深度未校准的光度学立体中学到了什么？ （ECCV 2020年）
05-04
本文旨在发现一种深度的未校准光度立体（UPS）网络可以解决该问题的固有歧义，并在我们的分析基础上引入一种引导式认证网络（GCNet）。 概述： 我们提供： 在， ， ，和合成数据集上测试我们的方法的代码。 用于...
flexible-yolov5:具有更多主干（resnet，shufflenet，moblienet）的更具可读性和灵活性的yolov5
03-26
flexible-yolov5 基于 。 原始的Yolo V5是一个了不起的项目。 对于专业人士而言，理解和修改其代码应该不难。 我不是专家。 当我想对网络进行一些更改时，这并不是一件容易的事，例如添加分支和尝试其他骨干网。 也许会有像我这样的人，所以我将yolov5模型拆分为{主干，脖子，头部}，以方便各种模块的操作并支持更多的主干。基本上，我只更改了模型，而没有更改架构，培训和测试yolov5。 因此，如果原始代码被更新，则更新该代码也非常方便。 目录 [培训与测试]（＃培训与测试） 特征 重组骨干，脖子，头部等模型结构，可以灵活方便地修改网络 更多主干，mobilenetV3，shufflenetV2，resnet18、50、101等 先决条件 请参阅requirements.txt 入门 数据集准备 以yolov5格式制作数据。 您可以使用utils / make_yolov5
百度网盘AI大赛表格结构检测第七名模型+预测文件
01-02
LCNet通常包含一系列的卷积层，池化层和激活函数，这些元素协同工作，能够识别和理解图像中的特征，对于表格的边缘和结构检测非常有用。 LCPAN（局部上下文金字塔注意力网络）是一种增强模型对局部细节捕获能力的...
YOLOV5轻量化改进-MobileNetV3替换骨干网络
weixin_44597885的博客
03-03 8503
YOLOV5轻量化改进-MobileNetV3替换骨干网络
目标检测算法——YOLOv5/YOLOv7改进之结合​PP-LCNet（轻量级CPU网络）
加勒比海带66——【YOLO魔法搭配&论文投稿咨询】
11-27 8838
​PP-LCNet——轻量级且超强悍的CPU级骨干网络！！PP-LCNet 在同样精度的情况下，速度远超当前所有的骨架网络！它应用在比如目标检测、语义分割等任务算法上，也可以使原本的网络有大幅度的性能提升。
YOLOv5改进 | 主干网络 | 将backbone替换为MobileNetV3【小白必备教程+附完整代码】
kay_545
05-18 1398
yolov5有效改进涨点，yolov5改进，yolov8
主干网络篇 | YOLOv5/v7 更换主干网络之 ShuffleNetv2 | 高效CNN架构设计的实用指南
热门推荐
YOLOv8项目贡献者
08-01 1万+
YOLOv5/v7 更换主干网络之 ShuffleNetv2
改进YOLOv5：涨点必备 | 创新实用 | 轻量化骨干网络大一统，包含FastNet、ShuffleNet、mobileNet、Ghostnet等
qq_44224801的博客
04-29 3319
本文实现了YOLOv8结合各种轻量化骨干网络，实现一篇文章助你实现YOLOv8轻量化。本文不仅实现了YOLOv8结合各种骨干网络，并且给出的多种结合形式，如替换轻量化卷积PConv、替换轻量化Block以及替换轻量化骨干。
yolov5 添加pp-lcnet
09-14
在最新版本的YOLov5中，已经添加了一个名为pp-lcnet的模型。 pp-lcnet是一种轻量级的目标检测网络，具有较低的参数量和计算复杂度。它的设计灵感来自于YOLOv4，在保持较高精度的同时减少了一些不必要的运算，从而...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值