EfficientNet(ICML 2019)原理与代码解析

paper:EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks

code:mmclassification/efficientnet.py at master · open-mmlab/mmclassification · GitHub 

背景

扩展scale up卷积网络被广泛用来获得更好的精度,比如ResNet可以通过堆叠更多的卷积层从ResNet-18扩展到ResNet-200。而缩小卷积网络则可以减小计算量获得更快的推理速度。常用的缩放维度包括深度depth、宽度channel和输入图像大小resolution。在之前的缩放方法中,通常只缩放三个维度中的一个,虽然可以任意的缩放两个或三个维度,但任意缩放需要繁琐的手工调参,而且通常仍然只能得到次优的精度和效率。 

本文的创新点

本文通过研究发现平衡深度、宽度、分辨率三个维度非常重要,并且发现这种平衡可以通过一个常量缩放因子来实现。基于此提出了一种复合缩放方法compound scaling method,与传统的任意缩放某个维度的方法不同,该方法用一组固定的缩放系数均匀地同时缩放三个维度。例如,如果我们想要用 \(2^{N}\) 倍的计算资源,可以简单地通过系数 \(\alpha^{N},\beta^{N},\gamma^{N}\) 来分别增加网络的深度、宽度、分辨率。其中 \(\alpha,\beta,\gamma\) 是常量系数,通过在原始的基础模型上通过网格搜索得到。

此外,缩放方法的有效性很大程度上取决于baseline模型,因此作者通过neural architecture search设计了一个新的基线模型,然后通过本文的缩放方法得到了一系列的模型EfficientNets。

方法介绍

作者根据经验观察到不同尺度的维度之间并不是相互独立的,对于更高分辨率的输入,应该增加网络深度来得到更大的感受野,并且需要更多的通道来提取更细粒的特征模式。因此在缩放时,应该协调和平衡好三个维度之间的关系,而不是只缩放其中一个维度。

本文提出一个复合缩放方法,利用符合系数 \(\phi\) 来统一的缩放深度、宽度、分辨率:

EfficientNet(ICML 2019)原理与代码解析_第1张图片

其中 \(\alpha,\beta,\gamma\) 是常量系数,通过在原始的基础模型上通过网格搜索得到。\(\phi\) 是用户指定的系数,用来控制模型有多少可用的计算资源。本文作者限制 \(\alpha \cdot \beta ^{2} \cdot \gamma ^{2}\approx 2\),从而对于任意的 \(\phi\) 值,模型的FLOPS大约增加 \(2^{\phi}\) 倍。作者通过NAS得到了一个新的baseline模型EfficientNet-B0,结构如下

EfficientNet(ICML 2019)原理与代码解析_第2张图片 

其中的MBConv和MobileNet v3中的InvertedResidualBlock类似,只不过换了激活函数并且加入了SE模块。

通过固定 \(\phi=1\),然后在B0上进行网格搜索得到最优值 \(\alpha=1.2,\beta=1.1,\gamma=1.15\)。然后固定 \(\alpha,\beta,\gamma\),通过式(3)调整 \(\phi\) 值大小,得到EfficientNet-B1~B7。

实验结果

作者首先在MobileNets和ResNets上验证了本文提出的复合缩放方法,结果如下,可以看出,与之前只缩放一个维度相比,本文提出的复合缩放方法在相似的FLOPS下均获得了最高的精度。

EfficientNet(ICML 2019)原理与代码解析_第3张图片

然后作者比较了EfficientNet-B0~B7和其它模型在ImageNet上的精度,结果如下,可以看出,和不同大小的模型相比,在相似的精度下,EfficientNet的FLOPS降低了2.6~8.4倍。

EfficientNet(ICML 2019)原理与代码解析_第4张图片 

代码解析

这里以mmclassification中的实现为例,首先定义了layer_settingsarch_settingslayer_settings是网络层结构的配置,'b'指的是上面的B0~B7,这里默认为基线模型B0,即Tabel 1中的结构。注意,表1中一共9个stage,而这里len(layer_settings)==7是因为将stage56合并为一层,stage78合并为一层。'e'是EdgeTPU的结构,这里不做介绍。arch_settings是缩放系数的配置,分别为width、depth的缩放因子和输入图片大小。这里没有按文中给出B0~B7具体的 \(\phi\) 值,让我们自己根据 \(\alpha,\beta,\gamma\) 计算,而是直接给出了计算好的结果,实际的 \(\phi\) 值也并不是按B0~B7对应为0~7。

# Parameters to build layers.
# 'b' represents the architecture of normal EfficientNet family includes
# 'b0', 'b1', 'b2', 'b3', 'b4', 'b5', 'b6', 'b7', 'b8'.
# 'e' represents the architecture of EfficientNet-EdgeTPU including 'es',
# 'em', 'el'.
# 6 parameters are needed to construct a layer, From left to right:
# - kernel_size: The kernel size of the block
# - out_channel: The number of out_channels of the block
# - se_ratio: The sequeeze ratio of SELayer.
# - stride: The stride of the block
# - expand_ratio: The expand_ratio of the mid_channels
# - block_type: -1: Not a block, 0: InvertedResidual, 1: EdgeResidual
layer_settings = {
    'b': [[[3, 32, 0, 2, 0, -1]],
          [[3, 16, 4, 1, 1, 0]],
          [[3, 24, 4, 2, 6, 0],
           [3, 24, 4, 1, 6, 0]],
          [[5, 40, 4, 2, 6, 0],
           [5, 40, 4, 1, 6, 0]],
          [[3, 80, 4, 2, 6, 0],
           [3, 80, 4, 1, 6, 0],
           [3, 80, 4, 1, 6, 0],
           [5, 112, 4, 1, 6, 0],
           [5, 112, 4, 1, 6, 0],
           [5, 112, 4, 1, 6, 0]],
          [[5, 192, 4, 2, 6, 0],
           [5, 192, 4, 1, 6, 0],
           [5, 192, 4, 1, 6, 0],
           [5, 192, 4, 1, 6, 0],
           [3, 320, 4, 1, 6, 0]],
          [[1, 1280, 0, 1, 0, -1]]
          ],
    'e': [[[3, 32, 0, 2, 0, -1]],
          [[3, 24, 0, 1, 3, 1]],
          [[3, 32, 0, 2, 8, 1],
           [3, 32, 0, 1, 8, 1]],
          [[3, 48, 0, 2, 8, 1],
           [3, 48, 0, 1, 8, 1],
           [3, 48, 0, 1, 8, 1],
           [3, 48, 0, 1, 8, 1]],
          [[5, 96, 0, 2, 8, 0],
           [5, 96, 0, 1, 8, 0],
           [5, 96, 0, 1, 8, 0],
           [5, 96, 0, 1, 8, 0],
           [5, 96, 0, 1, 8, 0],
           [5, 144, 0, 1, 8, 0],
           [5, 144, 0, 1, 8, 0],
           [5, 144, 0, 1, 8, 0],
           [5, 144, 0, 1, 8, 0]],
          [[5, 192, 0, 2, 8, 0],
           [5, 192, 0, 1, 8, 0]],
          [[1, 1280, 0, 1, 0, -1]]
          ]
}  # yapf: disable

# Parameters to build different kinds of architecture.
# From left to right: scaling factor for width, scaling factor for depth,
# resolution.
arch_settings = {
    'b0': (1.0, 1.0, 224),
    'b1': (1.0, 1.1, 240),
    'b2': (1.1, 1.2, 260),
    'b3': (1.2, 1.4, 300),
    'b4': (1.4, 1.8, 380),
    'b5': (1.6, 2.2, 456),
    'b6': (1.8, 2.6, 528),
    'b7': (2.0, 3.1, 600),
    'b8': (2.2, 3.6, 672),
    'es': (1.0, 1.0, 224),
    'em': (1.0, 1.1, 240),
    'el': (1.2, 1.4, 300)
}

函数model_scaling是根据缩放系数去调整对应的维度,实现如下,其中做了一些注释。

def model_scaling(layer_setting, arch_setting):
    """Scaling operation to the layer's parameters according to the
    arch_setting."""
    # scale width
    new_layer_setting = copy.deepcopy(layer_setting)
    for layer_cfg in new_layer_setting:
        for block_cfg in layer_cfg:
            block_cfg[1] = make_divisible(block_cfg[1] * arch_setting[0], 8)

    # scale depth
    split_layer_setting = [new_layer_setting[0]]
    for layer_cfg in new_layer_setting[1:-1]:  # 只scale中间的MBConv
        tmp_index = [0]
        for i in range(len(layer_cfg) - 1):
            if layer_cfg[i + 1][1] != layer_cfg[i][1]:
                tmp_index.append(i + 1)
        tmp_index.append(len(layer_cfg))
        # [0,1],[0,2],[0,2],[0,3,6],[0,4,5]
        for i in range(len(tmp_index) - 1):
            split_layer_setting.append(layer_cfg[tmp_index[i]:tmp_index[i +
                                                                        1]])
    split_layer_setting.append(new_layer_setting[-1])
    # 原始的layer_setting把论文中stage56合并,78合并,这里又还原回去,一共9个stage
    # [[[3, 32, 0, 2, 0, -1]],
    #  [[3, 16, 4, 1, 1, 0]],
    #  [[3, 24, 4, 2, 6, 0],
    #   [3, 24, 4, 1, 6, 0]],
    #  [[5, 40, 4, 2, 6, 0],
    #   [5, 40, 4, 1, 6, 0]],
    #  [[3, 80, 4, 2, 6, 0],
    #   [3, 80, 4, 1, 6, 0],
    #   [3, 80, 4, 1, 6, 0]],
    #  [[5, 112, 4, 1, 6, 0],
    #   [5, 112, 4, 1, 6, 0],
    #   [5, 112, 4, 1, 6, 0]],
    #  [[5, 192, 4, 2, 6, 0],
    #   [5, 192, 4, 1, 6, 0],
    #   [5, 192, 4, 1, 6, 0],
    #   [5, 192, 4, 1, 6, 0]],
    #  [[3, 320, 4, 1, 6, 0]],
    #  [[1, 1280, 0, 1, 0, -1]]]

    num_of_layers = [len(layer_cfg) for layer_cfg in split_layer_setting[1:-1]]  # [1,2,2,3,3,4,1]
    new_layers = [
        int(math.ceil(arch_setting[1] * num)) for num in num_of_layers
    ]  # 层数向上取ceil

    merge_layer_setting = [split_layer_setting[0]]
    for i, layer_cfg in enumerate(split_layer_setting[1:-1]):
        if new_layers[i] <= num_of_layers[i]:  # 因为b1的depth scale系数都等于1.1,后面的更大,并且层数取ceil,所以这里进不来
            tmp_layer_cfg = layer_cfg[:new_layers[i]]
        else:
            tmp_layer_cfg = copy.deepcopy(layer_cfg) + [layer_cfg[-1]] * (
                new_layers[i] - num_of_layers[i])  # 一个stage中除了第一层的stride有可能不一样,所有层的配置都是一样的。这里扩充的层都是stage的最后一层。
        if tmp_layer_cfg[0][3] == 1 and i != 0:  # 这里相当于又把stage56合并,78合并了
            merge_layer_setting[-1] += tmp_layer_cfg.copy()
        else:
            merge_layer_setting.append(tmp_layer_cfg.copy())
    merge_layer_setting.append(split_layer_setting[-1])
    # ## b1, depth scale factor = 1.1
    # [[[3, 32, 0, 2, 0, -1]],
    #  [[3, 16, 4, 1, 1, 0],
    #   [3, 16, 4, 1, 1, 0]],
    #  [[3, 24, 4, 2, 6, 0],
    #   [3, 24, 4, 1, 6, 0],
    #   [3, 24, 4, 1, 6, 0]],
    #  [[5, 40, 4, 2, 6, 0],
    #   [5, 40, 4, 1, 6, 0],
    #   [5, 40, 4, 1, 6, 0]],
    #  [[3, 80, 4, 2, 6, 0],
    #   [3, 80, 4, 1, 6, 0],
    #   [3, 80, 4, 1, 6, 0],
    #   [3, 80, 4, 1, 6, 0],
    #   [5, 112, 4, 1, 6, 0],
    #   [5, 112, 4, 1, 6, 0],
    #   [5, 112, 4, 1, 6, 0],
    #   [5, 112, 4, 1, 6, 0]],
    #  [[5, 192, 4, 2, 6, 0],
    #   [5, 192, 4, 1, 6, 0],
    #   [5, 192, 4, 1, 6, 0],
    #   [5, 192, 4, 1, 6, 0],
    #   [5, 192, 4, 1, 6, 0],
    #   [3, 320, 4, 1, 6, 0],
    #   [3, 320, 4, 1, 6, 0]],
    #  [[1, 1280, 0, 1, 0, -1]]]

    return merge_layer_setting

 最后根据实际的结构去搭建网络就好了,其中MBConv就是MobileNet v3中的InvertedResidualBlock,加上了SE模块,激活函数换成Swish。

你可能感兴趣的:(Classification,深度学习,人工智能,计算机视觉,图像分类,backbone)