devbox
从前慢现在也慢
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

SqueezeNet网络讲解_squeezenet 网络

作者：从前慢现在也慢 | 2024-04-06 19:32:06

赞

踩

squeezenet 网络

原文地址： https://zhuanlan.zhihu.com/p/31558773

引言

SqueezeNet是Han等提出的一种轻量且高效的CNN模型，它参数比AlexNet少50x，但模型性能（accuracy）与AlexNet接近。在可接受的性能下，小模型相比大模型，具有很多优势：（1）更高效的分布式训练，小模型参数小，网络通信量减少；（2）便于模型更新，模型小，客户端程序容易更新；（3）利于部署在特定硬件如FPGA，因为其内存受限。因此研究小模型是很有现实意义的。Han等将CNN模型设计的研究总结为四个方面：

（1）模型压缩：对pre-trained的模型进行压缩，使其变成小模型，如采用网络剪枝和量化等手段；

（2）CNN微观结构：对单个卷积层进行优化设计，如采用1x1的小卷积核，还有很多采用可分解卷积（factorized convolution）结构或者模块化的结构（blocks, modules）；

（3）CNN宏观结构：网络架构层面上的优化设计，如网路深度（层数），还有像ResNet那样采用“短路”连接（bypass connection）；

（4）设计空间：不同超参数、网络结构，优化器等的组合优化。

SqueezeNet也是从这四个方面来进行设计的，其设计理念可以总结为以下三点：

（1）大量使用1x1卷积核替换3x3卷积核，因为参数可以降低9倍；

（2）减少3x3卷积核的输入通道数（input channels），因为卷积核参数为：(number
of input channels) * (number of filters) * 3 * 3.

（3）延迟下采样（downsample），前面的layers可以有更大的特征图，有利于提升模型准确度。目前下采样一般采用strides>1的卷积层或者pool layer。

SqueezeNet网络结构

SqueezeNet网络基本单元是采用了模块化的卷积，其称为Fire module。Fire模块主要包含两层卷积操作：一是采用1x1卷积核的squeeze层；二是混合使用1x1和3x3卷积核的expand层。Fire模块的基本结构如图1所示。在squeeze层卷积核数记为 s_{1x1} ，在expand层，记1x1卷积核数为 e_{1x1}，而3x3卷积核数为 e_{3x3} 。为了尽量降低3x3的输入通道数，这里让 s_{1x1} 的值小于 e_{1x1} 与 e_{3x3} 的和。这算是一个设计上的trick。

图1 Fire模块的基本结构示意图

整个SqueezeNet就是使用Fire基本模块堆积而成的，网络结构如图2所示，其中左图是标准的SqueezeNet，其开始是一个卷积层，后面是Fire模块的堆积，值得注意的是其中穿插着stride=2的maxpool层，其主要作用是下采样，并且采用延迟的策略，尽量使前面层拥有较大的feature map。中图和右图分别是引入了不同“短路”机制的SqueezeNet，这是借鉴了ResNet的结构。具体每个层采用的参数信息如表1所示。

图2 SqueezeNet网络结构

下面说一下SqueezeNet的一些具体的实现细节：

（1）在Fire模块中，expand层采用了混合卷积核1x1和3x3，其stride均为1，对于1x1卷积核，其输出feature map与原始一样大小，但是由于它要和3x3得到的feature map做concat，所以3x3卷积进行了padding=1的操作，实现的话就设置padding=”same”；

（2）Fire模块中所有卷积层的激活函数采用ReLU；

（3）Fire9层后采用了dropout，其中keep_prob=0.5；

（4）SqueezeNet没有全连接层，而是采用了全局的avgpool层，即pool size与输入feature map大小一致；

（5）训练采用线性递减的学习速率，初始学习速率为0.04。

表1 SqueezeNet各层参数信息

SqueezeNet性能

从网络结构来看，SqueezeNet也算是设计精良了，但是最终性能还是要实验说话。论文作者将SqueezeNet与AlexNet在ImageNet上做了对比，值得注意的是，不仅对比了基础模型之间的差异，还对比了模型压缩的性能，其中模型压缩主要采用的技术有SVD，网络剪枝（network pruning）和量化（quantization）等。具体的对比结果如表2所示。首先看一下基准模型的性能对比，SqueezeNet的Top-1优于AlexNet，Top-5性能一样，但是最重要的模型大小降低了50倍，从240MB->4.8MB，这个提升是非常有价值的，因为这个大小意味着有可能部署在移动端。作者并没有止于此，而是继续进行了模型压缩。其中SVD就是奇异值分解，而所谓的网络剪枝就是在weight中设置一个阈值，低于这个阈值就设为0，从而将weight变成系数矩阵，可以采用比较高效的稀疏存储方式，进而降低模型大小。值得一提的Deep Compression技术，这个也是Han等提出的深度模型压缩技术，其包括网络剪枝，权重共享以及Huffman编码技术。这里简单说一下权重共享，其实就是对一个weight进行聚类，比如采用k-means分为256类，那么对这个weight只需要存储256个值就可以了，然后可以采用8 bit存储类别索引，其中用到了codebook来实现。关于Deep Compression详细技术可以参加文献[2]。从表2中可以看到采用6 bit的压缩，SqueezeNet模型大小降到了0.47MB，这已经降低了510倍，而性能还保持不变。为了实现硬件加速，Han等还设计了特定的硬件来高效实现这种压缩后的模型，具体参加文献[3]。顺便说过题外话就是模型压缩还可以采用量化（quantization），说白了就是对参数降低位数，比如从float32变成int8，这样是有道理，因为训练时采用高位浮点是为了梯度计算，而真正做inference时也许并不需要这么高位的浮点，TensorFlow中是提供了量化工具的，采用更低位的存储不仅降低模型大小，还可以结合特定硬件做inference加速。

表2 SqueezeNet与AlexNet的对比结果

除了上面的工作，作者还探索了网络的设计空间，包括微观结构和宏观结构，微观结构包括各个卷积层的维度等设置，宏观结构比如引入ResNet的短路连接机制，详细内容可以参考原论文[1]。

SqueezeNet的TensorFlow实现

Fire模块中的expand层可以看成两个普通的卷积层，然后做concat，所以SqueezeNet很容易使用TensorFlow实现：

  1. class SqueezeNet(object):
  2.     def __init__(self, inputs, nb_classes=1000, is_training=True):
  3.         # conv1
  4.         net = tf.layers.conv2d(inputs, 96, [7, 7], strides=[2, 2],
  5.                                  padding="SAME", activation=tf.nn.relu,
  6.                                  name="conv1")
  7.         # maxpool1
  8.         net = tf.layers.max_pooling2d(net, [3, 3], strides=[2, 2],
  9.                                       name="maxpool1")
  10.         # fire2
  11.         net = self._fire(net, 16, 64, "fire2")
  12.         # fire3
  13.         net = self._fire(net, 16, 64, "fire3")
  14.         # fire4
  15.         net = self._fire(net, 32, 128, "fire4")
  16.         # maxpool4
  17.         net = tf.layers.max_pooling2d(net, [3, 3], strides=[2, 2],
  18.                                       name="maxpool4")
  19.         # fire5
  20.         net = self._fire(net, 32, 128, "fire5")
  21.         # fire6
  22.         net = self._fire(net, 48, 192, "fire6")
  23.         # fire7
  24.         net = self._fire(net, 48, 192, "fire7")
  25.         # fire8
  26.         net = self._fire(net, 64, 256, "fire8")
  27.         # maxpool8
  28.         net = tf.layers.max_pooling2d(net, [3, 3], strides=[2, 2],
  29.                                       name="maxpool8")
  30.         # fire9
  31.         net = self._fire(net, 64, 256, "fire9")
  32.         # dropout
  33.         net = tf.layers.dropout(net, 0.5, training=is_training)
  34.         # conv10
  35.         net = tf.layers.conv2d(net, 1000, [1, 1], strides=[1, 1],
  36.                                padding="SAME", activation=tf.nn.relu,
  37.                                name="conv10")
  38.         # avgpool10
  39.         net = tf.layers.average_pooling2d(net, [13, 13], strides=[1, 1],
  40.                                           name="avgpool10")
  41.         # squeeze the axis
  42.         net = tf.squeeze(net, axis=[1, 2])
  43.  
  44.         self.logits = net
  45.         self.prediction = tf.nn.softmax(net)
  46.  
  47.  
  48.     def _fire(self, inputs, squeeze_depth, expand_depth, scope):
  49.         with tf.variable_scope(scope):
  50.             squeeze = tf.layers.conv2d(inputs, squeeze_depth, [1, 1],
  51.                                        strides=[1, 1], padding="SAME",
  52.                                        activation=tf.nn.relu, name="squeeze")
  53.             # squeeze
  54.             expand_1x1 = tf.layers.conv2d(squeeze, expand_depth, [1, 1],
  55.                                           strides=[1, 1], padding="SAME",
  56.                                           activation=tf.nn.relu, name="expand_1x1")
  57.             expand_3x3 = tf.layers.conv2d(squeeze, expand_depth, [3, 3],
  58.                                           strides=[1, 1], padding="SAME",
  59.                                           activation=tf.nn.relu, name="expand_3x3")
  60.             return tf.concat([expand_1x1, expand_3x3], axis=3)

总结

本文简单介绍了移动端CNN模型SqueezeNet，其核心是采用模块的卷积组合，当然做了一些trick，更重要的其结合深度模型压缩技术，因此SqueezeNet算是结合了小模型的两个研究方向：结构优化和模型压缩。

参考资料

  1. SqueezeNet: AlexNet-level accuracy with 50x fewer parameters and <0.5MB model size.
  2. Deep Compression: Compressing Deep Neural Networks with Pruning,Trained Quantization and Huffman Coding.
  3. EIE: Efficient inference engine on compressed deep neural network.

 

pytorch实现：

  1. import torch
  2. import torch.nn as nn
  3. import torch.nn.init as init
  4. import torch.utils.model_zoo as model_zoo
  5.  
  6.  
  7. __all__ = ['SqueezeNet', 'squeezenet1_0', 'squeezenet1_1']
  8.  
  9.  
  10. model_urls = {
  11.     'squeezenet1_0': 'https://download.pytorch.org/models/squeezenet1_0-a815701f.pth',
  12.     'squeezenet1_1': 'https://download.pytorch.org/models/squeezenet1_1-f364aa15.pth',
  13. }
  14.  
  15.  
  16. class Fire(nn.Module):
  17.  
  18.     def __init__(self, inplanes, squeeze_planes,
  19.                  expand1x1_planes, expand3x3_planes):
  20.         super(Fire, self).__init__()
  21.         self.inplanes = inplanes
  22.         self.squeeze = nn.Conv2d(inplanes, squeeze_planes, kernel_size=1)
  23.         self.squeeze_activation = nn.ReLU(inplace=True)
  24.         self.expand1x1 = nn.Conv2d(squeeze_planes, expand1x1_planes,
  25.                                    kernel_size=1)
  26.         self.expand1x1_activation = nn.ReLU(inplace=True)
  27.         self.expand3x3 = nn.Conv2d(squeeze_planes, expand3x3_planes,
  28.                                    kernel_size=3, padding=1)
  29.         self.expand3x3_activation = nn.ReLU(inplace=True)
  30.  
  31.     def forward(self, x):
  32.         x = self.squeeze_activation(self.squeeze(x))
  33.         return torch.cat([
  34.             self.expand1x1_activation(self.expand1x1(x)),
  35.             self.expand3x3_activation(self.expand3x3(x))
  36.         ], 1)
  37.  
  38.  
  39. class SqueezeNet(nn.Module):
  40.  
  41.     def __init__(self, version=1.0, num_classes=1000):
  42.         super(SqueezeNet, self).__init__()
  43.         if version not in [1.0, 1.1]:
  44.             raise ValueError("Unsupported SqueezeNet version {version}:"
  45.                              "1.0 or 1.1 expected".format(version=version))
  46.         self.num_classes = num_classes
  47.         if version == 1.0:
  48.             self.features = nn.Sequential(
  49.                 nn.Conv2d(3, 96, kernel_size=7, stride=2),
  50.                 nn.ReLU(inplace=True),
  51.                 nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True),
  52.                 Fire(96, 16, 64, 64),
  53.                 Fire(128, 16, 64, 64),
  54.                 Fire(128, 32, 128, 128),
  55.                 nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True),
  56.                 Fire(256, 32, 128, 128),
  57.                 Fire(256, 48, 192, 192),
  58.                 Fire(384, 48, 192, 192),
  59.                 Fire(384, 64, 256, 256),
  60.                 nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True),
  61.                 Fire(512, 64, 256, 256),
  62.             )
  63.         else:
  64.             self.features = nn.Sequential(
  65.                 nn.Conv2d(3, 64, kernel_size=3, stride=2),
  66.                 nn.ReLU(inplace=True),
  67.                 nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True),
  68.                 Fire(64, 16, 64, 64),
  69.                 Fire(128, 16, 64, 64),
  70.                 nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True),
  71.                 Fire(128, 32, 128, 128),
  72.                 Fire(256, 32, 128, 128),
  73.                 nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True),
  74.                 Fire(256, 48, 192, 192),
  75.                 Fire(384, 48, 192, 192),
  76.                 Fire(384, 64, 256, 256),
  77.                 Fire(512, 64, 256, 256),
  78.             )
  79.         # Final convolution is initialized differently form the rest
  80.         final_conv = nn.Conv2d(512, self.num_classes, kernel_size=1)
  81.         self.classifier = nn.Sequential(
  82.             nn.Dropout(p=0.5),
  83.             final_conv,
  84.             nn.ReLU(inplace=True),
  85.             nn.AdaptiveAvgPool2d((1, 1))
  86.         )
  87.  
  88.         for m in self.modules():
  89.             if isinstance(m, nn.Conv2d):
  90.                 if m is final_conv:
  91.                     init.normal_(m.weight, mean=0.0, std=0.01)
  92.                 else:
  93.                     init.kaiming_uniform_(m.weight)
  94.                 if m.bias is not None:
  95.                     init.constant_(m.bias, 0)
  96.  
  97.     def forward(self, x):
  98.         x = self.features(x)
  99.         x = self.classifier(x)
  100.         return x.view(x.size(0), self.num_classes)
  101.  
  102.  
  103. def squeezenet1_0(pretrained=False, **kwargs):
  104.     r"""SqueezeNet model architecture from the `"SqueezeNet: AlexNet-level
  105.     accuracy with 50x fewer parameters and <0.5MB model size"
  106.     <https://arxiv.org/abs/1602.07360>`_ paper.
  108.     Args:
  109.         pretrained (bool): If True, returns a model pre-trained on ImageNet
  110.     """
  111.     model = SqueezeNet(version=1.0, **kwargs)
  112.     if pretrained:
  113.         model.load_state_dict(model_zoo.load_url(model_urls['squeezenet1_0']))
  114.     return model
  115.  
  116.  
  117. def squeezenet1_1(pretrained=False, **kwargs):
  118.     r"""SqueezeNet 1.1 model from the `official SqueezeNet repo
  119.     <https://github.com/DeepScale/SqueezeNet/tree/master/SqueezeNet_v1.1>`_.
  120.     SqueezeNet 1.1 has 2.4x less computation and slightly fewer parameters
  121.     than SqueezeNet 1.0, without sacrificing accuracy.
  123.     Args:
  124.         pretrained (bool): If True, returns a model pre-trained on ImageNet
  125.     """
  126.     model = SqueezeNet(version=1.1, **kwargs)
  127.     if pretrained:
  128.         model.load_state_dict(model_zoo.load_url(model_urls['squeezenet1_1']))
  129.     return model

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/373891
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号