Transforms2D

Set of operators to perform data augmentation on 2D image tensors.

class kornia.augmentation.CenterCrop(size, align_corners=True, resample='BILINEAR', return_transform=False, p=1.0, keepdim=False, cropping_mode='slice')[source]

Crop a given image tensor at the center.

_images/CenterCrop.png
Parameters
  • size (Union[int, Tuple[int, int]]) – Desired output size (out_h, out_w) of the crop. If integer, out_h = out_w = size. If Tuple[int, int], out_h = size[0], out_w = size[1].

  • align_corners (bool, optional) – interpolation flag. Default: True

  • resample (Union[str, int, Resample], optional) – The interpolation mode. Default: 'BILINEAR'

  • return_transform (bool, optional) – if True return the matrix describing the transformation applied to each. Default: False

  • p (float, optional) – probability of applying the transformation for the whole batch. Default: 1.0

  • keepdim (bool, optional) – whether to keep the output shape the same as input (True) or broadcast it to the batch form (False). Default: False

  • cropping_mode (str, optional) – The used algorithm to crop. slice will use advanced slicing to extract the tensor based on the sampled indices. resample will use warp_affine using the affine transformation to extract and resize at once. Use slice for efficiency, or resample for proper differentiability. Default: 'slice'

Shape:
  • Input: \((C, H, W)\) or \((B, C, H, W)\), Optional: \((B, 3, 3)\)

  • Output: \((B, C, out_h, out_w)\)

Note

This function internally uses kornia.geometry.transform.crop_by_boxes().

Examples

>>> rng = torch.manual_seed(0)
>>> inputs = torch.randn(1, 1, 4, 4)
>>> inputs
tensor([[[[-1.1258, -1.1524, -0.2506, -0.4339],
          [ 0.8487,  0.6920, -0.3160, -2.1152],
          [ 0.3223, -1.2633,  0.3500,  0.3081],
          [ 0.1198,  1.2377,  1.1168, -0.2473]]]])
>>> aug = CenterCrop(2, p=1., cropping_mode="resample")
>>> out = aug(inputs)
>>> out
tensor([[[[ 0.6920, -0.3160],
          [-1.2633,  0.3500]]]])
>>> aug.inverse(out, padding_mode="border")
tensor([[[[ 0.6920,  0.6920, -0.3160, -0.3160],
          [ 0.6920,  0.6920, -0.3160, -0.3160],
          [-1.2633, -1.2633,  0.3500,  0.3500],
          [-1.2633, -1.2633,  0.3500,  0.3500]]]])
class kornia.augmentation.ColorJitter(brightness=0.0, contrast=0.0, saturation=0.0, hue=0.0, return_transform=False, same_on_batch=False, p=1.0, keepdim=False)[source]

Apply a random transformation to the brightness, contrast, saturation and hue of a tensor image.

_images/ColorJitter.png
Parameters
  • p (float, optional) – probability of applying the transformation. Default: 1.0

  • brightness (Union[Tensor, float, Tuple[float, float], List[float]], optional) – The brightness factor to apply. Default: 0.0

  • contrast (Union[Tensor, float, Tuple[float, float], List[float]], optional) – The contrast factor to apply. Default: 0.0

  • saturation (Union[Tensor, float, Tuple[float, float], List[float]], optional) – The saturation factor to apply. Default: 0.0

  • hue (Union[Tensor, float, Tuple[float, float], List[float]], optional) – The hue factor to apply. Default: 0.0

  • return_transform (bool, optional) – if True return the matrix describing the transformation applied to each input tensor. If False and the input is a tuple the applied transformation won’t be concatenated. Default: False

  • same_on_batch (bool, optional) – apply the same transformation across the batch. Default: False

  • keepdim (bool, optional) – whether to keep the output shape the same as input (True) or broadcast it to the batch form (False). Default: False

Shape:
  • Input: \((C, H, W)\) or \((B, C, H, W)\), Optional: \((B, 3, 3)\)

  • Output: \((B, C, H, W)\)

Examples

>>> rng = torch.manual_seed(0)
>>> inputs = torch.ones(1, 3, 3, 3)
>>> aug = ColorJitter(0.1, 0.1, 0.1, 0.1, p=1.)
>>> aug(inputs)
tensor([[[[0.9993, 0.9993, 0.9993],
          [0.9993, 0.9993, 0.9993],
          [0.9993, 0.9993, 0.9993]],

         [[0.9993, 0.9993, 0.9993],
          [0.9993, 0.9993, 0.9993],
          [0.9993, 0.9993, 0.9993]],

         [[0.9993, 0.9993, 0.9993],
          [0.9993, 0.9993, 0.9993],
          [0.9993, 0.9993, 0.9993]]]])
class kornia.augmentation.RandomAffine(degrees, translate=None, scale=None, shear=None, resample='BILINEAR', return_transform=False, same_on_batch=False, align_corners=False, padding_mode='ZEROS', p=0.5, keepdim=False)[source]

Apply a random 2D affine transformation to a tensor image.

_images/RandomAffine.png

The transformation is computed so that the image center is kept invariant.

Parameters
  • p (float, optional) – probability of applying the transformation. Default: 0.5

  • degrees (Union[Tensor, float, Tuple[float, float]]) – Range of degrees to select from. If degrees is a number instead of sequence like (min, max), the range of degrees will be (-degrees, +degrees). Set to 0 to deactivate rotations.

  • translate (Union[Tensor, Tuple[float, float], None], optional) – tuple of maximum absolute fraction for horizontal and vertical translations. For example translate=(a, b), then horizontal shift is randomly sampled in the range -img_width * a < dx < img_width * a and vertical shift is randomly sampled in the range -img_height * b < dy < img_height * b. Will not translate by default. Default: None

  • scale (Union[Tensor, Tuple[float, float], Tuple[float, float, float, float], None], optional) – scaling factor interval. If (a, b) represents isotropic scaling, the scale is randomly sampled from the range a <= scale <= b. If (a, b, c, d), the scale is randomly sampled from the range a <= scale_x <= b, c <= scale_y <= d. Will keep original scale by default. Default: None

  • shear (Union[Tensor, float, Tuple[float, float], None], optional) – Range of degrees to select from. If float, a shear parallel to the x axis in the range (-shear, +shear) will be applied. If (a, b), a shear parallel to the x axis in the range (-shear, +shear) will be applied. If (a, b, c, d), then x-axis shear in (shear[0], shear[1]) and y-axis shear in (shear[2], shear[3]) will be applied. Will not apply shear by default. Default: None

  • resample (Union[str, int, Resample], optional) – resample mode from “nearest” (0) or “bilinear” (1). Default: 'BILINEAR'

  • padding_mode (Union[str, int, SamplePadding], optional) – padding mode from “zeros” (0), “border” (1) or “refection” (2). Default: 'ZEROS'

  • return_transform (bool, optional) – if True return the matrix describing the transformation applied to each. Default: False

  • same_on_batch (bool, optional) – apply the same transformation across the batch. Default: False

  • align_corners (bool, optional) – interpolation flag. Default: False

  • keepdim (bool, optional) – whether to keep the output shape the same as input (True) or broadcast it to the batch form (False). Default: False

Shape:
  • Input: \((C, H, W)\) or \((B, C, H, W)\), Optional: \((B, 3, 3)\)

  • Output: \((B, C, H, W)\)

Note

This function internally uses kornia.geometry.transform.warp_affine().

Examples

>>> rng = torch.manual_seed(0)
>>> input = torch.rand(1, 1, 3, 3)
>>> aug = RandomAffine((-15., 20.), return_transform=True, p=1.)
>>> out = aug(input)
>>> out
(tensor([[[[0.3961, 0.7310, 0.1574],
          [0.1781, 0.3074, 0.5648],
          [0.4804, 0.8379, 0.4234]]]]), tensor([[[ 0.9923, -0.1241,  0.1319],
         [ 0.1241,  0.9923, -0.1164],
         [ 0.0000,  0.0000,  1.0000]]]))
>>> aug.inverse(out)
tensor([[[[0.3890, 0.6573, 0.1865],
          [0.2063, 0.3074, 0.5459],
          [0.3892, 0.7896, 0.4224]]]])
>>> input
tensor([[[[0.4963, 0.7682, 0.0885],
          [0.1320, 0.3074, 0.6341],
          [0.4901, 0.8964, 0.4556]]]])
class kornia.augmentation.RandomBoxBlur(kernel_size=(3, 3), border_type='reflect', normalized=True, return_transform=False, same_on_batch=False, p=0.5)[source]

Add random blur with a box filter to an image tensor.

_images/RandomBoxBlur.png
Parameters
  • kernel_size (Tuple[int, int], optional) – the blurring kernel size. Default: (3, 3)

  • border_type (str, optional) – the padding mode to be applied before convolving. The expected modes are: constant, reflect, replicate or circular. Default: 'reflect'

  • normalized (bool, optional) – if True, L1 norm of the kernel is set to 1. Default: True

  • return_transform (bool, optional) – if True return the matrix describing the transformation applied to each input tensor. If False and the input is a tuple the applied transformation won’t be concatenated. Default: False

  • same_on_batch (bool) – apply the same transformation across the batch. Default: False

  • p (float, optional) – probability of applying the transformation. Default: 0.5

Note

This function internally uses kornia.filters.box_blur().

Examples

>>> img = torch.ones(1, 1, 24, 24)
>>> out = RandomBoxBlur((7, 7))(img)
>>> out.shape
torch.Size([1, 1, 24, 24])
class kornia.augmentation.RandomCrop(size, padding=None, pad_if_needed=False, fill=0, padding_mode='constant', resample='BILINEAR', return_transform=False, same_on_batch=False, align_corners=True, p=1.0, keepdim=False, cropping_mode='slice')[source]

Crop random patches of a tensor image on a given size.

_images/RandomCrop.png
Parameters
  • p (float, optional) – probability of applying the transformation for the whole batch. Default: 1.0

  • size (Tuple[int, int]) – Desired output size (out_h, out_w) of the crop. Must be Tuple[int, int], then out_h = size[0], out_w = size[1].

  • padding (Union[int, Tuple[int, int], Tuple[int, int, int, int], None], optional) – Optional padding on each border of the image. Default is None, i.e no padding. If a sequence of length 4 is provided, it is used to pad left, top, right, bottom borders respectively. If a sequence of length 2 is provided, it is used to pad left/right, top/bottom borders, respectively. Default: None

  • pad_if_needed (Optional[bool], optional) – It will pad the image if smaller than the desired size to avoid raising an exception. Since cropping is done after padding, the padding seems to be done at a random offset. Default: False

  • fill (int, optional) – Pixel fill value for constant fill. Default is 0. If a tuple of length 3, it is used to fill R, G, B channels respectively. This value is only used when the padding_mode is constant. Default: 0

  • padding_mode (str, optional) – Type of padding. Should be: constant, edge, reflect or symmetric. Default: 'constant'

  • resample (Union[str, int, Resample], optional) – the interpolation mode. Default: 'BILINEAR'

  • return_transform (bool, optional) – if True return the matrix describing the transformation applied to each input tensor. If False and the input is a tuple the applied transformation won’t be concatenated. Default: False

  • same_on_batch (bool, optional) – apply the same transformation across the batch. Default: False

  • align_corners (bool, optional) – interpolation flag. Default: True

  • keepdim (bool, optional) – whether to keep the output shape the same as input (True) or broadcast it to the batch form (False). Default: False

  • cropping_mode (str, optional) – The used algorithm to crop. slice will use advanced slicing to extract the tensor based on the sampled indices. resample will use warp_affine using the affine transformation to extract and resize at once. Use slice for efficiency, or resample for proper differentiability. Default: 'slice'

Shape:
  • Input: \((C, H, W)\) or \((B, C, H, W)\), Optional: \((B, 3, 3)\)

  • Output: \((B, C, out_h, out_w)\)

Note

Input tensor must be float and normalized into [0, 1] for the best differentiability support. Additionally, this function accepts another transformation tensor (\((B, 3, 3)\)), then the applied transformation will be merged int to the input transformation tensor and returned.

Examples

>>> _ = torch.manual_seed(0)
>>> inputs = torch.arange(1*1*3*3.).view(1, 1, 3, 3)
>>> aug = RandomCrop((2, 2), p=1., cropping_mode="resample")
>>> out = aug(inputs)
>>> out
tensor([[[[3., 4.],
          [6., 7.]]]])
>>> aug.inverse(out, padding_mode="border")
tensor([[[[3., 4., 4.],
          [3., 4., 4.],
          [6., 7., 7.]]]])
class kornia.augmentation.RandomChannelShuffle(return_transform=False, same_on_batch=False, p=0.5)[source]

Shuffle the channels of a batch of multi-dimensional images.

_images/RandomChannelShuffle.png
Parameters
  • return_transform (bool, optional) – if True return the matrix describing the transformation applied to each input tensor. If False and the input is a tuple the applied transformation won’t be concatenated. Default: False

  • same_on_batch (bool, optional) – apply the same transformation across the batch. Default: False

  • p (float, optional) – probability of applying the transformation. Default: 0.5

Examples

>>> rng = torch.manual_seed(0)
>>> img = torch.arange(1*2*2*2.).view(1,2,2,2)
>>> RandomChannelShuffle()(img)
tensor([[[[4., 5.],
          [6., 7.]],

         [[0., 1.],
          [2., 3.]]]])
class kornia.augmentation.RandomCutMix(height, width, num_mix=1, cut_size=None, beta=None, same_on_batch=False, p=1.0, keepdim=False)[source]

Apply CutMix augmentation to a batch of tensor images.

_images/RandomCutMix.png

Implementation for CutMix: Regularization Strategy to Train Strong Classifiers with Localizable Features [YHO+19].

The function returns (inputs, labels), in which the inputs is the tensor that contains the mixup images while the labels is a \((\text{num_mixes}, B, 3)\) tensor that contains (label_permuted_batch, lambda) for each cutmix.

The implementation referred to the following repository: https://github.com/clovaai/CutMix-PyTorch.

The onehot label may be computed as:

def onehot(size, target):
    vec = torch.zeros(size, dtype=torch.float32)
    vec[target] = 1.
    return vec
def cutmix_label(labels, out_labels, size):
    lb_onehot = onehot(size, labels)
    for out_label in out_labels:
        label_permuted_batch, lam = out_label[:, 0], out_label[:, 1]
        label_permuted_onehot = onehot(size, label_permuted_batch)
        lb_onehot = lb_onehot * lam + label_permuted_onehot * (1. - lam)
    return lb_onehot
Parameters
  • height (int) – the width of the input image.

  • width (int) – the width of the input image.

  • p (float) – probability for applying an augmentation to a batch. This param controls the augmentation probabilities batch-wisely. Default: 1.0

  • num_mix (int) – cut mix times. Default is 1. Default: 1

  • beta (float or torch.Tensor, optional) – hyperparameter for generating cut size from beta distribution. Beta cannot be set to 0 after torch 1.8.0. If None, it will be set to 1. Default: None

  • cut_size ((float, float) or torch.Tensor, optional) – controlling the minimum and maximum cut ratio from [0, 1]. If None, it will be set to [0, 1], which means no restriction. Default: None

  • same_on_batch (bool) – apply the same transformation across the batch. This flag will not maintain permutation order. Default: False.

  • keepdim (bool) – whether to keep the output shape the same as input (True) or broadcast it to the batch form (False). Default: False

Inputs:
  • Input image tensors, shape of \((B, C, H, W)\).

  • Raw labels, shape of \((B)\).

Returns

  • Adjusted image, shape of \((B, C, H, W)\).

  • Raw labels, permuted labels and lambdas for each mix, shape of \((B, num_mix, 3)\).

Return type

Tuple[torch.Tensor, torch.Tensor]

Note

This implementation would randomly cutmix images in a batch. Ideally, the larger batch size would be preferred.

Examples

>>> rng = torch.manual_seed(3)
>>> input = torch.rand(2, 1, 3, 3)
>>> input[0] = torch.ones((1, 3, 3))
>>> label = torch.tensor([0, 1])
>>> cutmix = RandomCutMix(3, 3)
>>> cutmix(input, label)
(tensor([[[[0.8879, 0.4510, 1.0000],
          [0.1498, 0.4015, 1.0000],
          [1.0000, 1.0000, 1.0000]]],


        [[[1.0000, 1.0000, 0.7995],
          [1.0000, 1.0000, 0.0542],
          [0.4594, 0.1756, 0.9492]]]]), tensor([[[0.0000, 1.0000, 0.4444],
         [1.0000, 0.0000, 0.4444]]]))
class kornia.augmentation.RandomErasing(scale=(0.02, 0.33), ratio=(0.3, 3.3), value=0.0, return_transform=False, same_on_batch=False, p=0.5, keepdim=False)[source]

Erase a random rectangle of a tensor image according to a probability p value.

_images/RandomErasing.png

The operator removes image parts and fills them with zero values at a selected rectangle for each of the images in the batch.

The rectangle will have an area equal to the original image area multiplied by a value uniformly sampled between the range [scale[0], scale[1]) and an aspect ratio sampled between [ratio[0], ratio[1])

Parameters
  • p (float, optional) – probability that the random erasing operation will be performed. Default: 0.5

  • scale (Union[Tensor, Tuple[float, float]], optional) – range of proportion of erased area against input image. Default: (0.02, 0.33)

  • ratio (Union[Tensor, Tuple[float, float]], optional) – range of aspect ratio of erased area. Default: (0.3, 3.3)

  • same_on_batch (bool, optional) – apply the same transformation across the batch. Default: False

  • keepdim (bool, optional) – whether to keep the output shape the same as input (True) or broadcast it to the batch form (False). Default: False

Shape:
  • Input: \((C, H, W)\) or \((B, C, H, W)\), Optional: \((B, 3, 3)\)

  • Output: \((B, C, H, W)\)

Note

Input tensor must be float and normalized into [0, 1] for the best differentiability support. Additionally, this function accepts another transformation tensor (\((B, 3, 3)\)), then the applied transformation will be merged int to the input transformation tensor and returned.

Examples

>>> rng = torch.manual_seed(0)
>>> inputs = torch.ones(1, 1, 3, 3)
>>> rec_er = RandomErasing((.4, .8), (.3, 1/.3), p=0.5)
>>> rec_er(inputs)
tensor([[[[1., 0., 0.],
          [1., 0., 0.],
          [1., 0., 0.]]]])
class kornia.augmentation.RandomElasticTransform(kernel_size=(63, 63), sigma=(32.0, 32.0), alpha=(1.0, 1.0), align_corners=False, mode='bilinear', return_transform=False, same_on_batch=False, p=0.5)[source]

Add random elastic transformation to a tensor image.

_images/RandomElasticTransform.png
Parameters
  • kernel_size (Tuple[int, int], optional) – the size of the Gaussian kernel. Default: (63, 63)

  • sigma (Tuple[float, float], optional) – The standard deviation of the Gaussian in the y and x directions, respectively. Larger sigma results in smaller pixel displacements. Default: (32.0, 32.0)

  • alpha (Tuple[float, float], optional) – The scaling factor that controls the intensity of the deformation in the y and x directions, respectively. Default: (1.0, 1.0)

  • align_corners (bool, optional) – Interpolation flag used by grid_sample. Default: False

  • mode (str, optional) – Interpolation mode used by grid_sample. Either ‘bilinear’ or ‘nearest’. Default: 'bilinear'

  • return_transform (bool, optional) – if True return the matrix describing the transformation applied to each input tensor. If False and the input is a tuple the applied transformation won’t be concatenated. Default: False

  • same_on_batch (bool, optional) – apply the same transformation across the batch. Default: False

  • p (float, optional) – probability of applying the transformation. Default: 0.5

Note

This function internally uses kornia.geometry.transform.elastic_transform2d().

Examples

>>> img = torch.ones(1, 1, 2, 2)
>>> out = RandomElasticTransform()(img)
>>> out.shape
torch.Size([1, 1, 2, 2])
class kornia.augmentation.RandomEqualize(same_on_batch=False, return_transform=False, p=0.5, keepdim=False)[source]

Equalize given tensor image or a batch of tensor images randomly.

_images/RandomEqualize.png
Parameters
  • p (float, optional) – Probability to equalize an image. Default: 0.5

  • same_on_batch (bool, optional) – apply the same transformation across the batch. Default: False

  • return_transform (bool, optional) – if True return the matrix describing the transformation applied to each input tensor. If False and the input is a tuple the applied transformation won’t be concatenated. Default: False

  • keepdim (bool, optional) – whether to keep the output shape the same as input (True) or broadcast it to the batch form (False). Default: False

Shape:
  • Input: \((C, H, W)\) or \((B, C, H, W)\), Optional: \((B, 3, 3)\)

  • Output: \((B, C, H, W)\)

Note

This function internally uses kornia.enhance.equalize().

Examples

>>> rng = torch.manual_seed(0)
>>> input = torch.rand(1, 1, 5, 5)
>>> equalize = RandomEqualize(p=1.)
>>> equalize(input)
tensor([[[[0.4963, 0.7682, 0.0885, 0.1320, 0.3074],
          [0.6341, 0.4901, 0.8964, 0.4556, 0.6323],
          [0.3489, 0.4017, 0.0223, 0.1689, 0.2939],
          [0.5185, 0.6977, 0.8000, 0.1610, 0.2823],
          [0.6816, 0.9152, 0.3971, 0.8742, 0.4194]]]])
class kornia.augmentation.RandomFisheye(center_x, center_y, gamma, return_transform=False, same_on_batch=False, p=0.5)[source]

Add random camera radial distortion.

_images/RandomFisheye.png
Parameters
  • center_x (Tensor) – Ranges to sample respect to x-coordinate center with shape (2,).

  • center_y (Tensor) – Ranges to sample respect to y-coordinate center with shape (2,).

  • gamma (Tensor) – Ranges to sample for the gamma values respect to optical center with shape (2,).

  • return_transform (bool, optional) – if True return the matrix describing the transformation applied to each input tensor. If False and the input is a tuple the applied transformation won’t be concatenated. Default: False

  • same_on_batch (bool, optional) – apply the same transformation across the batch. Default: False

  • p (float, optional) – probability of applying the transformation. Default: 0.5

Examples

>>> img = torch.ones(1, 1, 2, 2)
>>> center_x = torch.tensor([-.3, .3])
>>> center_y = torch.tensor([-.3, .3])
>>> gamma = torch.tensor([.9, 1.])
>>> out = RandomFisheye(center_x, center_y, gamma)(img)
>>> out.shape
torch.Size([1, 1, 2, 2])
class kornia.augmentation.RandomGrayscale(return_transform=False, same_on_batch=False, p=0.1, keepdim=False)[source]

Apply random transformation to Grayscale according to a probability p value.

_images/RandomGrayscale.png
Parameters
  • p (float, optional) – probability of the image to be transformed to grayscale. Default: 0.1

  • return_transform (bool, optional) – if True return the matrix describing the transformation applied to each input tensor. If False and the input is a tuple the applied transformation won’t be concatenated. Default: False

  • same_on_batch (bool, optional) – apply the same transformation across the batch. Default: False

  • keepdim (bool, optional) – whether to keep the output shape the same as input (True) or broadcast it to the batch form (False). Default: False

Shape:
  • Input: \((C, H, W)\) or \((B, C, H, W)\), Optional: \((B, 3, 3)\)

  • Output: \((B, C, H, W)\)

Note

This function internally uses kornia.color.rgb_to_grayscale().

Examples

>>> rng = torch.manual_seed(0)
>>> inputs = torch.randn((1, 3, 3, 3))
>>> rec_er = RandomGrayscale(p=1.0)
>>> rec_er(inputs)
tensor([[[[-1.1344, -0.1330,  0.1517],
          [-0.0791,  0.6711, -0.1413],
          [-0.1717, -0.9023,  0.0819]],

         [[-1.1344, -0.1330,  0.1517],
          [-0.0791,  0.6711, -0.1413],
          [-0.1717, -0.9023,  0.0819]],

         [[-1.1344, -0.1330,  0.1517],
          [-0.0791,  0.6711, -0.1413],
          [-0.1717, -0.9023,  0.0819]]]])
class kornia.augmentation.RandomGaussianBlur(kernel_size, sigma, border_type='reflect', return_transform=False, same_on_batch=False, p=0.5)[source]

Apply gaussian blur given tensor image or a batch of tensor images randomly.

_images/RandomGaussianBlur.png
Parameters
  • kernel_size (Tuple[int, int]) – the size of the kernel.

  • sigma (Tuple[float, float]) – the standard deviation of the kernel.

  • border_type (str, optional) – the padding mode to be applied before convolving. The expected modes are: constant, reflect, replicate or circular. Default: 'reflect'

  • return_transform (bool, optional) – if True return the matrix describing the transformation applied to each input tensor. If False and the input is a tuple the applied transformation won’t be concatenated. Default: False

  • same_on_batch (bool, optional) – apply the same transformation across the batch. Default: False

  • p (float, optional) – probability of applying the transformation. Default: 0.5

Shape:
  • Input: \((C, H, W)\) or \((B, C, H, W)\), Optional: \((B, 3, 3)\)

  • Output: \((B, C, H, W)\)

Note

This function internally uses kornia.filters.gaussian_blur2d().

Examples

>>> rng = torch.manual_seed(0)
>>> input = torch.rand(1, 1, 5, 5)
>>> blur = RandomGaussianBlur((3, 3), (0.1, 2.0), p=1.)
>>> blur(input)
tensor([[[[0.6699, 0.4645, 0.3193, 0.1741, 0.1955],
          [0.5422, 0.6657, 0.6261, 0.6527, 0.5195],
          [0.3826, 0.2638, 0.1902, 0.1620, 0.2141],
          [0.6329, 0.6732, 0.5634, 0.4037, 0.2049],
          [0.8307, 0.6753, 0.7147, 0.5768, 0.7097]]]])
class kornia.augmentation.RandomGaussianNoise(mean=0.0, std=1.0, return_transform=False, same_on_batch=False, p=0.5)[source]

Add gaussian noise to a batch of multi-dimensional images.

_images/RandomGaussianNoise.png
Parameters
  • mean (float, optional) – The mean of the gaussian distribution. Default: 0.0

  • std (float, optional) – The standard deviation of the gaussian distribution. Default: 1.0

  • return_transform (bool, optional) – if True return the matrix describing the transformation applied to each input tensor. If False and the input is a tuple the applied transformation won’t be concatenated. Default: False

  • same_on_batch (bool, optional) – apply the same transformation across the batch. Default: False

  • p (float, optional) – probability of applying the transformation. Default: 0.5

Examples

>>> rng = torch.manual_seed(0)
>>> img = torch.ones(1, 1, 2, 2)
>>> RandomGaussianNoise(mean=0., std=1., p=1.)(img)
tensor([[[[ 2.5410,  0.7066],
          [-1.1788,  1.5684]]]])
class kornia.augmentation.RandomHorizontalFlip(return_transform=None, same_on_batch=False, p=0.5, p_batch=1.0, keepdim=False)[source]

Apply a random horizontal flip to a tensor image or a batch of tensor images with a given probability.

_images/RandomHorizontalFlip.png

Input should be a tensor of shape (C, H, W) or a batch of tensors \((B, C, H, W)\). If Input is a tuple it is assumed that the first element contains the aforementioned tensors and the second, the corresponding transformation matrix that has been applied to them. In this case the module will Horizontally flip the tensors and concatenate the corresponding transformation matrix to the previous one. This is especially useful when using this functionality as part of an nn.Sequential module.

Parameters
  • p (float, optional) – probability of the image being flipped. Default: 0.5

  • return_transform (Optional[bool], optional) – if True return the matrix describing the transformation applied to each input tensor. If False and the input is a tuple the applied transformation won’t be concatenated. Default: None

  • same_on_batch (bool, optional) – apply the same transformation across the batch. Default: False

  • keepdim (bool, optional) – whether to keep the output shape the same as input (True) or broadcast it to the batch form (False). Default: False

Shape:
  • Input: \((C, H, W)\) or \((B, C, H, W)\), Optional: \((B, 3, 3)\)

  • Output: \((B, C, H, W)\)

Note

This function internally uses kornia.geometry.transform.hflip().

Examples

>>> input = torch.tensor([[[[0., 0., 0.],
...                         [0., 0., 0.],
...                         [0., 1., 1.]]]])
>>> seq = RandomHorizontalFlip(p=1.0, return_transform=True)
>>> seq(input)
(tensor([[[[0., 0., 0.],
          [0., 0., 0.],
          [1., 1., 0.]]]]), tensor([[[-1.,  0.,  2.],
         [ 0.,  1.,  0.],
         [ 0.,  0.,  1.]]]))
>>> seq.inverse(seq(input)).equal(input)
True
class kornia.augmentation.RandomInvert(max_val=tensor(1.0), return_transform=False, same_on_batch=False, p=0.5)[source]

Invert the tensor images values randomly.

_images/RandomInvert.png
Parameters
  • max_val (Union[float, Tensor], optional) – The expected maximum value in the input tensor. The shape has to according to the input tensor shape, or at least has to work with broadcasting. Default: tensor(1.)

  • return_transform (bool, optional) – if True return the matrix describing the transformation applied to each input tensor. If False and the input is a tuple the applied transformation won’t be concatenated. Default: False

  • same_on_batch (bool, optional) – apply the same transformation across the batch. Default: False

  • p (float, optional) – probability of applying the transformation. Default: 0.5

Note

This function internally uses kornia.enhance.invert().

Examples

>>> rng = torch.manual_seed(0)
>>> img = torch.rand(1, 1, 5, 5)
>>> inv = RandomInvert()
>>> inv(img)
tensor([[[[0.4963, 0.7682, 0.0885, 0.1320, 0.3074],
          [0.6341, 0.4901, 0.8964, 0.4556, 0.6323],
          [0.3489, 0.4017, 0.0223, 0.1689, 0.2939],
          [0.5185, 0.6977, 0.8000, 0.1610, 0.2823],
          [0.6816, 0.9152, 0.3971, 0.8742, 0.4194]]]])
class kornia.augmentation.RandomMixUp(lambda_val=None, same_on_batch=False, p=1.0, keepdim=False)[source]

Apply MixUp augmentation to a batch of tensor images.

_images/RandomMixUp.png

Implementation for mixup: BEYOND EMPIRICAL RISK MINIMIZATION [ZnYNDLP18].

The function returns (inputs, labels), in which the inputs is the tensor that contains the mixup images while the labels is a \((B, 3)\) tensor that contains (label_batch, label_permuted_batch, lambda) for each image.

The implementation is on top of the following repository: https://github.com/hongyi-zhang/mixup/blob/master/cifar/utils.py.

The loss and accuracy are computed as:

def loss_mixup(y, logits):
    criterion = F.cross_entropy
    loss_a = criterion(logits, y[:, 0].long(), reduction='none')
    loss_b = criterion(logits, y[:, 1].long(), reduction='none')
    return ((1 - y[:, 2]) * loss_a + y[:, 2] * loss_b).mean()
def acc_mixup(y, logits):
    pred = torch.argmax(logits, dim=1).to(y.device)
    return (1 - y[:, 2]) * pred.eq(y[:, 0]).float() + y[:, 2] * pred.eq(y[:, 1]).float()
Parameters
  • p (float) – probability for applying an augmentation to a batch. This param controls the augmentation probabilities batch-wisely. Default: 1.0

  • lambda_val (float or torch.Tensor, optional) – min-max value of mixup strength. Default is 0-1. Default: None

  • same_on_batch (bool) – apply the same transformation across the batch. This flag will not maintain permutation order. Default: False.

  • keepdim (bool) – whether to keep the output shape the same as input (True) or broadcast it to the batch form (False). Default: False

Inputs:
  • Input image tensors, shape of \((B, C, H, W)\).

  • Label: raw labels, shape of \((B)\).

Returns

  • Adjusted image, shape of \((B, C, H, W)\).

  • Raw labels, permuted labels and lambdas for each mix, shape of \((B, 3)\).

Return type

Tuple[torch.Tensor, torch.Tensor]

Note

This implementation would randomly mixup images in a batch. Ideally, the larger batch size would be preferred.

Examples

>>> rng = torch.manual_seed(1)
>>> input = torch.rand(2, 1, 3, 3)
>>> label = torch.tensor([0, 1])
>>> mixup = RandomMixUp()
>>> mixup(input, label)
(tensor([[[[0.7576, 0.2793, 0.4031],
          [0.7347, 0.0293, 0.7999],
          [0.3971, 0.7544, 0.5695]]],


        [[[0.4388, 0.6387, 0.5247],
          [0.6826, 0.3051, 0.4635],
          [0.4550, 0.5725, 0.4980]]]]), tensor([[0.0000, 0.0000, 0.1980],
        [1.0000, 1.0000, 0.4162]]))
class kornia.augmentation.RandomMotionBlur(kernel_size, angle, direction, border_type='CONSTANT', resample='NEAREST', return_transform=False, same_on_batch=False, p=0.5, keepdim=False)[source]

Perform motion blur on 2D images (4D tensor).

_images/RandomMotionBlur.png
Parameters
  • p (float, optional) – probability of applying the transformation. Default: 0.5

  • kernel_size (Union[int, Tuple[int, int]]) – motion kernel size (odd and positive). If int, the kernel will have a fixed size. If Tuple[int, int], it will randomly generate the value from the range batch-wisely.

  • angle (Union[Tensor, float, Tuple[float, float]]) – angle of the motion blur in degrees (anti-clockwise rotation). If float, it will generate the value from (-angle, angle).

  • direction (Union[Tensor, float, Tuple[float, float]]) – forward/backward direction of the motion blur. Lower values towards -1.0 will point the motion blur towards the back (with angle provided via angle), while higher values towards 1.0 will point the motion blur forward. A value of 0.0 leads to a uniformly (but still angled) motion blur. If float, it will generate the value from (-direction, direction). If Tuple[int, int], it will randomly generate the value from the range.

  • border_type (Union[int, str, BorderType], optional) – the padding mode to be applied before convolving. CONSTANT = 0, REFLECT = 1, REPLICATE = 2, CIRCULAR = 3. Default: 'CONSTANT'

  • resample (Union[str, int, Resample], optional) – the interpolation mode. Default: 'NEAREST'

  • keepdim (bool, optional) – whether to keep the output shape the same as input (True) or broadcast it to the batch form (False). Default: False

Shape:
  • Input: \((C, H, W)\) or \((B, C, H, W)\), Optional: \((B, 3, 3)\)

  • Output: \((B, C, H, W)\)

Note

Input tensor must be float and normalized into [0, 1] for the best differentiability support. Additionally, this function accepts another transformation tensor (\((B, 3, 3)\)), then the applied transformation will be merged int to the input transformation tensor and returned.

Please set resample to 'bilinear' if more meaningful gradients wanted.

Note

This function internally uses kornia.filters.motion_blur().

Examples

>>> rng = torch.manual_seed(0)
>>> input = torch.ones(1, 1, 5, 5)
>>> motion_blur = RandomMotionBlur(3, 35., 0.5, p=1.)
>>> motion_blur(input)
tensor([[[[0.5773, 1.0000, 1.0000, 1.0000, 0.7561],
          [0.5773, 1.0000, 1.0000, 1.0000, 0.7561],
          [0.5773, 1.0000, 1.0000, 1.0000, 0.7561],
          [0.5773, 1.0000, 1.0000, 1.0000, 0.7561],
          [0.5773, 1.0000, 1.0000, 1.0000, 0.7561]]]])
class kornia.augmentation.RandomPerspective(distortion_scale=0.5, resample='BILINEAR', return_transform=False, same_on_batch=False, align_corners=False, p=0.5, keepdim=False)[source]

Apply a random perspective transformation to an image tensor with a given probability.

_images/RandomPerspective.png
Parameters
  • p (float, optional) – probability of the image being perspectively transformed.. Default: 0.5

  • distortion_scale (Union[Tensor, float], optional) – it controls the degree of distortion and ranges from 0 to 1. Default: 0.5

  • resample (Union[str, int, Resample], optional) – the interpolation method to use. Default: 'BILINEAR'

  • return_transform (bool, optional) – if True return the matrix describing the transformation applied to each. Default: False

  • same_on_batch (bool, optional) – apply the same transformation across the batch. Default: False.

  • align_corners (bool, optional) – interpolation flag. Default: False

  • keepdim (bool, optional) – whether to keep the output shape the same as input (True) or broadcast it to the batch form (False). Default: False

Shape:
  • Input: \((C, H, W)\) or \((B, C, H, W)\), Optional: \((B, 3, 3)\)

  • Output: \((B, C, H, W)\)

Note

This function internally uses kornia.geometry.transform.warp_pespective().

Examples

>>> rng = torch.manual_seed(0)
>>> inputs= torch.tensor([[[[1., 0., 0.],
...                         [0., 1., 0.],
...                         [0., 0., 1.]]]])
>>> aug = RandomPerspective(0.5, p=0.5)
>>> out = aug(inputs)
>>> out
tensor([[[[0.0000, 0.2289, 0.0000],
          [0.0000, 0.4800, 0.0000],
          [0.0000, 0.0000, 0.0000]]]])
>>> aug.inverse(out)
tensor([[[[0.0500, 0.0961, 0.0000],
          [0.2011, 0.3144, 0.0000],
          [0.0031, 0.0130, 0.0053]]]])
class kornia.augmentation.RandomPosterize(bits=3, same_on_batch=False, return_transform=False, p=0.5, keepdim=False)[source]

Posterize given tensor image or a batch of tensor images randomly.

_images/RandomPosterize.png
Parameters
  • p (float, optional) – probability of applying the transformation. Default: 0.5

  • bits (Union[int, Tuple[int, int], Tensor], optional) – Integer that ranged from (0, 8], in which 0 gives black image and 8 gives the original. If int x, bits will be generated from (x, 8). If tuple (x, y), bits will be generated from (x, y). Default: 3

  • same_on_batch (bool, optional) – apply the same transformation across the batch. Default: False

  • return_transform (bool, optional) – if True return the matrix describing the transformation applied to each input tensor. If False and the input is a tuple the applied transformation won’t be concatenated. Default: False

  • keepdim (bool, optional) – whether to keep the output shape the same as input (True) or broadcast it to the batch form (False). Default: False

Shape:
  • Input: \((C, H, W)\) or \((B, C, H, W)\), Optional: \((B, 3, 3)\)

  • Output: \((B, C, H, W)\)

Note

This function internally uses kornia.enhance.posterize().

Examples

>>> rng = torch.manual_seed(0)
>>> input = torch.rand(1, 1, 5, 5)
>>> posterize = RandomPosterize(3, p=1.)
>>> posterize(input)
tensor([[[[0.4706, 0.7529, 0.0627, 0.1255, 0.2824],
          [0.6275, 0.4706, 0.8784, 0.4392, 0.6275],
          [0.3451, 0.3765, 0.0000, 0.1569, 0.2824],
          [0.5020, 0.6902, 0.7843, 0.1569, 0.2510],
          [0.6588, 0.9098, 0.3765, 0.8471, 0.4078]]]])
class kornia.augmentation.RandomResizedCrop(size, scale=(0.08, 1.0), ratio=(0.75, 1.3333333333333333), resample='BILINEAR', return_transform=False, same_on_batch=False, align_corners=True, p=1.0, keepdim=False, cropping_mode='slice')[source]

Crop random patches in an image tensor and resizes to a given size.

_images/RandomResizedCrop.png
Parameters
  • size (Tuple[int, int]) – Desired output size (out_h, out_w) of each edge. Must be Tuple[int, int], then out_h = size[0], out_w = size[1].

  • scale (Union[Tensor, Tuple[float, float]], optional) – range of size of the origin size cropped. Default: (0.08, 1.0)

  • ratio (Union[Tensor, Tuple[float, float]], optional) – range of aspect ratio of the origin aspect ratio cropped. Default: (0.75, 1.3333333333333333)

  • resample (Union[str, int, Resample], optional) – the interpolation mode. Default: 'BILINEAR'

  • return_transform (bool, optional) – if True return the matrix describing the transformation applied to each input tensor. If False and the input is a tuple the applied transformation won’t be concatenated. Default: False

  • same_on_batch (bool, optional) – apply the same transformation across the batch. Default: False

  • align_corners (bool, optional) – interpolation flag. Default: True

  • keepdim (bool, optional) – whether to keep the output shape the same as input (True) or broadcast it to the batch form (False). Default: False

  • cropping_mode (str, optional) – The used algorithm to crop. slice will use advanced slicing to extract the tensor based on the sampled indices. resample will use warp_affine using the affine transformation to extract and resize at once. Use slice for efficiency, or resample for proper differentiability. Default: 'slice'

Shape:
  • Input: \((C, H, W)\) or \((B, C, H, W)\), Optional: \((B, 3, 3)\)

  • Output: \((B, C, out_h, out_w)\)

Note

Input tensor must be float and normalized into [0, 1] for the best differentiability support. Additionally, this function accepts another transformation tensor (\((B, 3, 3)\)), then the applied transformation will be merged int to the input transformation tensor and returned.

Example

>>> rng = torch.manual_seed(0)
>>> inputs = torch.tensor([[[0., 1., 2.],
...                         [3., 4., 5.],
...                         [6., 7., 8.]]])
>>> aug = RandomResizedCrop(size=(3, 3), scale=(3., 3.), ratio=(2., 2.), p=1., cropping_mode="resample")
>>> out = aug(inputs)
>>> out
tensor([[[[1.0000, 1.5000, 2.0000],
          [4.0000, 4.5000, 5.0000],
          [7.0000, 7.5000, 8.0000]]]])
>>> aug.inverse(out, padding_mode="border")
tensor([[[[1., 1., 2.],
          [4., 4., 5.],
          [7., 7., 8.]]]])
class kornia.augmentation.RandomRotation(degrees, resample='BILINEAR', return_transform=False, same_on_batch=False, align_corners=True, p=0.5, keepdim=False)[source]

Apply a random rotation to a tensor image or a batch of tensor images given an amount of degrees.

_images/RandomRotation.png
Parameters
  • p (float, optional) – probability of applying the transformation. Default: 0.5

  • degrees (Union[Tensor, float, Tuple[float, float], List[float]]) – range of degrees to select from. If degrees is a number the range of degrees to select from will be (-degrees, +degrees).

  • resample (Union[str, int, Resample], optional) – Default: the interpolation mode.

  • return_transform (bool, optional) – if True return the matrix describing the transformation applied to each input tensor. If False and the input is a tuple the applied transformation won’t be concatenated. Default: False

  • same_on_batch (bool, optional) – apply the same transformation across the batch. Default: False

  • align_corners (bool, optional) – interpolation flag. Default: True

  • keepdim (bool, optional) – whether to keep the output shape the same as input (True) or broadcast it to the batch form (False). Default: False

Shape:
  • Input: \((C, H, W)\) or \((B, C, H, W)\), Optional: \((B, 3, 3)\)

  • Output: \((B, C, H, W)\)

Note

This function internally uses kornia.geometry.transform.affine().

Examples

>>> rng = torch.manual_seed(0)
>>> input = torch.tensor([[1., 0., 0., 2.],
...                       [0., 0., 0., 0.],
...                       [0., 1., 2., 0.],
...                       [0., 0., 1., 2.]])
>>> aug = RandomRotation(degrees=45.0, return_transform=True, p=1.)
>>> out = aug(input)
>>> out
(tensor([[[[0.9824, 0.0088, 0.0000, 1.9649],
          [0.0000, 0.0029, 0.0000, 0.0176],
          [0.0029, 1.0000, 1.9883, 0.0000],
          [0.0000, 0.0088, 1.0117, 1.9649]]]]), tensor([[[ 1.0000, -0.0059,  0.0088],
         [ 0.0059,  1.0000, -0.0088],
         [ 0.0000,  0.0000,  1.0000]]]))
>>> aug.inverse(out)
tensor([[[[9.6526e-01, 8.6823e-03, 1.7263e-02, 1.9305e+00],
          [8.6398e-03, 2.9485e-03, 5.8971e-03, 1.7365e-02],
          [2.9055e-03, 9.9416e-01, 1.9825e+00, 2.3134e-02],
          [2.5777e-05, 1.1640e-02, 9.9992e-01, 1.9392e+00]]]])
class kornia.augmentation.RandomSharpness(sharpness=0.5, same_on_batch=False, return_transform=False, p=0.5, keepdim=False)[source]

Sharpen given tensor image or a batch of tensor images randomly.

_images/RandomSharpness.png
Parameters
  • p (float, optional) – probability of applying the transformation. Default: 0.5

  • sharpness (Union[Tensor, float, Tuple[float, float]], optional) – factor of sharpness strength. Must be above 0. Default: 0.5

  • same_on_batch (bool, optional) – apply the same transformation across the batch. Default: False

  • return_transform (bool, optional) – if True return the matrix describing the transformation applied to each input tensor. If False and the input is a tuple the applied transformation won’t be concatenated. Default: False

  • keepdim (bool, optional) – whether to keep the output shape the same as input (True) or broadcast it to the batch form (False). Default: False

Shape:
  • Input: \((C, H, W)\) or \((B, C, H, W)\), Optional: \((B, 3, 3)\)

  • Output: \((B, C, H, W)\)

Note

This function internally uses kornia.enhance.sharpness().

Examples

>>> rng = torch.manual_seed(0)
>>> input = torch.rand(1, 1, 5, 5)
>>> sharpness = RandomSharpness(1., p=1.)
>>> sharpness(input)
tensor([[[[0.4963, 0.7682, 0.0885, 0.1320, 0.3074],
          [0.6341, 0.4810, 0.7367, 0.4177, 0.6323],
          [0.3489, 0.4428, 0.1562, 0.2443, 0.2939],
          [0.5185, 0.6462, 0.7050, 0.2288, 0.2823],
          [0.6816, 0.9152, 0.3971, 0.8742, 0.4194]]]])
class kornia.augmentation.RandomSolarize(thresholds=0.1, additions=0.1, same_on_batch=False, return_transform=False, p=0.5, keepdim=False)[source]

Solarize given tensor image or a batch of tensor images randomly.

_images/RandomSolarize.png
Parameters
  • p (float, optional) – probability of applying the transformation. Default: 0.5

  • thresholds (Union[Tensor, float, Tuple[float, float], List[float]], optional) – If float x, threshold will be generated from (0.5 - x, 0.5 + x). If tuple (x, y), threshold will be generated from (x, y). Default: 0.1

  • additions (Union[Tensor, float, Tuple[float, float], List[float]], optional) – If float x, addition will be generated from (-x, x). If tuple (x, y), addition will be generated from (x, y). Default: 0.1

  • same_on_batch (bool, optional) – apply the same transformation across the batch. Default: False

  • return_transform (bool, optional) – if True return the matrix describing the transformation applied to each input tensor. If False and the input is a tuple the applied transformation won’t be concatenated. Default: False

  • keepdim (bool, optional) – whether to keep the output shape the same as input (True) or broadcast it to the batch form (False). Default: False

Shape:
  • Input: \((C, H, W)\) or \((B, C, H, W)\), Optional: \((B, 3, 3)\)

  • Output: \((B, C, H, W)\)

Note

This function internally uses kornia.enhance.solarize().

Examples

>>> rng = torch.manual_seed(0)
>>> input = torch.rand(1, 1, 5, 5)
>>> solarize = RandomSolarize(0.1, 0.1, p=1.)
>>> solarize(input)
tensor([[[[0.4132, 0.1412, 0.1790, 0.2226, 0.3980],
          [0.2754, 0.4194, 0.0130, 0.4538, 0.2771],
          [0.4394, 0.4923, 0.1129, 0.2594, 0.3844],
          [0.3909, 0.2118, 0.1094, 0.2516, 0.3728],
          [0.2278, 0.0000, 0.4876, 0.0353, 0.5100]]]])
class kornia.augmentation.RandomVerticalFlip(return_transform=None, same_on_batch=False, p=0.5, p_batch=1.0, keepdim=False)[source]

Apply a random vertical flip to a tensor image or a batch of tensor images with a given probability.

_images/RandomVerticalFlip.png
Parameters
  • p (float, optional) – probability of the image being flipped. Default: 0.5

  • return_transform (Optional[bool], optional) – if True return the matrix describing the transformation applied to each input tensor. If False and the input is a tuple the applied transformation won’t be concatenated. Default: None

  • same_on_batch (bool, optional) – apply the same transformation across the batch. Default: False

  • keepdim (bool, optional) – whether to keep the output shape the same as input (True) or broadcast it to the batch form (False). Default: False

Shape:
  • Input: \((C, H, W)\) or \((B, C, H, W)\), Optional: \((B, 3, 3)\)

  • Output: \((B, C, H, W)\)

Note

This function internally uses kornia.geometry.transform.vflip().

Examples

>>> input = torch.tensor([[[[0., 0., 0.],
...                         [0., 0., 0.],
...                         [0., 1., 1.]]]])
>>> seq = RandomVerticalFlip(p=1.0, return_transform=True)
>>> seq(input)
(tensor([[[[0., 1., 1.],
          [0., 0., 0.],
          [0., 0., 0.]]]]), tensor([[[ 1.,  0.,  0.],
         [ 0., -1.,  2.],
         [ 0.,  0.,  1.]]]))
>>> seq.inverse(seq(input)).equal(input)
True
class kornia.augmentation.RandomThinPlateSpline(scale=0.2, align_corners=False, return_transform=False, same_on_batch=False, p=0.5)[source]

Add random noise to the Thin Plate Spline algorithm.

_images/RandomThinPlateSpline.png
Parameters
  • scale (float, optional) – the scale factor to apply to the destination points. Default: 0.2

  • align_corners (bool, optional) – Interpolation flag used by grid_sample. Default: False

  • mode – Interpolation mode used by grid_sample. Either ‘bilinear’ or ‘nearest’.

  • return_transform (bool, optional) – if True return the matrix describing the transformation applied to each input tensor. If False and the input is a tuple the applied transformation won’t be concatenated. Default: False

  • same_on_batch (bool, optional) – apply the same transformation across the batch. Default: False

  • p (float, optional) – probability of applying the transformation. Default: 0.5

Note

This function internally uses kornia.geometry.transform.warp_image_tps().

Examples

>>> img = torch.ones(1, 1, 2, 2)
>>> out = RandomThinPlateSpline()(img)
>>> out.shape
torch.Size([1, 1, 2, 2])

Transforms3D

Set of operators to perform data augmentation on 3D volumetric tensors.

class kornia.augmentation.RandomDepthicalFlip3D(return_transform=False, same_on_batch=False, p=0.5, keepdim=False)[source]

Apply random flip along the depth axis of 3D volumes (5D tensor).

Input should be a tensor of shape \((C, D, H, W)\) or a batch of tensors \((*, C, D, H, W)\). If Input is a tuple it is assumed that the first element contains the aforementioned tensors and the second, the corresponding transformation matrix that has been applied to them. In this case the module will Depthically flip the tensors and concatenate the corresponding transformation matrix to the previous one. This is especially useful when using this functionality as part of an nn.Sequential module.

Parameters
  • p (float, optional) – probability of the image being flipped. Default: 0.5

  • return_transform (bool, optional) – if True return the matrix describing the transformation applied to each input tensor. If False and the input is a tuple the applied transformation won’t be concatenated. Default: False

  • same_on_batch (bool, optional) – apply the same transformation across the batch. Default: False

  • keepdim (bool, optional) – whether to keep the output shape the same as input True or broadcast it to the batch form False. Default: False

Shape:
  • Input: \((C, D, H, W)\) or \((B, C, D, H, W)\), Optional: \((B, 4, 4)\)

  • Output: \((B, C, D, H, W)\)

Note

Input tensor must be float and normalized into [0, 1] for the best differentiability support. Additionally, this function accepts another transformation tensor (\((B, 4, 4)\)), then the applied transformation will be merged int to the input transformation tensor and returned.

Examples

>>> x = torch.eye(3).repeat(3, 1, 1)
>>> seq = RandomDepthicalFlip3D(p=1.0, return_transform=True)
>>> seq(x)
(tensor([[[[[1., 0., 0.],
           [0., 1., 0.],
           [0., 0., 1.]],

          [[1., 0., 0.],
           [0., 1., 0.],
           [0., 0., 1.]],

          [[1., 0., 0.],
           [0., 1., 0.],
           [0., 0., 1.]]]]]), tensor([[[ 1.,  0.,  0.,  0.],
         [ 0.,  1.,  0.,  0.],
         [ 0.,  0., -1.,  2.],
         [ 0.,  0.,  0.,  1.]]]))
class kornia.augmentation.RandomHorizontalFlip3D(return_transform=False, same_on_batch=False, p=0.5, keepdim=False)[source]

Apply random horizontal flip to 3D volumes (5D tensor).

Parameters
  • p (float, optional) – probability of the image being flipped. Default: 0.5

  • return_transform (bool, optional) – if True return the matrix describing the transformation applied to each input tensor. If False and the input is a tuple the applied transformation won’t be concatenated. Default: False

  • same_on_batch (bool, optional) – apply the same transformation across the batch. Default: False

  • keepdim (bool, optional) – whether to keep the output shape the same as input True or broadcast it to the batch form False. Default: False

Shape:
  • Input: \((C, D, H, W)\) or \((B, C, D, H, W)\), Optional: \((B, 4, 4)\)

  • Output: \((B, C, D, H, W)\)

Note

Input tensor must be float and normalized into [0, 1] for the best differentiability support. Additionally, this function accepts another transformation tensor (\((B, 4, 4)\)), then the applied transformation will be merged int to the input transformation tensor and returned.

Examples

>>> x = torch.eye(3).repeat(3, 1, 1)
>>> seq = RandomHorizontalFlip3D(p=1.0, return_transform=True)
>>> seq(x)
(tensor([[[[[0., 0., 1.],
           [0., 1., 0.],
           [1., 0., 0.]],

          [[0., 0., 1.],
           [0., 1., 0.],
           [1., 0., 0.]],

          [[0., 0., 1.],
           [0., 1., 0.],
           [1., 0., 0.]]]]]), tensor([[[-1.,  0.,  0.,  2.],
         [ 0.,  1.,  0.,  0.],
         [ 0.,  0.,  1.,  0.],
         [ 0.,  0.,  0.,  1.]]]))
class kornia.augmentation.RandomVerticalFlip3D(return_transform=False, same_on_batch=False, p=0.5, keepdim=False)[source]

Apply random vertical flip to 3D volumes (5D tensor).

Input should be a tensor of shape \((C, D, H, W)\) or a batch of tensors \((*, C, D, H, W)\). If Input is a tuple it is assumed that the first element contains the aforementioned tensors and the second, the corresponding transformation matrix that has been applied to them. In this case the module will Vertically flip the tensors and concatenate the corresponding transformation matrix to the previous one. This is especially useful when using this functionality as part of an nn.Sequential module.

Parameters
  • p (float, optional) – probability of the image being flipped. Default: 0.5

  • return_transform (bool, optional) – if True return the matrix describing the transformation applied to each input tensor. If False and the input is a tuple the applied transformation won’t be concatenated. Default: False

  • same_on_batch (bool, optional) – apply the same transformation across the batch. Default: False

  • keepdim (bool, optional) – whether to keep the output shape the same as input True or broadcast it to the batch form False. Default: False

Shape:
  • Input: \((C, D, H, W)\) or \((B, C, D, H, W)\), Optional: \((B, 4, 4)\)

  • Output: \((B, C, D, H, W)\)

Note

Input tensor must be float and normalized into [0, 1] for the best differentiability support. Additionally, this function accepts another transformation tensor (\((B, 4, 4)\)), then the applied transformation will be merged int to the input transformation tensor and returned.

Examples

>>> x = torch.eye(3).repeat(3, 1, 1)
>>> seq = RandomVerticalFlip3D(p=1.0, return_transform=True)
>>> seq(x)
(tensor([[[[[0., 0., 1.],
           [0., 1., 0.],
           [1., 0., 0.]],

          [[0., 0., 1.],
           [0., 1., 0.],
           [1., 0., 0.]],

          [[0., 0., 1.],
           [0., 1., 0.],
           [1., 0., 0.]]]]]), tensor([[[ 1.,  0.,  0.,  0.],
         [ 0., -1.,  0.,  2.],
         [ 0.,  0.,  1.,  0.],
         [ 0.,  0.,  0.,  1.]]]))
class kornia.augmentation.RandomRotation3D(degrees, resample='BILINEAR', return_transform=False, same_on_batch=False, align_corners=False, p=0.5, keepdim=False)[source]

Apply random rotations to 3D volumes (5D tensor).

Input should be a tensor of shape (C, D, H, W) or a batch of tensors \((B, C, D, H, W)\). If Input is a tuple it is assumed that the first element contains the aforementioned tensors and the second, the corresponding transformation matrix that has been applied to them. In this case the module will rotate the tensors and concatenate the corresponding transformation matrix to the previous one. This is especially useful when using this functionality as part of an nn.Sequential module.

Parameters
  • degrees (Union[Tensor, float, Tuple[float, float, float], Tuple[Tuple[float, float], Tuple[float, float], Tuple[float, float]]]) – Range of degrees to select from. If degrees is a number, then yaw, pitch, roll will be generated from the range of (-degrees, +degrees). If degrees is a tuple of (min, max), then yaw, pitch, roll will be generated from the range of (min, max). If degrees is a list of floats [a, b, c], then yaw, pitch, roll will be generated from (-a, a), (-b, b) and (-c, c). If degrees is a list of tuple ((a, b), (m, n), (x, y)), then yaw, pitch, roll will be generated from (a, b), (m, n) and (x, y). Set to 0 to deactivate rotations.

  • resample (Union[str, int, Resample], optional) – Default: 'BILINEAR'

  • return_transform (bool, optional) – if True return the matrix describing the transformation applied to each input tensor. If False and the input is a tuple the applied transformation won’t be concatenated. Default: False

  • same_on_batch (bool, optional) – apply the same transformation across the batch. Default: False

  • align_corners (bool, optional) – interpolation flag. Default: False

  • keepdim (bool, optional) – whether to keep the output shape the same as input (True) or broadcast it to the batch form (False). Default: False

Shape:
  • Input: \((C, D, H, W)\) or \((B, C, D, H, W)\), Optional: \((B, 4, 4)\)

  • Output: \((B, C, D, H, W)\)

Note

Input tensor must be float and normalized into [0, 1] for the best differentiability support. Additionally, this function accepts another transformation tensor (\((B, 4, 4)\)), then the applied transformation will be merged int to the input transformation tensor and returned.

Examples

>>> rng = torch.manual_seed(0)
>>> input = torch.rand(1, 1, 3, 3, 3)
>>> aug = RandomRotation3D((15., 20., 20.), p=1.0, return_transform=True)
>>> aug(input)
(tensor([[[[[0.3819, 0.4886, 0.2111],
           [0.1196, 0.3833, 0.4722],
           [0.3432, 0.5951, 0.4223]],

          [[0.5553, 0.4374, 0.2780],
           [0.2423, 0.1689, 0.4009],
           [0.4516, 0.6376, 0.7327]],

          [[0.1605, 0.3112, 0.3673],
           [0.4931, 0.4620, 0.5700],
           [0.3505, 0.4685, 0.8092]]]]]), tensor([[[ 0.9722,  0.1131, -0.2049,  0.1196],
         [-0.0603,  0.9669,  0.2478, -0.1545],
         [ 0.2262, -0.2286,  0.9469,  0.0556],
         [ 0.0000,  0.0000,  0.0000,  1.0000]]]))
class kornia.augmentation.RandomAffine3D(degrees, translate=None, scale=None, shears=None, resample='BILINEAR', return_transform=False, same_on_batch=False, align_corners=False, p=0.5, keepdim=False)[source]

Apply affine transformation 3D volumes (5D tensor).

The transformation is computed so that the center is kept invariant.

Parameters
  • degrees (Union[Tensor, float, Tuple[float, float], Tuple[float, float, float], Tuple[Tuple[float, float], Tuple[float, float], Tuple[float, float]]]) – Range of yaw (x-axis), pitch (y-axis), roll (z-axis) to select from. If degrees is a number, then yaw, pitch, roll will be generated from the range of (-degrees, +degrees). If degrees is a tuple of (min, max), then yaw, pitch, roll will be generated from the range of (min, max). If degrees is a list of floats [a, b, c], then yaw, pitch, roll will be generated from (-a, a), (-b, b) and (-c, c). If degrees is a list of tuple ((a, b), (m, n), (x, y)), then yaw, pitch, roll will be generated from (a, b), (m, n) and (x, y). Set to 0 to deactivate rotations.

  • translate (Union[Tensor, Tuple[float, float, float], None], optional) – tuple of maximum absolute fraction for horizontal, vertical and Default: None

  • translations (depthical) – horizontal shift will be randomly sampled in the range -img_width * a < dx < img_width * a vertical shift will be randomly sampled in the range -img_height * b < dy < img_height * b. depthical shift will be randomly sampled in the range -img_depth * c < dz < img_depth * c. Will not translate by default.

  • scale (Union[Tensor, Tuple[float, float], Tuple[Tuple[float, float], Tuple[float, float], Tuple[float, float]], None], optional) – scaling factor interval. If (a, b) represents isotropic scaling, the scale is randomly sampled from the range a <= scale <= b. If ((a, b), (c, d), (e, f)), the scale is randomly sampled from the range a <= scale_x <= b, c <= scale_y <= d, e <= scale_z <= f. Will keep original scale by default. Default: None

  • shears (Union[Tensor, float, Tuple[float, float], Tuple[float, float, float, float, float, float], Tuple[Tuple[float, float], Tuple[float, float], Tuple[float, float], Tuple[float, float], Tuple[float, float], Tuple[float, float]], None], optional) – Range of degrees to select from. If shear is a number, a shear to the 6 facets in the range (-shear, +shear) will be applied. If shear is a tuple of 2 values, a shear to the 6 facets in the range (shear[0], shear[1]) will be applied. If shear is a tuple of 6 values, a shear to the i-th facet in the range (-shear[i], shear[i]) will be applied. If shear is a tuple of 6 tuples, a shear to the i-th facet in the range (-shear[i, 0], shear[i, 1]) will be applied. Default: None

  • resample (Union[str, int, Resample], optional) – Default: 'BILINEAR'

  • return_transform (bool, optional) – if True return the matrix describing the transformation applied to each. Default: False

  • same_on_batch (bool, optional) – apply the same transformation across the batch. Default: False

  • align_corners (bool, optional) – interpolation flag. Default: False

  • keepdim (bool, optional) – whether to keep the output shape the same as input (True) or broadcast it to the batch form (False). Default: False.

Shape:
  • Input: \((C, D, H, W)\) or \((B, C, D, H, W)\), Optional: \((B, 4, 4)\)

  • Output: \((B, C, D, H, W)\)

Note

Input tensor must be float and normalized into [0, 1] for the best differentiability support. Additionally, this function accepts another transformation tensor (\((B, 4, 4)\)), then the applied transformation will be merged int to the input transformation tensor and returned.

Examples

>>> rng = torch.manual_seed(0)
>>> input = torch.rand(1, 1, 3, 3, 3)
>>> aug = RandomAffine3D((15., 20., 20.), p=1., return_transform=True)
>>> aug(input)
(tensor([[[[[0.4503, 0.4763, 0.1680],
           [0.2029, 0.4267, 0.3515],
           [0.3195, 0.5436, 0.3706]],

          [[0.5255, 0.3508, 0.4858],
           [0.0795, 0.1689, 0.4220],
           [0.5306, 0.7234, 0.6879]],

          [[0.2971, 0.2746, 0.3471],
           [0.4924, 0.4960, 0.6460],
           [0.3187, 0.4556, 0.7596]]]]]), tensor([[[ 0.9722, -0.0603,  0.2262, -0.1381],
         [ 0.1131,  0.9669, -0.2286,  0.1486],
         [-0.2049,  0.2478,  0.9469,  0.0102],
         [ 0.0000,  0.0000,  0.0000,  1.0000]]]))
class kornia.augmentation.RandomCrop3D(size, padding=None, pad_if_needed=False, fill=0, padding_mode='constant', resample='BILINEAR', return_transform=False, same_on_batch=False, align_corners=True, p=1.0, keepdim=False)[source]

Apply random crop on 3D volumes (5D tensor).

Crops random sub-volumes on a given size.

Parameters
  • p (float, optional) – probability of applying the transformation for the whole batch. Default: 1.0

  • size (Tuple[int, int, int]) – Desired output size (out_d, out_h, out_w) of the crop. Must be Tuple[int, int, int], then out_d = size[0], out_h = size[1], out_w = size[2].

  • padding (Union[int, Tuple[int, int, int], Tuple[int, int, int, int, int, int], None], optional) – Optional padding on each border of the image. Default is None, i.e no padding. If a sequence of length 6 is provided, it is used to pad left, top, right, bottom, front, back borders respectively. If a sequence of length 3 is provided, it is used to pad left/right, top/bottom, front/back borders, respectively. Default: None

  • pad_if_needed (Optional[bool], optional) – It will pad the image if smaller than the desired size to avoid raising an exception. Since cropping is done after padding, the padding seems to be done at a random offset. Default: False

  • fill (int, optional) – Pixel fill value for constant fill. Default is 0. If a tuple of length 3, it is used to fill R, G, B channels respectively. This value is only used when the padding_mode is constant. Default: 0

  • padding_mode (str, optional) – Type of padding. Should be: constant, edge, reflect or symmetric. Default is constant. Default: 'constant'

  • resample (Union[str, int, Resample], optional) – Default: 'BILINEAR'

  • return_transform (bool, optional) – if True return the matrix describing the transformation applied to each input tensor. If False and the input is a tuple the applied transformation won’t be concatenated Default: False

  • same_on_batch (bool, optional) – apply the same transformation across the batch. Default: False

  • align_corners (bool, optional) – interpolation flag. Default: True

  • keepdim (bool, optional) – whether to keep the output shape the same as input (True) or broadcast it to the batch form (False). Default: False

Shape:
  • Input: \((C, D, H, W)\) or \((B, C, D, H, W)\), Optional: \((B, 4, 4)\)

  • Output: \((B, C, , out_d, out_h, out_w)\)

Note

Input tensor must be float and normalized into [0, 1] for the best differentiability support. Additionally, this function accepts another transformation tensor (\((B, 4, 4)\)), then the applied transformation will be merged int to the input transformation tensor and returned.

Examples

>>> rng = torch.manual_seed(0)
>>> inputs = torch.randn(1, 1, 3, 3, 3)
>>> aug = RandomCrop3D((2, 2, 2), p=1.)
>>> aug(inputs)
tensor([[[[[-1.1258, -1.1524],
           [-0.4339,  0.8487]],

          [[-1.2633,  0.3500],
           [ 0.1665,  0.8744]]]]])
class kornia.augmentation.CenterCrop3D(size, align_corners=True, resample='BILINEAR', return_transform=False, p=1.0, keepdim=False)[source]

Apply center crop on 3D volumes (5D tensor).

Parameters
  • p (float, optional) – probability of applying the transformation for the whole batch. Default: 1.0

  • size (Tuple[int, int, int] or int) – Desired output size (out_d, out_h, out_w) of the crop. If integer, out_d = out_h = out_w = size. If Tuple[int, int, int], out_d = size[0], out_h = size[1], out_w = size[2].

  • resample (Union[str, int, Resample], optional) – Default: 'BILINEAR'

  • return_transform (bool, optional) – if True return the matrix describing the transformation applied to each input tensor. If False and the input is a tuple the applied transformation won’t be concatenated. Default: False

  • align_corners (bool, optional) – interpolation flag. Default: True

  • keepdim (bool, optional) – whether to keep the output shape the same as input (True) or broadcast it to the batch form (False). Default: False

Shape:
  • Input: \((C, D, H, W)\) or \((B, C, D, H, W)\), Optional: \((B, 4, 4)\)

  • Output: \((B, C, out_d, out_h, out_w)\)

Note

Input tensor must be float and normalized into [0, 1] for the best differentiability support. Additionally, this function accepts another transformation tensor (\((B, 4, 4)\)), then the applied transformation will be merged int to the input transformation tensor and returned.

Examples

>>> rng = torch.manual_seed(0)
>>> inputs = torch.randn(1, 1, 2, 4, 6)
>>> inputs
tensor([[[[[-1.1258, -1.1524, -0.2506, -0.4339,  0.8487,  0.6920],
           [-0.3160, -2.1152,  0.3223, -1.2633,  0.3500,  0.3081],
           [ 0.1198,  1.2377,  1.1168, -0.2473, -1.3527, -1.6959],
           [ 0.5667,  0.7935,  0.5988, -1.5551, -0.3414,  1.8530]],

          [[ 0.7502, -0.5855, -0.1734,  0.1835,  1.3894,  1.5863],
           [ 0.9463, -0.8437, -0.6136,  0.0316, -0.4927,  0.2484],
           [ 0.4397,  0.1124,  0.6408,  0.4412, -0.1023,  0.7924],
           [-0.2897,  0.0525,  0.5229,  2.3022, -1.4689, -1.5867]]]]])
>>> aug = CenterCrop3D(2, p=1.)
>>> aug(inputs)
tensor([[[[[ 0.3223, -1.2633],
           [ 1.1168, -0.2473]],

          [[-0.6136,  0.0316],
           [ 0.6408,  0.4412]]]]])
class kornia.augmentation.RandomMotionBlur3D(kernel_size, angle, direction, border_type='CONSTANT', resample='NEAREST', return_transform=False, same_on_batch=False, p=0.5, keepdim=False)[source]

Apply random motion blur on 3D volumes (5D tensor).

Parameters
  • p (float, optional) – probability of applying the transformation. Default: 0.5

  • kernel_size (Union[int, Tuple[int, int]]) – motion kernel size (odd and positive). If int, the kernel will have a fixed size. If Tuple[int, int], it will randomly generate the value from the range batch-wisely.

  • angle (Union[Tensor, float, Tuple[float, float, float], Tuple[Tuple[float, float], Tuple[float, float], Tuple[float, float]]]) – Range of degrees to select from. If angle is a number, then yaw, pitch, roll will be generated from the range of (-angle, +angle). If angle is a tuple of (min, max), then yaw, pitch, roll will be generated from the range of (min, max). If angle is a list of floats [a, b, c], then yaw, pitch, roll will be generated from (-a, a), (-b, b) and (-c, c). If angle is a list of tuple ((a, b), (m, n), (x, y)), then yaw, pitch, roll will be generated from (a, b), (m, n) and (x, y). Set to 0 to deactivate rotations.

  • direction (Union[Tensor, float, Tuple[float, float]]) – forward/backward direction of the motion blur. Lower values towards -1.0 will point the motion blur towards the back (with angle provided via angle), while higher values towards 1.0 will point the motion blur forward. A value of 0.0 leads to a uniformly (but still angled) motion blur. If float, it will generate the value from (-direction, direction). If Tuple[int, int], it will randomly generate the value from the range.

  • border_type (Union[int, str, BorderType], optional) – the padding mode to be applied before convolving. CONSTANT = 0, REFLECT = 1, REPLICATE = 2, CIRCULAR = 3. Default: BorderType.CONSTANT.

  • resample (Union[str, int, Resample], optional) – resample mode from “nearest” (0) or “bilinear” (1). Default: 'NEAREST'

  • keepdim (bool, optional) – whether to keep the output shape the same as input (True) or broadcast it to the batch form (False). Default: False

Shape:
  • Input: \((C, D, H, W)\) or \((B, C, D, H, W)\), Optional: \((B, 4, 4)\)

  • Output: \((B, C, D, H, W)\)

Note

Input tensor must be float and normalized into [0, 1] for the best differentiability support. Additionally, this function accepts another transformation tensor (\((B, 4, 4)\)), then the applied transformation will be merged int to the input transformation tensor and returned.

Examples

>>> rng = torch.manual_seed(0)
>>> input = torch.rand(1, 1, 3, 5, 5)
>>> motion_blur = RandomMotionBlur3D(3, 35., 0.5, p=1.)
>>> motion_blur(input)
tensor([[[[[0.1654, 0.4772, 0.2004, 0.3566, 0.2613],
           [0.4557, 0.3131, 0.4809, 0.2574, 0.2696],
           [0.2721, 0.5998, 0.3956, 0.5363, 0.1541],
           [0.3006, 0.4773, 0.6395, 0.2856, 0.3989],
           [0.4491, 0.5595, 0.1836, 0.3811, 0.1398]],

          [[0.1843, 0.4240, 0.3370, 0.1231, 0.2186],
           [0.4047, 0.3332, 0.1901, 0.5329, 0.3023],
           [0.3070, 0.3088, 0.4807, 0.4928, 0.2590],
           [0.2416, 0.4614, 0.7091, 0.5237, 0.1433],
           [0.1582, 0.4577, 0.2749, 0.1369, 0.1607]],

          [[0.2733, 0.4040, 0.4396, 0.2284, 0.3319],
           [0.3856, 0.6730, 0.4624, 0.3878, 0.3076],
           [0.4307, 0.4217, 0.2977, 0.5086, 0.5406],
           [0.3686, 0.2778, 0.5228, 0.7592, 0.6455],
           [0.2033, 0.3014, 0.4898, 0.6164, 0.3117]]]]])
class kornia.augmentation.RandomEqualize3D(p=0.5, return_transform=False, same_on_batch=False, keepdim=False)[source]

Apply random equalization to 3D volumes (5D tensor).

Parameters
  • p (float, optional) – probability of the image being equalized. Default: 0.5

  • return_transform (bool, optional) – if True return the matrix describing the transformation applied to each input tensor. If False and the input is a tuple the applied transformation won’t be concatenated. Default: False

  • same_on_batch) – apply the same transformation across the batch.

  • keepdim (bool, optional) – whether to keep the output shape the same as input (True) or broadcast it to the batch form (False). Default: False

Shape:
  • Input: \((C, D, H, W)\) or \((B, C, D, H, W)\), Optional: \((B, 4, 4)\)

  • Output: \((B, C, D, H, W)\)

Note

Input tensor must be float and normalized into [0, 1] for the best differentiability support. Additionally, this function accepts another transformation tensor (\((B, 4, 4)\)), then the applied transformation will be merged int to the input transformation tensor and returned.

Examples

>>> rng = torch.manual_seed(0)
>>> input = torch.rand(1, 1, 3, 3, 3)
>>> aug = RandomEqualize3D(p=1.0)
>>> aug(input)
tensor([[[[[0.4963, 0.7682, 0.0885],
           [0.1320, 0.3074, 0.6341],
           [0.4901, 0.8964, 0.4556]],

          [[0.6323, 0.3489, 0.4017],
           [0.0223, 0.1689, 0.2939],
           [0.5185, 0.6977, 0.8000]],

          [[0.1610, 0.2823, 0.6816],
           [0.9152, 0.3971, 0.8742],
           [0.4194, 0.5529, 0.9527]]]]])

Normalizations

Normalization operations are shape-agnostic for both 2D and 3D tensors.

class kornia.augmentation.Denormalize(mean, std, return_transform=False, p=1.0, keepdim=False)[source]

Denormalize tensor images with mean and standard deviation.

\[\text{input[channel] = (input[channel] * std[channel]) + mean[channel]}\]

Where mean is \((M_1, ..., M_n)\) and std \((S_1, ..., S_n)\) for n channels,

Parameters
  • mean (Tensor) – Mean for each channel.

  • std (Tensor) – Standard deviations for each channel.

Returns

Denormalised tensor with same size as input \((*, C, H, W)\).

Note

This function internally uses kornia.enhance.denormalize().

Examples

>>> norm = Denormalize(mean=torch.zeros(1, 4), std=torch.ones(1, 4))
>>> x = torch.rand(1, 4, 3, 3)
>>> out = norm(x)
>>> out.shape
torch.Size([1, 4, 3, 3])
class kornia.augmentation.Normalize(mean, std, return_transform=False, p=1.0, keepdim=False)[source]

Normalize tensor images with mean and standard deviation.

\[\text{input[channel] = (input[channel] - mean[channel]) / std[channel]}\]

Where mean is \((M_1, ..., M_n)\) and std \((S_1, ..., S_n)\) for n channels,

Parameters
Returns

Normalised tensor with same size as input \((*, C, H, W)\).

Note

This function internally uses kornia.enhance.normalize().

Examples

>>> norm = Normalize(mean=torch.zeros(4), std=torch.ones(4))
>>> x = torch.rand(1, 4, 3, 3)
>>> out = norm(x)
>>> out.shape
torch.Size([1, 4, 3, 3])