YOLO算法改进7【中阶改进篇】：主干网络C3替换为轻量化网络MobileNetV3

已于 2023-12-25 13:24:12 修改
阅读量2.3k 收藏 47
点赞数 17
分类专栏： YOLOV5改进篇 文章标签： YOLO
于 2023-12-24 23:29:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39522016/article/details/135188948
版权

解决问题：YOLOv5主干特征提取网络采用C3结构，带来较大的参数量，检测速度较慢，应用受限，在某些真实的应用场景如移动或者嵌入式设备，如此大而复杂的模型时难以被应用的。首先是模型过于庞大，面临着内存不足的问题，其次这些场景要求低延迟，或者说响应速度要快，想象一下自动驾驶汽车的行人检测系统如果速度很慢会发生什么可怕的事情。所以，研究小而高效的CNN模型在这些场景至关重要，至少目前是这样，尽管未来硬件也会越来越快。本文尝试将主干特征提取网络替换为更轻量的MobileNet网络，以实现网络模型的轻量化，平衡速度和精度。

一、MobileNetV3简介

MobileNetV3，是谷歌在2019年3月21日提出的轻量化网络架构，在前两个版本的基础上，加入神经网络架构搜索（NAS）和h-swish激活函数，并引入SE通道注意力机制，性能和速度都表现优异，受到学术界和工业界的追捧。
引用大佬的描述：MobileNet V3 = MobileNet v2 + SE结构 + hard-swish activation +网络结构头尾微调
在这里插入图片描述

摘要： 我们提出下一代的mobilenet基于一种互补搜索技术的组合作为一种新颖的建筑设计。MobileNetV3调到手机cpu通过硬件组合感知网络架构搜索(NAS)的补充NetAdapt算法，然后进行改进通过新颖的建筑进步。这篇论文从探索如何自动搜索算法和网络工作设计可以一起利用互补的工作提高整体技术水平的方法。通过在这个过程中，我们创建了两个新的MobileNet模型:MobileNetV3-Large和MobileNetV3-Small针对高资源和低资源用例。这些然后调整模型并将其应用于对象检测和语义分割任务。为了完成任务语义分割(或任何密集像素预测)，我们提出了一种新的高效分割解码器空间金字塔池(LR-ASPP)。我们实现新状态的艺术结果移动分类，检测和分割。MobileNetV3-Large则高出3.2%准确的ImageNet分类，同时减少延迟与MobileNetV2相比减少了20%。MobileNetV3-Small是与MobileNetV2模型相比，准确率提高了6.6%具有相当的延迟。MobileNetV3-Large检测与MobileNetV2在COCO检测上的精度大致相同，速度快了25%以上。MobileNetV3-Large
LRASPP在类似情况下比MobileNetV2 R-ASPP快34%城市景观分割的准确性。

论文地址：https://arxiv.org/abs/1905.02244.pdf
代码：https://github.com/LeBron-Jian/DeepLearningNote

MobileNetV1&MobileNetV2&MobileNetV3总结
在这里插入图片描述
MobileNet V3 相关技术如下：
1，用 MnasNet 搜索网络结构
2，用 MobileNetV1 的深度可分离卷积
3，用 MobileNetV2 的倒置残差线性瓶颈结构
4，引入轻量级注意力 SE模块
5，使用新的激活函数 h-swish(x)
6，网络搜索中利用两个策略：资源受限的 NAS 和 NetAdapt
7，修改MobileNet V2 最后部分减小计算
在这里插入图片描述

二、YOLOv5结合MobileNetV3_small

方 法：

第一步修改common.py，增加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_InvertedResidual(nn.Module):
    def __init__(self, inp, oup, hidden_dim, kernel_size, stride, use_se, use_hs):
        super(MobileNetV3_InvertedResidual, 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

第二步：将yolo.py中注册模块。

if m in [Conv,MobileNetV3_InvertedResidual,ShuffleNetV2_InvertedResidual，
               ]:
# 加入h_sigmoid，h_swish，SELayer，conv_bn_hswish，MobileNetV3_InvertedResidual五个模块

第三步：修改yaml文件

backbone:
  # MobileNetV3-large
  # [from, number, module, args]
  [[-1, 1, conv_bn_hswish, [16, 2]],                   # 0-p1/2
   [-1, 1, MobileNetV3_InvertedResidual, [ 16,  16, 3, 1, 0, 0]],  # 1-p1/2
   [-1, 1, MobileNetV3_InvertedResidual, [ 24,  64, 3, 2, 0, 0]],  # 2-p2/4
   [-1, 1, MobileNetV3_InvertedResidual, [ 24,  72, 3, 1, 0, 0]],  # 3-p2/4
   [-1, 1, MobileNetV3_InvertedResidual, [ 40,  72, 5, 2, 1, 0]],  # 4-p3/8
   [-1, 1, MobileNetV3_InvertedResidual, [ 40, 120, 5, 1, 1, 0]],  # 5-p3/8
   [-1, 1, MobileNetV3_InvertedResidual, [ 40, 120, 5, 1, 1, 0]],  # 6-p3/8
   [-1, 1, MobileNetV3_InvertedResidual, [ 80, 240, 3, 2, 0, 1]],  # 7-p4/16
   [-1, 1, MobileNetV3_InvertedResidual, [ 80, 200, 3, 1, 0, 1]],  # 8-p4/16
   [-1, 1, MobileNetV3_InvertedResidual, [ 80, 184, 3, 1, 0, 1]],  # 9-p4/16
   [-1, 1, MobileNetV3_InvertedResidual, [ 80, 184, 3, 1, 0, 1]],  # 10-p4/16
   [-1, 1, MobileNetV3_InvertedResidual, [112, 480, 3, 1, 1, 1]],  # 11-p4/16
   [-1, 1, MobileNetV3_InvertedResidual, [112, 672, 3, 1, 1, 1]],  # 12-p4/16
   [-1, 1, MobileNetV3_InvertedResidual, [160, 672, 5, 1, 1, 1]],  # 13-p4/16
   [-1, 1, MobileNetV3_InvertedResidual, [160, 960, 5, 2, 1, 1]],  # 14-p5/32   原672改为原算法960
   [-1, 1, MobileNetV3_InvertedResidual, [160, 960, 5, 1, 1, 1]],  # 15-p5/32
  ]

根据MobileNetv3的网络结构来修改配置文件。
在这里插入图片描述
根据网络结构我们可以看出MobileNetV3模块包含六个参数[out_ch, hidden_ch, kernel_size, stride, use_se, use_hs]：
• out_ch： 输出通道
• hidden_ch： 表示在Inverted residuals中的扩张通道数
• kernel_size： 卷积核大小
• stride： 步长
• use_se： 表示是否使用 SELayer，使用了是1，不使用是0
• use_hs： 表示使用 h_swish 还是 ReLU，使用h_swish是1，使用 ReLU是0
修改的时候，需要注意/8，/16，/32等位置特征图的变换
在这里插入图片描述
同样的，head部分这几个concat的层也要做修改：
在这里插入图片描述
yaml文件修改后代码如下：

# YOLOv5 🚀 by Ultralytics, GPL-3.0 license
 
# Parameters
nc: 80  # number of classes
depth_multiple: 1.0  # model depth multiple
width_multiple: 1.0  # 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]
  [[-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)
  ]

三、YOLOv5结合MobileNetV3_large

MobileNetV3_large和MobileNetV3_small区别在于yaml文件中head中concat连接不同，深度因子和宽度因子不同。接下来我们就直接改动yaml的部分，其余参考上面步骤。

然后根据MobileNetv3的网络结构来修改配置文件。
在这里插入图片描述
修改后代码如下：

# Parameters
nc: 20  # number of classes
depth_multiple: 1.0  # model depth multiple
width_multiple: 1.0  # 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
   [-1, 1, MobileNetV3, [ 16,  16, 3, 1, 0, 0]],  # 1-p1/2
   [-1, 1, MobileNetV3, [ 24,  64, 3, 2, 0, 0]],  # 2-p2/4
   [-1, 1, MobileNetV3, [ 24,  72, 3, 1, 0, 0]],  # 3-p2/4
   [-1, 1, MobileNetV3, [ 40,  72, 5, 2, 1, 0]],  # 4-p3/8
   [-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
   [-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   原672改为原算法960
   [-1, 1, MobileNetV3, [160, 960, 5, 1, 1, 1]],  # 15-p5/32
  ]
# YOLOv5 v6.0 head
head:
  [ [ -1, 1, Conv, [ 256, 1, 1 ] ],
    [ -1, 1, nn.Upsample, [ None, 2, 'nearest' ] ],
    [ [ -1, 13], 1, Concat, [ 1 ] ],  # cat backbone P4
    [ -1, 1, C3, [ 256, False ] ],  # 13
 
    [ -1, 1, Conv, [ 128, 1, 1 ] ],
    [ -1, 1, nn.Upsample, [ None, 2, 'nearest' ] ],
    [ [ -1, 6 ], 1, Concat, [ 1 ] ],  # cat backbone P3
    [ -1, 1, C3, [ 128, False ] ],  # 17 (P3/8-small)
 
    [ -1, 1, Conv, [ 128, 3, 2 ] ],
    [ [ -1, 20 ], 1, Concat, [ 1 ] ],  # cat head P4
    [ -1, 1, C3, [ 256, False ] ],  # 20 (P4/16-medium)
 
    [ -1, 1, Conv, [ 256, 3, 2 ] ],
    [ [ -1, 16 ], 1, Concat, [ 1 ] ],  # cat head P5
    [ -1, 1, C3, [ 512, False ] ],  # 23 (P5/32-large)
 
    [ [ 23, 26, 29 ], 1, Detect, [ nc, anchors ] ],  # Detect(P3, P4, P5)
  ]

网络运行结果：
在这里插入图片描述
我们可以看到MobileNetV3-large模型比MobileNetV3-small多了更多的MobileNet_Block结构，残差倒置结构中通道数维度也增大了许多，速度比YOLOv5s慢将近一半，但是参数变少，效果介乎MobileNetV3-small和YOLOv5s之间，可以作为模型对比，凸显自己模型优势。

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

注：主干网络的替换不仅仅是适用改进YOLOv5，也可以改进其他的YOLO网络以及目标检测网络，比如YOLOv4、v3等。

梦在黎明破晓时啊
关注
专栏目录
主干网络篇 | YOLOv8 更换骨干网络之 MobileNetV3 | 《搜寻 MobileNetV3》
YOLOv8项目贡献者
04-21 7519
YOLOv8 更换骨干网络之 MobileNetV3 手把手教程
YOLOv8改进 | 主干篇 | CSWinTransformer交叉形窗口网络
Snu77的博客
01-04 2349
到此本文的正式分享内容就结束了，在这里给大家推荐我的YOLOv8改进有效涨点专栏，本专栏目前为新开的平均质量分98分，后期我会根据各种最新的前沿顶会进行论文复现，也会对一些老的改进机制进行补充，目前本专栏免费阅读(暂时，大家尽早关注不迷路~)，如果大家觉得本文帮助到你了，订阅本专栏，关注后续更多的更新~YOLOv8改进系列专栏——本专栏持续复习各种顶会内容——科研必备。
MobileNet-Yolo 项目教程
最新发布
gitblog_01023的博客
10-11 1011
MobileNet-Yolo 项目教程 MobileNet-Yolo MobileNetV2-YoloV3-Nano: 0.5BFlops 3MB HUAWEI P40: 6ms/img, YoloFace-500k:0.1Bflops 420KB:fire::fire::fire: ...
爆改YOLOv8|使用MobileNetV3替换Backbone
weixin_43986124的博客
08-27 968
MobileNetV3替换yolov8主干网，yolov8改进主干网，yolo暴力涨点
YOLOV5轻量化改进-MobileNetV3替换骨干网络
weixin_44597885的博客
03-03 8763
YOLOV5轻量化改进-MobileNetV3替换骨干网络
改进YOLOv5 | 在 C3 模块中添加【SimAM】【CoTAttention】【SKAttention】【DoubleAttention】注意力机制
weixin_39818775的博客
05-09 1024
YOLOv5 是一个强大的目标检测模型，在 COCO 数据集上取得了 state-of-the-art 的结果。为了进一步提高 YOLOv5 的性能，本文提出了一种改进方案，在 C3 模块中添加 SimAM、CoTAttention、SKAttention 和 DoubleAttention 注意力机制。
YOLOv5改进系列：替换主干网络为MobileNetV3的计算机视觉
IdfdFsharp的博客
09-18 733
目标检测是计算机视觉中的一个关键任务，而YOLOv5作为目标检测领域的先进方法，近年来备受关注。在YOLOv5的改进系列中，我们将探讨如何将MobileNetV3作为YOLOv5的主干网络。MobileNetV3通过引入一系列创新的模块和技术，提供了一种高效的解决方案，适用于移动设备和嵌入式系统。为了实现YOLOv5和MobileNetV3的结合，我们需要修改YOLOv5的代码，以将MobileNetV3作为主干网络。需要注意的是，这只是将MobileNetV3作为YOLOv5的主干网络的示例之一。
YOLOv8轻量化：MobileNetV3，理想的轻量级骨架选择 - 计算机视觉
JjtlReact的博客
09-17 1667
与传统的两阶段目标检测算法相比，YOLOv8具有更快的检测速度，但在小目标检测和边界框定位方面可能略有不足。通过将MobileNetV3作为YOLOv8的骨架网络，我们可以实现轻量化的目标检测。MobileNetV3的倒残差结构和可调的网络宽度参数使得模型具有较少的参数和计算复杂度，同时保持了较高的检测性能。它通过倒残差结构和可调的网络宽度参数，实现了在保持模型轻量化的同时提高了目标检测性能。在这方面，MobileNetV3是一个出色的选择，它具有较少的参数和计算复杂度，同时保持了较高的准确性和速度。
【YOLO】替换骨干网络为轻量级网络MobileNet3
m0_37556124的博客
08-09 1118
移动端部署深度卷积网络，无论什么视觉任务，选择高精度的计算量少和参数少的骨干网是必经之路。轻量化网络是移动端的研究重点。本文将介绍使用MobileNet3在yolo中作为骨干网络提取特征的应用。MobileNetV3在移动端上分类、检测和分割的最新技术成果。与MobileNetVV2相比，MobileNetV3-Large在ImageNet分类上的准确度高3.2％，同时将延迟降低了20％。与延迟相当的MobileNetV2模型相比，MobileNetV3-Small的准确性高出6.6％。
YOLOv8改进 | 主干篇 | 利用MobileNetV3替换Backbone（轻量化网络结构）
Snu77的博客
12-23 9032
本文给大家带来的改进机制是MobileNetV3轻量化网络结构，其主要改进思想集中在结合硬件感知的网络架构搜索（NAS）和NetAdapt算法，以优化移动设备CPU上的性能。它采用了新颖的架构设计，包括反转残差结构和线性瓶颈层，以及新的高效分割解码器（LR-ASPP），以提升在移动分类、检测和分割任务上的表现。实验表明，MobileNets在资源和准确性的权衡方面表现出色，并在多种应用（如对象检测、细粒度分类、面部属性识别和大规模地理定位）中展现了其有效性。
mobilenetv3-yolov3 训练模型
05-11
https://github.com/tanluren/mobilenetv3-yolov3 上的预训练模型，20分类，要class相同才能用
yolov3+mobilenet+darknet
03-11
github中的带mobilenet的darknet框架都是基于yolov2,不能使用yolov3模型，这是根据yolov3改的
YoloV8改进策略：主干网络篇|MobileNetV4主干替换YoloV8的BackBone（独家原创）
m0_47867638的博客
06-08 1964
今年，轻量级王者MobileNetV4闪亮登场！在我们这篇文章里，我们把MobileNetV4加入到了YoloV8中，替换原有的BackBone。哈哈，你猜怎么着？效果超赞！文章里详细记录了改进过程，给那些正在为创新点子发愁的小伙伴们提供了满满的灵感。嘿，想要发表关于轻量级改进的论文？这篇文章绝对是你的首选参考！
番外篇 | YOLOv8改进之更换主干网络MobileNetv3 + 添加CA注意力机制
突然好想你
05-21 1575
MobileNetv3是一种轻量级网络，采用了深度可分离卷积等轻量化技术，具有较小的模型参数量和计算复杂度，适合在计算能力较弱的设备上运行。本节课就让我们结合论文来对YOLOv8进行组合改进（更换主干网络MobileNetv3 + 添加CA注意力机制），希望同学们学完本节课可以有所启迪！🌈
YOLOv8改进 | 主干网络 | 替换EfficientViT为backbone【轻量化网络】
kay_545
08-12 1787
yolov8，yolov8改进，EfficientViT
YOLOv5算法改进（22）— 更换主干网络MobileNetv3 + 添加CA注意力机制
突然好想你
11-06 2048
本节课就让我们结合论文来对YOLOv5进行组合改进（更换主干网络MobileNetv3 + 添加CA注意力机制），小白必学~！🌈
主干网络篇 | YOLOv5/v7 更换骨干网络之 MobileNetV3 | 基于神经网络搜索的轻量级网络
热门推荐
YOLOv8项目贡献者
01-02 1万+
YOLOv5 框架引入 Google 轻量化网络 MobileNet V3
YOLOv3替换骨干网络为MobileNetV3的计算机视觉
GzvDart的博客
09-20 229
而MobileNetV3是一种轻量级的卷积神经网络，它使用了一系列的深度可分离卷积和线性瓶颈模块，以在减少参数数量的同时提供较好的准确率。在模型的前向传播过程中，我们首先通过MobileNetV3获取特征图，然后继续YOLOv3的其余网络结构，如预测边界框和类别。YOLOv3是一种流行的目标检测算法，而MobileNetV3则是一种轻量级的骨干网络，它可以提供高效的计算性能和较好的准确率。总结起来，将MobileNetV3应用于YOLOv3的骨干网络可以提供较好的计算性能和较高的准确率。
YOLOv5-7.0改进（一）MobileNetv3替换主干网络
mw的博客
05-03 4959
本篇博客主要讲解YOLOv5主干网络的替换，使用MobileNetv3实现模型轻量化，平衡速度和精度。以下为改进的具体流程~
PyTorch，怎么下载MobileNetv3-Small文件
05-14
你可以通过以下步骤来下载MobileNetv3-Small文件： 1. 首先打开终端或命令行界面。 2. 然后使用以下命令安装PyTorch： ``` pip install torch torchvision ``` 3. 接下来使用以下命令下载MobileNetv3-Small模型文件： ``` wget https://download.pytorch.org/models/mobilenet_v3_small-047dcff4.pth ``` 4. 下载完毕后，你就可以在你的项目中使用MobileNetv3-Small模型文件了。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

梦在黎明破晓时啊

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值