MobileNetV_3代码理解

最新推荐文章于 2024-05-28 09:35:36 发布
最新推荐文章于 2024-05-28 09:35:36 发布
阅读量893 收藏 4
点赞数 1
分类专栏： pytorch基本模型理解
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40970506/article/details/104467623
版权 
class MobileNetV3(nn.Module):
    # def __init__(self, model_mode="SMALL", num_classes=30, multiplier=1.0):
    def __init__(self, model_mode="SMALL", num_classes=30, multiplier=1.0, dropout_rate=0.0):
        super(MobileNetV3, self).__init__()
        self.num_classes = num_classes

        if model_mode == "LARGE":
            # 参数设置
            layers = [
                [16, 16, 3, 1, "RE", False, 16],
                [16, 24, 3, 2, "RE", False, 64],
                [24, 24, 3, 1, "RE", False, 72],
                [24, 40, 5, 2, "RE", True, 72],
                [40, 40, 5, 1, "RE", True, 120],

                [40, 40, 5, 1, "RE", True, 120],
                [40, 80, 3, 2, "HS", False, 240],
                [80, 80, 3, 1, "HS", False, 200],
                [80, 80, 3, 1, "HS", False, 184],
                [80, 80, 3, 1, "HS", False, 184],

                [80, 112, 3, 1, "HS", True, 480],
                [112, 112, 3, 1, "HS", True, 672],
                [112, 160, 5, 1, "HS", True, 672],
                [160, 160, 5, 2, "HS", True, 672],
                [160, 160, 5, 1, "HS", True, 960],
            ]
            init_conv_out = _make_divisible(16 * multiplier)
            self.init_conv = nn.Sequential(
                nn.Conv2d(in_channels=3, out_channels=init_conv_out, kernel_size=3, stride=2, padding=1),
                nn.BatchNorm2d(init_conv_out),
                h_swish(inplace=True),
            )  # 3x3卷积 第一个卷积层

            self.block = []
            for in_channels, out_channels, kernal_size, stride, nonlinear, se, exp_size in layers:  # 依次遍历15个参数设置
                # 输入通道数，输出通道数，卷积核大小，步长，非线性，se模块，扩张因子exp_size
                in_channels = _make_divisible(in_channels * multiplier)
                out_channels = _make_divisible(out_channels * multiplier)
                exp_size = _make_divisible(exp_size * multiplier)  # 新的层数
                self.block.append(MobileBlock(in_channels, out_channels, kernal_size, stride, nonlinear, se, exp_size))
            self.block = nn.Sequential(*self.block)  # 15个bneck

            out_conv1_in = _make_divisible(160 * multiplier)
            out_conv1_out = _make_divisible(960 * multiplier)
            self.out_conv1 = nn.Sequential(
                nn.Conv2d(out_conv1_in, out_conv1_out, kernel_size=1, stride=1),  # 1x1卷积  倒数第三个conv2d, 1x1
                nn.BatchNorm2d(out_conv1_out),
                h_swish(inplace=True),
            )
            self.avg_pool = nn.AdaptiveAvgPool2d(1)  # 自适应池化操作
            out_conv2_in = _make_divisible(960 * multiplier)
            out_conv2_out = _make_divisible(1280 * multiplier)
            self.out_conv2 = nn.Sequential(
                nn.Conv2d(out_conv2_in, out_conv2_out, kernel_size=1, stride=1),  # 1x1卷积 倒数第二个conv2d 1x1, NBN
                h_swish(inplace=True),
                nn.Dropout(dropout_rate),  # dropout
                nn.Conv2d(out_conv2_out, self.num_classes, kernel_size=1, stride=1),  # 1x1卷积 最后一个conv2d 1x1, NBN
            )

        elif model_mode == "SMALL":
            layers = [
                [16, 16, 3, 2, "RE", True, 16],
                [16, 24, 3, 2, "RE", False, 72],
                [24, 24, 3, 1, "RE", False, 88],
                [24, 40, 5, 2, "RE", True, 96],
                [40, 40, 5, 1, "RE", True, 240],
                [40, 40, 5, 1, "RE", True, 240],
                [40, 48, 5, 1, "HS", True, 120],
                [48, 48, 5, 1, "HS", True, 144],
                [48, 96, 5, 2, "HS", True, 288],
                [96, 96, 5, 1, "HS", True, 576],
                [96, 96, 5, 1, "HS", True, 576],
            ]

            init_conv_out = _make_divisible(16 * multiplier)
            self.init_conv = nn.Sequential(
                nn.Conv2d(in_channels=3, out_channels=init_conv_out, kernel_size=3, stride=2, padding=1),
                nn.BatchNorm2d(init_conv_out),
                h_swish(inplace=True),
            )
            self.block = []
            for in_channels, out_channels, kernal_size, stride, nonlinear, se, exp_size in layers:  # 依次遍历15个参数设置
                in_channels = _make_divisible(in_channels * multiplier)
                out_channels = _make_divisible(out_channels * multiplier)
                exp_size = _make_divisible(exp_size * multiplier)
                self.block.append(MobileBlock(in_channels, out_channels, kernal_size, stride, nonlinear, se, exp_size))
            self.block = nn.Sequential(*self.block)

            out_conv1_in = _make_divisible(96 * multiplier)
            out_conv1_out = _make_divisible(576 * multiplier)
            self.out_conv1 = nn.Sequential(
                nn.Conv2d(out_conv1_in, out_conv1_out, kernel_size=1, stride=1),  # 1x1卷积 倒数第三个 用了se模块
                SqueezeBlock(out_conv1_out),  # se模块
                nn.BatchNorm2d(out_conv1_out),
                h_swish(inplace=True),
            )
            self.avg_pool = nn.AdaptiveAvgPool2d(1)  # 自适应池化操作

            out_conv2_in = _make_divisible(576 * multiplier)
            out_conv2_out = _make_divisible(1280 * multiplier)
            self.out_conv2 = nn.Sequential(
                nn.Conv2d(out_conv2_in, out_conv2_out, kernel_size=1, stride=1),   # 1x1卷积 倒数第二个
                h_swish(inplace=True),
                nn.Dropout(dropout_rate),  # dropout
                nn.Conv2d(out_conv2_out, self.num_classes, kernel_size=1, stride=1),   # 1x1卷积 倒数第一个
            )

        self.apply(_weights_init)

    def forward(self, x):
        out = self.init_conv(x)
        out = self.block(out)
        out = self.out_conv1(out)
        batch, channels, height, width = out.size()
        out = self.avg_pool(out)  #
        out = self.out_conv2(out).view(batch, -1)
        return out

def _make_divisible(v, divisor=8, min_value=None):
	# 计算新的通道数divisor=8
    if min_value is None:
        min_value = divisor
    new_v = max(min_value, int(v + divisor / 2) // divisor * divisor)
    # Make sure that round down does not go down by more than 10%.
    if new_v < 0.9 * v:
        new_v += divisor
    return new_v

class MobileBlock(nn.Module):
    # def __init__(self, in_channels, out_channels, kernal_size, stride, nonLinear, SE, exp_size, dropout_rate=1.0):
    def __init__(self, in_channels, out_channels, kernal_size, stride, nonLinear, SE, exp_size):
        super(MobileBlock, self).__init__()
        self.out_channels = out_channels
        self.nonLinear = nonLinear
        self.SE = SE
        # self.dropout_rate = dropout_rate
        padding = (kernal_size - 1) // 2

        self.use_connect = stride == 1 and in_channels == out_channels  # 残差选择

        if self.nonLinear == "RE":  # 激活函数选择
            activation = nn.ReLU
        else:
            activation = h_swish

        self.conv = nn.Sequential(
            nn.Conv2d(in_channels, exp_size, kernel_size=1, stride=1, padding=0, bias=False),
            nn.BatchNorm2d(exp_size),
            activation(inplace=True)
        )
        self.depth_conv = nn.Sequential(
            nn.Conv2d(exp_size, exp_size, kernel_size=kernal_size, stride=stride, padding=padding, groups=exp_size),  # 可分离卷积
            nn.BatchNorm2d(exp_size),
        )

        if self.SE:
            self.squeeze_block = SqueezeBlock(exp_size)  # se模块

        self.point_conv = nn.Sequential(
            nn.Conv2d(exp_size, out_channels, kernel_size=1, stride=1, padding=0),  # 点卷积 1x1卷积
            nn.BatchNorm2d(out_channels),
            activation(inplace=True)
        )

    def forward(self, x):
        # MobileNetV2
        out = self.conv(x)
        out = self.depth_conv(out)

        # Squeeze and Excite
        if self.SE:  # se模块计算
            out = self.squeeze_block(out)

        # point-wise conv
        out = self.point_conv(out)

        # connection
        if self.use_connect:  # 残差计算
            return x + out
        else:
            return out

class SqueezeBlock(nn.Module):
    def __init__(self, exp_size, divide=4):
        super(SqueezeBlock, self).__init__()
        self.avg_pool = nn.AdaptiveAvgPool2d(1)
        self.dense = nn.Sequential(
            nn.Linear(exp_size, exp_size // divide),
            nn.ReLU(inplace=True),
            nn.Linear(exp_size // divide, exp_size),
            h_sigmoid()
        )

    def forward(self, x):
        batch, channels, height, width = x.size()
        # out = F.avg_pool2d(x, kernel_size=[height, width]).view(batch, -1)
        out = self.avg_pool(x).view(batch, channels)
        out = self.dense(out)
        out = out.view(batch, channels, 1, 1)
        # out = hard_sigmoid(out)

        return out * x

def _weights_init(m):
    if isinstance(m, nn.Conv2d):
        torch.nn.init.xavier_uniform_(m.weight)
        if m.bias is not None:
            torch.nn.init.zeros_(m.bias)
    elif isinstance(m, nn.BatchNorm2d):
        m.weight.data.fill_(1)
        m.bias.data.zero_()
    elif isinstance(m, nn.Linear):
        n = m.weight.size(1)
        m.weight.data.normal_(0, 0.01)
        m.bias.data.zero_()


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

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


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

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

论文链接
代码链接

土士
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
MobileNetV3代码（pytorch）
smallworldxyl的博客
11-28 6853
MobileNetV3-Large结构图 第一列Input代表mobilenetV3每个特征层的shape变化； 第二列Operator代表每次特征层即将经历的block结构，我们可以看到在MobileNetV3中，特征提取经过了许多的bneck结构； 第三、四列分别代表了bneck内逆残差结构上升后的通道数、输入到bneck时特征层的通道数。 第五列SE代表了是否在这一层引入注意力机制。 第六列NL代表了激活函数的种类，HS代表h-swish，RE代表RELU。 第七列s代表了每一次block结构所用的步
MobileNetV3
2401_83817122的博客
04-07 903
out = out.view(b, -1)out = self.SEblock(out)out = out.view(b, c, 1, 1)return out * xclass SEInvertedBottleneck(nn.Module):def init(self, in_channels, mid_channels, out_channels, kernel_size, stride,activate, use_se, se_kernel_size=1):super(SEInvertedBottle
推荐文章：MobileNetV3 —— 移动端高效的深度学习模型
最新发布
gitblog_00056的博客
05-28 408
推荐文章：MobileNetV3 —— 移动端高效的深度学习模型 MobileNetV3项目地址:https://gitcode.com/gh_mirrors/mob/MobileNetV3 项目介绍 MobileNetV3 是一个基于Keras的深度学习框架实现，专门针对移动设备优化的轻量级神经网络架构。该项目源自学术论文《Searching for MobileNetV3》，旨在探索更高效、...
MobileNet V3代码
weixin_44543648的博客
04-26 1620
代码： 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(...
MobileNetV3代码和网络
qq_43739296的博客
01-06 1863
MobileNetV3实现 参考博客： https://zhuanlan.zhihu.com/p/323346888 https://blog.csdn.net/qq_43739296/article/details/122338041 来自paddelocr中的MobileNetV3，实现网络的类如下。 ConvBNLayer ConvBNLayer类实际上就是实现了一个卷积层+bn层，如名所示。当我们写其他模块需要用到各种卷积层如1x1卷积和depth-wise卷积时，就可以通过传入各种相关参数给它实
使用pytorch写的mobilenet v3代码，详细注释，可以生成训练集和测试集的损失和准确率的折线图
05-01
在本项目中，我们主要探讨的是使用PyTorch框架实现的Mobilenet V3模型，这是一个轻量级的深度学习模型，特别适用于移动设备和资源有限的...同时，注释丰富的代码也适合初学者理解和实践深度学习模型的构建和训练流程。
Python-MobileNetV3的PyTorch实现提供预训练的模型
08-11
1. **源代码**：实现MobileNetV3架构的Python文件，可能包括模型定义、训练脚本和评估代码。 2. **预训练模型**：保存在`.pth`或`.pt`文件中的模型权重，可以直接加载到PyTorch模型实例中。 3. **示例数据**：用于...
目标检测实战4-运行object_detection_tutorial demo
12-21
4. **执行程序**：如果你的TensorFlow版本与教程中的不一致（例如，这里使用的是2.0.0-alpha0），可能需要对源代码进行一些修改，比如在`label_map_util.py`文件中。确保所有路径使用绝对路径，因为错误常常与...
object_detection
08-12
随后的YOLOv2和YOLOv3进行了改进，例如引入了多尺度检测和更先进的网络结构，提升了检测精度。 **SSD**：Single Shot MultiBox Detector（SSD）是另一种单阶段检测框架，它直接在特征图上预测边界框和类别，避免了...
MobileNetV3-PyTorch:MobileNetV3的PyTorch实现
03-16
MobileNetV3-PyTorch MobileNetV3的PyTorch实现 概述 MobileNetV3体系结构的PyTorch实现： 。 基于MNASNet（可通过架构搜索找到），添加了量化友好的SqueezeExcite和Swish + NetAdapt + Compact层。 结果：比MobileNetV2快2倍，并且更准确。 MobileNetV3体系结构 MobileNetV3结果
mobileNetv3.zip
10-22
包含MobileNet v3 large和small两个版本，其中除了原始版本的使用H-swish和SE模块的prototxt外，还有用relu和SE模块实现的版本，以及使用relu并去掉SE模块的最精简的版本，三个版本测试效果差别不大，最精简的版本，模型最小（5.89M），我自己得250类车辆分类数据集上可以达到0.996的测试准确率。
图像分类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
MobileViT代码
08-20
MobileViT网络，将 CNN 和 ViT 的优势结合起来。在轻量的基础上具有可以处理全局信息的能力。 实验结果表明：在不同的任务和数据集上，MobileViT明显优于基于cnn和viti的网络。在ImageNet-1k数据集上，MobileViT在约600万个参数下达到了78.4%的前1准确率，在相同数量的参数下，比MobileNetv3(基于CNN)和 DeIT (基于ViT)的准确率分别提高了3.2%和6.2%。在MS-COCO目标检测任务上，对于相似数量的参数，MobileViT比MobileNetv3的准确率高5.7%。
Python-使用Pytorch实现搜索MobileNetV3论文
08-11
通过阅读和理解这些代码，你可以深入理解MobileNetV3的结构以及如何在PyTorch中实现它。 总结起来，Python和PyTorch结合使得我们能够轻松地复现MobileNetV3这样的先进模型，同时享受到动态图带来的便利。在实际应用...
MobileNetv_3网络结构+代码
y473459100的博客
03-21 2658
前言 MobileNet系列由Google提出，2019年Google正式提出MobileNetv_3，论文题目为《Searching for MobileNetV3》 论文地址：https://arxiv.org/pdf/1905.02244.pdf 代码地址：https://hub.fastgit.org/xiaolai-sqlai/mobilenetv3（hub.fastgit.org为Github的镜像网站，可加速进入） MobileNetv_3是MnasNet的改进版，研究人员公布了.
chainer-骨干网络backbone-MobileNetV3代码重构【附源码】
ctu_sue的博客
01-14 431
本文基于chainer实现MobileNetV3网络结构，并基于torch的结构方式构建chainer版的，并计算MobileNetV3的参数量。本次基于chainer 实现了Hardsigmoid、Hardswish、Relu6、Relu等激活函数。
【神经网络】(16) MobileNetV3 代码复现，网络解析，附Tensorflow完整代码
热门推荐
博观而约取，厚积而薄发
03-14 1万+
各位同学好，今天和大家分享一下如何使用 Tensorflow 构建 MobileNetV3 轻量化网络模型。 之前我介绍了许多种类的卷积神经网络模型，感兴趣的可以看一下：https://blog.csdn.net/dgvv4/category_11517910.html MobileNetV3 ...
请你把MobileNetV3_Small 代码模型写出来
06-12
好的，这里是 MobileNetV3_Small 的代码实现： ``` import torch import torch.nn as nn class ConvBNReLU(nn.Sequential): """Convolutional layer with batch normalization and ReLU activation.""" def __init__(self, in_planes, out_planes, kernel_size=3, stride=1, groups=1): padding = (kernel_size - 1) // 2 super(ConvBNReLU, self).__init__( nn.Conv2d(in_planes, out_planes, kernel_size, stride, padding, groups=groups, bias=False), nn.BatchNorm2d(out_planes), nn.ReLU6(inplace=True) ) class InvertedResidual(nn.Module): """Inverted residual block.""" def __init__(self, inp, oup, stride, expand_ratio): super(InvertedResidual, self).__init__() hidden_dim = round(inp * expand_ratio) self.use_res_connect = stride == 1 and inp == oup layers = [] if expand_ratio != 1: # pointwise layers.append(ConvBNReLU(inp, hidden_dim, kernel_size=1)) layers.extend([ # depthwise ConvBNReLU(hidden_dim, hidden_dim, stride=stride, groups=hidden_dim), # pointwise-linear nn.Conv2d(hidden_dim, oup, 1, 1, 0, bias=False), nn.BatchNorm2d(oup), ]) self.conv = nn.Sequential(*layers) def forward(self, x): if self.use_res_connect: return x + self.conv(x) else: return self.conv(x) class MobileNetv3_small(nn.Module): """MobileNetV3_Small model.""" def __init__(self, num_classes=1000, width_mult=1.0): super(MobileNetv3_small, self).__init__() # setting of inverted residual blocks self.cfgs = [ # k, t, c, SE, s [3, 16, 16, 0, 1], [3, 72, 24, 0, 2], [3, 88, 24, 0, 1], [5, 96, 40, 1, 2], [5, 240, 40, 1, 1], [5, 240, 40, 1, 1], [5, 120, 48, 1, 1], [5, 144, 48, 1, 1], [5, 288, 96, 1, 2], [5, 576, 96, 1, 1], [5, 576, 96, 1, 1], ] # building first layer input_channel = int(16 * width_mult) last_channel = int(576 * width_mult) if width_mult > 1.0 else 576 self.features = [ConvBNReLU(3, input_channel, stride=2)] # building inverted residual blocks for k, exp_size, c, se, s in self.cfgs: output_channel = int(c * width_mult) self.features.append(InvertedResidual(input_channel, output_channel, stride=s, expand_ratio=exp_size/ input_channel)) input_channel = output_channel # building last several layers self.features.append(ConvBNReLU(input_channel, last_channel, kernel_size=1)) self.features.append(nn.AdaptiveAvgPool2d((1, 1))) self.features.append(nn.Conv2d(last_channel, 1024, kernel_size=1, stride=1, padding=0, bias=False)) self.features.append(nn.Hardswish()) self.features.append(nn.Conv2d(1024, num_classes, kernel_size=1, stride=1, padding=0, bias=True)) self.features = nn.Sequential(*self.features) def forward(self, x): x = self.features(x) x = x.view(x.size(0), -1) return x ``` 这个实现中包含了 MobileNetV3_Small 模型中使用的 Inverted Residual Block 和 ConvBNReLU 等基本组件。同时，在实现模型的过程中，作者还考虑到了模型的可配置性，可以通过调整宽度因子 `width_mult` 来控制模型的宽度。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值