轻量化网络 Mobilenet V1/V2/V3（原理+pytorch代码）

已于 2023-04-27 13:51:47 修改
阅读量2.4k 收藏 27
点赞数 6
分类专栏： 深度学习 文章标签： 深度学习
于 2022-11-21 14:39:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54338498/article/details/127845652
版权

参考视频

2016年直至现在，业内提出了SqueezeNet、ShuffleNet、NasNet、MnasNet以及MobileNet等轻量级网络模型。这些模型使移动终端、嵌入式设备运行神经网络模型成为可能。

V1(DW卷积)->V2(逆残差)->V3(SEattention)

1. 传统卷积

在这里插入图片描述

  • 输入特征in_channel=卷积核的channel
  • 输出特征图的out_channnel=卷积核的个数
    在这里插入图片描述
    计算量 与 图像大小HW、卷积核大小有关
    在这里插入图片描述
    在这里插入图片描述

2. Mobilenet V1

2个亮点：

  • DepthWise Separable卷积（深度可分离卷积）大大减少运算量：DW卷积+PW卷积
  • 增加超参数alpha(控制卷积核个数)和beta(控制输入图像大小WH)

2.1 DepthWise Separable卷积

D W 卷积 ( 增大感受野，缩小特征图 W H ) + P W 卷积 ( 缩放特征图通道数 C ) DW卷积(增大感受野，缩小特征图WH)+PW卷积(缩放特征图通道数C) DW卷积(增大感受野，缩小特征图WH)+PW卷积(缩放特征图通道数C)
Step1：逐通道独立卷积（DepthWise卷积）：
一个卷积核负责一个通道

  • 卷积核个数 = 输入特征图的in_channel = 输出特征图的out_channel
  • 卷积核的channnel = 1
    在这里插入图片描述
    在这里插入图片描述

Step2：逐点卷积（Pointwise卷积）
卷积核1x1的普通卷积，省参数，N个卷积核得到N个特征图
在这里插入图片描述
Step3：串联DW卷积和PW卷积
两步走的Separable卷积效果与普通卷积相似，但计算量大大减小
在这里插入图片描述

深度可分离卷积 VS 普通卷积：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2.2 整体结构

在这里插入图片描述
mobilenet v1一路卷积到底(单分支DW卷积块串行)，但训练后DW卷积核很多参数为0，效果不理想。

3. Mobilenet V2

在这里插入图片描述

3.1 逆残差

  • DW卷积:不改变通道数，但可缩小特征图WH
  • 1x1卷积:不改变特征图WH，但可缩放通道数C

在这里插入图片描述

  • 原始残差：先降维，后升维。两边厚，中间薄。
  • 逆残差：先升维，后降维。两部薄，中间厚。

在这里插入图片描述

激活函数使用ReLU6：对ReLU设置max(6)
在这里插入图片描述

3.2 Relu干了坏事

Relu使 低维特征 损失信息
在这里插入图片描述
逆残差块输出的是低位特征图(通道维度小)，所以在输出时需要使用线性linear激活函数，避免信息损失，而在逆残差块其他部分，仍然使用ReLU6激活函数。
在这里插入图片描述

3.3 整体结构

此处的bottleneck就是逆残差块，单分支一路卷积到底，bottleneck内部可能有shortcut。
在这里插入图片描述

4. Mobilenet V3

亮点：

  • 更新bottleneck：引入SE attention，非线性激活函数NL将swish改为h-swish，用于替代relu6
  • 使用NAS搜索参数（Neural Architecture Search）
  • 重新设置耗时层(对搜索出来的网络逐层分析优化)

4.1 更新bottleneck

在这里插入图片描述

①SE Attention：
在这里插入图片描述
在这里插入图片描述

Step1:求每个通道的权重值（1x1xc）（全局平均池化）
在这里插入图片描述

Step2:使用两个全连接层计算权重值的回归值sc（1x1xc），然后完成加权操作(每个通道权重回归值sc x 每个通道原始特征图uc)

在这里插入图片描述

②Switch激活函数：
基于Switch提出h-Switch激活函数，用于替代mobilenetV2中的relu6。
S w i t c h ( x ) = x ∗ s i g m o i d ( x ) Switch(x)=x*sigmoid(x) Switch(x)=x∗sigmoid(x)
在这里插入图片描述
h − s i g m o i d ( x ) = r e l u 6 ( x + 3 ) / 6 h-sigmoid(x)=relu6(x+3)/6 h−sigmoid(x)=relu6(x+3)/6

h − S w i t c h ( x ) = x ∗ h − s i g m o i d ( x ) = x ∗ r e l u 6 ( x + 3 ) / 6 h-Switch(x)=x*h-sigmoid(x)=x*relu6(x+3)/6 h−Switch(x)=x∗h−sigmoid(x)=x∗relu6(x+3)/6
在这里插入图片描述

4.2 重新设置耗时层

因为实验发现第一个卷积操作和最后的卷积操作才是耗时性能瓶颈，所以减少了第一个卷积层的output channel从32到16，且减少最后两层卷积层数量。
在这里插入图片描述

4.3 整体结构

在这里插入图片描述
在这里插入图片描述

5. Mobilenet V3 代码

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn import init



class hswish(nn.Module):
    def forward(self, x):
        out = x * F.relu6(x + 3, inplace=True) / 6
        return out


class hsigmoid(nn.Module):
    def forward(self, x):
        out = F.relu6(x + 3, inplace=True) / 6
        return out


class SeModule(nn.Module):
    def __init__(self, in_size, reduction=4):
        super(SeModule, self).__init__()
        self.se = nn.Sequential(
            nn.AdaptiveAvgPool2d(1),
            nn.Conv2d(in_size, in_size // reduction, kernel_size=1, stride=1, padding=0, bias=False),
            nn.BatchNorm2d(in_size // reduction),
            nn.ReLU(inplace=True),
            nn.Conv2d(in_size // reduction, in_size, kernel_size=1, stride=1, padding=0, bias=False),
            nn.BatchNorm2d(in_size),
            hsigmoid()
        )

    def forward(self, x):
        return x * self.se(x)


class Block(nn.Module):
    '''expand + depthwise + pointwise'''
    def __init__(self, kernel_size, in_size, expand_size, out_size, nolinear, semodule, stride):
        super(Block, self).__init__()
        self.stride = stride
        self.se = semodule

        self.conv1 = nn.Conv2d(in_size, expand_size, kernel_size=1, stride=1, padding=0, bias=False)
        self.bn1 = nn.BatchNorm2d(expand_size)
        self.nolinear1 = nolinear
        self.conv2 = nn.Conv2d(expand_size, expand_size, kernel_size=kernel_size, stride=stride, padding=kernel_size//2, groups=expand_size, bias=False)
        self.bn2 = nn.BatchNorm2d(expand_size)
        self.nolinear2 = nolinear
        self.conv3 = nn.Conv2d(expand_size, out_size, kernel_size=1, stride=1, padding=0, bias=False)
        self.bn3 = nn.BatchNorm2d(out_size)

        self.shortcut = nn.Sequential()
        if stride == 1 and in_size != out_size:
            self.shortcut = nn.Sequential(
                nn.Conv2d(in_size, out_size, kernel_size=1, stride=1, padding=0, bias=False),
                nn.BatchNorm2d(out_size),
            )

    def forward(self, x):
        out = self.nolinear1(self.bn1(self.conv1(x)))
        out = self.nolinear2(self.bn2(self.conv2(out)))
        out = self.bn3(self.conv3(out))
        if self.se != None:
            out = self.se(out)
        out = out + self.shortcut(x) if self.stride==1 else out
        return out


class MobileNetV3_Large(nn.Module):
    def __init__(self, num_classes=1000):
        super(MobileNetV3_Large, self).__init__()
        self.conv1 = nn.Conv2d(3, 16, kernel_size=3, stride=2, padding=1, bias=False)
        self.bn1 = nn.BatchNorm2d(16)
        self.hs1 = hswish()

        self.bneck = nn.Sequential(
            Block(3, 16, 16, 16, nn.ReLU(inplace=True), None, 1),
            Block(3, 16, 64, 24, nn.ReLU(inplace=True), None, 2),
            Block(3, 24, 72, 24, nn.ReLU(inplace=True), None, 1),
            Block(5, 24, 72, 40, nn.ReLU(inplace=True), SeModule(40), 2),
            Block(5, 40, 120, 40, nn.ReLU(inplace=True), SeModule(40), 1),
            Block(5, 40, 120, 40, nn.ReLU(inplace=True), SeModule(40), 1),
            Block(3, 40, 240, 80, hswish(), None, 2),
            Block(3, 80, 200, 80, hswish(), None, 1),
            Block(3, 80, 184, 80, hswish(), None, 1),
            Block(3, 80, 184, 80, hswish(), None, 1),
            Block(3, 80, 480, 112, hswish(), SeModule(112), 1),
            Block(3, 112, 672, 112, hswish(), SeModule(112), 1),
            Block(5, 112, 672, 160, hswish(), SeModule(160), 1),
            Block(5, 160, 672, 160, hswish(), SeModule(160), 2),
            Block(5, 160, 960, 160, hswish(), SeModule(160), 1),
        )


        self.conv2 = nn.Conv2d(160, 960, kernel_size=1, stride=1, padding=0, bias=False)
        self.bn2 = nn.BatchNorm2d(960)
        self.hs2 = hswish()
        self.linear3 = nn.Linear(960, 1280)
        self.bn3 = nn.BatchNorm1d(1280)
        self.hs3 = hswish()
        self.linear4 = nn.Linear(1280, num_classes)
        self.init_params()

    def init_params(self):
        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                init.kaiming_normal_(m.weight, mode='fan_out')
                if m.bias is not None:
                    init.constant_(m.bias, 0)
            elif isinstance(m, nn.BatchNorm2d):
                init.constant_(m.weight, 1)
                init.constant_(m.bias, 0)
            elif isinstance(m, nn.Linear):
                init.normal_(m.weight, std=0.001)
                if m.bias is not None:
                    init.constant_(m.bias, 0)

    def forward(self, x):
        out = self.hs1(self.bn1(self.conv1(x)))
        out = self.bneck(out)
        out = self.hs2(self.bn2(self.conv2(out)))
        out = F.avg_pool2d(out, 7)
        out = out.view(out.size(0), -1)
        out = self.hs3(self.bn3(self.linear3(out)))
        out = self.linear4(out)
        return out



class MobileNetV3_Small(nn.Module):
    def __init__(self, num_classes=1000):
        super(MobileNetV3_Small, self).__init__()
        self.conv1 = nn.Conv2d(3, 16, kernel_size=3, stride=2, padding=1, bias=False)
        self.bn1 = nn.BatchNorm2d(16)
        self.hs1 = hswish()

        self.bneck = nn.Sequential(
            Block(3, 16, 16, 16, nn.ReLU(inplace=True), SeModule(16), 2),
            Block(3, 16, 72, 24, nn.ReLU(inplace=True), None, 2),
            Block(3, 24, 88, 24, nn.ReLU(inplace=True), None, 1),
            Block(5, 24, 96, 40, hswish(), SeModule(40), 2),
            Block(5, 40, 240, 40, hswish(), SeModule(40), 1),
            Block(5, 40, 240, 40, hswish(), SeModule(40), 1),
            Block(5, 40, 120, 48, hswish(), SeModule(48), 1),
            Block(5, 48, 144, 48, hswish(), SeModule(48), 1),
            Block(5, 48, 288, 96, hswish(), SeModule(96), 2),
            Block(5, 96, 576, 96, hswish(), SeModule(96), 1),
            Block(5, 96, 576, 96, hswish(), SeModule(96), 1),
        )


        self.conv2 = nn.Conv2d(96, 576, kernel_size=1, stride=1, padding=0, bias=False)
        self.bn2 = nn.BatchNorm2d(576)
        self.hs2 = hswish()
        self.linear3 = nn.Linear(576, 1280)
        self.bn3 = nn.BatchNorm1d(1280)
        self.hs3 = hswish()
        self.linear4 = nn.Linear(1280, num_classes)
        self.init_params()

    def init_params(self):
        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                init.kaiming_normal_(m.weight, mode='fan_out')
                if m.bias is not None:
                    init.constant_(m.bias, 0)
            elif isinstance(m, nn.BatchNorm2d):
                init.constant_(m.weight, 1)
                init.constant_(m.bias, 0)
            elif isinstance(m, nn.Linear):
                init.normal_(m.weight, std=0.001)
                if m.bias is not None:
                    init.constant_(m.bias, 0)

    def forward(self, x):
        out = self.hs1(self.bn1(self.conv1(x)))
        out = self.bneck(out)
        out = self.hs2(self.bn2(self.conv2(out)))
        out = F.avg_pool2d(out, 7)
        out = out.view(out.size(0), -1)
        out = self.hs3(self.bn3(self.linear3(out)))
        out = self.linear4(out)
        return out



def test():
    net = MobileNetV3_Small()
    x = torch.randn(2,3,224,224)
    y = net(x)
    print(y.size())

test()
Yuezero_
关注
  • 6
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
MobileNetV3-SSD:MobileNetV3-SSD用于PyTorch中的对象检测和实现
05-28
MobileNetV3-SSD MobileNetV3-SSD implementation in PyTorch 关于第二个版本请移步 有测试结果 希望尝试新技术请到这里 一个轻量级的目标检测包括多种模型 目的 Object Detection 应用于目标检测 环境 操作系统: Ubuntu18.04 Python: 3.6 PyTorch: 1.1.0 使用MobileNetV3-SSD实现目标检测 Support Export ONNX 代码参考（严重参考以下代码） 一 SSD部分 二 MobileNetV3 部分 4 MobileNetV1, MobileNetV2, VGG based SSD/SSD-lite implementation in Pytorch 1.0 / Pytorch 0.4. Out-of-box support for retraining on O
Python-MobileNetV2在pytorch中的实现
08-09
MobileNet V2在pytorch中的实现
【轻量化网络系列（3）】MobileNetV3论文超详细解读（翻译 ＋学习笔记+代码实现）
路人贾的博客
05-23 7043
MobileNetV3论文《MobileNetV3: Searching for MobileNetV3》翻译+超详细精读，包含代码实现
经典轻量化网络结构（pytorch代码）
最新发布
全栈O-Jay的博客
03-13 263
经典轻量化网络结构（pytorch代码），MobileNet，SqueezeNet，ShuffleNet。
MobileNetV3原理说明及实践落地
benben044的专栏
12-15 1751
每个Block经过两个卷积层后得到一个由channel个元素组成的向量，每个元素是针对每个通道的权重，将权重和原特征图对应相乘，得到新的特征图数据。
MobileNets(V1)简介及两个初步的代码实验
chenxy_bwave的专栏
04-25 3339
MobileNet在2017年由谷歌2017年提出[1]，主要是为了解决卷积神经网络在移动端或者嵌入式平台中落地应用的运算负荷的问题。一方面，各路大神不断地在修炼越来越大的网络，另一方面，移动端或者嵌入式则要求轻量级的网络，同时又要求性能上没有严重的损失，正所谓既要马儿跑的好，又要马儿不吃草。本文概要性地价绍MobileNet的基本要素，然后做了两个代码实验： (1) 基于预训练的MobileNet模型的特征提取训练的猫狗分类器；(2) 仅利用MobileNet模型结构在CIFAR10数据集
MobileNet V3代码
weixin_44543648的博客
04-26 1544
代码： import torch import torch.nn as nn import torch.nn.functional as F class h_swish(nn.Module): def forward(self,x): return x*F.relu6(x+3)/6 class swish(nn.Module): def forward(self,x): return x*F.sigmoid(x) class h_sigmoid(...
Pytorch MobileNetV1 学习
记录学习过程
07-24 402
pytorch mobilenet v1
MobileNet-V2 pytorch0.3.0代码
08-12
MobileNet-V2 pytorch0.3.0代码,很好用希望对大家有帮助！
MobileNet代码
敲代码的小风
02-15 953
参考链接: pytorch实现MobileNet 实验代码展示: import torch import torch.nn as nn import torch.nn.functional as F class Block(nn.Module): '''Depthwise conv + Pointwise conv 实现深度卷积和逐点卷积''' def __init__(self, in_planes, out_planes, stride=1): super(B
MobileNetV3代码（pytorch）
smallworldxyl的博客
11-28 6588
MobileNetV3-Large结构图 第一列Input代表mobilenetV3每个特征层的shape变化； 第二列Operator代表每次特征层即将经历的block结构，我们可以看到在MobileNetV3中，特征提取经过了许多的bneck结构； 第三、四列分别代表了bneck内逆残差结构上升后的通道数、输入到bneck时特征层的通道数。 第五列SE代表了是否在这一层引入注意力机制。 第六列NL代表了激活函数的种类，HS代表h-swish，RE代表RELU。 第七列s代表了每一次block结构所用的步
mobilenetV2.py
12-07
mobilenetV2 网络结构，实测可用，可以详细读懂代码，欢迎下载
图像分类MobileNet系列源代码:v1-v3
07-05
完整的MobileNet v1-v3的源代码，包括模型脚本、训练以及预测脚本。并有完整的博客介绍： 1. MobileNet系列(1) :MobileNet V1网络详解：https://blog.csdn.net/weixin_38346042/article/details/125329726?spm=1001.2014.3001.5501 2. MobileNet系列(2)：MobileNet-V2 网络详解：https://blog.csdn.net/weixin_38346042/article/details/125355111?spm=1001.2014.3001.5501 3.MobileNet系列(4):MobileNetv3网络详解：https://blog.csdn.net/weixin_38346042/article/details/125470446?spm=1001.2014.3001.5501
Mobile代码
01-11
基于MobileNet中卷积策略的改进，适用一维数据和二维数据。
MobileNetV3-PyTorch:MobileNetV3的PyTorch实现
03-16
MobileNetV3-PyTorch MobileNetV3的PyTorch实现 概述 MobileNetV3体系结构的PyTorch实现： 。 基于MNASNet（可通过架构搜索找到），添加了量化友好的SqueezeExcite和Swish + NetAdapt + Compact层。 结果：比MobileNetV2快2倍，并且更准确。 MobileNetV3体系结构 MobileNetV3结果
深度学习网络模型 MobileNet系列v1 ~ v3网络详解以及pytorch代码复现
10-31
深度学习网络模型 MobileNet系列v1 ~ v3网络详解以及pytorch代码复现 1、DW卷积与普通卷积计算量对比 DW与PW计算量 普通卷积计算量 计算量对比 2、MobileNet V1 MobileNet V1网络结构 MobileNet V1网络结构代码 3、...
Pointnet2 / Pointnet ++的PyTorch实现-Python开发
05-25
支持PyTorch版本> = 1.0.0。 使用v1.0支持较旧版本的PyTorch。 有关正式的模型定义和超参数，请参见本文的官方代码发布（以tensorflow格式），charlesq34 / pointnet2。 使用CUDA的GPU当前仅支持Pointnet ++使用的...
代码+扩散卷积循环神经网络的交通流预测（代码+内附论文+pytorch版本）
03-25
代码+扩散卷积循环神经网络的交通流预测（代码+内附论文+pytorch版本）
自爆绝缘子语义分割，deeplab_v3+完整pytorch工程代码
04-22
主干网络在算力不足时可选择轻量版的mobilenet_v2，算力足够时可选择Xception。 deeplab_v3+：用一个简单有效的解码器模块扩展deeplab_v3优化细分结果，尤其是沿目标边界。此外，在这种编码器 - 解码器结构中，可以...
python tnn mobilenet分类代码
05-31
以下是使用TensorFlow Lite实现Mobilenet分类的Python代码： ```python import tensorflow as tf import numpy as np from PIL import Image # 加载模型 interpreter = tf.lite.Interpreter(model_path="mobilenet.tflite") interpreter.allocate_tensors() # 获取输入和输出张量 input_details = interpreter.get_input_details() output_details = interpreter.get_output_details() # 加载标签 with open("labels.txt", "r") as f: labels = [line.strip() for line in f.readlines()] # 读取图像并进行预处理 img = Image.open("test.jpg").resize((224, 224)) img_array = np.array(img).astype('float32') / 255.0 img_array = np.expand_dims(img_array, axis=0) # 输入图像并进行推理 interpreter.set_tensor(input_details[0]['index'], img_array) interpreter.invoke() # 获取输出结果并进行后处理 output_data = interpreter.get_tensor(output_details[0]['index']) predictions = np.squeeze(output_data) # 输出预测结果 top_k = predictions.argsort()[-5:][::-1] for i in top_k: print(labels[i], predictions[i]) ``` 其中，`mobilenet.tflite`是经过训练的Mobilenet模型，`labels.txt`是包含标签名称的文本文件，`test.jpg`是待分类的图像。你需要将这些文件替换成自己的文件。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Yuezero_

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

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

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

打赏作者

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

抵扣说明：

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

余额充值