輕量化模型之MobileNet系列

       自 2012 年 AlexNet 以來，卷積神經網絡在圖像分類、目標檢測、語義分割等領域獲得廣泛應用。隨着性能要求越來越高，AlexNet 已經無法滿足大家的需求，於是乎各路大牛紛紛提出性能更優越的 CNN 網絡，如 VGG、GoogLeNet、ResNet、DenseNet 等。由於神經網絡的性質，為了獲得更好的性能，網絡層數不斷增加，從 7 層 AlexNet 到 16 層 VGG，再從 16 層 VGG 到 GoogLeNet 的 22 層，再到 152 層 ResNet，更有上千層的 ResNet 和 DenseNet。雖然網絡性能得到了提高，但隨之而來的就是效率問題。

       效率問題主要是模型的存儲問題和模型進行預測的速度問題。

       1、存儲問題。數百層網絡有着大量的權值參數，保存大量權值參數對設備的內存要求很高；

       2、速度問題。在實際應用中，往往是毫秒級別，為了達到實際應用標准，要么提高處理器性能（很難），要么就減少計算量。

       只有解決 CNN 效率問題，才能讓 CNN 走出實驗室，更廣泛的應用於移動端。

       對於效率問題，通常的方法是進行模型壓縮（Model Compression），即在已經訓練好的模型上進行壓縮，使得網絡攜帶更少的網絡參數，從而解決內存問題，同時可以解決速度問題。

       相比於在已經訓練好的模型上進行處理，輕量化模型模型設計則是另辟蹊徑。輕量化模型設計主要思想在於設計更高效的「網絡計算方式」（主要針對主干網卷積），從而使網絡參數減少的同時，不損失網絡性能。

 

MobileNetV1

       谷歌在2017年提出專注於移動端或者嵌入式設備中的輕量級CNN網絡：MobileNet。最大的創新點是深度可分離卷積。

       傳統卷積分成兩步，每個卷積核與每張特征圖進行按位相成然后進行相加，此時，計算量為DF∗DF∗DK∗DK∗M∗N，其中DF為特征圖尺寸，DK為卷積核尺寸，M為輸入通道數，N為輸出通道數。深度可分離卷積將傳統卷積的兩步進行分離開來，分別是depthwise和pointwise。從下面的圖可以看出，首先按照通道進行計算按位相乘的計算，此時通道數不改變；然后依然得到將第一步的結果，使用1*1的卷積核進行傳統的卷積運算，此時通道數可以進行改變。使用了深度可分離卷積，其計算量為DK∗DK∗M∗DF∗DF+1∗1∗M∗N∗DF∗DF。

 通過深度可分離卷積，計算量將會下降，當時，深度可分離卷積比傳統卷積少8到9倍的計算量。深度可分離卷積雖然很好的減少計算量，但同時也會損失一定的准確率。

最后給出v1的整個模型結構，該網絡有28層。可以看出，該網絡基本去除了pool層，使用stride來進行降采樣。

depthwise后接BN層和RELU6，pointwise后也接BN層和RELU6，如下圖所示（圖中應該是RELU6）。左圖是傳統卷積，右圖是深度可分離卷積。更多的ReLU6，增加了模型的非線性變化，增強了模型的泛化能力。

v1中使用了RELU6作為激活函數，這個激活函數在float16/int8的嵌入式設備中效果很好，能較好地保持網絡的魯棒性。

MobileNet給出了2個超參，寬度乘子α和分辨率乘子β，通過這兩個超參，可以進一步縮減模型，文章中也給出了具體的試驗結果。此時，我們反過來看，擴大寬度和分辨率，都能提高網絡的准確率，但如果單一提升一個的話，准確率很快就會達到飽和，這就是2019年谷歌提出efficientnet的原因之一，動態提高深度、寬度、分辨率來提高網絡的准確率。

 

MobileNetV2

2018年谷歌又一新作，在V1的基礎上，引入了Inverted Residuals和Linear Bottlenecks。

在使用V1的時候，發現depthwise部分的卷積核容易費掉，即卷積核大部分為零。作者認為這是ReLU引起的。

簡單來說，就是當低維信息映射到高維，經過ReLU后再映射回低維時，若映射到的維度相對較高，則信息變換回去的損失較小；若映射到的維度相對較低，則信息變換回去后損失很大，如下圖所示：

因此，認為對低維度做ReLU運算，很容易造成信息的丟失。而在高維度進行ReLU運算的話，信息的丟失則會很少。另外一種解釋是，高維信息變換回低維信息時，相當於做了一次特征壓縮，會損失一部分信息，而再經過relu后，損失的部分就更加大了。作者為了這個問題，就將ReLU替換成線性激活函數。

Inverted Residuals

這個可以翻譯成“倒殘差模塊”。什么意思呢？我們來對比一下殘差模塊和倒殘差模塊的區別。

• 殘差模塊：輸入首先經過1*1的卷積進行壓縮，然后使用3*3的卷積進行特征提取，最后在用1*1的卷積把通道數變換回去。整個過程是“壓縮-卷積-擴張”。這樣做的目的是減少3*3模塊的計算量，提高殘差模塊的計算效率。
• 倒殘差模塊：輸入首先經過1*1的卷積進行通道擴張，然后使用3*3的depthwise卷積，最后使用1*1的pointwise卷積將通道數壓縮回去。整個過程是“擴張-卷積-壓縮”。為什么這么做呢？因為depthwise卷積不能改變通道數，因此特征提取受限於輸入的通道數，所以將通道數先提升上去。文中的擴展因子為6。

Linear Bottleneck

這個模塊是為了解決一開始提出的那個低維-高維-低維的問題，即將最后一層的ReLU6替換成線性激活函數，而其他層的激活函數依然是ReLU6。

 

將兩個模塊進行結合，如下圖所示。當stride=1時，輸入首先經過1*1的卷積進行通道數的擴張，此時激活函數為ReLU6；然后經過3*3的depthwise卷積，激活函數是ReLU6；接着經過1*1的pointwise卷積，將通道數壓縮回去，激活函數是linear；最后使用shortcut，將兩者進行相加。而當stride=2時，由於input和output的特征圖的尺寸不一致，所以就沒有shortcut了。

最后，給出v2的網絡結構。其中，t為擴張系數，c為輸出通道數，n為該層重復的次數，s為不長。可以看出，v2的網絡比v1網絡深了很多，v2有54層。

當然，少不了性能對比圖。v2的准確率比v1高出不少，延時也低了很多，是一款不錯的輕量化網絡。

MoblieNetV3

 MobileNet V3發表於2019年，該v3版本結合了v1的深度可分離卷積、v2的Inverted Residuals和Linear Bottleneck、SE模塊，利用NAS（神經結構搜索）來搜索網絡的配置和參數。

v3在v2的版本上有以下的改進：

• 作者發現，計算資源耗費最多的層是網絡的輸入和輸出層，因此作者對這兩部分進行了改進。如下圖所示，上面是v2的最后輸出幾層，下面是v3的最后輸出的幾層。可以看出，v3版本將平均池化層提前了。在使用1*1卷積進行擴張后，就緊接池化層-激活函數，最后使用1*1的卷積進行輸出。通過這一改變，能減少10ms的延遲，提高了15%的運算速度，且幾乎沒有任何精度損失。其次，對於v2的輸入層，通過3*3卷積將輸入擴張成32維。作者發現使用ReLU或者switch激活函數，能將通道數縮減到16維，且准確率保持不變。這又能節省3ms的延時。

• 由於嵌入式設備計算sigmoid是會耗費相當大的計算資源的，因此作者提出了h-switch作為激活函數。且隨着網絡的加深，非線性激活函數的成本也會隨之減少。所以，只有在較深的層使用h-switch才能獲得更大的優勢。

• 在v2的block上引入SE模塊，SE模塊是一種輕量級的通道注意力模塊。在depthwise之后，經過池化層，然后第一個fc層，通道數縮小4倍，再經過第二個fc層，通道數變換回去（擴大4倍），然后與depthwise進行按位相加。

最后，v3的結構如下圖所示。作者提供了兩個版本的v3，分別是large和small，對應於高資源和低資源的情況。兩者都是使用NAS進行搜索出來的。

從下面的試驗結果，可以看出v3-large的准確率和計算速度都高於v2。所以，AutoML搭出來的網絡，已經能代替大部分調參了。

MobileNetV3網絡結構分為三部分：

• 起始部分：1個卷積層，通過3x3的卷積，提取特征；
• 中間部分：多個卷積層，不同Large和Small版本，層數和參數不同；
• 最后部分：通過兩個1x1的卷積層，代替全連接，輸出類別；

網絡框架如下，其中參數是Large體系：

 

源碼如下（Pytorch）：

def forward(self, x):
    # 起始部分
    out = self.init_conv(x)
    # 中間部分
    out = self.block(out)
    # 最后部分
    out = self.out_conv1(out)
    batch, channels, height, width = out.size()
    out = F.avg_pool2d(out, kernel_size=[height, width])
    out = self.out_conv2(out)
    out = out.view(batch, -1)
    return out

起始部分

起始部分，在Large和Small中均相同，也就是結構列表中的第1個卷積層，其中包括3個部分，即卷積層、BN層、h-swish激活層。

 

Start

源碼如下：

init_conv_out = _make_divisible(16 * multiplier)
self.init_conv = nn.Sequential(
    nn.Conv2d(in_channels=3, out_channels=init_conv_out, kernel_size=3, stride=2, padding=1),
    nn.BatchNorm2d(init_conv_out),
    h_swish(inplace=True),
)

h-swish 和 h-sigmoid

h-swish是非線性激活函數，公式如下：

圖形如下：

 

源碼如下：

out = F.relu6(x + 3., self.inplace) / 6.
return out * x

H-sigmoid是非線性激活函數，用於SE結構，源碼如下：

return F.relu6(x + 3., inplace=self.inplace) / 6.

 

 卷積計算公式：

• 輸入圖片：W×W
• 卷積核：F×F
• 步長：S
• Padding的像素值：P
• 輸出圖片大小為：N×N

N = (W − F + 2P ) / S + 1 #其中，向下取整，多余的像素不參於計算。

中間部分

中間部分是多個含有卷積層的塊（MobileBlock）的網絡結構，Large的網絡結構：

Large

其中：

• SE：Squeeze-and-Excite結構，壓縮和激發；
• NL：Non-Linearity，非線性；HS：h-swish激活函數，RE：ReLU激活函數；
• bneck：bottleneck layers，瓶頸層；
• exp size：expansion factor，膨脹參數；

每一行都是一個MobileBlock，即bneck。

源碼：

self.block = []
for in_channels, out_channels, kernel_size, stride, nonlinear, se, exp_size in layers:
    in_channels = _make_divisible(in_channels * multiplier)
    out_channels = _make_divisible(out_channels * multiplier)
    exp_size = _make_divisible(exp_size * multiplier)
    self.block.append(MobileBlock(in_channels, out_channels, kernal_size, stride, nonlinear, se, exp_size))
    self.block = nn.Sequential(*self.block)

MobileBlock

三個必要步驟：

1. 1x1卷積，由輸入通道，轉換為膨脹通道；
2. 3x3或5x5卷積，膨脹通道，使用步長stride；
3. 1x1卷積，由膨脹通道，轉換為輸出通道。

 

兩個可選步驟：

1. SE結構：Squeeze-and-Excite；
2. 連接操作，Residual殘差；步長為1，同時輸入和輸出通道相同；

其中激活函數有兩種：ReLU和h-swish。

結構如下，參數為特定，非通用：

 

MobileBlock

def forward(self, x):
    # MobileNetV2
    out = self.conv(x)  # 1x1卷積
    out = self.depth_conv(out)  # 深度卷積

    # Squeeze and Excite
    if self.SE:
        out = self.squeeze_block(out)

    # point-wise conv
    out = self.point_conv(out)

    # connection
    if self.use_connect:
        return x + out
    else:
        return out

其中，1x1卷積：

self.conv = nn.Sequential(
    nn.Conv2d(in_channels, exp_size, kernel_size=1, stride=1, padding=0),
    nn.BatchNorm2d(exp_size),
    activation(inplace=True)
)

SE模塊：

self.depth_conv = nn.Sequential(
    nn.Conv2d(exp_size, exp_size, kernel_size=kernal_size, stride=stride, padding=padding, groups=exp_size),
    nn.BatchNorm2d(exp_size),
)

1x1逐點卷積

self.point_conv = nn.Sequential(
    nn.Conv2d(exp_size, out_channels, kernel_size=1, stride=1, padding=0),
    nn.BatchNorm2d(out_channels),
    activation(inplace=True)
)

SE結構

1. 池化；
2. Squeeze線性連接 + RELU + Excite線性連接 + h-sigmoid；
3. resize；
4. 權重與原值相乘；

class SqueezeBlock(nn.Module):
    def __init__(self, exp_size, divide=4):
        super(SqueezeBlock, self).__init__()
        self.dense = nn.Sequential(
            nn.Linear(exp_size, exp_size // divide),
            nn.ReLU(inplace=True),
            nn.Linear(exp_size // divide, exp_size),
            h_sigmoid()
        )

    def forward(self, x):
        batch, channels, height, width = x.size()
        out = F.avg_pool2d(x, kernel_size=[height, width]).view(batch, -1)
        out = self.dense(out)
        out = out.view(batch, channels, 1, 1)

        return out * x

殘差結構

最終的輸出與原值相加，源碼如下：

self.use_connect = (stride == 1 and in_channels == out_channels)

if self.use_connect:
    return x + out
else:
    return out

最后部分

最后部分（Last Stage），通過將Avg Pooling提前，減少計算量，將Squeeze操作省略，直接使用1x1的卷積，如圖：

 

源碼如下：

out = self.out_conv1(out)
batch, channels, height, width = out.size()
out = F.avg_pool2d(out, kernel_size=[height, width])
out = self.out_conv2(out)

第1個卷積層conv1，SE結構同上，源碼如下：

out_conv1_in = _make_divisible(96 * multiplier)
out_conv1_out = _make_divisible(576 * multiplier)
self.out_conv1 = nn.Sequential(
    nn.Conv2d(out_conv1_in, out_conv1_out, kernel_size=1, stride=1),
    SqueezeBlock(out_conv1_out),
    h_swish(inplace=True),
)

第2個卷積層：

out_conv2_in = _make_divisible(576 * multiplier)
out_conv2_out = _make_divisible(1280 * multiplier)
self.out_conv2 = nn.Sequential(
    nn.Conv2d(out_conv2_in, out_conv2_out, kernel_size=1, stride=1),
    h_swish(inplace=True),
    nn.Conv2d(out_conv2_out, self.num_classes, kernel_size=1, stride=1),
)

最后，調用resize方法，將Cx1x1轉換為類別，即可：

out = out.view(batch, -1)

除此之外，還可以設置multiplier參數，等比例的增加和減少通道的個數，滿足8的倍數，源碼如下：

def _make_divisible(v, divisor=8, min_value=None):
    if min_value is None:
        min_value = divisor
    new_v = max(min_value, int(v + divisor / 2) // divisor * divisor)
    # Make sure that round down does not go down by more than 10%.
    if new_v < 0.9 * v:
        new_v += divisor
    return new_v

至此，網絡結構完成。