python代码可以自己扩充图像数据集。

​ 无论我们喜欢Keras还是Pytorch，我们都可以使用丰富的资料库来有效地增广我们的图像。 但是如果遇到特殊情况：

• 我们的数据集结构复杂（例如3个输入图像和1-2个分段输出）。
• 我们需要完全的自由和透明度。
• 我们希望进行这些库未提供的扩充方法。

​ 对于这些情况以及其他特殊情况，我们必须能够掌握我们自己的图像增广函数。 而且，我每次都使用自己的函数。 因此，在本文中，我将介绍并提供执行图像增广的功能。

​ 我将使用朋友的照片来提醒我在加拿大度过的美好时光作为示例。 希望您喜欢这张照片，因为这是您在本文中看到的唯一一张照片。

​ 我将增广过程细分为一个实际的案例，将我们的函数与图像和目标图像一起使用。 这将使您对将要描述的方法的灵活性有所了解：

• 翻转
• 裁剪
• 过滤和锐化
• 模糊
• 旋转，平移，剪切，缩放
• 剪下
• 色彩
• 亮度
• 对比
• 均匀和高斯噪声
• 渐变
• 镜头变形

​ 本文的目的不是为了证明增广技术是如何设计的，而是理解它们的用法。

一些有用的函数

​ 在开始之前，我想解释每种方法具有的通用结构。 它实际上是一个要初始化的对象。 该对象将以我们的样本作为参数调用，并将返回我们的扩充样本。 这就是全部？ 是的，仅此而已！ 然后，让我们从增广功能之前的一些有用函数开始。

Resize

​ 第一个有用的函数允许我们使用（宽度，高度）形状调整图像大小。 这个类使我们看到了所有其他的初始化方式。 我们实例化一个对象，该对象的大小被参数化。 在我们的例子中，所有样本（图像和目标）将以相同的尺寸返回。 使用此类型的功能，我们可以轻松地以所需方式处理图像和目标。

class Resize(object):
    def __init__(self, output_size):
        self.output_size = output_size

    def __call__(self, X, Y):
        _X = cv2.resize(X, self.output_size)
        w, h = self.output_size
        c = Y.shape[-1]
        _Y = np.zeros((h, w, c))
        for i in range(Y.shape[-1]):
            _Y[..., i] = cv2.resize(Y[..., i], self.output_size)
        return _X, _Y

Clip

​ 剪辑函数是一项非常有用的函数，尤其是当您需要从一种颜色空间切换到另一种颜色空间或在0和1或0和255之间重置图像时。

​ 默认情况下，如果仅指定一个阈值，则最小阈值为0。

class Clip(object):
    def __init__(self, mini, maxi=None):
        if maxi is None:
            self.mini, self.maxi = 0, mini
        else:
            self.mini, self.maxi = mini, maxi

    def __call__(self, X, Y):
        mini_mask = np.where(X < self.mini)
        maxi_mask = np.where(X > self.maxi)
        X[mini_mask] = self.mini
        X[maxi_mask] = self.maxi
        return X, Y

Normalize or Standardize

​ 在传递模型中的输入之前，我们通常希望对数据进行标准化或规范化。 当然，这些操作可以在特定的轴上完成。

​ 默认情况下，对整个图像执行标准化和规范化。

class Normalize(object):
    def __init__(self, axis=None):
        self.axis = axis

    def __call__(self, X, Y):
        mini = np.min(X, self.axis)
        maxi = np.max(X, self.axis)
        X = (X - mini) / (maxi - mini)
        return X, Y

class Standardize(object):
    def __init__(self, axis=None):
        self.axis = axis

    def __call__(self, X, Y):
        mean =  np.mean(X, self.axis)
        std = np.std(X, self.axis)
        X = (X - mean) / std
        return X, Y

ToTensor

​ 最后，如果您使用的是Pytorch，则需要将图像转换为Torch.Tensor。 唯一需要注意的是，使用Pytorch，我们的图像维度中首先是通道，而不是最后是通道。 最后，我们还可以选择张量的输出类型。

class ToTensor(object):
    def __init__(self, X_type=None, Y_type=None):
        # must bu torch types
        self.X_type = X_type
        self.Y_type = Y_type

    def __call__(self, X, Y):

        # swap color axis because
        # numpy img_shape: H x W x C
        # torch img_shape: C X H X W
        X = X.transpose((2, 0, 1))
        Y = Y.transpose((2, 0, 1))

        # convert to tensor
        X = torch.from_numpy(X)
        Y = torch.from_numpy(Y)

        if self.X_type is not None:
            X = X.type(self.X_type)
        if self.Y_type is not None:
            Y = Y.type(self.Y_type)
        return X, Y

怎么使用？

​ 我们要做的就是定义我们要在样本中进行的转换的列表，仅此而已。 之后我们什么也别碰。 请注意，转换顺序很重要。 而且由你决定。

X, Y = get_next_sample()

    for t in transform: # data augmentation
        X, Y = t(X, Y)

    pred = model.predict(X, Y)

​ 现在，我们可以深入研究本文的目的，并查看图像增广技术。

旋转

​ 第一个，也是最简单的一个，包括在图像的水平和垂直轴上随机执行翻转。 换句话说，执行垂直翻转的机会为50/100，执行水平翻转的机会为50/100。

class Flip(object):
    def __call__(self, X, Y):
        for axis in [0, 1]:
            if np.random.rand(1) < 0.5:
                X = np.flip(X, axis)
                Y = np.flip(Y, axis)
        return X, Y

裁剪

​ 要进行图像增广，通常会随机裁剪图像。 换句话说，我们在随机区域上裁剪了一部分随机大小的图像。

​ 可以从尺寸的比例（高度，宽度）中选择裁剪图像的尺寸。 如果未指定裁剪的比例最大大小，则默认情况下，我们将认为它是图像的大小。

class Crop(object):
    def __init__(self, min_size_ratio, max_size_ratio=(1, 1)):
        self.min_size_ratio = np.array(list(min_size_ratio))
        self.max_size_ratio = np.array(list(max_size_ratio))

    def __call__(self, X, Y):
        size = np.array(X.shape[:2])
        mini = self.min_size_ratio * size
        maxi = self.max_size_ratio * size
        # random size
        h = np.random.randint(mini[0], maxi[0])
        w = np.random.randint(mini[1], maxi[1])
        # random place
        shift_h = np.random.randint(0, size[0] - h)
        shift_w = np.random.randint(0, size[1] - w)
        X = X[shift_h:shift_h+h, shift_w:shift_w+w]
        Y = Y[shift_h:shift_h+h, shift_w:shift_w+w]

        return X, Y

过滤器

一般情况

​ 我们将开始一些有趣的事情。 过滤器是很棒的方法，但我认为能够轻松创建我们自己的卷积过滤器非常重要。

​ 所以我想做一个通用的函数，以便能够使用我们自己的过滤器。

class CustomFilter(object):
    def __init__(self, kernel):
        self.kernel = kernel

    def __call__(self, X, Y):
        X = cv2.filter2D(X, -1, self.kernel)
        return X, Y

锐化

​ 就过滤器而言，可以通过选择上游过滤器并以随机权重应用过滤器来进行进一步处理。 例如，我向您介绍用于锐化图像的过滤器。

中心值从0到65。

class Sharpen(object):
    def __init__(self, max_center=4):
        self.identity = np.array([[0, 0, 0],
                                  [0, 1, 0],
                                  [0, 0, 0]])
        self.sharpen = np.array([[ 0, -1,  0],
                                [-1,  4, -1],
                                [ 0, -1,  0]]) / 4

    def __call__(self, X, Y):

        sharp = self.sharpen * np.random.random() * self.max_center
        kernel = self.identity + sharp

        X = cv2.filter2D(X, -1, kernel)
        return X, Y

模糊

​ 可以用最流行的滤镜来随机模糊我们的图像。 有很多方法可以模糊我们的图像。 最著名的是平均值，中值，高斯或双边滤波器。

平均模糊

内核大小从1到35

​ 关于平均滤波器。 顾名思义，它使我们可以对给定中心的值取平均值。 这是由内核完成的。 可以指定其大小以增加或减少模糊。 要使用平均滤波器增广图像，我们只需要使用随机大小的内核对输入图像进行滤波。

class GaussianBlur(object):
    def __init__(self, max_kernel=(7, 7)):
        self.max_kernel = ((max_kernel + 1) // 2)

    def __call__(self, X, Y):
        kernel_size = (
            np.random.randint(1, self.max_kernel[0]) * 2 + 1,
            np.random.randint(1, self.max_kernel[1]) * 2 + 1,
        )
        X = cv2.GaussianBlur(X, kernel_size, 0)
        return X, Y

高斯模糊

内核大小从1到35

​ 高斯模糊不使用平均滤波器，而是使用高斯滤波器，因此这些值对应于从中心开始的高斯曲线。 请注意，内核维数只能包含奇数。

class GaussianBlur(object):
    def __init__(self, max_kernel=(7, 7)):
        self.max_kernel = max_kernel

    def __call__(self, X, Y):
        kernel_size = (
            np.random.randint(1, self.max_kernel[0] + 1),
            np.random.randint(1, self.max_kernel[1] + 1),
        )
        X = cv2.GaussianBlur(X, kernel_size, 0)
        return X, Y

透视变换

​ 迄今为止，最广泛使用的图像增广技术是透视变换。 有旋转，平移，剪切和缩放。 这些转换可以在3D维度中执行。 通常，它们仅在2D中使用。 让我们利用我们拥有的一切。

翻转

平移

剪切

缩放

结合

​ 我不会在2D图像的3D转换上花费更多的时间，因为我写了有关这方面的整篇文章。 因此，我选择了本文结尾处提供的函数。

​ 应该注意的是，该函数允许我们根据所提出的4个矩阵随机执行变换。 顺序很重要。 这里我们有剪切，然后是旋转，然后是比例缩放，最后是平移。 注意，平移是通过图像尺寸的比例完成的。

结合随机旋转平移剪切和比例缩放

class Perspective(object):
    def __init__(self,
                 max_ratio_translation=(0.2, 0.2, 0),
                 max_rotation=(10, 10, 360),
                 max_scale=(0.1, 0.1, 0.2),
                 max_shearing=(15, 15, 5)):

        self.max_ratio_translation = np.array(max_ratio_translation)
        self.max_rotation = np.array(max_rotation)
        self.max_scale = np.array(max_scale)
        self.max_shearing = np.array(max_shearing)

    def __call__(self, X, Y):

        # get the height and the width of the image
        h, w = X.shape[:2]
        max_translation = self.max_ratio_translation * np.array([w, h, 1])
        # get the values on each axis
        t_x, t_y, t_z = np.random.uniform(-1, 1, 3) * max_translation
        r_x, r_y, r_z = np.random.uniform(-1, 1, 3) * self.max_rotation
        sc_x, sc_y, sc_z = np.random.uniform(-1, 1, 3) * self.max_scale + 1
        sh_x, sh_y, sh_z = np.random.uniform(-1, 1, 3) * self.max_shearing

        # convert degree angles to rad
        theta_rx = np.deg2rad(r_x)
        theta_ry = np.deg2rad(r_y)
        theta_rz = np.deg2rad(r_z)
        theta_shx = np.deg2rad(sh_x)
        theta_shy = np.deg2rad(sh_y)
        theta_shz = np.deg2rad(sh_z)


        # compute its diagonal
        diag = (h ** 2 + w ** 2) ** 0.5
        # compute the focal length
        f = diag
        if np.sin(theta_rz) != 0:
            f /= 2 * np.sin(theta_rz)

        # set the image from cartesian to projective dimension
        H_M = np.array([[1, 0, -w / 2],
                        [0, 1, -h / 2],
                        [0, 0,      1],
                        [0, 0,      1]])
        # set the image projective to carrtesian dimension
        Hp_M = np.array([[f, 0, w / 2, 0],
                         [0, f, h / 2, 0],
                         [0, 0,     1, 0]])

        # adjust the translation on z
        t_z = (f - t_z) / sc_z ** 2
        # translation matrix to translate the image
        T_M = np.array([[1, 0, 0, t_x],
                        [0, 1, 0, t_y],
                        [0, 0, 1, t_z],
                        [0, 0, 0,  1]])

        # calculate cos and sin of angles
        sin_rx, cos_rx = np.sin(theta_rx), np.cos(theta_rx)
        sin_ry, cos_ry = np.sin(theta_ry), np.cos(theta_ry)
        sin_rz, cos_rz = np.sin(theta_rz), np.cos(theta_rz)
        # get the rotation matrix on x axis
        R_Mx = np.array([[1,      0,       0, 0],
                         [0, cos_rx, -sin_rx, 0],
                         [0, sin_rx,  cos_rx, 0],
                         [0,      0,       0, 1]])
        # get the rotation matrix on y axis
        R_My = np.array([[cos_ry, 0, -sin_ry, 0],
                         [     0, 1,       0, 0],
                         [sin_ry, 0,  cos_ry, 0],
                         [     0, 0,       0, 1]])
        # get the rotation matrix on z axis
        R_Mz = np.array([[cos_rz, -sin_rz, 0, 0],
                         [sin_rz,  cos_rz, 0, 0],
                         [     0,       0, 1, 0],
                         [     0,       0, 0, 1]])
        # compute the full rotation matrix
        R_M = np.dot(np.dot(R_Mx, R_My), R_Mz)

        # get the scaling matrix
        Sc_M = np.array([[sc_x,     0,    0, 0],
                         [   0,  sc_y,    0, 0],
                         [   0,     0, sc_z, 0],
                         [   0,     0,    0, 1]])

        # get the tan of angles
        tan_shx = np.tan(theta_shx)
        tan_shy = np.tan(theta_shy)
        tan_shz = np.tan(theta_shz)
        # get the shearing matrix on x axis
        Sh_Mx = np.array([[      1, 0, 0, 0],
                          [tan_shy, 1, 0, 0],
                          [tan_shz, 0, 1, 0],
                          [      0, 0, 0, 1]])
        # get the shearing matrix on y axis
        Sh_My = np.array([[1, tan_shx, 0, 0],
                          [0,       1, 0, 0],
                          [0, tan_shz, 1, 0],
                          [0,       0, 0, 1]])
        # get the shearing matrix on z axis
        Sh_Mz = np.array([[1, 0, tan_shx, 0],
                          [0, 1, tan_shy, 0],
                          [0, 0,       1, 0],
                          [0, 0,       0, 1]])
        # compute the full shearing matrix
        Sh_M = np.dot(np.dot(Sh_Mx, Sh_My), Sh_Mz)

        Identity = np.array([[1, 0, 0, 0],
                             [0, 1, 0, 0],
                             [0, 0, 1, 0],
                             [0, 0, 0, 1]])

        # compute the full transform matrix
        M = Identity
        M = np.dot(Sh_M, M)
        M = np.dot(R_M,  M)
        M = np.dot(Sc_M, M)
        M = np.dot(T_M,  M)
        M = np.dot(Hp_M, np.dot(M, H_M))
        # apply the transformation
        X = cv2.warpPerspective(X, M, (w, h))
        Y = cv2.warpPerspective(Y, M, (w, h))
        return X, Y

剪下

在整个输入上用0替换进行抠图并同时裁剪目标

​ 抠图非常直观。 它涉及随机删除输入图像的区域。 它的工作方式与我们之前提到的裁剪相同。 但是，我们不删除相关区域。 因此，我们可以再次允许用户提供每个比例的要删除区域的最小和最大大小，最大区域数，以同时或不同时从目标剪切区域，我们可以剪切每个通道，还选择已删除区域的默认替换值。

输入剪切通道替换为1，不裁剪目标

class Cutout(object):
    def __init__(self,
                 min_size_ratio,
                 max_size_ratio,
                 channel_wise=False,
                 crop_target=True,
                 max_crop=10,
                 replacement=0):
        self.min_size_ratio = np.array(list(min_size_ratio))
        self.max_size_ratio = np.array(list(max_size_ratio))
        self.channel_wise = channel_wise
        self.crop_target = crop_target
        self.max_crop = max_crop
        self.replacement = replacement

    def __call__(self, X, Y):
        size = np.array(X.shape[:2])
        mini = self.min_size_ratio * size
        maxi = self.max_size_ratio * size
        for _ in range(self.max_crop):
            # random size
            h = np.random.randint(mini[0], maxi[0])
            w = np.random.randint(mini[1], maxi[1])
            # random place
            shift_h = np.random.randint(0, size[0] - h)
            shift_w = np.random.randint(0, size[1] - w)
            if self.channel_wise:
                c = np.random.randint(0, X.shape[-1])
                X[shift_h:shift_h+h, shift_w:shift_w+w, c] = self.replacement
                if self.crop_target:
                    Y[shift_h:shift_h+h, shift_w:shift_w+w] = self.replacement
            else:
                X[shift_h:shift_h+h, shift_w:shift_w+w] = self.replacement
                if self.crop_target:
                    Y[shift_h:shift_h+h, shift_w:shift_w+w] = self.replacement
        return X, Y

色彩空间

​ 现在，我们进入最有趣的部分。 也是很少考虑的部分。 如果我们知道色彩空间，则可以利用它们的属性来增广图像。 举一个简单的例子，借助HSV颜色空间，我们可以很容易地提取树叶的颜色，并根据我们的意愿随机更改其颜色。 那是一件很酷的事情！ 并且我们可以了解自己的图像增广功能的原理。 当然，这需要更多的创造力。 因此，重要的是要了解我们的色彩空间，以充分利用它们。 特别是因为它们对于我们（深度）机器学习模型的预处理至关重要。

class Leaf(object):
    def __init__(self):
        pass
    def __call__(self, X, Y):
        blur = cv2.GaussianBlur(X, (7, 7), 0)
        hsv_blur = cv2.cvtColor(blur, cv2.COLOR_BGR2HSV)
        # lower mask (0-10)
        lower_red = np.array([0,130,130])
        upper_red = np.array([20,255,255])
        mask_0 = cv2.inRange(hsv_blur, lower_red, upper_red)

        # upper mask (170-180)
        lower_red = np.array([165,130,130])
        upper_red = np.array([185,255,255])
        mask_1 = cv2.inRange(hsv_blur, lower_red, upper_red)
        hsv_blur[np.where(mask_1)] = hsv_blur[np.where(mask_1)] - np.array([165, 0, 0])

        mask = mask_0 + mask_1
        # change color
        turn_color = np.random.randint(0, 255)
        hsv_blur[np.where(mask)] = hsv_blur[np.where(mask)] + np.array([turn_color, 0, 0])
        X_blur = cv2.cvtColor(hsv_blur, cv2.COLOR_HSV2BGR)
        X[np.where(mask)] = X_blur[np.where(mask)]
        return X, Y

亮度

亮度从-100到100

​ 图像增广的一个伟大经典就是能够改变亮度。 有几种方法可以做到这一点，最简单的就是简单地添加一个随机偏差。

class Brightness(object):
    def __init__(self, range_brightness=(-50, 50)):
        self.range_brightness = range_brightness

    def __call__(self, X, Y):
        brightness = np.random.randint(*self.range_brightness)
        X = X + brightness
        return X, Y

对比度

对比度从-100到100

​ 同样，使用对比非常简单。 这也可以通过随机数完成。

class Contrast(object):
    def __init__(self, range_contrast=(-50, 50)):
        self.range_contrast = range_contrast

    def __call__(self, X, Y):
        contrast = np.random.randint(*self.range_contrast)
        X = X * (contrast / 127 + 1) - contrast
        return X, Y

噪声注入

​ 最后一种相当常见的图像增广技术是噪声注入。 实际上，我们只添加与输入大小相同的矩阵。 该矩阵由遵循随机分布的元素组成。 可以从任何随机分布中进行噪声注入。 实际上，我们只看到其中两个。 但是随时可以进一步

一般方法

class UniformNoise(object):
    def __init__(self, low=-50, high=50):
        self.low = low
        self.high = high

    def __call__(self, X, Y):
        noise = np.random.uniform(self.low, self.high, X.shape)
        X = X + noise
        return X, Y

高斯方法

class GaussianNoise(object):
    def __init__(self, center=0, std=50):
        self.center = center
        self.std = std

    def __call__(self, X, Y):
        noise = np.random.normal(self.center, self.std, X.shape)
        X = X + noise
        return X, Y

渐晕

​ 最后，更少使用但并非没有用的一种方法。 有些相机会产生渐晕效果。 考虑如何通过随机模仿这种现象来增广图像也很有趣。 我们还将尝试为用户提供灵活性。 我们将能够确定距离效果和可以随机开始的最小距离，确定其强度，甚至可以确定效果是朝着黑色还是向白色方向发展。

class Vignetting(object):
    def __init__(self,
                 ratio_min_dist=0.2,
                 range_vignette=(0.2, 0.8),
                 random_sign=False):
        self.ratio_min_dist = ratio_min_dist
        self.range_vignette = np.array(range_vignette)
        self.random_sign = random_sign

    def __call__(self, X, Y):
        h, w = X.shape[:2]
        min_dist = np.array([h, w]) / 2 * np.random.random() * self.ratio_min_dist

        # create matrix of distance from the center on the two axis
        x, y = np.meshgrid(np.linspace(-w/2, w/2, w), np.linspace(-h/2, h/2, h))
        x, y = np.abs(x), np.abs(y)

        # create the vignette mask on the two axis
        x = (x - min_dist[0]) / (np.max(x) - min_dist[0])
        x = np.clip(x, 0, 1)
        y = (y - min_dist[1]) / (np.max(y) - min_dist[1])
        y = np.clip(y, 0, 1)

        # then get a random intensity of the vignette
        vignette = (x + y) / 2 * np.random.uniform(*self.range_vignette)
        vignette = np.tile(vignette[..., None], [1, 1, 3])

        sign = 2 * (np.random.random() < 0.5) * (self.random_sign) - 1
        X = X * (1 + sign * vignette)

        return X, Y

镜头变形

​ 最后，这是一种非常好的方法。 我很惊讶它不经常被使用。 但是它可以模仿相机镜头的失真。 就像透过圆形玻璃看。 在我们看来，由于透镜（玻璃）是圆形的，因此失真了。 因此，如果我们的图像是从带镜头的相机拍摄的，为什么不模拟它们。 默认情况下，应将其用于图像。 至少我是这样认为的。

​ 因此，我建议在最后一个函数中，通过播放径向系数k1，k2，k3和切向系数p1，p2，可以随机模拟我们的镜头失真。 在该方法中，系数的顺序如下：k1，k2，p1，p2，k3。 我邀请您阅读有关此主题的OpenCV文档。

class LensDistortion(object):
    def __init__(self, d_coef=(0.15, 0.15, 0.1, 0.1, 0.05)):
        self.d_coef = np.array(d_coef)

    def __call__(self, X, Y):

        # get the height and the width of the image
        h, w = X.shape[:2]

        # compute its diagonal
        f = (h ** 2 + w ** 2) ** 0.5

        # set the image projective to carrtesian dimension
        K = np.array([[f, 0, w / 2],
                      [0, f, h / 2],
                      [0, 0,     1]])

        d_coef = self.d_coef * np.random.random(5) # value
        d_coef = d_coef * (2 * (np.random.random(5) < 0.5) - 1) # sign
        # Generate new camera matrix from parameters
        M, _ = cv2.getOptimalNewCameraMatrix(K, d_coef, (w, h), 0)

        # Generate look-up tables for remapping the camera image
        remap = cv2.initUndistortRectifyMap(K, d_coef, None, M, (w, h), 5)

        # Remap the original image to a new image
        X = cv2.remap(X, *remap, cv2.INTER_LINEAR)
        Y = cv2.remap(Y, *remap, cv2.INTER_LINEAR)
        return X, Y

希望对您有用！
请随时关注我或就您喜欢或不喜欢的内容给我反馈。 ️
待会儿见！

资料来源和参考

特别感谢Elise授权使用此图片

作者：Axel Thevenot

deephub翻译组：孟翔杰