MobilenetV2网络结构

已于 2022-04-02 12:04:18 修改
阅读量5.2k 收藏 22
点赞数 1
文章标签： 深度学习
于 2022-04-02 10:58:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43907354/article/details/123857000
版权

1.MobilenetV2

  1. 均采用PW (Point-wise） +DW(Depth-wise）的卷积方式提取特征
  2. V2版本在DW卷积之前新加入一个PW卷积，能动态改变特征通道
  3. V2去掉了第二个PW的激活函数,最大程度保留有效特征
  4. 借鉴ResNet,都采用了lx1->3x3->1x1的模式
    借鉴 ResNet，同样使用Shortcut 短路连接将输出与输入相加
    ResNet利用标准卷积提取特征，V2利用深度卷积(DW）提取特征
    ResNet 先降维、卷积、再升维，而V2则是先升维、卷积、再降维
    watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA6Z2S6JGx5bKB5pyI5aSP5bCP5Yeh,size_20,color_FFFFFF,t_70,g_se,x_16

2. 亮点：引入逆残差结构

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA6Z2S6JGx5bKB5pyI5aSP5bCP5Yeh,size_20,color_FFFFFF,t_70,g_se,x_16

当stride=1时，且输入特征矩阵与输出

3. mobilenet网络结构

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA6Z2S6JGx5bKB5pyI5aSP5bCP5Yeh,size_20,color_FFFFFF,t_70,g_se,x_16

其中：

t 是输入通道的倍增系数（即中间部分的通道数是输入通道数的多少倍）

n 是该模块重复次数

c 是输出通道数

s 是该模块第一次重复时的 stride

from torchvision.models import mobilenet_v2

net=mobilenet_v2().cuda()
print(net)

        可以看出，第一层先来一个3x3卷积+BN+ReLU6，随后来到第一个bottleneck,也就是逆残差结构，bottleneck1只重复一次，并且 S=1，按照上面的逆残差结构来看，应该加一个1x1的卷积ReLU6,然而在代码部分并没有体现，原因在于t=1，并不会对其进行升维，故在bottleneck1代码中我们并没有写入1x1、

MobileNetV2(
  (features): Sequential(
    (0): ConvNormActivation(
      (0): Conv2d(3, 32, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
      (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): ReLU6(inplace=True)
    )
    (1): InvertedResidual(
      (conv): Sequential(
        (0): ConvNormActivation(
          (0): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)
          (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (1): Conv2d(32, 16, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (2): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (2): InvertedResidual(
      (conv): Sequential(
        (0): ConvNormActivation(
          (0): Conv2d(16, 96, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (1): ConvNormActivation(
          (0): Conv2d(96, 96, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), groups=96, bias=False)
          (1): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (2): Conv2d(96, 24, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(24, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (3): InvertedResidual(
      (conv): Sequential(
        (0): ConvNormActivation(
          (0): Conv2d(24, 144, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(144, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (1): ConvNormActivation(
          (0): Conv2d(144, 144, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=144, bias=False)
          (1): BatchNorm2d(144, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (2): Conv2d(144, 24, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(24, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (4): InvertedResidual(
      (conv): Sequential(
        (0): ConvNormActivation(
          (0): Conv2d(24, 144, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(144, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (1): ConvNormActivation(
          (0): Conv2d(144, 144, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), groups=144, bias=False)
          (1): BatchNorm2d(144, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (2): Conv2d(144, 32, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (5): InvertedResidual(
      (conv): Sequential(
        (0): ConvNormActivation(
          (0): Conv2d(32, 192, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (1): ConvNormActivation(
          (0): Conv2d(192, 192, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=192, bias=False)
          (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (2): Conv2d(192, 32, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (6): InvertedResidual(
      (conv): Sequential(
        (0): ConvNormActivation(
          (0): Conv2d(32, 192, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (1): ConvNormActivation(
          (0): Conv2d(192, 192, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=192, bias=False)
          (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (2): Conv2d(192, 32, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (7): InvertedResidual(
      (conv): Sequential(
        (0): ConvNormActivation(
          (0): Conv2d(32, 192, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (1): ConvNormActivation(
          (0): Conv2d(192, 192, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), groups=192, bias=False)
          (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (2): Conv2d(192, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (8): InvertedResidual(
      (conv): Sequential(
        (0): ConvNormActivation(
          (0): Conv2d(64, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (1): ConvNormActivation(
          (0): Conv2d(384, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=384, bias=False)
          (1): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (2): Conv2d(384, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (9): InvertedResidual(
      (conv): Sequential(
        (0): ConvNormActivation(
          (0): Conv2d(64, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (1): ConvNormActivation(
          (0): Conv2d(384, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=384, bias=False)
          (1): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (2): Conv2d(384, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (10): InvertedResidual(
      (conv): Sequential(
        (0): ConvNormActivation(
          (0): Conv2d(64, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (1): ConvNormActivation(
          (0): Conv2d(384, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=384, bias=False)
          (1): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (2): Conv2d(384, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (11): InvertedResidual(
      (conv): Sequential(
        (0): ConvNormActivation(
          (0): Conv2d(64, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (1): ConvNormActivation(
          (0): Conv2d(384, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=384, bias=False)
          (1): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (2): Conv2d(384, 96, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (12): InvertedResidual(
      (conv): Sequential(
        (0): ConvNormActivation(
          (0): Conv2d(96, 576, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(576, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (1): ConvNormActivation(
          (0): Conv2d(576, 576, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=576, bias=False)
          (1): BatchNorm2d(576, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (2): Conv2d(576, 96, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (13): InvertedResidual(
      (conv): Sequential(
        (0): ConvNormActivation(
          (0): Conv2d(96, 576, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(576, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (1): ConvNormActivation(
          (0): Conv2d(576, 576, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=576, bias=False)
          (1): BatchNorm2d(576, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (2): Conv2d(576, 96, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (14): InvertedResidual(
      (conv): Sequential(
        (0): ConvNormActivation(
          (0): Conv2d(96, 576, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(576, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (1): ConvNormActivation(
          (0): Conv2d(576, 576, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), groups=576, bias=False)
          (1): BatchNorm2d(576, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (2): Conv2d(576, 160, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (15): InvertedResidual(
      (conv): Sequential(
        (0): ConvNormActivation(
          (0): Conv2d(160, 960, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(960, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (1): ConvNormActivation(
          (0): Conv2d(960, 960, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=960, bias=False)
          (1): BatchNorm2d(960, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (2): Conv2d(960, 160, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (16): InvertedResidual(
      (conv): Sequential(
        (0): ConvNormActivation(
          (0): Conv2d(160, 960, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(960, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (1): ConvNormActivation(
          (0): Conv2d(960, 960, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=960, bias=False)
          (1): BatchNorm2d(960, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (2): Conv2d(960, 160, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (17): InvertedResidual(
      (conv): Sequential(
        (0): ConvNormActivation(
          (0): Conv2d(160, 960, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(960, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (1): ConvNormActivation(
          (0): Conv2d(960, 960, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=960, bias=False)
          (1): BatchNorm2d(960, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (2): Conv2d(960, 320, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(320, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (18): ConvNormActivation(
      (0): Conv2d(320, 1280, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (1): BatchNorm2d(1280, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): ReLU6(inplace=True)
    )
  )
  (classifier): Sequential(
    (0): Dropout(p=0.2, inplace=False)
    (1): Linear(in_features=1280, out_features=1000, bias=True)
  )
） 

        我们调用torchvision.models里面的mobilenetV2网络，默认输出是1000，num_class= 1000，例如，我们有训练cifar10，只需要将最后一层classier修改为10即可。

from torchvision.models import mobilenet_v2

num_classes = 10
net = mobilenet_v2().cuda()
net.classifier = nn.Sequential(
    nn.Dropout(0.2),
    nn.Linear(in_features=1280, out_features=num_classes, bias=True))
print(net.classifier)
---------------------------------------------------------------
Sequential(
  (0): Dropout(p=0.2, inplace=False)
  (1): Linear(in_features=1280, out_features=10, bias=True)
)

 

 

青葱岁月夏小凡
关注
  • 1
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
MobileNetV4——移动生态系统的通用模型
AI浩
04-26 1527
论文链接：https://arxiv.org/pdf/2404.10518我们推出了最新一代的MobileNets，称为MobileNetV4（MNv4），其特点是为移动设备提供普遍高效的架构设计。在核心部分，我们引入了通用倒置瓶颈（UIB）搜索块，这是一种统一且灵活的结构，融合了倒置瓶颈（IB）、ConvNext、前馈网络（FFN）以及新型Extra Depthwise（ExtraDW）变体。
【第27篇】MobileNetV2：倒置残差和线性瓶颈
最新发布
2401_83816838的博客
04-09 574
在第 6 节中，我们凭经验表明，在瓶颈中使用非线性层确实会降低几个百分点的性能，进一步验证了我们的假设。对于大小为 h × w h \times w h×w、扩展因子为 t 和内核大小为 k 的块，具有 d ′ d^{\prime } d′ 个输入通道和 d ′ ′ d^{\prime \prime} d′′个输出通道，所需的乘加总数 是 h ⋅ w ⋅ d ′ ⋅ t ( d ′ + k 2 + d ′ ′ ) h \cdot w \cdot d^{\prime} \cdot t\left(d。
轻量级网络--MobileNet V1、V2、V3(学习记录；完善ing)
qq_43308156的博客
01-17 2045
MobileNet全系列
轻量化网络：MobileNet-V2
热门推荐
人工智能技术学习与分享
01-23 14万+
创新点 正文 MobileNet-V2网络结构 MobileNetV2: 《Inverted Residuals and Linear Bottlenecks: Mobile Networks for Classification, Detection and Segmentation》 于2018年1月公开在arXiv(美[ˈɑ:rkaɪv]) ：https://arxi...
深度学习之图像分类（十一）--MobileNetV2 网络结构
木卯_THU的博客
09-03 3万+
深度学习之图像分类（十一）MobileNetV2 网络结构 目录深度学习之图像分类（十一）MobileNetV2 网络结构1. 前言2. Inverted Residuals 倒残差结构3. Linear Bottlenecks4. MobileNetV2 网络结构5. 代码 本节学习 MobileNetV2 网络结构。学习视频源于 Bilibili，部分参考描述源自知乎 详解MobileNetV2。 1. 前言 MobileNetV2 是由google团队在 2018 年提出的，相比于 MobileNe
深度学习之图像分类（十一）MobileNetV2详解
m0_46521375的博客
10-13 1691
在本文中，我们描述了一种新的移动架构MobileNetV2，它提高了移动模型在多个任务和基准测试以及不同模型大小范围内的最新性能。我们还描述了在一个我们称之为SSDLite的新框架中将这些移动模型应用于对象检测的有效方法。此外，我们演示了如何通过DeepLabv3的简化形式构建移动语义分割模型，我们称之为Mobile DeepLabv3。基于逆残差结构，其中残差链接位于薄瓶颈层之间。中间扩展层使用轻量级深度卷积来过滤作为非线性来源的特征。此外，我们发现，为了保持代表性，消除窄层中的非线性是很重要的。
MobileNet-v2网络框架
thisiszdy的博客
05-12 1万+
一、MobileNet-v2 MobileNetV2: Inverted Residuals and Linear Bottlenecks 论文链接：https://arxiv.org/abs/1801.04381 论文翻译：https://www.e-learn.cn/content/qita/675949 论文详解：https://www.cnblogs.com/darkknightzh/p...
MobileNet网络结构详解
m0_56247038的博客
06-12 3470
t为一个扩展因子，对应倒残差结构中第一层1*1conv卷积核的扩展倍率，c代表输出特征矩阵的channel，n代表bottlenect(倒残差结构)重复的次数，s代表每一个block中第一层bottlenect(倒残差结构)所对应的步距，该block中其它层bottlenect所对应的步距都为1，步距指的是DW卷积的步距 MobileNet(v1、v2)网络详解与模型的搭建_太阳花的小绿豆的博客-CSDN博客7.1 MobileNet网络详解_哔哩哔哩_bilibili......
MobileNetV2轻量化网络结构（TensorFlow-2.6.0实现结构）
Keep_Trying_Go的博客
05-07 1755
文章目录1.论文地址2.关于MobileNetV1博客3.MobileNetV1的局限性4.模型之间的对比（1）MobileNetV1和MobileNetV2（2）ResNet和MobileNetV25.MobileNetV2采用了新的激活函数ReLU66.MobileNetV2网络结构7.为什么很多Depthwise convolutions之后训练出来的很多都是0呢？8.实验结果对比9.TensorFlow实现网络结构 1.论文地址 https://arxiv.org/abs/1801.04381 2
基于chainer的mobilenetV2网络结构，需要配合分类框架一块使用，具体可见博客文章
09-20
在文章与之前编写的图像分类框架构建组合使用，这里只讲述基于chainer的模型构建，本次讲解如何使用chainer构建MobileNetV2网络结构，以及对应的mobilenetv2_0.25,mobilenetv2_0.5,mobilenetv2_0.75,mobilenetv2_1.0...
MobileNetV2-master
03-27
我上传的是一份适合于分类的代码，...内含有代码和论文，移动端网络结构MobileNetV2，谷歌MobileNetV2 在 MobileNetV1 的基础上获得了显著的提升，并推动了移动视觉识别技术的有效发展，包括分类、目标检测和语义分割。
yolov7+mobilenetv3-large网络结构.yaml
08-07
yolov7+mobilenetv3_large网络结构，用于yolov7相关网络降参提速，对轻量化模型较为友好。
DeepLabv3_MobileNetv2_PyTorch:MobileNetv2 + DeepLabv3的PyTorch实现
04-28
这是MobileNet v2网络的PyTorch实施，具有用于语义分割的DeepLab v3结构。 MobileNetv2的骨干来自纸面： DeepLabv3的段头来自纸面： 如果您对这些块有一些困惑，请参考这些文件，以获取有关诸如Atrous卷积，反向...
mobilenetv2.pytorch:ImageNet上72.8％的MobileNetV2 1.0模型以及一系列预先训练的MobileNetV2模型
05-28
MobileNet V2的PyTorch实施 + Release of next generation of MobileNet in my repo... 此实现提供了一个示例过程，用于训练和验证任何流行的深度神经网络体系结构，并集成了模块化数据处理，训练，日志记录和可视化。
【轻量化网络系列（2）】MobileNetV2论文超详细解读（翻译 ＋学习笔记+代码实现）
路人贾的博客
05-21 9551
MobileNetV2论文《MobileNetV2: Inverted Residuals and Linear Bottlenecks》翻译+超详细解读，包含代码实现
MobileNetv1、MobileNetv2、MobileNetv3网络讲解
chase
10-20 4870
MobileNetv1、MobileNetv2、MobileNetv3网络讲解
MobileNetV2
Star_ID的博客
11-12 1679
MobileNetV2
【深度学习经典网络架构—７】：MobileNet系列（V1、V2、V3）
王乐予的博客
03-23 3860
😺一、简述 自从AlexNet赢得ImageNet挑战赛：ILSVRC 2012以来，卷积神经网络已成为计算机视觉中的普遍应用。总体趋势是制作更深、更复杂的网络，以实现更高的准确度。然而，这些提高准确性的进步并不一定会使网络在规模和速度方面更有效率。在机器人、汽车自动驾驶和增强现实等许多现实世界的应用中，识别任务需要在计算受限的平台上及时执行。 谷歌提出MobileNet的目的就是**构造一个可以在移动端和嵌入式端应用深度学习的网络，使得在CPU上也能达到理想的速度要求。** MobileNet V1
【图像分类】【深度学习】【轻量级网络】【Pytorch版本】MobileNets_V2模型算法详解
yangyu0515的博客
11-20 829
【图像分类】【深度学习】【轻量级网络】【Pytorch版本】MobileNets_V2模型算法详解
2请画出GSM网络结构，并说明各模块功能
05-25
GSM（Global System for Mobile Communications）是一种数字移动通信标准，它采用了时分多址（TDMA）技术，用于第二代移动通信系统。下面是GSM网络结构图： ![GSM网络结构图](https://cdn.jsdelivr.net/gh/1078547939/CDN/images/gsm-network-structure.png) GSM网络结构分为四层：物理层、数据链路层、网络层和应用层。各模块功能如下： 1. 物理层：负责GSM无线信号的传输和接收，包括调制解调、信道编解码及射频传输等。 2. 数据链路层：负责数据的传输和错误检测，包括帧同步、差错控制、流量控制、传输格式等。 3. 网络层：负责GSM网络中的路由、寻址和连接管理，包括移动用户的位置管理、呼叫控制、短信传递等。 4. 应用层：提供各种应用服务，如语音通话、短信、数据传输、传真等。 此外，GSM网络还包括基站子系统和网络和运营商之间的接口。基站子系统包括基站控制器（BSC）和多个基站收发机（BTS），BSC负责基站的管理和控制，而BTS则负责无线信号的传输和接收。网络和运营商之间的接口包括SS7信令链路和运营商之间的互联接口，用于实现呼叫的跨网络传输。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

青葱岁月夏小凡

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

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

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

打赏作者

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

抵扣说明：

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

余额充值