一文看懂MobileNet

MobileNet框架

深度可分离卷积

传统卷积操作是在卷积的过程中既进行卷积操作，同时将输入组合成新的输出。深度可分离卷积将这一步骤分成两步。如下图2.(a)就是一个标准卷积操作，分解成图2.(b)中的深度卷积和图2.©的1*1卷积。

为什么要分离呢？为了降低计算成本。
首先，标准卷积

输入$D_F\ast D_F\ast M(input)，D_F$是输入特征图宽度和高度，$M$是输入通道数。
卷积核$D_K\ast D_K\ast M\ast N(kernel)，D_K$是卷积核的k_size，$M$是输入通道数，$N$是输出通道数。
输出$D_G\ast D_G\ast N(output)，D_G$是输出特征图的宽度和高度，$N$是输出深度。如下式

由此，标准卷积核的计算代价是：
$D_K\ast D_K\ast M\ast N\ast D_F\ast D_F$

$Depthwiseseparableconvolution=depthconvolutions+pointwiseconvolutions(1\ast 1卷积)$，如下式：

$D_K\ast D_K\ast M\ast D_F\ast D_F+M\ast N\ast D_F\ast D_F$
那么我们可以将两个计算量相除进行比较：
$\frac{D_K\ast D_K\ast M\ast D_F\ast D_F+M\ast N\ast D_F\ast D_F}{D_K\ast D_K\ast M\ast N\ast D_F\ast D_F}=\frac{1}{N}+\frac{1}{D_K^2}$
可以看出$\frac{1}{N}+\frac{1}{D_K^2}$小于零，那么可以验证前面的说法，减少了参数量。

网络结构

MobileNet如下表所示：

Conv dw：

Conv：

每层所占的资源

宽度乘数：缩小模型

Mobilenet中引入了宽度乘子$\alpha$，输入通道的个数$M$变成$\alpha M$，输出通道的个数$N$变成$\alpha N$
通过宽度乘子的可分离卷积的计算代价就变为了：
$D_K\ast D_K\ast \alpha M\ast D_F\ast D_F+\alpha M\ast \alpha N\ast D_F\ast D_F,\alpha \in (0，1]$，宽度乘子可以用于任何模型结构，以定义一个新的更小的模型，具有合理的精度、延迟和大小。

分辨率乘数：减少表征数

文中还引入了一个超参数，是分辨率乘子$\rho$。将分辨率乘子应用到输入图像中，在每一层的内部表征中都以相同的方法进行缩减。
他的计算代价为：
$D_K\ast D_K\ast \alpha M\ast \rho D_F\ast \rho D_F+\alpha M\ast \alpha N\ast \rho D_F\ast \rho D_F,\alpha \in (0，1]，\rho \in (0，1]$
文中提到，$\rho$通常是隐式设置的，因此网络输入分辨率为224、192、160或128。

实验结果

首先，如上表MobileNet的实验结果相较于全卷积模型准确率下降了1%，但是，他的数据量减少了将近9倍，而超参数减少了7倍。
然后，是宽度算子$\alpha =0.75$，如下表，可以看出，在其他条件相同的条件下，thinner网络比原网络在准确度上提高了3%

表6、7表示$\alpha 和\rho$在MobileNet结构在精度、计算和大小相权衡的情况下的结果。

与其他网络比较结果

人脸属性分类任务

COCO数据集

与FaceNet人脸识别模型比较

代码

  def _depthwise_separable_conv(inputs,
                                num_pwc_filters,
                                width_multiplier,
                                sc,
                                downsample=False):
    """ Helper function to build the depth-wise separable convolution layer.
    """
    num_pwc_filters = round(num_pwc_filters * width_multiplier)
    _stride = 2 if downsample else 1

    # skip pointwise by setting num_outputs=None
    depthwise_conv = slim.separable_convolution2d(inputs,
                                                  num_outputs=None,
                                                  stride=_stride,
                                                  depth_multiplier=1,
                                                  kernel_size=[3, 3],
                                                  scope=sc+'/depthwise_conv')

    bn = slim.batch_norm(depthwise_conv, scope=sc+'/dw_batch_norm')
    pointwise_conv = slim.convolution2d(bn,
                                        num_pwc_filters,
                                        kernel_size=[1, 1],
                                        scope=sc+'/pointwise_conv')
    bn = slim.batch_norm(pointwise_conv, scope=sc+'/pw_batch_norm')
    return bn

  with tf.variable_scope(scope) as sc:
    end_points_collection = sc.name + '_end_points'
    with slim.arg_scope([slim.convolution2d, slim.separable_convolution2d],
                        activation_fn=None,
                        outputs_collections=[end_points_collection]):
      with slim.arg_scope([slim.batch_norm],
                          is_training=is_training,
                          activation_fn=tf.nn.relu,
                          fused=True):
        net = slim.convolution2d(inputs, round(32 * width_multiplier), [3, 3], stride=2, padding='SAME', scope='conv_1')
        net = slim.batch_norm(net, scope='conv_1/batch_norm')
        net = _depthwise_separable_conv(net, 64, width_multiplier, sc='conv_ds_2')
        net = _depthwise_separable_conv(net, 128, width_multiplier, downsample=True, sc='conv_ds_3')
        net = _depthwise_separable_conv(net, 128, width_multiplier, sc='conv_ds_4')
        net = _depthwise_separable_conv(net, 256, width_multiplier, downsample=True, sc='conv_ds_5')
        net = _depthwise_separable_conv(net, 256, width_multiplier, sc='conv_ds_6')
        net = _depthwise_separable_conv(net, 512, width_multiplier, downsample=True, sc='conv_ds_7')

        net = _depthwise_separable_conv(net, 512, width_multiplier, sc='conv_ds_8')
        net = _depthwise_separable_conv(net, 512, width_multiplier, sc='conv_ds_9')
        net = _depthwise_separable_conv(net, 512, width_multiplier, sc='conv_ds_10')
        net = _depthwise_separable_conv(net, 512, width_multiplier, sc='conv_ds_11')
        net = _depthwise_separable_conv(net, 512, width_multiplier, sc='conv_ds_12')

        net = _depthwise_separable_conv(net, 1024, width_multiplier, downsample=True, sc='conv_ds_13')
        net = _depthwise_separable_conv(net, 1024, width_multiplier, sc='conv_ds_14')
        net = slim.avg_pool2d(net, [7, 7], scope='avg_pool_15')

    end_points = slim.utils.convert_collection_to_dict(end_points_collection)
    net = tf.squeeze(net, [1, 2], name='SpatialSqueeze')
    end_points['squeeze'] = net
    logits = slim.fully_connected(net, num_classes, activation_fn=None, scope='fc_16')
    predictions = slim.softmax(logits, scope='Predictions')

    end_points['Logits'] = logits
    end_points['Predictions'] = predictions

  return logits, end_points

mobilenet.default_image_size = 224

总结

文中共提出了三个内容，一个是深度可分离卷积，另外两个是宽度乘法器和分辨率乘法器。深度可分离卷积在减少参数量上起到了明显的作用，而宽度乘法器和分辨率乘法器需要调整合适的大小，在参数量和精度之间进行权衡，得到一个既精度损失不大，而参数量减小的结果。

论文链接

Mobilenet论文

代码链接

Mobilenet代码