pytorch——MobileNet详解及PyTorch实现

MobileNet详解及PyTorch实现

背景

Mobile是移动、手机的概念，MobileNet是Google在2017年提出的轻量级深度神经网络，专门用于移动端、嵌入式这种计算力不高、要求速度、实时性的设备。

深度可分离卷积

主要应用了深度可分离卷积来代替传统的卷积操作，并且放弃pooling层。把标准卷积分解成：

• 深度卷积(depthwise convolution)
• 逐点卷积(pointwise convolution)。这么做的好处是可以大幅度降低参数量和计算量。

一般卷积计算量

我们先来回顾一下什么是一般的卷积：

深度可分离卷积计算量

• 深度可分离卷积（Depthwise Separable Convolution，DSC）

假设在一次一般的卷积中，需要将一个输入特征图64×7×7，经过3×3的卷积核，变成128×7×7的输出特征图。计算一下这个过程需要多少的计算量：

如果用了深度可分离卷积，就是把这个卷积变成两个步骤：

• Depthwise：先用64×7×7经过3×3的卷积核得到一个64×7×7的特征图。注意注意！这里是64×7×7的特征图经过3×3的卷积核，不是64×3×3的卷积核！这里将64×7×7的特征图看成64张7×7的图片，然后依次与3×3的卷积核进行卷积；
• Pointwise：在Depthwise的操作中，不难发现，这样的计算根本无法整合不同通道的信息，因为上一步把所有通道都拆开了，所以在这一步要用64×1×1的卷积核去整合不同通道上的信息，用128个64×1×1的卷积核，产生128×7×7的特征图。

最后的计算量就是：

计算量减少了百分之80以上。
分解过程示意图如下：

网络结构

左图表示的是一般卷积过程，卷积之后跟上BN和ReLU激活层，因为DBC将分成了两个卷积过程，所以就变成了图右这种结构，Depthwise之后加上BN和ReLU，然后Pointwise之后再加上Bn和ReLU。

从整个网络结构可以看出来：

• 除了第一层为标准的卷积层之外，其他的层都为深度可分离卷积。
• 整个网络没有使用Pooling层。

PyTorch实现

import torch
import torch.nn as nn
import torch.nn.functional as F


class Block(nn.Module):
    '''Depthwise conv + Pointwise conv'''
    def __init__(self, in_planes, out_planes, stride=1):
        super(Block, self).__init__()
        self.conv1 = nn.Conv2d\
            (in_planes, in_planes, kernel_size=3, stride=stride, 
             padding=1, groups=in_planes, bias=False)
        self.bn1 = nn.BatchNorm2d(in_planes)
        self.conv2 = nn.Conv2d\
            (in_planes, out_planes, kernel_size=1, 
            stride=1, padding=0, bias=False)
        self.bn2 = nn.BatchNorm2d(out_planes)

    def forward(self, x):
        out = F.relu(self.bn1(self.conv1(x)))
        out = F.relu(self.bn2(self.conv2(out)))
        return out


class MobileNet(nn.Module):
    # (128,2) means conv planes=128, conv stride=2, 
    # by default conv stride=1
    cfg = [64, (128,2), 128, (256,2), 256, (512,2), 
           512, 512, 512, 512, 512, (1024,2), 1024]

    def __init__(self, num_classes=10):
        super(MobileNet, self).__init__()
        self.conv1 = nn.Conv2d(3, 32, kernel_size=3, 
         stride=1, padding=1, bias=False)
        self.bn1 = nn.BatchNorm2d(32)
        self.layers = self._make_layers(in_planes=32)
        self.linear = nn.Linear(1024, num_classes)

    def _make_layers(self, in_planes):
        layers = []
        for x in self.cfg:
            out_planes = x if isinstance(x, int) else x[0]
            stride = 1 if isinstance(x, int) else x[1]
            layers.append(Block(in_planes, out_planes, stride))
            in_planes = out_planes
        return nn.Sequential(*layers)

    def forward(self, x):
        out = F.relu(self.bn1(self.conv1(x)))
        out = self.layers(out)
        out = F.avg_pool2d(out, 2)
        out = out.view(out.size(0), -1)
        out = self.linear(out)
        return out

net = MobileNet()
x = torch.randn(1,3,32,32)
y = net(x)
print(y.size())
> torch.Size([1, 10])

正常情况下这个预训练模型都会输出1024个线性节点，然后这里我自己加上了一个1024->10的一个全连接层。
我们来看一下这个网络结构：

print(net)