轻量化网络 Mobilenet V1/V2/V3 学习记录

news2024/11/17 9:59:48

    • 1. 传统卷积
    • 2. Mobilenet V1
      • 2.1 Separable卷积
      • 2.2 整体结构
    • 3. Mobilenet V2
      • 3.1 Relu
      • 3.2 逆残差
      • 3.3 整体结构
    • 4. Mobilenet V3
      • 4.1 SE attention
      • 4.2 Switch激活函数
    • 5. Mobilenet V3 代码

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

V1(Separable卷积)->V2(逆残差)->V3(SE)

1. 传统卷积

在这里插入图片描述
输入图像的channel=卷积核的channel
在这里插入图片描述
计算量 与 H W 卷积核大小有关
在这里插入图片描述

2. Mobilenet V1

2.1 Separable卷积

Step1：逐通道独立卷积（Depthwise卷积）：一个卷积核负责一个通道
在这里插入图片描述在这里插入图片描述

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

2.2 整体结构

在这里插入图片描述
v1一路卷积到底
使用relu6

3. Mobilenet V2

在这里插入图片描述

3.1 Relu

relu使低维数据损失信息
在这里插入图片描述

3.2 逆残差

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

3.3 整体结构

在这里插入图片描述

4. Mobilenet V3

在这里插入图片描述

4.1 SE attention

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

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

在这里插入图片描述

4.2 Switch激活函数

在这里插入图片描述

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()

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/22667.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

根目录挂载的/dev/mapper/centos-root分区扩容

根目录挂载的/dev/mapper/centos-root分区扩容

iso：centos7.9 操作系统40G，我想用其中一块盘扩容给我的根目录 1. 新增一个分区，并将分区设置为物理卷 [rootmaster ~]# parted /dev/vdb GNU Parted 3.3 使用 /dev/vdb 欢迎使用 GNU Parted！输入 help 来查看命令列表。 (…
阅读更多...
IPD的商业实现过程

IPD的商业实现过程

一、商业实现的主要流程 在传统的以产品为唯一中心的企业里，商业实现其实是产品实现的结果和表现。但随着企业外部影响商业结果的因素增多，随着产业链中更多的企业间协调机会和协同要求的出项，商业实现像产品实现一样具有实体性，也需要发现机会，需要制定计划，进行商业开发…
阅读更多...
【Java 数据结构】栈与OJ题

【Java 数据结构】栈与OJ题

篮球哥温馨提示：编程的同时不要忘记锻炼哦！风在叙述它的阅历，树在书写它的温柔。 目录 1、什么是栈？ 2、模拟实现一个栈 2.1 构造方法和成员属性 2.2 push 方法 2.3 pop 方法 2.4 peek 方法 2.5 empty 方法 3. 栈相关的OJ…
阅读更多...
一次请求的来龙去脉 - Tomcat架构解析(一)

一次请求的来龙去脉 - Tomcat架构解析(一)

> Tomcat作为我们学习JavaEE的一个重要的web服务器，对整个请求的来龙去脉有所了解，将直接使得我们对JavaEE的学习更加的事半功倍。并且深入了解Tomcat架构设计之后，将使得我们在以后搭建自己的项目架构提供借鉴。那么接下来，我…
阅读更多...
DOTA-PEG-葡萄糖 DOTA-葡萄糖

DOTA-PEG-葡萄糖 DOTA-葡萄糖

DOTA-PEG-葡萄糖 DOTA-葡萄糖 中文名称：葡萄糖-四氮杂环十二烷四乙酸 英文名称：Glucose-DOTA 别称：DOTA修饰葡萄糖，DOTA-葡萄糖 PEG接枝修饰葡萄糖 葡萄糖-聚乙二醇-四氮杂环十二烷四乙酸 DOTA-PEG-葡萄糖 纯度&#xff1a…
阅读更多...
Vue--》简述组件的数据共享

Vue--》简述组件的数据共享

目录 组件数据共享 父组件向子组件共享数据 子组件向父组件共享数据 兄弟组件共享数据 组件数据共享 组件之间的关系：在项目开发中，组件之间的最常用的关系分为两种：父子关系和兄弟关系。 父组件向子组件共享数据 通过自定义属性实现父…
阅读更多...
进大厂必备的 Java 八股文大全（2022 最强精简易懂版）

进大厂必备的 Java 八股文大全（2022 最强精简易懂版）

很多同学会问 Java 面试八股文有必要背吗？ 答案是，必须背，博主是个三本，今年凭借这篇八股文斩获了多个大厂暑期实习 offer，相信秋招一定也可以发挥重要作用。 你可以讨厌这种模式，但你一定要去背&#xf…
阅读更多...
【Kafka从成神到升仙系列 四】你真的了解 Kafka 的缓存池机制嘛

【Kafka从成神到升仙系列 四】你真的了解 Kafka 的缓存池机制嘛

👏作者简介：大家好，我是爱敲代码的小黄，独角兽企业的Java开发工程师，CSDN博客专家，Java领域新星创作者📕系列专栏：Java设计模式、数据结构和算法、Kafka从入门到成神、Kafka从成神到…
阅读更多...
垃圾回收器（宋红康JVM学习笔记）

垃圾回收器（宋红康JVM学习笔记）

垃圾回收器分类 按线程数分，可以分为串行垃圾回收器和并行垃圾回收器。 串行回收指的是同一时间内只允许有一个CPU用于执行垃圾回收操作，此时工作线程被暂停，直到垃圾收集工作结束。 并行收集可以运用多个CPU同时执行垃圾回收&#xff0c…
阅读更多...
Bootstrap实现个人blog项目(1+X Web前端开发中级 例题)——初稿

Bootstrap实现个人blog项目(1+X Web前端开发中级 例题)——初稿

📄题目要求 阅读下列说明、效果图和HTML代码，进行静态网页开发，填写（1）至（20）代码。🧩说明 这是个人blog项目，该项目的目录是myblog，现在我们需要编写该blog…
阅读更多...
在地图上可视化地理空间数据的12种方法

在地图上可视化地理空间数据的12种方法

地图绘制或制图是地理空间数据的可视化。它是一门艺术，因其寻求以一种更容易被非技术受众理解或解释的形式来表示数据。但它也是一门确保视觉效果与所基于的数据准确一致的科学。鉴于地图的优势和局限性，一些样式的地图在表示某些类型的信息方面比其他样…
阅读更多...
PTA题目 福到了

PTA题目 福到了

“福”字倒着贴，寓意“福到”。不论到底算不算民俗，本题且请你编写程序，把各种汉字倒过来输出。这里要处理的每个汉字是由一个 N N 的网格组成的，网格中的元素或者为字符 或者为空格。而倒过来的汉字所用的字符由裁判指定。 输…
阅读更多...
原来 GitHub 不仅能学代码，还有这些东西

原来 GitHub 不仅能学代码，还有这些东西

今天介绍几个很有意思的 github 开源项目，看过之后就会发现，github 果然深意暗藏。 github 作为一个若隐若现（有时墙有时不墙）的网站，对于程序员来说，再熟悉不过了，绝大多数时候，我…
阅读更多...
铁死亡化合物库

铁死亡化合物库

铁死亡是 2012 年新发现的一种细胞死亡机制，目前已经成为科研领域的研究热点。铁死亡是依赖铁离子及活性氧诱导脂质过氧化导致的调节性细胞坏死，其在形态学、生物学及基因水平上均明显不同于凋亡、坏死、自噬等其他形式的程序性性细胞死亡。铁死亡在形态…
阅读更多...
详解：自增ID与UUID的优缺点及选择建议，MySQL有序uuid与自定义函数实现

详解：自增ID与UUID的优缺点及选择建议，MySQL有序uuid与自定义函数实现

文章目录1.自增ID的优缺点1.1 优点1.2 缺点1.3 不适合以自增ID主键作为主键的情况2.UUID作为主键2.1 介绍2.2 优点2.3 缺点3.有序UUID作为主键3.1 介绍3.2 演示使用3.2.1 前提知识3.2.1.1 数据类型 - binary3.2.1.2 函数 - hex()3.2.1.3 函数 - unhex()3.2.2 数据库层3.2.3 JAV…
阅读更多...
Mybatis的二级缓存 (ehcache方式)

Mybatis的二级缓存 (ehcache方式)

目录前置pom: jar配置文件: ehcache.xml配置指定方式恢复 .index 文件 (ApplicationClosedEventListener.java)效果图前置 会演示二级缓存生效/失效的场景 项目地址: https://gitee.com/xmaxm/test-code/blob/master/chaim-cache/chaim-mybatis-cache/chaim-mybatis-cache-two…
阅读更多...
基于PHP+MySQL汽车票订票系统的设计与实现（含论文）

基于PHP+MySQL汽车票订票系统的设计与实现（含论文）

从前,对汽车站的管理和规范问题一直是困扰政府的一个大难题,如何让人们方便快捷的买到自己想去的城市的票一直是一个问题。 但是现在,随着时代的飞速发展,交通越来越发达,人们可以更加方便的去各个城市,回家也好,旅游也好,当然,科学技术也在提高,出现了网上购票的新的购票方式,…
阅读更多...
redux 和 react-redux

redux 和 react-redux

Redux 一、redux 工作流 二、创建 redux npm install redux src/redux/languageReducer.ts 数据处理逻辑 // 数据类型 export interface LanguageState {language: "en" | "zh"languageList: {name: string
阅读更多...
Springboot 小巧简便的限流器使用 RateLimiter

Springboot 小巧简便的限流器使用 RateLimiter

前言 之前，写过一篇基于redis限流，能应用到分布式相关场景：（Redis使用系列） Springboot 使用redis实现接口Api限流 十_小目标青年的博客-CSDN博客 也在很久之前，写过一个使用也非常便捷的，整合…
阅读更多...
Google Earth 成长历程的15个小故事

Google Earth 成长历程的15个小故事

利用 Google Earth，可以像宇航员一样从太空中看到我们的星球，只需点击或轻触几秒钟就可以在地球上的任何地方旅行。如今的 Google Earth 仍然是世界上最大的可公开获取的地理图像存储库。它将航空摄影、卫星图像、3D 地形、地理数据和街景组合成一幅可以…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023