EfficientNetV2: Smaller Models and Faster Training

最新推荐文章于 2024-03-31 21:25:44 发布

风吴痕

最新推荐文章于 2024-03-31 21:25:44 发布

阅读量987

点赞数 1

分类专栏： # 论文

论文专栏收录该内容

1 篇文章 1 订阅

订阅专栏

https://arxiv.org/pdf/2104.00298v1.pdf
https://www.paperswithcode.com/paper/efficientnetv2-smaller-models-and-faster
https://github.com/google/automl/efficientnetv2
https://github.com/d-li14/efficientnetv2.pytorch
https://github.com/rwightman/pytorch-image-models

1. Introduction

在这里插入图片描述
NFNets 目的消除昂贵的批归一化，提高训练效率;
ResNet-RS 优化尺度超参数，提高训练效率;
Lambda Networks 和 BotNet 通过卷积网络使用注意层来提高训练速度
Vision Transformers 提高了大规模数据集的训练效率变压器模块
然而，这些方法通常会在参数大小上带来昂贵的开销

Bello, I. Lambdanetworks: Modeling long-range interactions without attention. ICLR, 2021.
Bello, I., Fedus, W., Du, X., Cubuk, E. D., Srinivas, A.,
Lin, T.-Y., Shlens, J., and Zoph, B. Revisiting resnets:
Improved training and scaling strategies. arXiv preprint
arXiv:2103.07579, 2021.
Brock, A., De, S., Smith, S. L., and Simonyan, K. Highperformance large-scale image recognition without normalization. arXiv preprint arXiv:2102.06171, 2021.
Dosovitskiy, A., Beyer, L., Kolesnikov, A., Weissenborn,
D., Zhai, X., Unterthiner, T., Dehghani, M., Minderer,
M., Heigold, G., Gelly, S., Uszkoreit, J., and Houlsby, N.
An image is worth 16x16 words: Transformers for image
recognition at scale. ICLR, 2021.
Wightman, R. Pytorch image model. https://github.
com/rwightman/pytorch-image-models, Accessed on Feb.18, 2021, 2021.

我们的研究表明:(1)在非常大的图像尺寸下，训练是缓慢的;(2)在早期层，depthwise convolutions 速度较慢。(3)每个阶段同等放大是次优的。

基于这些观察，我们设计了一个搜索空间，并添加了诸如 Fused-MBConv，并应用训练感知的NAS和缩放来联合优化模型精度、训练速度和参数大小。

我们的训练可以通过在训练过程中逐步增加图像大小来进一步加速

许多以前的作品，如渐进resize(Howard, 2018)、FixRes (Touvron等人，2019)和Mix&Match (Hoffer等人，2019)，在训练中使用较小的图像尺寸;然而，他们通常对所有图像大小保持相同的正则化，导致精度下降。

Howard, J. Training imagenet in 3 hours for 25 minutes.
https://www.fast.ai/2018/04/30/dawnbench-fastai/, 2018.
Touvron, H., Vedaldi, A., Douze, M., and Jegou, H. Fix- ´
ing the train-test resolution discrepancy. arXiv preprint
arXiv:1906.06423, 2019.
Hoffer, E., Weinstein, B., Hubara, I., Ben-Nun, T., Hoefler,
T., and Soudry, D. Mix & match: training convnets with
mixed image sizes for improved accuracy, speed and scale
resiliency. arXiv preprint arXiv:1908.08986, 2019.

我们认为对于不同大小的图像保持相同的正则化是不理想的:对于相同的网络，小的图像大小导致小的网络容量，因此需要弱的正则化;反之亦然，大图像尺寸需要更强的正则化来对抗过拟合(见4.1节)。基于这一认识，我们提出了一种改进的渐进学习方法:在早期的训练时期，我们用小图像size和弱正则化(如dropout和data augmentation)训练网络，然后我们逐渐增大图像大小，加入更强的正则化。

基于渐进调整resize(Howard, 2018)，但通过动态调整正则化，我们的方法可以在不造成精度下降的情况下加速训练。

我们的贡献有三方面:

我们推出了EfficientNetV2，这是一个更小更快的新系列机型。通过我们的训练感知NAS和扩展发现，EfficientNetV2在训练速度和参数效率方面都优于以前的模型。
我们提出了一种改进的渐进学习方法，它可以随着图像大小自适应地调整正则化。我们表明，它加快了训练，同时提高了准确性。
我们在ImageNet上演示了高达11倍的训练速度和高达6.8倍的参数效率，CIFAR, Cars, Flowers数据集，比现有技术。

2. Related work

训练和参数效率:许多工作，如DenseNet (Huang et al.， 2017)和EfficientNet (Tan . net)& Le, 2019a)，关注参数效率，以更少的参数达到更好的精度。最近的工作旨在提高训练或推理速度，而不是参数效率.例如，RegNet (Radosavovic et al.， 2020)、ResNeSt (Zhang et al.， 2020)、trenet (Ridnik et al.， 2020)和EfficientNet-X (Li et al.， 2021) focus on
GPU和/或TPU推理速度;λ网络(贝罗,2021年)，NFNets (Brock等人，2021年)，BoTNets(Srinivas等人，ResNet-RS (Bello et al.， 2021)关注TPU训练速度。然而，他们的训练速度往往伴随着更多参数的代价。本文旨在显著提高训练和参数效率比现有技术。

渐进训练:先前的著作提出了不同种类的渐进训练，它可以动态改变GANs (Karras et al.， 2018)、迁移学习(Karras et al.， 2018)、对抗学习(Yu et al.， 2019)和语言模型(Press et al.， 2021)的训练设置或网络。渐进式调整(Howard, 2018)主要与我们的方法有关，其目的是提高训练速度。然而，它通常伴随着精度下降的代价。例如，Fastai团队在DAWNBench比赛中使用渐进大小快速训练，但它必须增加最终图像大小与更高的推理成本，以满足精度约束(霍华德，2018)。另一项密切相关的工作是Mix&Match (Hoffer et al.， 2019)，它对每个批次随机采样不同的图像大小。
渐进调整和混合匹配对所有图像大小使用相同的正则化，导致精度下降。在本文中，我们的主要区别在于还可以自适应地调整正则化，从而提高训练的速度和精度。我们的方法也部分地受到了课程学习的启发(Bengio et al.， 2009)，课程学习安排了从容易到难的训练例子。我们的方法也通过增加更多的正规化逐步增加学习难度，但我们没有选择性地选择训练实例。

3.2. Understanding Training Efficiency

Training with very large image sizes is slow:
由于GPU/TPU上的总内存是固定的，我们必须用更小的批处理大小来训练这些模型，这大大降低了训练的速度。一个简单的改进就是应用
FixRes (Touvron et al.， 2019)，通过使用较小的图像大小进行训练，而不是用于推理。如表2所示，图像尺寸越小，计算量越少，批量越大，训练速度提高2.2倍。值得注意的是，正如(Touvron等人，2020;
Brock等人，2021年)，使用较小的图像大小进行训练也会导致准确性下降。但与(Touvron et al.， 2019)不同的是，我们在训练后不会微调任何图层。

在第4节中，我们将探索一种更高级的训练方法，在训练过程中逐步调整图像大小和正规化

Depthwise convolutions are slow in early layers:

EfficientNet的另一个训练瓶颈来自depthwise(Sifre, 2014)。depthwise比常规卷积有更少的参数和FLOPs，但它们往往不能充分利用现代加速器。在1-3阶段早期应用fuse- mbconv可以提高训练速度，在参数和FLOPs上的开销较小，但如果我们将所有块替换为fuse- mbconv(阶段1-7)，则会显著增加参数和FLOPs，同时也会减慢训练速度。找到MBConv和fuse -MBConv这两个构建块的正确组合并非易事，这促使我们利用神经结构搜索来自动搜索最佳组合。

在这里插入图片描述

Equally scaling up every stage is sub-optimal:EfficientNet使用一个简单的复合标度规则，均匀地扩大所有阶段。例如，当深度系数为2时，网络中所有阶段的层数都会增加一倍。此外，EfficientNets逐步地扩大图像大小，导致大内存消耗和缓慢的训练。为了解决这个问题，我们稍微修改了缩放规则，并将最大图像大小限制为一个较小的值。

我们的搜索空间是一个基于阶段的因式分解空间，类似于(Tan et al.， 2019)，包含了卷积运算类型的设计选择{MBConv, Fused-MBConv},层数，核大小{3x3, 5x5}，膨胀比 {1, 4, 6}。

我们将推理图像的最大大小限制为480，因为过大的图像通常会导致昂贵的内存开销和训练速度开销;

4. Progressive Learning

如第3节所述，图像大小对训练效率起着重要的作用。除了FixRes (Touvron et al.， 2019)，许多其他作品在训练期间动态改变图像大小(Howard, 2018;Hoffer等人，2019)，但它们往往会导致准确性下降。

我们假设精度下降的原因是不平衡的正则化:当使用不同大小的图像进行训练时，我们也应该相应地调整正则化的强度(而不是像之前的工作那样使用固定的正则化)。事实上，大型模型通常需要更强的正则化来对抗过拟合:例如，与B0相比，EfficientNet-B7使用了更大的dropout和更强的数据增强。在本文中，我们认为即使对于同一网络，较小的图像大小也会导致较小的网络容量，因此需要较弱的正则化;反之，图像尺寸越大，计算量越大，容量越大，越容易过拟合。当图像尺寸较小时，增强效果较弱，精度最好;但对于较大的图像，增强效果更好。这种洞察力促使我们在训练过程中随图像大小自适应地调整正则化，从而改进了我们的渐进学习方法。

在这里插入图片描述

4.2. Progressive Learning with adaptive Regularization

图4展示了我们改进渐进学习的训练过程:在早期的训练时期，我们用较小的图像和弱正则化来训练网络，使网络能够轻松快速地学习简单的表示。然后，我们逐渐增加图像的大小，但也增加了更强的正则化，使学习更加困难。我们的方法是建立在(Howard, 2018)逐步改变图像大小的基础上，但在这里，我们也自适应调整正则化。

在这里插入图片描述

图4。在我们的培训过程中改进了渐进式学习
它从较小的图像大小和弱正则化(epoch=1)开始，然后随着图像大小和强正则化逐渐增加学习难度:dropout rate较大，RandAugment幅度较大，mixup ratio(如epoch=300)较大。

形式上，假设整个训练共有N步，目标图像大小为 $S_e$ ，正则化幅度为 $_e = {φ ^k_ e}$ ，其中k表示一种正则化类型，如dropout rate or mixup rate value. 我们将训练分为M个阶段:对于每个阶段 $1 \leq i \leq M$ ，使用图像大小 $S_i$ 和正则化幅度 $_i = {φ ^k_i}$ 对模型进行训练。最后阶段M将使用目标图像大小 $S_e$ 和正则化 $φ_e$ 。为简便起见，我们启发式地选取初始图像大小 $S_0$ 和正则化 $φ _0$ ，然后使用线性插值来确定每个阶段的值。

算法1总结了过程。
在每一阶段的开始，网络将继承前一阶段的所有权值。不像变压器的权值(如位置嵌入)可能依赖于输入长度，卷积网络权值与图像大小无关，因此很容易继承。

在这里插入图片描述
我们改进的渐进学习通常与现有的正规化兼容。为简单起见，本文主要研究以下三种正则化方法:

Dropout (Srivastava et al., 2014):一种网络级正则化，通过随机丢弃信道减少协同适应。我们将调整 dropout rate γ。
RandAugment (Cubuk et al., 2020):每幅图像的数据增强可调大小 $\varepsilon$
Mixup (Zhang et al., 2018):

在这里插入图片描述

5.1. ImageNet ILSVRC2012

ImageNet ILSVRC2012 (Russakovsky et al.， 2015)包含约128万张训练图像和50,000张验证图像，包含1000个类。在架构搜索或超参数调优过程中，我们保留了25,000张图像(约为
2%)作为精度评估的最小值。我们还使用minival来执行早期停止。

我们的ImageNet的训练设置很大程度上遵循了EfficientNets (Tan
& Le, 2019a):decay=0.9，momentum=0.9的RMSProp优化器;batch norm momentum 0.99; weight decay 1e-5。每个模型训练350个epoch，总批量4096个。学习速率先从0到0.256，然后每2.4个epoch衰减0.97。
在这里插入图片描述
对于渐进学习，我们将训练过程分为四个阶段，每个阶段大约87个epoch:早期阶段使用小图像大小，弱正则化，而后期阶段使用大图像大小，强正则化，如算法1所述。为简单起见，所有模型都使用相同的最小值大小和正则化，但采用不同的最大值，因为较大的模型通常需要更多的正则化来对抗过拟合。

我们用于训练的最大图像尺寸比推断小约20%，但是我们在训练后没有对任何图层进行微调。

5.2. ImageNet21k

安装:ImageNet21k (Russakovsky等人，2015)包含大约有13M训练图像，21,841个class。最初的ImageNet21k没有train/eval分离，所以我们保留随机选取的100,000张图像作为验证集，并使用剩下的作为训练集。我们在很大程度上重复使用相同的培训设置ImageNet ILSVRC2012与一些改变:(1)我们把训练epochs改为60或30个，以减少训练时间，并利用余弦学习速率的衰减来适应无需额外调整的不同步骤;(2)自每幅图像有多个labels，我们把labels标准化其和为1在计算softmax loss前的1。pretrained后ImageNet21k，每个模型在ILSVRC2012微调15个epochs使用余弦学习速率衰减。

在这里插入图片描述

6.2. Progressive Learning for Different Networks

我们在不同的网络中削弱了渐进学习的性能。表12显示了使用相同的ResNet和EfficientNet模型，我们的渐进训练和基线训练之间的性能比较。
在这里，基线ResNet比原始论文具有更高的准确性(He等人，2016年)，因为它们使用我们改进的训练设置(见第5节)，使用更多的时间和更好的优化器进行训练。我们还将resnet的图像大小从224增加到380，以进一步增加网络容量和准确性。

在这里插入图片描述
如表12所示，我们的渐进学习一般减少了训练时间，同时提高了所有不同网络的准确性。不足为奇的是，当默认的图像大小非常小，如ResNet50(224)与尺寸为224x224，训练加速受限(1.4x加速);但是，当默认图像大小越大，模型越复杂时，我们的方法在精度和训练效率上都获得了较大的增益:对于ResNet152(380)，我们的方法在训练速度上提高了2.1倍，精度略有提高;对于EfficientNet-B4，我们的方法将训练速度提高了2.2倍。

6.3. Importance of Adaptive Regularization

我们的训练方法的一个关键洞察力是自适应正则化，它根据图像大小动态调整正则化。本文选择了一种简单的渐进方法，因为它比较简单，但同时也是一种可以与其他方法相结合的通用方法。

表13研究了我们在两种训练设置上的自适应正则化:一种是将图像大小从小到大逐步增加(Howard, 2018)，另一种是按照中提出的对每批图像随机采样不同大小的图像Mix&Match (Hoffer et al.， 2019)。
在这里插入图片描述

Howard, J. Training imagenet in 3 hours for 25 minutes.
https://www.fast.ai/2018/04/30/dawnbench-fastai/, 2018.

Hoffer, E., Weinstein, B., Hubara, I., Ben-Nun, T., Hoefler,
T., and Soudry, D. Mix & match: training convnets with
mixed image sizes for improved accuracy, speed and scale
resiliency. arXiv preprint arXiv:1908.08986, 2019.

Huang, G., Sun, Y., Liu, Z., Sedra, D., and Weinberger,
K. Q. Deep networks with stochastic depth. ECCV, pp.
646–661, 2016.

Cubuk, E. D., Zoph, B., Shlens, J., and Le, Q. V. Randaugment: Practical automated data augmentation with a
reduced search space. ECCV, 2020.

总结

训练中 Progressive resize + 自适应正则化

RandAugment

https://arxiv.org/pdf/1909.13719.pdf
https://github.com/tensorflow/tpu/blob/master/models/official/efficientnet/autoaugment.py
https://blog.csdn.net/weixin_42990464/article/details/107669200

RandAugment: Practical automated data augmentation
with a reduced search space

在这里插入图片描述

import cv2
import numpy as np
import cv2

## aug functions
def identity_func(img):
    return img


def autocontrast_func(img, cutoff=2):
    '''
        same output as PIL.ImageOps.autocontrast
    '''
    n_bins = 256

    def tune_channel(ch):
        n = ch.size
        cut = cutoff * n // 100
        if cut == 0:
            high, low = ch.max(), ch.min()
        else:
            hist = cv2.calcHist([ch], [0], None, [n_bins], [0, n_bins])
            low = np.argwhere(np.cumsum(hist) > cut)
            low = 0 if low.shape[0] == 0 else low[0]
            high = np.argwhere(np.cumsum(hist[::-1]) > cut)
            high = n_bins - 1 if high.shape[0] == 0 else n_bins - 1 - high[0]
        if high <= low:
            table = np.arange(n_bins)
        else:
            scale = (n_bins - 1) / (high - low)
            offset = -low * scale
            table = np.arange(n_bins) * scale + offset
            table[table < 0] = 0
            table[table > n_bins - 1] = n_bins - 1
        table = table.clip(0, 255).astype(np.uint8)
        return table[ch]

    channels = [tune_channel(ch) for ch in cv2.split(img)]
    out = cv2.merge(channels)
    return out


def equalize_func(img):
    '''
        same output as PIL.ImageOps.equalize
        PIL's implementation is different from cv2.equalize
    '''
    n_bins = 256

    def tune_channel(ch):
        hist = cv2.calcHist([ch], [0], None, [n_bins], [0, n_bins])
        non_zero_hist = hist[hist != 0].reshape(-1)
        step = np.sum(non_zero_hist[:-1]) // (n_bins - 1)
        if step == 0: return ch
        n = np.empty_like(hist)
        n[0] = step // 2
        n[1:] = hist[:-1]
        table = (np.cumsum(n) // step).clip(0, 255).astype(np.uint8)
        return table[ch]

    channels = [tune_channel(ch) for ch in cv2.split(img)]
    out = cv2.merge(channels)
    return out


def rotate_func(img, degree, fill=(0, 0, 0)):
    '''
    like PIL, rotate by degree, not radians
    '''
    H, W = img.shape[0], img.shape[1]
    center = W / 2, H / 2
    M = cv2.getRotationMatrix2D(center, degree, 1)
    out = cv2.warpAffine(img, M, (W, H), borderValue=fill)
    return out


def solarize_func(img, thresh=128):
    '''
        same output as PIL.ImageOps.posterize
    '''
    table = np.array([el if el < thresh else 255 - el for el in range(256)])
    table = table.clip(0, 255).astype(np.uint8)
    out = table[img]
    return out


def color_func(img, factor=5):
    '''
        same output as PIL.ImageEnhance.Color
    '''
    ## implementation according to PIL definition, quite slow
    #  degenerate = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)[:, :, np.newaxis]
    #  out = blend(degenerate, img, factor)
    #  M = (
    #      np.eye(3) * factor
    #      + np.float32([0.114, 0.587, 0.299]).reshape(3, 1) * (1. - factor)
    #  )[np.newaxis, np.newaxis, :]
    M = (
            np.float32([
                [0.886, -0.114, -0.114],
                [-0.587, 0.413, -0.587],
                [-0.299, -0.299, 0.701]]) * factor
            + np.float32([[0.114], [0.587], [0.299]])
    )
    out = np.matmul(img, M).clip(0, 255).astype(np.uint8)
    return out


def contrast_func(img, factor=5):
    """
        same output as PIL.ImageEnhance.Contrast
    """
    mean = np.sum(np.mean(img, axis=(0, 1)) * np.array([0.114, 0.587, 0.299]))
    table = np.array([(
        el - mean) * factor + mean
        for el in range(256)
    ]).clip(0, 255).astype(np.uint8)
    out = table[img]
    return out


def brightness_func(img, factor=2):
    '''
        same output as PIL.ImageEnhance.Contrast
    '''
    table = (np.arange(256, dtype=np.float32) * factor).clip(0, 255).astype(np.uint8)
    out = table[img]
    return out


def sharpness_func(img, factor=2):
    '''
    The differences the this result and PIL are all on the 4 boundaries, the center
    areas are same
    '''
    kernel = np.ones((3, 3), dtype=np.float32)
    kernel[1][1] = 5
    kernel /= 13
    degenerate = cv2.filter2D(img, -1, kernel)
    if factor == 0.0:
        out = degenerate
    elif factor == 1.0:
        out = img
    else:
        out = img.astype(np.float32)
        degenerate = degenerate.astype(np.float32)[1:-1, 1:-1, :]
        out[1:-1, 1:-1, :] = degenerate + factor * (out[1:-1, 1:-1, :] - degenerate)
        out = out.astype(np.uint8)
    return out


def shear_x_func(img, factor, fill=(0, 0, 0)):
    H, W = img.shape[0], img.shape[1]
    M = np.float32([[1, factor, 0], [0, 1, 0]])
    out = cv2.warpAffine(img, M, (W, H), borderValue=fill, flags=cv2.INTER_LINEAR).astype(np.uint8)
    return out


def translate_x_func(img, offset=10, fill=(0, 0, 0)):
    '''
        same output as PIL.Image.transform
    '''
    H, W = img.shape[0], img.shape[1]
    M = np.float32([[1, 0, -offset], [0, 1, 0]])
    out = cv2.warpAffine(img, M, (W, H), borderValue=fill, flags=cv2.INTER_LINEAR).astype(np.uint8)
    return out


def translate_y_func(img, offset, fill=(0, 0, 0)):
    '''
        same output as PIL.Image.transform
    '''
    H, W = img.shape[0], img.shape[1]
    M = np.float32([[1, 0, 0], [0, 1, -offset]])
    out = cv2.warpAffine(img, M, (W, H), borderValue=fill, flags=cv2.INTER_LINEAR).astype(np.uint8)
    return out


def posterize_func(img, bits):
    '''
        same output as PIL.ImageOps.posterize
    '''
    out = np.bitwise_and(img, np.uint8(255 << (8 - bits)))
    return out


def shear_y_func(img, factor, fill=(0, 0, 0)):
    H, W = img.shape[0], img.shape[1]
    M = np.float32([[1, 0, 0], [factor, 1, 0]])
    out = cv2.warpAffine(img, M, (W, H), borderValue=fill, flags=cv2.INTER_LINEAR).astype(np.uint8)
    return out


def cutout_func(img, pad_size, replace=(0, 0, 0)):
    replace = np.array(replace, dtype=np.uint8)
    H, W = img.shape[0], img.shape[1]
    rh, rw = np.random.random(2)
    pad_size = pad_size // 2
    ch, cw = int(rh * H), int(rw * W)
    x1, x2 = max(ch - pad_size, 0), min(ch + pad_size, H)
    y1, y2 = max(cw - pad_size, 0), min(cw + pad_size, W)
    out = img.copy()
    out[x1:x2, y1:y2, :] = replace
    return out


### level to args
def enhance_level_to_args(MAX_LEVEL):
    def level_to_args(level):
        return ((level / MAX_LEVEL) * 1.8 + 0.1,)
    return level_to_args


def shear_level_to_args(MAX_LEVEL, replace_value):
    def level_to_args(level):
        level = (level / MAX_LEVEL) * 0.3
        if np.random.random() > 0.5: level = -level
        return (level, replace_value)

    return level_to_args


def translate_level_to_args(translate_const, MAX_LEVEL, replace_value):
    def level_to_args(level):
        level = (level / MAX_LEVEL) * float(translate_const)
        if np.random.random() > 0.5: level = -level
        return (level, replace_value)

    return level_to_args


def cutout_level_to_args(cutout_const, MAX_LEVEL, replace_value):
    def level_to_args(level):
        level = int((level / MAX_LEVEL) * cutout_const)
        return (level, replace_value)

    return level_to_args


def solarize_level_to_args(MAX_LEVEL):
    def level_to_args(level):
        level = int((level / MAX_LEVEL) * 256)
        return (level, )
    return level_to_args


def none_level_to_args(level):
    return ()


def posterize_level_to_args(MAX_LEVEL):
    def level_to_args(level):
        level = int((level / MAX_LEVEL) * 4)
        return (level, )
    return level_to_args


def rotate_level_to_args(MAX_LEVEL, replace_value):
    def level_to_args(level):
        level = (level / MAX_LEVEL) * 30
        if np.random.random() < 0.5:
            level = -level
        return (level, replace_value)

    return level_to_args


func_dict = {
    'Identity': identity_func,
    'AutoContrast': autocontrast_func,
    'Equalize': equalize_func,
    # 'Rotate': rotate_func,
    'Solarize': solarize_func,
    'Color': color_func,
    'Contrast': contrast_func,
    'Brightness': brightness_func,
    'Sharpness': sharpness_func,
    # 'ShearX': shear_x_func,
    # 'TranslateX': translate_x_func,
    # 'TranslateY': translate_y_func,
    'Posterize': posterize_func,
    # 'ShearY': shear_y_func,
}

translate_const = 10
MAX_LEVEL = 10
replace_value = (128, 128, 128)
arg_dict = {
    'Identity': none_level_to_args,
    'AutoContrast': none_level_to_args,
    'Equalize': none_level_to_args,
    # 'Rotate': rotate_level_to_args(MAX_LEVEL, replace_value),
    'Solarize': solarize_level_to_args(MAX_LEVEL),
    'Color': enhance_level_to_args(MAX_LEVEL),
    'Contrast': enhance_level_to_args(MAX_LEVEL),
    'Brightness': enhance_level_to_args(MAX_LEVEL),
    'Sharpness': enhance_level_to_args(MAX_LEVEL),
    # 'ShearX': shear_level_to_args(MAX_LEVEL, replace_value),
    # 'TranslateX': translate_level_to_args(
    #     translate_const, MAX_LEVEL, replace_value
    # ),
    # 'TranslateY': translate_level_to_args(
    #     translate_const, MAX_LEVEL, replace_value
    # ),
    'Posterize': posterize_level_to_args(MAX_LEVEL),
    # 'ShearY': shear_level_to_args(MAX_LEVEL, replace_value),
}


class RandomAugment(object):

    def __init__(self, N=2, M=10):
        self.N = N
        self.M = M

    def get_random_ops(self):
        sampled_ops = np.random.choice(list(func_dict.keys()), self.N)
        return [(op, 1., self.M) for op in sampled_ops]

    def __call__(self, img):
        ops = self.get_random_ops()
        for name, prob, level in ops:
            if np.random.random() > prob:
                continue
            args = arg_dict[name](level)
            img = func_dict[name](img, *args)
        # img = cutout_func(img, 16, replace_value)
        return img


if __name__ == '__main__':
    import matplotlib.pyplot as plt
    a = RandomAugment()
    # img = np.random.randn(32, 32, 3)
    # a(img)
    imgPath = 'Subset1_img__3.png'
    img = cv2.imread(imgPath)
    img2 = a(img)
    plt.subplot(121)
    plt.imshow(img)
    plt.subplot(122)
    plt.imshow(img2)
    plt.show()

Progressive resize

https://www.fast.ai/2018/04/30/dawnbench-fastai/

在开始训练时，先在较小的图像上训练，然后随着训练的深入，逐渐增加图像的大小。从直觉上来说，你不需要大图来了解猫和狗的大致样子(例如)，但后来当你试图了解每种狗的区别时，你通常需要大图。

通过使用渐进的大小调整，我们既能够使初始的时代比通常的更快(使用128 × 128的图像而不是通常的224x224)，但也使最终的时代更精确(使用288x288的图像甚至更高的精度)。但业绩只是成功的一半原因;另一个影响是较好的泛化性能。通过向网络显示更多不同大小的图像，它有助于避免过度拟合。

Random resize

https://arxiv.org/pdf/1908.08986.pdf
https://github.com/eladhoffer/convNet.pytorch

在这项工作中，我们描述和评估了一种新颖的混合尺寸训练机制，在训练时混合了几种图像尺寸。我们证明，使用我们的方法训练的模型对图像大小变化更有弹性，即使在小图像上也能很好地泛化。

在这项工作中，我们将引入一种新颖的训练机制，“MixSize”，用于使用随机图像和批大小的卷积网络。混合大小体系的主要贡献是:

降低图像大小灵敏度。我们证明了混合大小的训练机制可以提高模型在评估中广泛使用的大小的性能。
更快的推理。由于我们的混合尺寸模型可以在更小的图像尺寸下进行评估，我们发现要达到与基线模型相同的精度，推理所需的计算量减少了2倍。
更快的训练vs.更高的准确性。我们表明，在训练时减少平均图像大小导致训练模型所需的时间和最终精度之间的权衡。

MIXSIZE: TRAINING WITH MULTIPLE IMAGE SCALES

我们建议“MixSize”，一种随机训练机制，其中输入大小可以在每个优化步骤中变化(即：每个batch).在这种情况下，我们修改空间维度H,W 和 batch_size

CIFAR10/100 28x28
在这里插入图片描述
这个制度被设计成以28的平均值为中心。

对于ImageNet数据集，我们使用以下随机机制，这是通过几个备选方案的交叉验证发现的(见附录D):

在这里插入图片描述

风吴痕

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
EfficientNetV2: Smaller Models and Faster Training

https://arxiv.org/pdf/2104.00298v1.pdfhttps://www.paperswithcode.com/paper/efficientnetv2-smaller-models-and-fasterhttps://github.com/google/automl/efficientnetv2https://github.com/d-li14/efficientnetv2.pytorchhttps://github.com/rwightman/pytorch-imag.
复制链接

扫一扫