增强操作

关于自动增强，增强是满足以下要求的图像处理函数

1. 它的第一个参数是用于处理的输入批次

2. 第二个参数是控制操作的参数（例如旋转角度）。

3. 它可以接受额外的关键字参数。

4. 它使用 DALI 操作符 实现。

5. 它使用 @augmentation 进行装饰

这是一个定义简化的旋转增强的示例

from nvidia.dali.auto_aug.core import augmentation
from nvidia.dali import fn

@augmentation(mag_range=(0, 30), randomly_negate=True)
def rotate_aug(data, angle, fill_value=128, rotate_keep_size=True):
   return fn.rotate(data, angle=angle, fill_value=fill_value, keep_size=True)

基于现有的增强，可以创建一个新的增强，并调整参数

rotate_aug_60 = rotate_aug.augmentation(mag_range=(0, 60), randomly_negate=False)

要了解有关如何使用此处列出的增强来构建策略的更多信息，请查看特定自动增强方案的文档：AutoAugment、RandAugment 或 TrivialAugment。

装饰器

@nvidia.dali.auto_aug.core.augmentation(function=None, *, mag_range=None, randomly_negate=None, mag_to_param=None, param_device=None, name=None, augmentation_cls=None)

一个装饰器，将使用 DALI 实现的转换变为可用于自动增强（例如 AutoAugment、RandAugment、TrivialAugment）的增强。

function 必须接受至少两个参数：一个样本和一个参数。装饰器处理参数的计算。装饰后的增强接受幅度 bin 和总 bin 数，而不是参数。然后，bin 用于计算参数，就像调用 mag_to_param(magnitudes[magnitude_bin] * ((-1) ** random_sign)) 一样，其中 magnitudes=linspace(mag_range[0], mag_range[1], num_magnitude_bins)。

参数:

• function (callable) – 一个函数，它接受至少两个位置参数：要处理的批次（表示为 DataNode）和转换的参数。该函数必须使用 DALI 操作符来处理批次并返回此类处理的单个输出。

• mag_range ((number, number) 或 np.ndarray) – 指定操作的适用幅度范围。如果提供元组，则幅度将计算为 linspace(mag_range[0], mag_range[1], num_magnitude_bins)。如果提供 np.ndarray，它将直接使用，而不是 linspace。如果未指定 mag_range，则传递给 function 的参数将为 None。

• randomly_negate (bool) – 如果为 True，则对于每个样本，幅度范围内的幅度将被随机取反。

• mag_to_param (callable) – 一个回调，将幅度转换为参数。参数将传递给装饰后的操作，而不是纯幅度。通过这种方式，可以预先计算一系列幅度的参数并将其存储为 Constant 节点。注意，回调必须返回 numpy 数组或可直接转换为 numpy 数组的数据（特别是，回调中不能使用 pipeline 化的 DALI 操作符）。输出类型和维度必须一致，并且不依赖于幅度。

• param_device (str) – “cpu”、“gpu” 或 “auto”；默认为 “cpu”。描述存储预计算参数的位置（即 mag_to_param 输出）。如果指定 “auto”，则将选择 CPU 或 GPU 后端以匹配 sample 的后端。

• name (str) – 增强的名称。默认情况下，使用装饰函数的名称。

返回值:

使用 Augmentation 类包装的操作，以便它可以与 auto_aug 转换一起使用。

返回类型:

Augmentation

class nvidia.dali.auto_aug.core._augmentation.Augmentation

使用 @augmentation 装饰函数的结果是类 Augmentation() 的实例。该类不应直接实例化，需要使用装饰器创建。

一旦获得这些对象，它们就成为可调用的对象，可用于指定 AutoAugment、RandAugment 或 TrivialAugment 的策略。

def augmentation(self, mag_range, randomly_negate, mag_to_param, param_device, name) -> Augmentation

您可以调用此方法以基于现有实例创建新的 Augmentation() 实例，并调整参数。所有参数都是可选的 - 指定的参数将替换先前传递给 @augmentation 的参数。

参数:

• mag_range – 可选，请参阅 @augmentation。

• randomly_negate – 可选，请参阅 @augmentation。

• mag_to_param – 可选，请参阅 @augmentation。

• param_device – 可选，请参阅 @augmentation。

• name – 可选，请参阅 @augmentation。

增强

以下是 DALI 定义的可调用 Augmentation() 实例列表。请注意，为了简洁起见，从 @augmentation 装饰器列表中省略了 mag_to_param、param_device 和 name 参数。

要调整参数范围，请对下面列出的现有 Augmentation() 实例使用 augmentation 方法，例如

# Create a steeper sheer operation based on existing one
steep_shear_x = shear_x.augmentation(mag_range=(0, 0.5), name="steep_shear_x")

nvidia.dali.auto_aug.augmentations.shear_x(data, *, magnitude_bin=None, num_magnitude_bins=None, **kwargs)

使用 nvidia.dali.fn.transforms.shear() 和 shear_x 因子应用 nvidia.dali.fn.warp_affine()。

@augmentation(mag_range=(0, 0.3), randomly_negate=True, ...)
def shear_x(data, shear, fill_value=128, interp_type=None)

nvidia.dali.auto_aug.augmentations.shear_y(data, *, magnitude_bin=None, num_magnitude_bins=None, **kwargs)

使用 nvidia.dali.fn.transforms.shear() 和 shear_y 因子应用 nvidia.dali.fn.warp_affine()。

@augmentation(mag_range=(0, 0.3), randomly_negate=True, ...)
def shear_y(data, shear, fill_value=128, interp_type=None)

nvidia.dali.auto_aug.augmentations.translate_x(data, *, magnitude_bin=None, num_magnitude_bins=None, **kwargs)

使用 nvidia.dali.fn.transforms.translation() 和 x 轴中相对于形状的偏移应用 nvidia.dali.fn.warp_affine()。

@augmentation(mag_range=(0., 1.), randomly_negate=True, ...)
def translate_x(data, rel_offset, shape, fill_value=128, interp_type=None)

nvidia.dali.auto_aug.augmentations.translate_x_no_shape(data, *, magnitude_bin=None, num_magnitude_bins=None, **kwargs)

使用 nvidia.dali.fn.transforms.translation() 和 x 轴中的绝对偏移应用 nvidia.dali.fn.warp_affine()。

@augmentation(mag_range=(0, 250), randomly_negate=True, ...)
def translate_x_no_shape(data, offset, fill_value=128, interp_type=None)

nvidia.dali.auto_aug.augmentations.translate_y(data, *, magnitude_bin=None, num_magnitude_bins=None, **kwargs)

使用 nvidia.dali.fn.transforms.translation() 和 y 轴中相对于形状的偏移应用 nvidia.dali.fn.warp_affine()。

@augmentation(mag_range=(0., 1.), randomly_negate=True, ...)
def translate_y(data, rel_offset, shape, fill_value=128, interp_type=None)

nvidia.dali.auto_aug.augmentations.translate_y_no_shape(data, *, magnitude_bin=None, num_magnitude_bins=None, **kwargs)

使用 nvidia.dali.fn.transforms.translation() 和 y 轴中的绝对偏移应用 nvidia.dali.fn.warp_affine()。

@augmentation(mag_range=(0, 250), randomly_negate=True, ...)
def translate_y_no_shape(data, offset, fill_value=128, interp_type=None)

nvidia.dali.auto_aug.augmentations.rotate(data, *, magnitude_bin=None, num_magnitude_bins=None, **kwargs)

使用 nvidia.dali.fn.rotate() 旋转图像。

@augmentation(mag_range=(0, 30), randomly_negate=True)
def rotate(data, angle, fill_value=128, interp_type=None, rotate_keep_size=True)

nvidia.dali.auto_aug.augmentations.brightness(data, *, magnitude_bin=None, num_magnitude_bins=None, **kwargs)

使用 nvidia.dali.fn.brightness() 调整亮度。幅度映射到 [0, 2] 参数范围。

@augmentation(mag_range=(0, 0.9), randomly_negate=True, ...)
def brightness(data, parameter)

nvidia.dali.auto_aug.augmentations.contrast(data, *, magnitude_bin=None, num_magnitude_bins=None, **kwargs)

使用通道加权平均值作为对比度中心调整对比度。幅度映射到 [0, 2] 参数范围。

@augmentation(mag_range=(0, 0.9), randomly_negate=True, ...)
def contrast(data, parameter)

nvidia.dali.auto_aug.augmentations.color(data, *, magnitude_bin=None, num_magnitude_bins=None, **kwargs)

使用 nvidia.dali.fn.saturation() 调整颜色。幅度映射到 [0, 2] 参数范围。

@augmentation(mag_range=(0, 0.9), randomly_negate=True, ...)
def color(data, parameter)

nvidia.dali.auto_aug.augmentations.sharpness(data, *, magnitude_bin=None, num_magnitude_bins=None, **kwargs)

输出对应于 PIL 的 ImageEnhance.Sharpness。

@augmentation(mag_range=(0, 0.9), randomly_negate=True, ...)
def sharpness(data, kernel)

nvidia.dali.auto_aug.augmentations.posterize(data, *, magnitude_bin=None, num_magnitude_bins=None, **kwargs)

通过屏蔽较低的输入位来进行 Posterize 图像处理。

@augmentation(mag_range=(0, 4), ...)
def posterize(data, mask)

nvidia.dali.auto_aug.augmentations.solarize(data, *, magnitude_bin=None, num_magnitude_bins=None, **kwargs)

反转低于阈值的像素。

@augmentation(mag_range=(256, 0), ...)
def solarize(data, threshold)

nvidia.dali.auto_aug.augmentations.solarize_add(data, *, magnitude_bin=None, num_magnitude_bins=None, **kwargs)

将偏移应用于值低于 128 的像素。

@augmentation(mag_range=(0, 110), ...)
def solarize_add(data, shift)

nvidia.dali.auto_aug.augmentations.invert(data, *, magnitude_bin=None, num_magnitude_bins=None, **kwargs)

反转图像。

@augmentation
def invert(data, _)

nvidia.dali.auto_aug.augmentations.equalize(data, *, magnitude_bin=None, num_magnitude_bins=None, **kwargs)

应用直方图均衡化，使用 nvidia.dali.fn.experimental.equalize。

@augmentation
def equalize(data, _)
    """
    DALI's equalize follows OpenCV's histogram equalization.
    The PIL uses slightly different formula when transforming histogram's
    cumulative sum into lookup table.

nvidia.dali.auto_aug.augmentations.auto_contrast(data, *, magnitude_bin=None, num_magnitude_bins=None, **kwargs)

应用自动对比度调整。

@augmentation
def auto_contrast(data, _)

nvidia.dali.auto_aug.augmentations.identity(data, *, magnitude_bin=None, num_magnitude_bins=None, **kwargs)

恒等运算 - 不应用任何处理。

@augmentation
def identity(data, _)