图像分类任务中，数据增广是一种非常有用的正则化方法，可以有效的提升图像分类的效果，尤其对于数据不足或者模型网络较大的场景。图像增广的方法可以分为3类，$\color{orange}{图像变换类}$， $\color{orange}{图像剪切类}$，$\color{orange}{图像混叠类}$。图像变换类是指对全图进行一些变换，图像裁剪类是指对图像以一定的方式遮挡部分区域的变换，图像混叠类是指对多张图进行混叠为一张新图的变换。

1、图像变换类

AutoAugment

RandomAugment

2、图像裁剪类

CutOut

$\color{orange}{Cutout}$在训练的时候随机把图片的一部分剪掉，这样能够提高模型的鲁棒性。CutOut可以理解为Dropout的一种扩展的操作，不同的是Dropout是对图像经过网络后生成的特征进行遮挡，而Cutout是直接对输入的图像进行遮挡，相当于Dropout对噪声的鲁棒性更好。作者在论文中进行了详细的说明，这样做有一下的两点优势：(1)通过Cutout可以模拟真实场景中主题被部分遮挡时的场景；(2)可以促进模型充分利用图像中更多的内容(context)来进行分类，防止网络只关注显著性的图像区域，从而发生过拟合。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
class Cutout(object):
    """Randomly mask out one or more patches from an image.
    Args:
        n_holes (int): Number of patches to cut out of each image.
        length (int): The length (in pixels) of each square patch.
    """
    def __init__(self, n_holes, length):
        self.n_holes = n_holes
        self.length = length

    def __call__(self, img):
        """
        Args:
            img (Tensor): Tensor image of size (C, H, W).
        Returns:
            Tensor: Image with n_holes of dimension length x length cut out of it.
        """
        (w, h) = img.size
        mask = np.ones((h, w, 3), dtype=np.int)

        for n in range(self.n_holes):
            y = np.random.randint(h)
            x = np.random.randint(w)

            y1 = np.clip(y - self.length // 2, 0, h)
            y2 = np.clip(y + self.length // 2, 0, h)
            x1 = np.clip(x - self.length // 2, 0, w)
            x2 = np.clip(x + self.length // 2, 0, w)

            mask[y1: y2, x1: x2, :] = 0
        img = img * mask
        return img

Random Erasing

$\color{orange}{Random erasing}$其实和cutout非常相似，也是一种模拟物体遮挡的数据增强方法，同样是为了解决训练出的模型在有遮挡的数据集上泛化能力比较差的问题。区别在于，cutout是把图片中随机选中的矩形区域的像素值置为0，相当于裁剪掉，Random erasing是用随机数或者数据集中像素的平均值来替换原来的像素值，而且，cutout每次裁剪的区域大小是固定的，Random erasing替换掉的区域大小是随机的，而且在Random erasing中，图片是以一定的概率接受该预处理的方法，生成掩码的尺寸大小与长宽比也是根据预设的超参数来随机生成的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
class RandomErasing(object):
    def __init__(self, EPSILON=0.5, sl=0.02, sh=0.4, r1=0.3, mean=[0.4914, 0.4822, 0.4465]):
        self.EPSILON = EPSILON
        self.mean = mean
        self.sl = sl
        self.sh = sh
        self.r1 = r1

    def __call__(self, img):
        # (c, h, w)
        if random.uniform(0, 1) > self.EPSILON:
            return img

        for attempt in range(100):
            area = img.shape[1] * img.shape[2]
            target_area = random.uniform(self.sl, self.sh) * area
            aspect_ratio = random.uniform(self.r1, 1/self.r1)

            h = int(round(math.sqrt(target_area * aspect_ratio)))
            w = int(round(math.sqrt(target_area / aspect_ratio)))

            if w < img.shape[2] and h < img.shape[1]:
                x1 = random.randint(0, img.shape[1] - h)
                y1 = random.randint(0, img.shape[2] - w)
                if img.shape[0] == 3:
                    img[0, x1:x1+h, y1:y1+w] = self.mean[0]
                    img[1, x1:x1+h, y1:y1+w] = self.mean[1]
                    img[2, x1:x1+h, y1:y1+w] = self.mean[2]
                else:
                    img[0, x1:x1+h, y1:y1+w] = self.mean[1]
                return img
        return img

GridMask

3、图像混叠类

MixUp

$\color{orange}{Mixup}$是最先提出的图像混叠的增广方案，其原理简单，方便实现，不仅在图像分类上，在目标检测上也可以取得不错的效果。为了便于实现，通常只对一个batch内的数据进行混叠，在CutMix中也是如此。MixUp在一个batch中的实现代码如下。下面的代码实现中有可能存在相同的两张照片混叠。MixUp的定义如下。

$$\hat{x}=\lambda{x_{i}}+(1-\lambda)x_{j}$$
$$\hat{y}=\lambda{y_{i}}+(1-\lambda)y_{j}$$

其中$\lambda\in[0, 1]$是从$Beta(\alpha, \alpha)$中选择的随机数。我们使用MixUp后的数据进行训练$(\hat{x}, \hat{y})$。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
def mixup_data(x, y, alpha=1.0, use_cuda=True):

    '''Returns mixed inputs, pairs of targets, and lambda'''

    if alpha > 0:
        lam = np.random.beta(alpha, alpha)
    else:
        lam = 1
    batch_size = x.size()[0]
    if use_cuda:
        index = torch.randperm(batch_size).cuda()
    else:
        index = torch.randperm(batch_size)

    mixed_x = lam * x + (1 - lam) * x[index, :]
    y_a, y_b = y, y[index]
    return mixed_x, y_a, y_b, lam

def mixup_criterion(criterion, pred, y_a, y_b, lam):
    return lam * criterion(pred, y_a) + (1 - lam) * criterion(pred, y_b)

在训练中MixUp的调用。

1
2
3
4
5
6
for i, (input, target) in enumerate(train_loader):
    input = input.cuda()
    target = target.cuda()
    mixed_x, y_a, y_b, lam = mixup_data(input, target)
    output = model(mixed_x)
    loss = mixup_criterion(criterion, output, y_a, y_b, lam)

CutMix

AugMix

[1] https://zhuanlan.zhihu.com/p/142940546
[2] https://paddleclas.readthedocs.io/zh_CN/latest/advanced_tutorials/image_augmentation/ImageAugment.html
[3] https://mp.weixin.qq.com/s?__biz=MzI4MjA0NDgxNA==&mid=2650722499&idx=1&sn=b489bb77ba12be14df197fdc77893b22&chksm=f3958022c4e20934aee7516645a415a379275423b1805da63e7419766ad38460e1f8cd18fc6d&mpshare=1&scene=23&srcid=0303HrF8UEJNThmdJNHWNSqd#rd
[4] https://github.com/tengshaofeng/ResidualAttentionNetwork-pytorch/blob/master/Residual-Attention-Network/train_mixup.py