SqueezeNet详细解读

最新推荐文章于 2023-07-09 20:17:45 发布
最新推荐文章于 2023-07-09 20:17:45 发布
阅读量451 收藏 5
点赞数 1

概要：SqueezeNet的工作为以下几个方面：

  1. 提出了新的网络架构Fire Module，通过减少参数来进行模型压缩
  2. 使用其他方法对提出的SqeezeNet模型进行进一步压缩
  3. 对参数空间进行了探索，主要研究了压缩比和3∗33∗3卷积比例的影响

这篇文章是 SQUEEZENET: ALEXNET-LEVEL ACCURACY WITH 50X FEWER PARAMETERS AND <0.5MB MODEL SIZE 的解读，在精简部分内容的同时补充了相关的概念。如有错误，敬请指正。 
论文链接：http://arxiv.org/abs/1602.07360 
代码链接：https://github.com/DeepScale/SqueezeNet

ABSTRACT

近来深层卷积网络的主要研究方向集中在提高正确率。对于相同的正确率水平，更小的CNN架构可以提供如下的优势： 
（1）在分布式训练中，与服务器通信需求更小 
（2）参数更少，从云端下载模型的数据量小 
（3）更适合在FPGA等内存受限的设备上部署。 
基于这些优点，本文提出SqeezeNet。它在ImageNet上实现了和AlexNet相同的正确率，但是只使用了1/50的参数。更进一步，使用模型压缩技术，可以将SqueezeNet压缩到0.5MB，这是AlexNet的1/510。

1 INTRODUCTION AND MOTIVATION

对于一个给定的正确率，通常可以找到多种CNN架构来实现与之相近的正确率。其中，参数数量更少的CNN架构有如下优势： 
（1）更高效的分布式训练 
服务器间的通信是分布式CNN训练的重要限制因素。对于分布式 数据并行 训练方式，通信需求和模型参数数量正相关。小模型对通信需求更低。 
（2）减小下载模型到客户端的额外开销 
比如在自动驾驶中，经常需要更新客户端模型。更小的模型可以减少通信的额外开销，使得更新更加容易。 
（3）便于FPGA和嵌入式硬件上的部署

2.1 MODEL COMPRESSION

常用的模型压缩技术有： 
（1）奇异值分解(singular value decomposition (SVD))1 
（2）网络剪枝（Network Pruning）2：使用网络剪枝和稀疏矩阵 
（3）深度压缩（Deep compression）3：使用网络剪枝，数字化和huffman编码 
（4）硬件加速器（hardware accelerator）4

2.2 CNN MICROARCHITECTURE

在设计深度网络架构的过程中，如果手动选择每一层的滤波器显得过于繁复。通常先构建由几个卷积层组成的小模块，再将模块堆叠形成完整的网络。定义这种模块的网络为CNN microarchitecture。

2.3 CNN MACROARCHITECTURE

与模块相对应，定义完整的网络架构为CNN macroarchitecture。在完整的网络架构中，深度是一个重要的参数。

2.4 NEURAL NETWORK DESIGN SPACE EXPLORATION

由于超参数繁多，深度神经网络具有很大的设计空间（design space）。通常进行设计空间探索的方法有： 
（1）贝叶斯优化 
（2）模拟退火 
（3）随机搜索 
（4）遗传算法

3 SQUEEZENET: PRESERVING ACCURACY WITH FEW PARAMETERS

3.1 ARCHITECTURAL DESIGN STRATEGIES

使用以下三个策略来减少SqueezeNet设计参数 
（1）使用1∗11∗1卷积代替3∗33∗3 卷积：参数减少为原来的1/9 
（2）减少输入通道数量：这一部分使用squeeze layers来实现 
（3）将欠采样操作延后，可以给卷积层提供更大的激活图：更大的激活图保留了更多的信息，可以提供更高的分类准确率 
其中，（1）和（2）可以显著减少参数数量，（3）可以在参数数量受限的情况下提高准确率。

3.2 THE FIRE MODULE

Fire Module是SqueezeNet中的基础构建模块，如下定义 Fire Module :

 


 

 

  1. squeeze convolution layer：只使用1∗11∗1 卷积 filter，即以上提到的策略（1）
  2. expand layer：使用1∗11∗1 和3∗33∗3 卷积 filter的组合
  3. Fire module中使用3ge可调的超参数：s1x1s1x1（squeeze convolution layer中1∗11∗1 filter的个数）、e1x1e1x1（expand layer中1∗11∗1filter的个数）、e3x3e3x3（expand layer中3∗33∗3 filter的个数）
  4. 使用Fire module的过程中，令s1x1s1x1 < e1x1e1x1 + e3x3e3x3，这样squeeze layer可以限制输入通道数量，即以上提到的策略（2）

3.3 THE SQUEEZENET ARCHITECTURE

SqueezeNet以卷积层（conv1）开始，接着使用8个Fire modules (fire2-9)，最后以卷积层（conv10）结束。每个fire module中的filter数量逐渐增加，并且在conv1, fire4, fire8, 和 conv10这几层之后使用步长为2的max-pooling，即将池化层放在相对靠后的位置，这使用了以上的策略（3）。

 


 

如上图，左边为原始的SqueezeNet，中间为包含simple bypass的改进版本，最右侧为使用complex bypass的改进版本。在下表中给出了更多的细节。

 


 

因为这是一篇讲解网络压缩的文章，这里顺便提一下参数计算的方法。以上表中的fire2模块为例：maxpool1层的输出为55∗55∗9655∗55∗96，一共有96个通道。之后紧接着的Squeeze层有16个1∗1∗961∗1∗96的卷积filter，注意这里是多通道卷积，为了避免与二维卷积混淆，在卷积尺寸末尾写上了通道数。这一层的输出尺寸为55∗55∗1655∗55∗16，之后将输出分别送到expand层中的1∗1∗161∗1∗16（64个）和3∗3∗163∗3∗16（64个）进行处理，注意这里不对16个通道进行切分。为了得到大小相同的输出，对3∗3∗163∗3∗16的卷积输入进行尺寸为１的zero padding。分别得到55∗55∗6455∗55∗64和55∗55∗6455∗55∗64大小相同的两个feature map。将这两个feature map连接到一起得到55∗55∗12855∗55∗128大小的feature map。考虑到bias参数，这里的参数总数为： 

(1∗1∗96+1)∗16+(1∗1∗16+1)∗64+(3∗3∗16+1)∗64＝(1552+1088+9280)=11920(1∗1∗96+1)∗16+(1∗1∗16+1)∗64+(3∗3∗16+1)∗64＝(1552+1088+9280)=11920

 

可以看出，Squeeze层由于使用1∗11∗1卷积极大地压缩了参数数量，并且进行了降维操作，但是对应的代价是输出特征图的通道数（维数）也大大减少。之后的expand层使用不同尺寸的卷积模板来提取特征，同时将两个输出连接到一起，又将维度升高。但是3∗3∗163∗3∗16的卷积模板参数较多，远超1∗11∗1卷积的参数，对减少参数十分不利，所以作者又针对3∗3∗163∗3∗16卷积进行了剪枝操作以减少参数数量。从网络整体来看，feature map的尺寸不断减小，通道数不断增加，最后使用平均池化将输出转换成1∗1∗10001∗1∗1000完成分类任务。

3.3.1 OTHER SQUEEZENET DETAILS

以下是网络设计中的一些要点： 
（1）为了使 1∗11∗1 和 3∗33∗3 filter输出的结果又相同的尺寸，在expand modules中，给3∗33∗3 filter的原始输入添加一个像素的边界（zero-padding）。 
（2）squeeze 和 expand layers中都是用ReLU作为激活函数 
（3）在fire9 module之后，使用Dropout，比例取50% 
（4）注意到SqueezeNet中没有全连接层，这借鉴了Network in network的思想 
（5）训练过程中，初始学习率设置为0.04，，在训练过程中线性降低学习率。更多的细节参见本项目在github中的配置文件。 
（6）由于Caffee中不支持使用两个不同尺寸的filter，在expand layer中实际上是使用了两个单独的卷积层（1∗11∗1 filter 和 3∗33∗3filter），最后将这两层的输出连接在一起，这在数值上等价于使用单层但是包含两个不同尺寸的filter。 
在github上还有SqueezeNet在其他框架下的实现：MXNet、Chainer、Keras、Torch。

4 EVALUATION OF SQUEEZENET

在表2中，以AlexNet为标准来比较不同压缩方法的效果。

 


 

 


SVD方法能将预训练的AlexNet模型压缩为原先的1/5，top1正确率略微降低。网络剪枝的方法能将模型压缩到原来的1/9，top1和top5正确率几乎保持不变。深度压缩能将模型压缩到原先的1/35，正确率基本不变。SqeezeNet的压缩倍率可以达到50以上，并且正确率还能有 略微的提升。注意到几时使用未进行压缩的32位数值精度来表示模型，SqeezeNet也比压缩率最高的模型更小，同时表现也更好。 
如果将深度压缩（Deep Compression）的方法用在SqeezeNet上，使用33%的稀疏表示和8位精度，会得到一个仅有0.66MB的模型。进一步，如果使用6位精度，会得到仅有0.47MB的模型，同时正确率不变。 
此外，结果表明深度压缩不仅对包含庞大参数数量的CNN网络作用，对于较小的网络，比如SqueezeNet，也是有用的。将SqueezeNet的网络架构创新和深度压缩结合起来可以将原模型压缩到1/510。

 

5 CNN MICROARCHITECTURE DESIGN SPACE EXPLORATION

5.1 CNN MICROARCHITECTURE METAPARAMETERS

在SqueezeNet中，每一个Fire module有3个维度的超参数，即s1x1s1x1 、 e1x1e1x1 和 e3x3e3x3。SqueezeNet一共有8个Fire modules，即一共24个超参数。下面讨论其中一些重要的超参数的影响。为方便研究，定义如下参数：

  1. baseebasee：Fire module中expand filter的个数
  2. freqfreq：Fire module的个数
  3. increeincree：在每freqfreq个Fire module之后增加的expand filter个数
  4. eiei：第ii 个Fire module中，expand filters的个数
  5. SRSR：压缩比，即the squeeze ratio ，为squeeze layer中filter个数除以Fire module中filter总个数得到的一个比例
  6. pct3x3pct3x3：在expand layer有1∗11∗1和3∗33∗3两种卷积，这里定义的参数是3∗33∗3卷积个占卷积总个数的比例

下图为实验结果：

5.2 SQUEEZE RATIO

Figure 3 中左图给出了压缩比（SR）的影响。压缩比小于0.25时，正确率开始显著下降。

5.3 TRADING OFF 1X1 AND 3X3 FILTERS

Figure 3 中右图给出了3∗33∗3卷积比例的影响，在比例小于25%时，正确率开始显著下降，此时模型大小约为原先的44%。超过50%后，模型大小显著增加，但是正确率不再上升。

6 CNN MACROARCHITECTURE DESIGN SPACE EXPLORATION

受ResNet启发，这里探究旁路连接（bypass conection）的影响。在Figure 2中展示了三种不同的网络架构。下表给出了实验结果：

 


 


注意到使用旁路连接后正确率确实有一定提高。

 

7 Conclusions

在SqueezeNet提出后，Dense-Sparse-Dense (DSD)5使用了新的方法来进行压缩同时提高了精度。

8 Implementation

在这里我们分析SqeezeNet的PyTorch实现，以加深对网络架构的理解。源代码可见：https://github.com/pytorch/vision/blob/master/torchvision/models/squeezenet.py

为方便分析，除去其中不必要的代码。

8.1 Fire module的实现

首先Fire类是对torch.nn.Modules类进行拓展得到的，需要继承Modules类，并实现__init__()方法，以及forward()方法。其中，__init__()方法用于定义一些新的属性，这些属性可以包括Modules的实例，如一个torch.nn.Conv2d，nn.ReLU等。即创建该网络中的子网络，在创建这些子网络时，这些网络的参数也被初始化。接着使用super(Fire, self).__init__()调用基类初始化函数对基类进行初始化。

首先，在Fire类的__init__()函数中，定义了如下几个新增的属性： 
1. inplanes：输入向量 
2. squeeze：sqeeze layer，由二维1∗11∗1卷积组成。其中，参考PyTorch文档，torch.nn.Conv2d 的定义为class torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True)，代码中inplanes为输入通道，squeeze_planes为输出通道，卷积模板尺寸为1∗11∗1. 
3. expand1x1：expand layer中的1∗11∗1卷积。 
4. expand3x3：expand layer中的3∗33∗3卷积。注意，为了使 1∗11∗1 和 3∗33∗3 filter输出的结果有相同的尺寸，在expand modules中，给3∗3 filter的原始输入添加一个像素的边界（zero-padding） 
5. 所有的激活函数都选择ReLU。注意inplace=True参数可以在原始的输入上直接进行操作，不会再为输出分配额外的内存，可以节省一部分内存，但同时也会破坏原始的输入。

之后实现foward方法，整个流程如下： 
首先，将输入x经过squeeze layer进行卷积操作，再经过 squeeze_activation（） 进行激活，然后将输出分别送到expand1x1expand1x1和expand3x3expand3x3中进行卷积和激活操作，最后，使用torch.cat()可以将expand1x1_activation和 expand3x3_activation这两个维度相同的输出张量连接在一起。注意这里的dim=1，即按照列连接，最终得到若干行。

class Fire(nn.Module):

    def __init__(self, inplanes, squeeze_planes,
                 expand1x1_planes, expand3x3_planes):
        super(Fire, self).__init__()
        self.inplanes = inplanes
        self.squeeze = nn.Conv2d(inplanes, squeeze_planes, kernel_size=1)
        self.squeeze_activation = nn.ReLU(inplace=True)
        self.expand1x1 = nn.Conv2d(squeeze_planes, expand1x1_planes,
                                   kernel_size=1)
        self.expand1x1_activation = nn.ReLU(inplace=True)
        self.expand3x3 = nn.Conv2d(squeeze_planes, expand3x3_planes,
                                   kernel_size=3, padding=1)
        self.expand3x3_activation = nn.ReLU(inplace=True)

    def forward(self, x):
        x = self.squeeze_activation(self.squeeze(x))
        return torch.cat([
            self.expand1x1_activation(self.expand1x1(x)),
            self.expand3x3_activation(self.expand3x3(x))
        ], 1)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

以上实现了SqeezeNet中最重要的Fire module，为搭建整体网络做好了准备。接下来定义SqueezeNet类，它同样继承自nn.Module，这里实现了version=1.0和version=1.1两个SqueezeNet版本。区别在于1.0只有 AlexNet的1/50的参数，而1.1在1.0的基础上进一步压缩，参数略微减少，计算量降低为1.0的40%左右。SqueezeNet类定义了如下属性： 
1. num_classes：分类的类别个数 
2. self.features：定义了主要的网络层，nn.Sequential()是PyTorch中的序列容器（sequential container），可以按照顺序将Modules添加到其中，这也是网络宏观架构实现的重要步骤。要理解这一部分代码，最好结合表1中的细节，并且自己计算一遍卷积操作后的feature map的尺寸。注意表1中的输入图片尺寸是227∗227227∗227而不是224∗224224∗224，否则跟之后的输出尺寸对不上。 
3. 注意nn.MaxPool2d()函数中ceil_mode=True会对池化结果进行向上取整而不是向下取整。 
4. 最后一个卷积层的初始化方法与其他层不同，在接下来的for循环中，定义了不同层的初始化方法，可以看到，最后一层使用了均值为0，方差为0.01的正太分布初始化方法，其余层使用He Kaiming论文中的均匀分布初始化方法。同时这里使用了num_classes参数，可以调整分类类别数目。并且所有的bias初始化为零。 
5. self.classifier：定义了网络末尾的分类器模块，注意其中使用了nn.Dropout() 
6. forward()方法：可以看到由features模块和classifier模块构成。

class SqueezeNet(nn.Module):

    def __init__(self, version=1.0, num_classes=1000):
        super(SqueezeNet, self).__init__()
        if version not in [1.0, 1.1]:
            raise ValueError("Unsupported SqueezeNet version {version}:"
                             "1.0 or 1.1 expected".format(version=version))
        self.num_classes = num_classes
        if version == 1.0:
            self.features = nn.Sequential(
                nn.Conv2d(3, 96, kernel_size=7, stride=2),
                nn.ReLU(inplace=True),
                nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True),
                Fire(96, 16, 64, 64),
                Fire(128, 16, 64, 64),
                Fire(128, 32, 128, 128),
                nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True),
                Fire(256, 32, 128, 128),
                Fire(256, 48, 192, 192),
                Fire(384, 48, 192, 192),
                Fire(384, 64, 256, 256),
                nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True),
                Fire(512, 64, 256, 256),
            )
        else:
            self.features = nn.Sequential(
                nn.Conv2d(3, 64, kernel_size=3, stride=2),
                nn.ReLU(inplace=True),
                nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True),
                Fire(64, 16, 64, 64),
                Fire(128, 16, 64, 64),
                nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True),
                Fire(128, 32, 128, 128),
                Fire(256, 32, 128, 128),
                nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True),
                Fire(256, 48, 192, 192),
                Fire(384, 48, 192, 192),
                Fire(384, 64, 256, 256),
                Fire(512, 64, 256, 256),
            )
        # Final convolution is initialized differently form the rest
        final_conv = nn.Conv2d(512, self.num_classes, kernel_size=1)
        self.classifier = nn.Sequential(
            nn.Dropout(p=0.5),
            final_conv,
            nn.ReLU(inplace=True),
            nn.AvgPool2d(13)
        )

        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                if m is final_conv:
                    init.normal(m.weight.data, mean=0.0, std=0.01)
                else:
                    init.kaiming_uniform(m.weight.data)
                if m.bias is not None:
                    m.bias.data.zero_()

    def forward(self, x):
        x = self.features(x)
        x = self.classifier(x)
        return x.view(x.size(0), self.num_classes)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62

在之后的代码中定义了完整的squeezenet1_0和squeezenet1_1，如果需要的话，可以使用PyTorch的预训练模型。

def squeezenet1_0(pretrained=False, **kwargs):
    r"""SqueezeNet model architecture from the `"SqueezeNet: AlexNet-level
    accuracy with 50x fewer parameters and <0.5MB model size"
    <https://arxiv.org/abs/1602.07360>`_ paper.

    Args:
        pretrained (bool): If True, returns a model pre-trained on ImageNet
    """
    model = SqueezeNet(version=1.0, **kwargs)
    if pretrained:
        model.load_state_dict(model_zoo.load_url(model_urls['squeezenet1_0']))
    return model


def squeezenet1_1(pretrained=False, **kwargs):
    r"""SqueezeNet 1.1 model from the `official SqueezeNet repo
    <https://github.com/DeepScale/SqueezeNet/tree/master/SqueezeNet_v1.1>`_.
    SqueezeNet 1.1 has 2.4x less computation and slightly fewer parameters
    than SqueezeNet 1.0, without sacrificing accuracy.

    Args:
        pretrained (bool): If True, returns a model pre-trained on ImageNet
    """
    model = SqueezeNet(version=1.1, **kwargs)
    if pretrained:
        model.load_state_dict(model_zoo.load_url(model_urls['squeezenet1_1']))
    return model
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27

Refference

  1. E.L Denton, W. Zaremba, J. Bruna, Y. LeCun, and R. Fergus. Exploiting linear structure within 
    convolutional networks for efficient evaluation. In NIPS, 2014. ↩
  2. S. Han, J. Pool, J. Tran, and W. Dally. Learning both weights and connections for efficient neural 
    networks. In NIPS, 2015b. ↩
  3. S. Han, H. Mao, and W. Dally. Deep compression: Compressing DNNs with pruning, trained 
    quantization and huffman coding. arxiv:1510.00149v3, 2015a. ↩
  4. Song Han, Xingyu Liu, Huizi Mao, Jing Pu, Ardavan Pedram, Mark A Horowitz, and William J 
    Dally. Eie: Efficient inference engine on compressed deep neural network. International Symposium 
    on Computer Architecture (ISCA), 2016a. ↩
  5. Song Han, Jeff Pool, Sharan Narang, Huizi Mao, Shijian Tang, Erich Elsen, Bryan Catanzaro, John 
    Tran, and William J. Dally. Dsd: Regularizing deep neural networks with dense-sparse-dense 
    training flow. arXiv:1607.04381, 2016b. ↩
CVAIDL
关注
深度解读SqueezeNet网络结构
qq_24946843的博客
09-18 3422
SqueezeNet 由伯克利&斯坦福的研究人员合作发表于 ICLR-2017，论文标题: 《SqueezeNet：AlexNet-level accuracy with 50x fewer parameters and &lt;0.5MB》 命名： 从名字——SqueezeNet 就知道，本文的新意是 squeeze，squeeze 在 SqueezeNet 中表示一个 s...
机器学习笔记 - EfficientNet论文解读
学以致用 知行合一
05-25 981
EfficientNet是一种卷积神经网络架构和缩放方法，它使用复合系数统一缩放深度/宽度/分辨率的所有维度。与任意缩放这些因子的传统做法不同，EfficientNet 缩放方法使用一组固定缩放系数统一缩放网络宽度、深度和分辨率。例如，如果我们想使用倍的计算资源，那么我们可以简单地增加网络深度, 宽度, 和图像大小， α,β,γ是由原始小模型上的小网格搜索确定的常数系数。EfficientNet 使用复合系数φ以有原则的方式统一缩放网络宽度、深度和分辨率。
SqueezeNet 算法的介绍
weixin_48818887的博客
09-09 1219
SqueezeNet
SqueezeNet网络模型详解
独行侠
10-19 2318
目录 前言： SqueezeNet模型原理 Fire Module SqueezeNet模型结构 SqueezeNet模型特点 SqueezeNet网络实现 前言： CNN网络模型一直在追求识别成功率，从AlexNet到VGGNet模型，识别精度不断提高，TOP-5错误率从15.3%下降到7.3%，但参数数量也越来越多，但参数数量也越来越多，从60M增加到140M。过多的参数降低了...
[ 轻量级网络 ] 经典网络模型1——SqueezeNet 详解与复现
A_John 的博客
05-03 8545
[ 轻量级网络 ] 经典网络模型1——SqueezeNet 详解与复现； 1、SqueezeNet； 2、SqueezeNet详解； 3、SqueezeNet复现； SqueezeNet 在 ImageNet 上实现与 AlexNet 同等级别的精度，但 参数少了50倍 ； 通过模型压缩技术，实现了 SqueezeNet 模型压缩到小于0.5MB，相比 AlexNet 模型小了510倍 ； 🔗 论文地址：SqueezeNet: AlexNet-level accuracy with 50x fewer...
SqueezeNet算法解析—鸟类识别—Paddle实战
一名在读大学生，正在学习深度学习，会定期分享一些该领域内容。欢迎大家一起交流学习~
07-09 2266
SqueezeNet算法，顾名思义，Squeeze的中文意思是压缩和挤压的意思，所以我们通过算法的名字就可以猜想到，该算法一定是通过解压模型来降低模型参数量的。当然任何算法的改进都是在原先的基础上提升精度或者降低模型参数，因此该算法的主要目的就是在于降低模型参数量的同时保持模型精度。随着CNN卷积神经网络的研究发展，越来越多的模型被研发出来，而为了提高模型的精度，深层次的模型例如AlexNet和ResNet等得到了大家的广泛认可。
45.SqueezeNet详细解读 - 花有重开日 人无再少年 - CSDN博客1
08-03
SqueezeNet是一种轻量级的卷积神经网络（CNN），其设计目的是在保持高精度的同时大幅减少模型的参数数量，从而提高模型的效率和可移植性。该网络的核心创新是引入了“Fire Module”结构，这使得SqueezeNet能够在有限...
1044-极智开发-解读SqueezeNet及示例代码
最新发布
01-24
1044_极智开发_解读SqueezeNet及示例代码
SE net：Squeeze-and-Excitation Networks论文解读
Sesen的木屋
10-09 1568
近期对有关注意力机制的两篇文章进行了解读。分别是可以嵌入到很多网络结构中去的SE block的提出论文SENet，以及在GAN生成领域引入注意力机制的SAGAN。这两篇文章都是很经典的文章，这里将其详细整理一下。 SE Net：Squeeze-and-Excitation Networks (CVPR2018) 这篇文章的主要贡献是对通道间的依赖关系、各通道特征的权重进行了学习和分配。...
详细介绍SqueezeNet
weixin_42576186的博客
01-12 301
SqueezeNet是一种轻量级的卷积神经网络(CNN)模型，由谷歌研究员在2016年提出。它主要特点是在保持高精度的同时，使用少量的参数和计算量。这使得它非常适合部署在资源有限的环境中，如移动设备和嵌入式系统。 SqueezeNet的架构类似于其他经典的CNN模型，如AlexNet和VGG，但它使用了更小的卷积核和池化层。此外，SqueezeNet还采用了一种称为"Squeeze"的操作，该操作...
深度学习方法（七）：最新SqueezeNet 模型详解，CNN模型参数降低50倍，压缩461倍！...
weixin_30767921的博客
03-16 852
欢迎转载，转载请注明：本文出自Bin的专栏blog.csdn.net/xbinworld。 技术交流QQ群：433250724，欢迎对算法、技术感兴趣的同学加入。 继续前面关于深度学习CNN经典模型的整理，之前介绍了CNN网络Lenet，Alexnet，Googlenet，VGG，Deep Residual Learning(点击查看)的网络结构。 本文讲一下最新由U...
SqueezeNet学习笔记
ouyangfushu的博客
05-16 1444
SqueezeNet学习笔记 一、前言 《SQUEEZENET: ALEXNET-LEVEL ACCURACY WITH 50X FEWER PARAMETERS AND <0.5MB MODEL SIZE》[1]主要贡献是提出了减少网络参数的轻量级网络结构：SqueezeNet，该网络在ImageNet上的精度比肩AlexNet，然而模型的参数量比AlexNet少50倍，配...
SqueezeNet 1_1版本的网络结构
xuhuimingc的博客
11-24 1018
SqueezeNet
weixin_30782331的博客
05-15 125
SqueezeNet 虽然网络性能得到了提高，但随之而来的就是效率问题(AlexNet VGG GoogLeNet Resnet DenseNet) 效率问题主要是模型的存储问题和模型进行预测的速度问题. Model Compression: 从模型权重数值角度压缩 从网络架构角度压缩 对于效率问题，通常的方法即...
SqueezeNet网络讲解
急流勇进
03-27 7233
原文地址：https://zhuanlan.zhihu.com/p/31558773 引言 SqueezeNet是Han等提出的一种轻量且高效的CNN模型，它参数比AlexNet少50x，但模型性能（accuracy）与AlexNet接近。在可接受的性能下，小模型相比大模型，具有很多优势：（1）更高效的分布式训练，小模型参数小，网络通信量减少；（2）便于模型更新，模型小，客户端程序容易更新；...
DL之SqueezeNet：SqueezeNet算法的简介(论文介绍)、架构详解、案例应用等配图集合之详细攻略
近期请国内外头部出版社可尽快私信博主！——心比天高，仗剑走天涯，保持热爱，奔赴向梦想！低调，谦虚，自律，反思，成长，还算是比较正能量的博主，公益免费传播……内心特别想在AI界做出一些可以推进历史进程影响力的东西(兴趣使然，有点小情怀，也有点使命感呀)…
08-01 6619
DL之SqueezeNet：SqueezeNet算法的简介(论文介绍)、架构详解、案例应用等配图集合之详细攻略 目录 SqueezeNet算法的简介(论文介绍) 1、轻量级的CNN架构优势 2、主要特点 3、常用的模型压缩技术 SqueezeNet算法的架构详解 SqueezeNet算法的案例应用 相关文章DL之SqueezeN...
squeezenet代码_【网络优化】超轻量级网络SqueezeNet算法详解
weixin_32487755的博客
01-14 365
s1s_1s1​: squeeze部分，1×1卷积层的通道数e1e_1e1​: expand部分，1×1卷积层的通道数e3e_3e3​: expand部分，3×3卷积层的通道数输入输出尺寸相同。输入通道数不限，输出通道数为e1+e3e_1+e_3e1​+e3​。 在本文提出的SqueezeNet结构中，e1=e3=4s1e_1=e_3= 4s_1e1​=e3​=4s1​。网络结构整个网络包含10层...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值