Advertisement

molbilenet v1 (MobileNets: Efficient Convolutional Neural Networks for Mobile Vision Applications )

阅读量:

深度可分离卷积

一种轻量级的网络架构设计。进一步探讨了其他类型的空 separable convolutions后发现,该种卷积并未带来计算效率上的提升。

首先作者分析了传统的标准卷积的计算成本。

标准卷积具有筛选特征和组合特征的效果。

作者将标准卷积进行分解,分别进行筛选特征和组合特征。

深度卷积的计算成本。

考虑到深度卷积未对组合特征施加影响,在此背景下我们采用了逐点卷积机制来实现通道维度特征的线性组合

深度可分离卷积与标准卷积的复杂度对比。

此处的N代表输出特征图的数量,在实际应用中通常会取较大的值。因此所占比例较小。若采用3×3的卷积核尺寸,则总运算量将减少约9倍。

网络结构

基准的网络的结构。整个网络只有28层。

作者在此基础上引入了两个超参数。这些新增的超参数用于调节宽度和分辨率使得模型调节更加灵活。

下面有四个表格进行了详细分析。第一个表格展示了深度可分离卷积在各方面的优势表现。第二张表格展示了浅网络和窄网络性能的对比结果(浅层网络通过减少模型层数来实现简化;而窄网络则通过降低中间特征图的空间维度来优化性能)。从对比数据可以看出,在参数量和计算复杂度相近的情况下,窄网络表现出更为优异的效果。第三张表格探讨了宽度调节器对模型性能的影响;第四张表格则深入分析了分辨率调节器对模型性能的具体影响机制

和优秀模型的对比。

复制代码
 """mobilenet in pytorch

    
 [1] Andrew G. Howard, Menglong Zhu, Bo Chen, Dmitry Kalenichenko, Weijun Wang, Tobias Weyand, Marco Andreetto, Hartwig Adam
    
     MobileNets: Efficient Convolutional Neural Networks for Mobile Vision Applications
    
     https://arxiv.org/abs/1704.04861
    
 """
    
  
    
 import torch
    
 import torch.nn as nn
    
  
    
  
    
 class DepthSeperabelConv2d(nn.Module):
    
  
    
     def __init__(self, input_channels, output_channels, kernel_size, **kwargs):
    
     super().__init__()
    
     self.depthwise = nn.Sequential(
    
         nn.Conv2d(input_channels,input_channels,kernel_size,groups=input_channels,**kwargs),
    
         nn.BatchNorm2d(input_channels),
    
         nn.ReLU(inplace=True)
    
     )
    
     self.pointwise = nn.Sequential(
    
         nn.Conv2d(input_channels, output_channels, 1),
    
         nn.BatchNorm2d(output_channels),
    
         nn.ReLU(inplace=True)
    
     )
    
  
    
     def forward(self, x):
    
     x = self.depthwise(x)
    
     x = self.pointwise(x)
    
  
    
     return x
    
  
    
  
    
 class BasicConv2d(nn.Module):
    
  
    
     def __init__(self, input_channels, output_channels, kernel_size, **kwargs):
    
  
    
     super().__init__()
    
     self.conv = nn.Conv2d(input_channels, output_channels, kernel_size, **kwargs)
    
     self.bn = nn.BatchNorm2d(output_channels)
    
     self.relu = nn.ReLU(inplace=True)
    
  
    
     def forward(self, x):
    
     x = self.conv(x)
    
     x = self.bn(x)
    
     x = self.relu(x)
    
  
    
     return x
    
  
    
  
    
 class MobileNet(nn.Module):
    
  
    
     """
    
     Args:
    
     width multipler: The role of the width multiplier α is to thin
    
                      a network uniformly at each layer. For a given
    
                      layer and width multiplier α, the number of
    
                      input channels M becomes αM and the number of
    
                      output channels N becomes αN.
    
     """
    
  
    
     def __init__(self, width_multiplier=1, class_num=100):
    
    super().__init__()
    
  
    
    alpha = width_multiplier
    
    self.stem = nn.Sequential(
    
        BasicConv2d(3, int(32 * alpha), 3, padding=1, bias=False),
    
        DepthSeperabelConv2d(int(32 * alpha),int(64 * alpha),3,padding=1,bias=False)
    
    )
    
    #downsample
    
    self.conv1 = nn.Sequential(
    
        DepthSeperabelConv2d(int(64 * alpha),int(128 * alpha),3,stride=2,padding=1,bias=False),
    
        DepthSeperabelConv2d(int(128 * alpha),int(128 * alpha),3,padding=1,bias=False)
    
    )
    
  
    
    #downsample
    
    self.conv2 = nn.Sequential(
    
        DepthSeperabelConv2d(int(128 * alpha),int(256 * alpha),3,stride=2,padding=1,bias=False),
    
        DepthSeperabelConv2d(int(256 * alpha),int(256 * alpha),3,padding=1,bias=False)
    
    )
    
  
    
    #downsample
    
    self.conv3 = nn.Sequential(
    
        DepthSeperabelConv2d(int(256 * alpha),int(512 * alpha),3,stride=2,padding=1,bias=False),
    
        DepthSeperabelConv2d(int(512 * alpha),int(512 * alpha),3,padding=1,bias=False),
    
        DepthSeperabelConv2d(int(512 * alpha),int(512 * alpha),3,padding=1,bias=False),
    
        DepthSeperabelConv2d(int(512 * alpha),int(512 * alpha),3,padding=1,bias=False),
    
        DepthSeperabelConv2d(int(512 * alpha),int(512 * alpha),3,padding=1,bias=False),
    
        DepthSeperabelConv2d(int(512 * alpha),int(512 * alpha),3,padding=1,bias=False)
    
    )
    
  
    
    #downsample
    
    self.conv4 = nn.Sequential(
    
        DepthSeperabelConv2d(int(512 * alpha),int(1024 * alpha),3,stride=2,padding=1,bias=False),
    
        DepthSeperabelConv2d(int(1024 * alpha),int(1024 * alpha),3,padding=1,bias=False)
    
    )
    
  
    
    self.fc = nn.Linear(int(1024 * alpha), class_num)
    
    self.avg = nn.AdaptiveAvgPool2d(1)
    
  
    
     def forward(self, x):
    
     x = self.stem(x)
    
  
    
     x = self.conv1(x)
    
     x = self.conv2(x)
    
     x = self.conv3(x)
    
     x = self.conv4(x)
    
  
    
     x = self.avg(x)
    
     x = x.view(x.size(0), -1)
    
     x = self.fc(x)
    
     return x
    
  
    
  
    
 def mobilenet(alpha=1, class_num=100):
    
     return MobileNet(alpha, class_num)
    
  
    
 if __name__=='__main__':
    
     from torchstat import stat
    
     model=mobilenet()
    
     # print(model)
    
     x=torch.rand(3,128,128)  
    
     stat(model,x.shape)

参考文献

对轻量级网络中的MobileNet技术进行解析,在博客上发表的文章详细阐述了该研究的核心内容与创新点。研究者通过引入深度压缩机制优化了传统卷积神经网络的计算效率,在保持分类精度的同时实现了模型参数规模的大幅缩减。

全部评论 (0)

还没有任何评论哟~