探索與實現(xiàn) MobileNet V3 網(wǎng)絡(luò)結(jié)構(gòu)

MobileNetV3是由Google在2019年3月21日提出的網(wǎng)絡(luò)架構(gòu)，參考arXiv的論文，其中包括兩個子版本，即Large和Small。

源碼參考：https://github.com/SpikeKing/mobilenet_v3/blob/master/mn3_model.py

重點：

  1. PyTorch實現(xiàn)MobileNetV3架構(gòu)；
  2. h-swish和h-sigmoid的設(shè)計；
  3. 新的MobileNet單元；
  4. SE結(jié)構(gòu)和Residual結(jié)構(gòu)；
  5. Last Stage：提前Avg Pooling，和使用1x1卷積；

網(wǎng)絡(luò)結(jié)構(gòu)：

網(wǎng)絡(luò)結(jié)構(gòu)

整體架構(gòu)

MobileNetV3的網(wǎng)絡(luò)結(jié)構(gòu)可以分為三個部分：

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

網(wǎng)絡(luò)框架如下，其中參數(shù)是Large體系：

Overall

源碼如下：

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中均相同，也就是結(jié)構(gòu)列表中的第1個卷積層，其中包括3個部分，即卷積層、BN層、h-switch激活層。

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-switch 和 h-sigmoid

h-switch是非線性激活函數(shù)，公式如下：

Formula

圖形如下：

h-switch

源碼：

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

h-sigmoid是非線性激活函數(shù)，用于SE結(jié)構(gòu)：

源碼：

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

圖形如下：

h-sigmoid

卷積的計算公式

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

公式：

N = (W ? F + 2P ) / S + 1

其中，向下取整，多余的像素不參于計算。

中間部分

中間部分是多個含有卷積層的塊（MobileBlock）的網(wǎng)絡(luò)結(jié)構(gòu)，參考，Large的網(wǎng)絡(luò)結(jié)構(gòu)，Small類似：

Large

其中：

  • SE：Squeeze-and-Excite結(jié)構(gòu)，壓縮和激發(fā)；
  • NL：Non-Linearity，非線性；HS：h-swish激活函數(shù)，RE：ReLU激活函數(shù)；
  • bneck：bottleneck layers，瓶頸層；
  • exp size：expansion factor，膨脹參數(shù)；

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

源碼：

self.block = []
for in_channels, out_channels, kernal_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卷積，由輸入通道，轉(zhuǎn)換為膨脹通道；
  2. 3x3或5x5卷積，膨脹通道，使用步長stride；
  3. 1x1卷積，由膨脹通道，轉(zhuǎn)換為輸出通道。

兩個可選步驟：

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

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

結(jié)構(gòu)如下，參數(shù)為特定，非通用：

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

子步驟如下：

第1步：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)
)

第2步：膨脹的卷積操作

groups是exp值，每個通道對應(yīng)一個卷積，參考，并且不含有激活層。

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),
)

第3步：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)
)

可選操作1：SE結(jié)構(gòu)

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

源碼：

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

可選操作2：殘差結(jié)構(gòu)

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

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的卷積，如圖：

Last Stage

源碼：

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)
網(wǎng)絡(luò)結(jié)構(gòu)

第1個卷積層conv1，SE結(jié)構(gòu)同上，源碼：

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個卷積層conv2：

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),
)

最后，調(diào)用resize方法，將Cx1x1轉(zhuǎn)換為類別，即可

out = out.view(batch, -1)

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

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

至此，MobileNet V3的網(wǎng)絡(luò)結(jié)構(gòu)已經(jīng)介紹完成。

?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
平臺聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務(wù)。

推薦閱讀更多精彩內(nèi)容