移动端/嵌入式-CV模型-2019：MobileNets-v3【①Bottleneck结构中引入SE结构（注意力机制）来计算各通道的重要性、②重新设计耗时层结构、③重新设计激活函数（h-swish）】

喜欢ヅ旅行 2023-09-28 19:07 1阅读 0赞

[《MobileNets-v3原始论文：Searching for MobileNetV3》][MobileNets-v3_Searching for MobileNetV3]

比v2更准确、更快

mobilenet-v3是Google继mobilenet-v2之后的又一力作，作为mobilenet系列的新成员，自然效果会提升。

mobilenet-v3提供了两个版本，分别为：

*  mobilenet-v3 large
 *  mobilenet-v3 small

这两个版本分别适用于对资源不同要求的情况。

论文中提到：

*  mobilenet-v3 small在imagenet分类任务上，较mobilenet-v2，精度提高了大约3.2%，时间却减少了15%，
 *  mobilenet-v3 large在imagenet分类任务上，较mobilenet-v2，精度提高了大约4.6%，时间减少了5%，
 *  mobilenet-v3 large 与v2相比，在COCO上达到相同的精度，速度快了25%，
 *  同时在分割算法上也有一定的提高。

本文还有一个亮点在于，网络的设计利用了NAS（network architecture search）算法以及NetAdapt algorithm算法。并且，本文还介绍了一些提升网络效果的trick，这些trick也提升了不少的精度以及速度。

## 一、概述 ##

近年来，随着智能应用的不断增加，轻量化网络成为近年来的一个研究热点，毕竟不是所有设备都有GPU来计算的，轻量化 网络顾名思义，就是网络的参数量比较少，速度较快，下面总结了目前常用的一些减少网络计算量的方法：

*  **基于轻量化网络设计**：比如mobilenet系列，shufflenet系列， Xception等，使用Group卷积、1x1卷积等技术减少网络计算量的同时，尽可能的保证网络的精度。
 *  **模型剪枝**： 大网络往往存在一定的冗余，通过剪去冗余部分，减少网络计算量。
 *  **量化**：利用TensorRT量化，一般在GPU上可以提速几倍。
 *  **知识蒸馏**：利用大模型（teacher model）来帮助小模型（student model）学习，提高student model的精度。

MobelNets系列当然是典型的第一种方法。

在介绍MobelNets-v3前，先来回顾一下mobilenet v1和v2的创新点：

*  **MobelNets-v1**：
    
     *  利用分组卷积降低网络的计算量，并且mobilenet将分组卷积应用到极致，即网络的分组数与网络的channel数量相等，使网络的计算量减到最低，但是这样channel之间的交互就没有了，所以作者又使用的point-wise conv,即使用1x1的卷积进行channel之间的融合。
     *  直筒结构。
 *  **MobelNets-v2**：
    
     *  引入了Inverted Bottleneck结构。
     *  将Resnet的Bottleneck结构变成了纺锤型，即Resnet是先缩小为原来的1/4，再放大，他是放大到原来的6倍，再缩小。
     *  并且去掉了Residual Block最后的ReLU。

## 二、MobelNets-v3创新点 ##

### 1、在Bottleneck结构中引入SE结构 ###

在Bottleneck结构中加入了SE（Squeeze-and-Excite）结构，并且放在了depthwise filter之后，如下图。

![在这里插入图片描述][d73a9c099da141518b8a8a1bb7d96088.png_pic_center]  
![在这里插入图片描述][b86035c1ce114d5ea7f545fa6028cfb3.png_pic_center]  
因为SE结构会消耗一定的时间，所以作者在含有SE的结构中，将expansion layer的channel变为原来的1/4，这样作者发现，即提高了精度，同时还没有增加时间消耗。并且SE结构放在了depthwise之后。

### 2、重新设计耗时层结构 ###

![在这里插入图片描述][e64425b8bb6e469593106d0cbe9d23e2.png_pic_center]

#### 2.1 减少第一个卷积层的卷积核个数（32–>16） ####

修改头部卷积核channel数量，MobelNets-v2中使用的是32 x 3 x 3，作者发现，其实32可以再降低一点，所以这里作者改成了16，在保证了精度的前提下，降低了3ms的速度。

![在这里插入图片描述][75245fb975024b009c8b1e2fc511443c.png_pic_center]

#### 2.2 精简Last Stage ####

在MobelNets-v2中，在avg pooling之前，存在一个1x1的卷积层，目的是提高特征图的维度，更有利于结构的预测，但是这其实带来了一定的计算量了，所以这里作者修改了，将其放在avg pooling的后面，首先利用avg pooling将特征图大小由7x7降到了1x1，降到1x1后，然后再利用1x1提高维度，这样就减少了7x7=49倍的计算量。

并且为了进一步的降低计算量，作者直接去掉了前面纺锤型卷积的3x3以及1x1卷积，进一步减少了计算量，就变成了如下图第二行所示的结构，作者将其中的3x3以及1x1去掉后，精度并没有得到损失。这里降低了大约15ms的速度。  
![在这里插入图片描述][ba0dfe1b5ead4573b89c957057c9340d.png_pic_center]

### 3、重新设计激活函数 ###

![在这里插入图片描述][bdd7f74f12ad48ab8651e0c6d0f810a2.png_pic_center]  
使用 **h-swish** 替换 **swish**，swish是谷歌自家的研究成果，颇有点自卖自夸的意思，这次在其基础上，为速度进行了优化。

swish与h-swish公式如下所示，  
![在这里插入图片描述][ac2ea12d0291476fb16f271b6cb3ce2c.png_pic_center]

由于  s i g m o i d sigmoid sigmoid 的计算耗时较长，特别是在移动端，这些耗时就会比较明显，所以作者使用  R e L U 6 ( x + 3 ) / 6 ReLU6(x+3)/6 ReLU6(x\+3)/6 来近似替代sigmoid.  
![在这里插入图片描述][1ae807a3048c4316b5616a27b169ab0f.png_pic_center]

观察下图可以发现，其实相差不大的。  
![在这里插入图片描述][93ed9b915a3e43df8f7278980bcbbf41.png_pic_center]  
利用ReLU有几点好处，

1.  可以在任何软硬件平台进行计算；
2.  量化的时候，它消除了潜在的精度损失，使用 h-swish 替换 swith，在量化模式下回提高大约15%的效率，
3.  另外，**h-swish** 在深层网络中更加明显。

## 三、MobelNets-v3 与 MobelNets-v2 性能对比 ##

![在这里插入图片描述][37418d7c2bd1416d8a42e1bd237cdc62.png_pic_center]

## 四、总结 ##

总结来看，mobilenet V3其实并没有惊艳的结构提出，最主要的还是应用了诸如SE、H-Swish等tricks，然后利用Google前面提出的NAS以及NetAdapt算法进行结构的自动搜索，提升了一定的精度，降低了一定的速度。

可能本篇论文的重点更在于进一步展示一下网络自动结构搜索的有效性，这样对应了文中的标题：Searching for，毕竟这也是发展的一个势头。

## 五、MobileNets-v3代码 ##

import torch
    import torch.nn as nn
    import torch.nn.functional as F
    
    
    __all__ = ['MobileNetV3', 'mobilenetv3']
    
    
    def conv_bn(inp, oup, stride, conv_layer=nn.Conv2d, norm_layer=nn.BatchNorm2d, nlin_layer=nn.ReLU):
        return nn.Sequential(
            conv_layer(inp, oup, 3, stride, 1, bias=False),
            norm_layer(oup),
            nlin_layer(inplace=True)
        )
    
    
    def conv_1x1_bn(inp, oup, conv_layer=nn.Conv2d, norm_layer=nn.BatchNorm2d, nlin_layer=nn.ReLU):
        return nn.Sequential(
            conv_layer(inp, oup, 1, 1, 0, bias=False),
            norm_layer(oup),
            nlin_layer(inplace=True)
        )
    
    
    class Hswish(nn.Module):
        def __init__(self, inplace=True):
            super(Hswish, self).__init__()
            self.inplace = inplace
    
        def forward(self, x):
            return x * F.relu6(x + 3., inplace=self.inplace) / 6.
    
    
    class Hsigmoid(nn.Module):
        def __init__(self, inplace=True):
            super(Hsigmoid, self).__init__()
            self.inplace = inplace
    
        def forward(self, x):
            return F.relu6(x + 3., inplace=self.inplace) / 6.
    
    
    class SEModule(nn.Module):
        def __init__(self, channel, reduction=4):
            super(SEModule, self).__init__()
            self.avg_pool = nn.AdaptiveAvgPool2d(1)
            self.fc = nn.Sequential(
                nn.Linear(channel, channel // reduction, bias=False),
                nn.ReLU(inplace=True),
                nn.Linear(channel // reduction, channel, bias=False),
                Hsigmoid()
                # nn.Sigmoid()
            )
    
        def forward(self, x):
            b, c, _, _ = x.size()
            y = self.avg_pool(x).view(b, c)
            y = self.fc(y).view(b, c, 1, 1)
            return x * y.expand_as(x)
    
    
    class Identity(nn.Module):
        def __init__(self, channel):
            super(Identity, self).__init__()
    
        def forward(self, x):
            return x
    
    
    def make_divisible(x, divisible_by=8):
        import numpy as np
        return int(np.ceil(x * 1. / divisible_by) * divisible_by)
    
    
    class MobileBottleneck(nn.Module):
        def __init__(self, inp, oup, kernel, stride, exp, se=False, nl='RE'):
            super(MobileBottleneck, self).__init__()
            assert stride in [1, 2]
            assert kernel in [3, 5]
            padding = (kernel - 1) // 2
            self.use_res_connect = stride == 1 and inp == oup
    
            conv_layer = nn.Conv2d
            norm_layer = nn.BatchNorm2d
            if nl == 'RE':
                nlin_layer = nn.ReLU # or ReLU6
            elif nl == 'HS':
                nlin_layer = Hswish
            else:
                raise NotImplementedError
            if se:
                SELayer = SEModule
            else:
                SELayer = Identity
    
            self.conv = nn.Sequential(
                # pw
                conv_layer(inp, exp, 1, 1, 0, bias=False),
                norm_layer(exp),
                nlin_layer(inplace=True),
                # dw
                conv_layer(exp, exp, kernel, stride, padding, groups=exp, bias=False),
                norm_layer(exp),
                SELayer(exp),
                nlin_layer(inplace=True),
                # pw-linear
                conv_layer(exp, oup, 1, 1, 0, bias=False),
                norm_layer(oup),
            )
    
        def forward(self, x):
            if self.use_res_connect:
                return x + self.conv(x)
            else:
                return self.conv(x)
    
    
    class MobileNetV3(nn.Module):
        def __init__(self, n_class=1000, input_size=224, dropout=0.8, mode='small', width_mult=1.0):
            super(MobileNetV3, self).__init__()
            input_channel = 16
            last_channel = 1280
            if mode == 'large':
                # refer to Table 1 in paper
                mobile_setting = [
                    # k, exp, c,  se,     nl,  s,
                    [3, 16,  16,  False, 'RE', 1],
                    [3, 64,  24,  False, 'RE', 2],
                    [3, 72,  24,  False, 'RE', 1],
                    [5, 72,  40,  True,  'RE', 2],
                    [5, 120, 40,  True,  'RE', 1],
                    [5, 120, 40,  True,  'RE', 1],
                    [3, 240, 80,  False, 'HS', 2],
                    [3, 200, 80,  False, 'HS', 1],
                    [3, 184, 80,  False, 'HS', 1],
                    [3, 184, 80,  False, 'HS', 1],
                    [3, 480, 112, True,  'HS', 1],
                    [3, 672, 112, True,  'HS', 1],
                    [5, 672, 160, True,  'HS', 2],
                    [5, 960, 160, True,  'HS', 1],
                    [5, 960, 160, True,  'HS', 1],
                ]
            elif mode == 'small':
                # refer to Table 2 in paper
                mobile_setting = [
                    # k, exp, c,  se,     nl,  s,
                    [3, 16,  16,  True,  'RE', 2],
                    [3, 72,  24,  False, 'RE', 2],
                    [3, 88,  24,  False, 'RE', 1],
                    [5, 96,  40,  True,  'HS', 2],
                    [5, 240, 40,  True,  'HS', 1],
                    [5, 240, 40,  True,  'HS', 1],
                    [5, 120, 48,  True,  'HS', 1],
                    [5, 144, 48,  True,  'HS', 1],
                    [5, 288, 96,  True,  'HS', 2],
                    [5, 576, 96,  True,  'HS', 1],
                    [5, 576, 96,  True,  'HS', 1],
                ]
            else:
                raise NotImplementedError
    
            # building first layer
            assert input_size % 32 == 0
            last_channel = make_divisible(last_channel * width_mult) if width_mult > 1.0 else last_channel
            self.features = [conv_bn(3, input_channel, 2, nlin_layer=Hswish)]
            self.classifier = []
    
            # building mobile blocks
            for k, exp, c, se, nl, s in mobile_setting:
                output_channel = make_divisible(c * width_mult)
                exp_channel = make_divisible(exp * width_mult)
                self.features.append(MobileBottleneck(input_channel, output_channel, k, s, exp_channel, se, nl))
                input_channel = output_channel
    
            # building last several layers
            if mode == 'large':
                last_conv = make_divisible(960 * width_mult)
                self.features.append(conv_1x1_bn(input_channel, last_conv, nlin_layer=Hswish))
                self.features.append(nn.AdaptiveAvgPool2d(1))
                self.features.append(nn.Conv2d(last_conv, last_channel, 1, 1, 0))
                self.features.append(Hswish(inplace=True))
            elif mode == 'small':
                last_conv = make_divisible(576 * width_mult)
                self.features.append(conv_1x1_bn(input_channel, last_conv, nlin_layer=Hswish))
                # self.features.append(SEModule(last_conv))  # refer to paper Table2, but I think this is a mistake
                self.features.append(nn.AdaptiveAvgPool2d(1))
                self.features.append(nn.Conv2d(last_conv, last_channel, 1, 1, 0))
                self.features.append(Hswish(inplace=True))
            else:
                raise NotImplementedError
    
            # make it nn.Sequential
            self.features = nn.Sequential(*self.features)
    
            # building classifier
            self.classifier = nn.Sequential(
                nn.Dropout(p=dropout),    # refer to paper section 6
                nn.Linear(last_channel, n_class),
            )
    
            self._initialize_weights()
    
        def forward(self, x):
            x = self.features(x)
            x = x.mean(3).mean(2)
            x = self.classifier(x)
            return x
    
        def _initialize_weights(self):
            # weight initialization
            for m in self.modules():
                if isinstance(m, nn.Conv2d):
                    nn.init.kaiming_normal_(m.weight, mode='fan_out')
                    if m.bias is not None:
                        nn.init.zeros_(m.bias)
                elif isinstance(m, nn.BatchNorm2d):
                    nn.init.ones_(m.weight)
                    nn.init.zeros_(m.bias)
                elif isinstance(m, nn.Linear):
                    nn.init.normal_(m.weight, 0, 0.01)
                    if m.bias is not None:
                        nn.init.zeros_(m.bias)
    
    
    def mobilenetv3(pretrained=False, **kwargs):
        model = MobileNetV3(**kwargs)
        if pretrained:
            state_dict = torch.load('mobilenetv3_small_67.4.pth.tar')
            model.load_state_dict(state_dict, strict=True)
            # raise NotImplementedError
        return model
    
    
    if __name__ == '__main__':
        net = mobilenetv3()
        print('mobilenetv3:\n', net)
        print('Total params: %.2fM' % (sum(p.numel() for p in net.parameters())/1000000.0))
        input_size=(1, 3, 224, 224)
        # pip install --upgrade git+https://github.com/kuan-wang/pytorch-OpCounter.git
        from thop import profile
        flops, params = profile(net, input_size=input_size)
        # print(flops)
        # print(params)
        print('Total params: %.2fM' % (params/1000000.0))
        print('Total flops: %.2fM' % (flops/1000000.0))
        x = torch.randn(input_size)
        out = net(x)

--------------------

参考资料：  
[mobilenet系列之又一新成员—mobilenet-v3][mobilenet_mobilenet-v3]  
[轻量化网络——MobileNet][MobileNet]  
[深度学习在图像处理中的应用（tensorflow2.4以及pytorch1.10实现）][tensorflow2.4_pytorch1.10]  
[轻量级网络-Mobilenet系列(v1,v2,v3)][-Mobilenet_v1_v2_v3]  
[GitHub：A PyTorch implementation of MobileNetV3][GitHub_A PyTorch implementation of MobileNetV3]

[MobileNets-v3_Searching for MobileNetV3]: https://arxiv.org/abs/1905.02244
[d73a9c099da141518b8a8a1bb7d96088.png_pic_center]: https://img-blog.csdnimg.cn/d73a9c099da141518b8a8a1bb7d96088.png#pic_center
[b86035c1ce114d5ea7f545fa6028cfb3.png_pic_center]: https://img-blog.csdnimg.cn/b86035c1ce114d5ea7f545fa6028cfb3.png#pic_center
[e64425b8bb6e469593106d0cbe9d23e2.png_pic_center]: https://img-blog.csdnimg.cn/e64425b8bb6e469593106d0cbe9d23e2.png#pic_center
[75245fb975024b009c8b1e2fc511443c.png_pic_center]: https://img-blog.csdnimg.cn/75245fb975024b009c8b1e2fc511443c.png#pic_center
[ba0dfe1b5ead4573b89c957057c9340d.png_pic_center]: https://img-blog.csdnimg.cn/ba0dfe1b5ead4573b89c957057c9340d.png#pic_center
[bdd7f74f12ad48ab8651e0c6d0f810a2.png_pic_center]: https://img-blog.csdnimg.cn/bdd7f74f12ad48ab8651e0c6d0f810a2.png#pic_center
[ac2ea12d0291476fb16f271b6cb3ce2c.png_pic_center]: https://img-blog.csdnimg.cn/ac2ea12d0291476fb16f271b6cb3ce2c.png#pic_center
[1ae807a3048c4316b5616a27b169ab0f.png_pic_center]: https://img-blog.csdnimg.cn/1ae807a3048c4316b5616a27b169ab0f.png#pic_center
[93ed9b915a3e43df8f7278980bcbbf41.png_pic_center]: https://img-blog.csdnimg.cn/93ed9b915a3e43df8f7278980bcbbf41.png#pic_center
[37418d7c2bd1416d8a42e1bd237cdc62.png_pic_center]: https://img-blog.csdnimg.cn/37418d7c2bd1416d8a42e1bd237cdc62.png#pic_center
[mobilenet_mobilenet-v3]: https://blog.csdn.net/Chunfengyanyulove/article/details/91358187
[MobileNet]: https://zhuanlan.zhihu.com/p/402766063
[tensorflow2.4_pytorch1.10]: https://blog.csdn.net/qq_37541097/article/details/103482003
[-Mobilenet_v1_v2_v3]: https://zhuanlan.zhihu.com/p/394975928
[GitHub_A PyTorch implementation of MobileNetV3]: https://github.com/kuan-wang/pytorch-mobilenet-v3