YOLOv5改进（五）-- 轻量化模型MobileNetv3

已于 2024-06-02 16:48:40 修改
阅读量822 收藏 25
点赞数 12
分类专栏： 目标检测 文章标签： YOLO 目标检测 人工智能
于 2024-06-02 16:21:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44231797/article/details/139393046
版权

文章目录

1、MobileNetV3论文

Searching for MobileNetV3论文

MobileNetV3代码

MobileNetV3 是 Google 提出的一种轻量级神经网络结构，旨在在移动设备上实现高效的图像识别和分类任务。与之前的 MobileNet 系列相比，MobileNetV3 在模型结构和性能上都有所改进。

MobileNetV3 的结构主要包括以下几个关键组件：

  1. 基础模块（Base Module）：MobileNetV3 使用了一种称为**“倒残差”（Inverted Residuals）**的基础模块结构。该结构采用了深度可分离卷积和线性瓶颈，它由一个1x1卷积层和一个3x3深度可分离卷积层组成。这个操作单元通过使用非线性激活函数，如ReLU6，并且在残差连接中使用线性投影，以减少参数数量和计算复杂度来提高网络的特征表示能力，并且保持了模型的有效性。

  2. Squeeze-and-Excitation 模块：MobileNetV3 引入了 Squeeze-and-Excitation 模块，使用全局平均池化层来降低特征图的维度，并使用一个1x1卷积层将特征图的通道数压缩成最终的类别数量。最后，使用softmax函数对输出进行归一化，得到每个类别的概率分布。通过学习通道之间的相互关系，动态地调整通道权重，以增强模型的表征能力。这有助于提高模型对关键特征的感知能力，从而提高分类性能。

  3. Hard-Swish 激活函数：MobileNetV3 使用了一种称为 Hard-Swish 的激活函数。与传统的 ReLU 激活函数相比，Hard-Swish 具有更快的计算速度和更好的性能。

  4. 网络架构优化：MobileNetV3 在网络结构上进行了优化，包括通过网络宽度和分辨率的动态调整，以适应不同的计算资源和任务需求。

总体而言，MobileNetV3 通过这些创新设计和优化，实现了更高的性能和更低的计算成本，使其成为移动设备上图像识别任务的理想选择之一。

MobileNetV3 的主要处理流程如下：

  1. 输入处理：输入图像首先经过预处理步骤，例如归一化和大小调整，以使其适应网络的输入要求。

  2. 特征提取：经过输入处理后，图像通过一系列基础模块（Base Module）进行特征提取。每个基础模块通常包含深度可分离卷积、激活函数（如 Hard-Swish）和通道注意力（如 Squeeze-and-Excitation）模块。

  3. 特征增强：在特征提取的过程中，通过 Squeeze-and-Excitation 模块对提取的特征图进行增强，以加强对重要特征的感知能力。

  4. 全局平均池化：在特征提取的最后阶段，通过全局平均池化操作将特征图的空间维度降低到一个固定大小。

  5. 分类器：全局平均池化后的特征图输入到分类器中，进行分类或其他任务的预测。分类器通常由一个或多个全连接层组成，最后输出预测结果。

2、代码实现

2.1、MobileNetV3-small

(1) 在models/common.py的引入MobileNetV3模块

# 引入MobileNetV3模块
class StemBlock(nn.Module):
    def __init__(self, c1, c2, k = 3, s = 2, p = None, g = 1, act = True):
        super(StemBlock, self).__init__()
        self.stem_1 = Conv(c1, c2, k, s, p, g, act)
        self.stem_2a = Conv(c2, c2 // 2, 1, 1, 0)
        self.stem_2b = Conv(c2 // 2, c2, 3, 2, 1)
        self.stem_2p = nn.MaxPool2d(kernel_size = 2, stride = 2, ceil_mode = True)
        self.stem_3 = Conv(c2 * 2, c2, 1, 1, 0)

    def forward(self, x):
        stem_1_out = self.stem_1(x)
        stem_2a_out = self.stem_2a(stem_1_out)
        stem_2b_out = self.stem_2b(stem_2a_out)
        stem_2p_out = self.stem_2p(stem_1_out)
        out = self.stem_3(torch.cat((stem_2b_out, stem_2p_out), 1))
        return out


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

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


class h_swish(nn.Module):
    def __init__(self, inplace = True):
        super(h_swish, self).__init__()
        self.sigmoid = h_sigmoid(inplace = inplace)

    def forward(self, x):
        y = self.sigmoid(x)
        return x * y


class SELayer(nn.Module):
    def __init__(self, channel, reduction = 4):
        super(SELayer, self).__init__()
        self.avg_pool = nn.AdaptiveAvgPool2d(1)
        self.fc = nn.Sequential(
            nn.Linear(channel, channel // reduction),
            nn.ReLU(inplace = True),
            nn.Linear(channel // reduction, channel),
            h_sigmoid()
        )

    def forward(self, x):
        b, c, _, _ = x.size()
        y = self.avg_pool(x)
        y = y.view(b, c)
        y = self.fc(y).view(b, c, 1, 1)
        return x * y


class Conv_bn_hswish(nn.Module):
    """
    This equals to
    def conv_3x3_bn(inp, oup, stride):
        return nn.Sequential(
            nn.Conv2d(inp, oup, 3, stride, 1, bias=False),
            nn.BatchNorm2d(oup),
            h_swish()
        )
    """

    def __init__(self, c1, c2, stride):
        super(Conv_bn_hswish, self).__init__()
        self.conv = nn.Conv2d(c1, c2, 3, stride, 1, bias = False)
        self.bn = nn.BatchNorm2d(c2)
        self.act = h_swish()

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

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


class MobileNetV3(nn.Module):
    def __init__(self, inp, oup, hidden_dim, kernel_size, stride, use_se, use_hs):
        super(MobileNetV3, self).__init__()
        assert stride in [1, 2]

        self.identity = stride == 1 and inp == oup

        # 输入通道图 = 扩张通道数 则不进行通道扩张
        if inp == hidden_dim:
            self.conv = nn.Sequential(
                # dw
                nn.Conv2d(hidden_dim, hidden_dim, kernel_size, stride, (kernel_size - 1) // 2, groups = hidden_dim,
                          bias = False),
                nn.BatchNorm2d(hidden_dim),
                h_swish() if use_hs else nn.ReLU(inplace = True),
                # Squeeze-and-Excite
                SELayer(hidden_dim) if use_se else nn.Sequential(),
                # Eca_layer(hidden_dim) if use_se else nn.Sequential(),#1.13.2022
                # pw-linear
                nn.Conv2d(hidden_dim, oup, 1, 1, 0, bias = False),
                nn.BatchNorm2d(oup),
            )
        else:
            # 否则先进行扩张
            self.conv = nn.Sequential(
                # pw
                nn.Conv2d(inp, hidden_dim, 1, 1, 0, bias = False),
                nn.BatchNorm2d(hidden_dim),
                h_swish() if use_hs else nn.ReLU(inplace = True),
                # dw
                nn.Conv2d(hidden_dim, hidden_dim, kernel_size, stride, (kernel_size - 1) // 2, groups = hidden_dim,
                          bias = False),
                nn.BatchNorm2d(hidden_dim),
                # Squeeze-and-Excite
                SELayer(hidden_dim) if use_se else nn.Sequential(),
                # Eca_layer(hidden_dim) if use_se else nn.Sequential(),  # 1.13.2022
                h_swish() if use_hs else nn.ReLU(inplace = True),
                # pw-linear
                nn.Conv2d(hidden_dim, oup, 1, 1, 0, bias = False),
                nn.BatchNorm2d(oup),
            )

    def forward(self, x):
        y = self.conv(x)
        if self.identity:
            return x + y
        else:
            return y

(2) 在models/yolo.py的parse_model函数，添加Conv_bn_hswish,MobileNetV3 两个模块

 if m in [Conv, GhostConv, Bottleneck, GhostBottleneck, SPP, DWConv, MixConv2d, Focus, CrossConv, BottleneckCSP,C3, C3TR,Conv_bn_hswish,MobileNetV3]:

在这里插入图片描述

(3) 构建yolov5s-mobileNetV3-samll.yaml 网络模型

# YOLOv5 🚀 by Ultralytics, GPL-3.0 license

# Parameters
nc: 6  # number of classes
depth_multiple: 0.33  # model depth multiple
width_multiple: 0.5  # 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

   # Mobilenetv3-small backbone
   # MobileNetV3_InvertedResidual [out_ch, hid_ch, k_s, stride, SE, HardSwish]
backbone:
  # [from, number, module, args]
  # /2 /4 /6 /8，/16，/32 位置特征图的大小降半
  # MobileNetV3模块包含六个参数[out_ch, hidden_ch, kernel_size, stride, use_se, use_hs]
  [[-1, 1, Conv_bn_hswish, [16, 2]],             # 0-p1/2   320*320
   [-1, 1, MobileNetV3, [16,  16, 3, 2, 1, 0]],  # 1-p2/4   160*160
   [-1, 1, MobileNetV3, [24,  72, 3, 2, 0, 0]],  # 2-p3/8   80*80
   [-1, 1, MobileNetV3, [24,  88, 3, 1, 0, 0]],  # 3        80*80
   [-1, 1, MobileNetV3, [40,  96, 5, 2, 1, 1]],  # 4-p4/16  40*40
   [-1, 1, MobileNetV3, [40, 240, 5, 1, 1, 1]],  # 5        40*40
   [-1, 1, MobileNetV3, [40, 240, 5, 1, 1, 1]],  # 6        40*40
   [-1, 1, MobileNetV3, [48, 120, 5, 1, 1, 1]],  # 7        40*40
   [-1, 1, MobileNetV3, [48, 144, 5, 1, 1, 1]],  # 8        40*40
   [-1, 1, MobileNetV3, [96, 288, 5, 2, 1, 1]],  # 9-p5/32  20*20
   [-1, 1, MobileNetV3, [96, 576, 5, 1, 1, 1]],  # 10       20*20
   [-1, 1, MobileNetV3, [96, 576, 5, 1, 1, 1]],  # 11       20*20
  ]

# YOLOv5 v6.0 head
head:
  [[-1, 1, Conv, [96, 1, 1]],  # 12                         20*20
   [-1, 1, nn.Upsample, [None, 2, 'nearest']], # 13         40*40
   [[-1, 8], 1, Concat, [1]],  # cat backbone P4            40*40
   [-1, 3, C3, [144, False]],  # 15                         40*40

   [-1, 1, Conv, [144, 1, 1]], # 16                         40*40
   [-1, 1, nn.Upsample, [None, 2, 'nearest']], # 17          80*80
   [[-1, 3], 1, Concat, [1]],  # cat backbone P3            80*80
   [-1, 3, C3, [168, False]],  # 19 (P3/8-small)            80*80

   [-1, 1, Conv, [168, 3, 2]], # 20                         40*40
   [[-1, 16], 1, Concat, [1]], # cat head P4                40*40
   [-1, 3, C3, [312, False]],  # 22 (P4/16-medium)          40*40

   [-1, 1, Conv, [312, 3, 2]], # 23                         20*20
   [[-1, 12], 1, Concat, [1]], # cat head P5                20*20
   [-1, 3, C3, [408, False]],  # 25 (P5/32-large)           20*20

   [[19, 22, 25], 1, Detect, [nc, anchors]],  # Detect(P3, P4, P5)
  ]

MobileNetV3-samll网络结构

根据网络结构我们可以看出**MobileNetV3**模块包含六个参数**[out_ch, hidden_ch, kernel_size, stride, use_se, use_hs]：**
  1. out_ch： 输出通道
  2. hidden_ch： 表示在Inverted residuals中的扩张通道数
  3. kernel_size： 卷积核大小
  4. stride： 步长
  5. use_se： 表示是否使用 SELayer，使用了是1，不使用是0
  6. use_hs： 表示使用 h_swish 还是 ReLU，使用h_swish是1，使用 ReLU是0

2.2、MobileNetV3-large

MobileNetV3-large和MobileNetV3-small 区别在于网络层数加深，深度因子，宽度因子不同以及yaml文件中head中concat不同层数拼接。我们就直接改动yaml的部分，其余参考上面步骤。

在这里插入图片描述

MobileNetV3-large.yaml

# Parameters
nc: 6  # number of classes
depth_multiple: 1  # model depth multiple
width_multiple: 0.5 # 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:
  [[-1, 1, conv_bn_hswish, [16, 2]],              # 0-p1/2  320*320
   [-1, 1, MobileNetV3, [ 16,  16, 3, 1, 0, 0]],  # 1-p1/2  320*320
   [-1, 1, MobileNetV3, [ 24,  64, 3, 2, 0, 0]],  # 2-p2/4  160*160
   [-1, 1, MobileNetV3, [ 24,  72, 3, 1, 0, 0]],  # 3-p2/4  160*160
   [-1, 1, MobileNetV3, [ 40,  72, 5, 2, 1, 0]],  # 4-p3/8  80*80
   [-1, 1, MobileNetV3, [ 40, 120, 5, 1, 1, 0]],  # 5-p3/8
   [-1, 1, MobileNetV3, [ 40, 120, 5, 1, 1, 0]],  # 6-p3/8
   [-1, 1, MobileNetV3, [ 80, 240, 3, 2, 0, 1]],  # 7-p4/16  40*40
   [-1, 1, MobileNetV3, [ 80, 200, 3, 1, 0, 1]],  # 8-p4/16
   [-1, 1, MobileNetV3, [ 80, 184, 3, 1, 0, 1]],  # 9-p4/16
   [-1, 1, MobileNetV3, [ 80, 184, 3, 1, 0, 1]],  # 10-p4/16
   [-1, 1, MobileNetV3, [112, 480, 3, 1, 1, 1]],  # 11-p4/16
   [-1, 1, MobileNetV3, [112, 672, 3, 1, 1, 1]],  # 12-p4/16
   [-1, 1, MobileNetV3, [160, 672, 5, 1, 1, 1]],  # 13-p4/16
   [-1, 1, MobileNetV3, [160, 960, 5, 2, 1, 1]],  # 14-p5/32   20*20
   [-1, 1, MobileNetV3, [160, 960, 5, 1, 1, 1]],  # 15-p5/32
  ]
# YOLOv5 v6.0 head
head:
  [ [ -1, 1, Conv, [ 512, 1, 1 ] ],
    [ -1, 1, nn.Upsample, [ None, 2, 'nearest' ] ],
    [ [ -1, 13], 1, Concat, [ 1 ] ],  # cat backbone P4
    [ -1, 1, C3, [ 512, False ] ],  # 19

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

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

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

    [ [ 23, 26, 29 ], 1, Detect, [ nc, anchors ] ],  # Detect(P3, P4, P5)
  ]

3、运行效果

如果训练之后发现掉点纯属正常现象，因为轻量化网络在提速减少计算量的同时会降低精度

在这里插入图片描述

4、目标检测系列文章

  1. YOLOv5s网络模型讲解(一看就会)
  2. 生活垃圾数据集（YOLO版）
  3. YOLOv5如何训练自己的数据集
  4. 双向控制舵机（树莓派版）
  5. 树莓派部署YOLOv5目标检测（详细篇）
  6. YOLO_Tracking 实践 （环境搭建 & 案例测试）
  7. 目标检测：数据集划分 & XML数据集转YOLO标签
  8. DeepSort行人车辆识别系统（实现目标检测+跟踪+统计）
  9. YOLOv5参数大全(parse_opt篇)
  10. YOLOv5改进（一）-- 轻量化YOLOv5s模型
  11. YOLOv5改进（二）-- 目标检测优化点（添加小目标头检测）
  12. YOLOv5改进（三）-- 引进Focaler-IoU损失函数
  13. YOLOv5改进（四）–轻量化模型ShuffleNetv2
wisdom_zhe
关注
  • 12
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
YOLOV5轻量化改进-MobileNetV3替换骨干网络
weixin_44597885的博客
03-03 8486
YOLOV5轻量化改进-MobileNetV3替换骨干网络
mobile-yolov5-pruning-distillation:mobilev2-yolov5s剪枝，蒸馏，支持ncnn，tensorRT部署。超轻但性能更好！
03-19
移动式yolov5修剪蒸馏mobilev2-yolov5s的通道修剪和蒸馏。超轻但性能更好！ TensorRT版本===> Android版本===> 背景yolov5s在640x640分辨率下的计算量和参数量分别为8.39G和7.07M。在速度上仍然有提升空间，通过替换...
基于YOLOv5模型改进
02-05
1. **优化Backbone**：可以尝试替换或调整现有的Backbone网络，如使用更轻量级的MobileNetV3或者更强大的EfficientNet，以平衡速度与精度。 2. **改进Neck结构**：添加PANet或ASFF等模块，以更好地利用多尺度信息，...
算法部署-使用NCNN在Android平台部署MobileNetv2-YOLOv3-Nano目标检测算法.zip
03-13
5. **YOLOv3-Nano**：YOLO（You Only Look Once）是一种实时目标检测系统，YOLOv3是其第三个版本，而YOLOv3-Nano是针对资源有限的设备进行优化的轻量化版本。它保留了YOLOv3的特性，如多尺度检测和更丰富的类别，但...
yolo-基于caffe的mobilenetv2+yolov3的实现-达到实时检测-附完整源码+教程.zip
01-26
在目标检测任务中，MobileNetV2可以作为特征提取器，与YOLO的检测头部结合，形成一个轻量级但效果良好的检测模型。 **YOLOv3**： YOLOv3在YOLOv2的基础上进行了改进，引入了更大的网络输入尺寸、多尺度预测、Anchor...
yolov7+mobilenetv3-large网络结构.yaml
08-07
yolov7+mobilenetv3_large网络结构，用于yolov7相关网络降参提速，对轻量化模型较为友好。
绝缘子陶瓷绝缘子玻色绝缘子聚合物绝缘子检测数据集VOC+YOLO格式2050张3类别
FL1623863129的博客
07-06 125
数据集格式：Pascal VOC格式+YOLO格式(不包含分割路径的txt文件，仅仅包含jpg图片以及对应的VOC格式xml文件和yolo格式txt文件)标注类别名称:["glass insulator","polymer insulator","porcelain insulator"]特别声明：本数据集不对训练的模型或者权重文件精度作任何保证，数据集只提供准确且合理标注。图片数量(jpg文件个数)：2050。标注数量(xml文件个数)：2050。标注数量(txt文件个数)：2050。
YOLO 应用
weixin_46807151的博客
07-04 176
YOLO（You Only Look Once）算法是一种高效的对象检测模型，自其发布以来，在多个领域中都得到了广泛的应用。总的来说，YOLO算法凭借其高效性和准确性，在多个领域中都有着广泛的应用前景。随着技术的不断发展，YOLO算法的性能和适用范围还将继续提升和扩展。
详解yolov5的网络结构
m0_71124168的博客
07-05 736
YOLOv5是一种基于轻量级卷积神经网络（CNN）的目标检测算法，整体可以分为三个部分，如上图所示，我们需要先理解三个模块：Conv，C3，SPPF，以便理解网络结构图。关于这三个模块的解释放在文章末尾。其他我觉得有用的前置知识也会放在文章末尾。YOLOv5是一种基于轻量级卷积神经网络（CNN）的目标检测算法，整体可以分为三个部分，，以便理解网络结构图。关于这三个模块的解释放在文章末尾。其他我觉得有用的前置知识也会放在文章末尾。
YOLOv8模型调参---数据增强
weixin_45303602的博客
07-04 764
离线增强是指在模型训练前在计算机上一次性完成所有数据增强操作，将原始数据集转化为包含多种增强版本的扩充数据集，并将增强后的样本保存到磁盘或内存中，然后使用这个固定的扩充数据集进行训练。
Yolo v7网络实现细节（一）
xiaoxu的博客
07-06 1037
YOLO v7网络架构的整体介绍同时，我们还针对不同的业务需求，使用基础模型进行模型缩放，得到不同类型的模型。对于YOLOv7，我们对颈部进行stack scaling，并使用提出的复合缩放方法对整个模型的深度和宽度进行缩放，并以此获得YOLOv7-X。
YOLO V7项目使用
xiaoxu的博客
07-05 995
同样在使用yolo v7项目启动时也会和v5项目一样发生类似的报错信息。我第一次下载的项目使用的是github上下载的压缩包文件，经过解压之后导入的pycharm，在启动验证的时候缺少git相关的文件导致启动失败。安装GPU(CUDA)版本的torch，之后我们在执行训练模型的文件将整个YOLO v7项目启动失败（先卸载之前pip安装的cpu版本）YOLO v7中的拓展功能测试（关键点检测）提前手动下载所需要的yolov7-w6-pose.pt文件。这是我们默认使用的就是GPU的环境。
YOLOv8改进 添加CVPR2024 PKINet中注意力机制CAAttention
分享一些自己改进代码的实例
07-04 184
本文加入2024CVPR发布的PKINet中的CAA注意力机制，使得模型可以更好地捕捉到图像或视频中目标物体周围的长距离上下文信息，提高了对目标的理解和解释能力。助力涨点！
YOLOv8改进 | 注意力机制 | 结合静态和动态上下文信息的注意力机制
kay_545
07-06 852
yolov8，yolov8改进，yolov8添加注意力机制，yolov8
yolov8-seg分割模型TensorRt部署，去掉torch
qq_44224801的博客
07-05 275
输入为brg图像，图像的路径和输出路径，最后会保存masktxt。cudart推理，不包含torch。
yolov5 json 和 txt数据格式关系
weixin_41021342的博客
07-06 99
关于yolov5 数据格式一直以来都傻傻分不清楚，这下进行了一个梳理，做了笔记，也希望可帮助到有需要的有缘人~
YOLOv8改进 | 卷积模块 | 减少冗余计算和内存访问的PConv【CVPR2023】
kay_545
07-02 985
yolov8，pconv，yolov8改进
【YOLOv5/v7改进系列】改进池化层为RFB
最新发布
2401_84870184的博客
07-08 1040
RFB模块的设计是手工制作的，这意味着它可能不如自适应机制灵活，例如可变形卷积神经网络中使用的那些，后者可以根据对象的尺度和形状调整感受野的分布。分支的内核大小、填充和扩张率各不相同，目的是捕捉不同尺度的信息。: RFB模块利用多个分支，每个分支有不同的卷积核大小和空洞卷积层，这有助于捕捉图像中不同尺度的信息，类似于人类视觉系统中感受野的多样性。: RFB模块通过模拟人类视觉系统中感受野的大小和偏心率之间的关系，增强了轻量级CNN网络的特征表示，从而提高了特征的区分性和鲁棒性。构造函数接收输入通道数。
yolov7轻量化改进 MobileNetV3
09-09
Yolov7是基于Yolov3的改进版本，而MobileNetV3是一种轻量级的卷积神经网络模型。如果要将Yolov7与MobileNetV3结合，可以通过将Yolov7的特征提取部分替换为MobileNetV3来实现轻量化改进。 MobileNetV3在模型设计上引入了一些创新，例如使用了一种称为"轻量化倒残差"（Lightweight Inverted Residuals）的结构，以及一种称为"可分离卷积"（Depthwise Separable Convolution）的卷积操作。这些设计可以在减少参数量和计算复杂度的同时，保持较高的检测精度。 对于Yolov7来说，可以将其原有的卷积层替换为MobileNetV3的轻量化倒残差结构和可分离卷积操作。这样的改进可以使Yolov7在保持较高检测精度的同时，减少模型参数量和计算复杂度，使其更适合在移动设备等资源有限的环境中部署和运行。 需要注意的是，具体的改进方式可能需要根据实际情况进行调整和优化，以最大程度地提升模型性能和效果。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值