# Image Augmentations#

## Transforms2D#

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

### Intensity#

class kornia.augmentation.RandomPlanckianJitter(mode='blackbody', select_from=None, same_on_batch=False, p=0.5, keepdim=False, return_transform=None)[source]#

Apply planckian jitter transformation to input tensor.

This is physics based color augmentation, that creates realistic variations in chromaticity, this can simulate the illumination changes in the scene.

See [ZBTvdW22] for more details.

Parameters
Shape:
• Input: $$(C, H, W)$$ or $$(B, C, H, W)$$

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

Note

Input tensor must be float and normalized into [0, 1].

Examples

To apply planckian jitter based on mode

>>> rng = torch.manual_seed(0)
>>> input = torch.randn(1, 3, 2, 2)
>>> aug = RandomPlanckianJitter(mode='CIED')
>>> aug(input)
tensor([[[[ 1.0000, -0.2389],
[-1.7740,  0.4628]],

[[-1.0845, -1.3986],
[ 0.4033,  0.8380]],

[[-0.9228, -0.5175],
[-0.7654,  0.2335]]]])


To apply planckian jitter on image(s) from list of interested jitters

>>> rng = torch.manual_seed(0)
>>> input = torch.randn(2, 3, 2, 2)
>>> aug = RandomPlanckianJitter(mode='blackbody', select_from=[23, 24, 1, 2])
>>> aug(input)
tensor([[[[-1.1258, -1.1524],
[-0.2506, -0.4339]],

[[ 0.8487,  0.6920],
[-0.3160, -2.1152]],

[[ 0.4681, -0.1577],
[ 1.4437,  0.2660]]],

[[[ 0.2465,  1.0000],
[-0.2125, -0.1653]],

[[ 0.9318,  1.0000],
[ 1.0000,  0.0537]],

[[ 0.2426, -0.1621],
[-0.3302, -0.9093]]]])


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

This is based on the original paper: TorMentor: Deterministic dynamic-path, data augmentations with fractals. See: [NCR+22] for more details.

Note

This function internally uses kornia.contrib.diamond_square().

Parameters

Examples

>>> rng = torch.manual_seed(0)
>>> img = torch.ones(1, 1, 3, 4)
tensor([[[[0.7682, 1.0000, 1.0000, 1.0000],
[1.0000, 1.0000, 1.0000, 1.0000],
[1.0000, 1.0000, 1.0000, 1.0000]]]])

class kornia.augmentation.RandomPlasmaBrightness(roughness=(0.1, 0.7), intensity=(0.0, 1.0), same_on_batch=False, p=0.5, keepdim=False, return_transform=None)[source]#

Adds brightness to the image based on a fractal map generated by the diamond square algorithm.

This is based on the original paper: TorMentor: Deterministic dynamic-path, data augmentations with fractals. See: [NCR+22] for more details.

Note

This function internally uses kornia.contrib.diamond_square().

Parameters

Examples

>>> rng = torch.manual_seed(0)
>>> img = torch.ones(1, 1, 3, 4)
>>> RandomPlasmaBrightness(roughness=(0.1, 0.7), p=1.)(img)
tensor([[[[0.6415, 1.0000, 0.3142, 0.6836],
[1.0000, 0.5593, 0.5556, 0.4566],
[0.5809, 1.0000, 0.7005, 1.0000]]]])

class kornia.augmentation.RandomPlasmaContrast(roughness=(0.1, 0.7), same_on_batch=False, p=0.5, keepdim=False, return_transform=None)[source]#

Adds contrast to the image based on a fractal map generated by the diamond square algorithm.

This is based on the original paper: TorMentor: Deterministic dynamic-path, data augmentations with fractals. See: [NCR+22] for more details.

Note

This function internally uses kornia.contrib.diamond_square().

Parameters
• roughness (Tuple[float, float], optional) – value to scale during the recursion in the generation of the fractal map. Default: (0.1, 0.7)

• 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

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

Examples

>>> rng = torch.manual_seed(0)
>>> img = torch.ones(1, 1, 3, 4)
>>> RandomPlasmaContrast(roughness=(0.1, 0.7), p=1.)(img)
tensor([[[[0.9651, 1.0000, 1.0000, 1.0000],
[1.0000, 0.9103, 0.8038, 0.9263],
[0.6882, 1.0000, 0.9544, 1.0000]]]])

class kornia.augmentation.ColorJiggle(brightness=0.0, contrast=0.0, saturation=0.0, hue=0.0, same_on_batch=False, p=1.0, keepdim=False, return_transform=None)[source]#

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

Parameters
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 = ColorJiggle(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]]]])

To apply the exact augmenation again, you may take the advantage of the previous parameter state:
>>> input = torch.randn(1, 3, 32, 32)
>>> aug = ColorJiggle(0.1, 0.1, 0.1, 0.1, p=1.)
>>> (aug(input) == aug(input, params=aug._params)).all()
tensor(True)

class kornia.augmentation.ColorJitter(brightness=0.0, contrast=0.0, saturation=0.0, hue=0.0, same_on_batch=False, p=1.0, keepdim=False, return_transform=None, silence_instantiation_warning=False)[source]#

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

This implementation aligns PIL. Hence, the output is close to TorchVision.

Parameters
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.adjust_brightness_accumulative(), kornia.enhance.adjust_contrast_with_mean_subtraction(), kornia.enhance.adjust_saturation_with_gray_subtraction(), kornia.enhance.adjust_hue().

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]]]])

To apply the exact augmenation again, you may take the advantage of the previous parameter state:
>>> input = torch.randn(1, 3, 32, 32)
>>> aug = ColorJitter(0.1, 0.1, 0.1, 0.1, p=1.)
>>> (aug(input) == aug(input, params=aug._params)).all()
tensor(True)

class kornia.augmentation.RandomBoxBlur(kernel_size=(3, 3), border_type='reflect', normalized=True, same_on_batch=False, p=0.5, keepdim=False, return_transform=None)[source]#

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

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

• 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

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

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])

To apply the exact augmenation again, you may take the advantage of the previous parameter state:
>>> input = torch.randn(1, 3, 32, 32)
>>> aug = RandomBoxBlur((7, 7), p=1.)
>>> (aug(input) == aug(input, params=aug._params)).all()
tensor(True)

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

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

Parameters
• 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

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

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.]]]])

To apply the exact augmenation again, you may take the advantage of the previous parameter state:
>>> input = torch.randn(1, 3, 32, 32)
>>> aug = RandomChannelShuffle(p=1.)
>>> (aug(input) == aug(input, params=aug._params)).all()
tensor(True)

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

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

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

• 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]]]])

To apply the exact augmenation again, you may take the advantage of the previous parameter state:
>>> input = torch.rand(1, 3, 32, 32)
>>> aug = RandomEqualize(p=1.)
>>> (aug(input) == aug(input, params=aug._params)).all()
tensor(True)

class kornia.augmentation.RandomGrayscale(same_on_batch=False, p=0.1, keepdim=False, return_transform=None)[source]#

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

Parameters
• rgb_weights – Weights that will be applied on each channel (RGB). The sum of the weights should add up to one.

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

• 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))
>>> aug = RandomGrayscale(p=1.0)
>>> aug(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]]]])

To apply the exact augmenation again, you may take the advantage of the previous parameter state:
>>> input = torch.randn(1, 3, 32, 32)
>>> aug = RandomGrayscale(p=1.0)
>>> (aug(input) == aug(input, params=aug._params)).all()
tensor(True)

class kornia.augmentation.RandomGaussianBlur(kernel_size, sigma, border_type='reflect', same_on_batch=False, p=0.5, keepdim=False, return_transform=None)[source]#

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

Parameters
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]]]])

To apply the exact augmenation again, you may take the advantage of the previous parameter state:
>>> input = torch.randn(1, 3, 32, 32)
>>> aug = RandomGaussianBlur((3, 3), (0.1, 2.0), p=1.)
>>> (aug(input) == aug(input, params=aug._params)).all()
tensor(True)

class kornia.augmentation.RandomGaussianNoise(mean=0.0, std=1.0, same_on_batch=False, p=0.5, keepdim=False, return_transform=None)[source]#

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

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

• 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

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

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]]]])

To apply the exact augmenation again, you may take the advantage of the previous parameter state:
>>> input = torch.randn(1, 3, 32, 32)
>>> aug = RandomGaussianNoise(mean=0., std=1., p=1.)
>>> (aug(input) == aug(input, params=aug._params)).all()
tensor(True)

class kornia.augmentation.RandomMotionBlur(kernel_size, angle, direction, border_type=BorderType.CONSTANT.name, resample=Resample.NEAREST.name, same_on_batch=False, p=0.5, keepdim=False, return_transform=None)[source]#

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

Parameters
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]]]])

To apply the exact augmenation again, you may take the advantage of the previous parameter state:
>>> input = torch.randn(1, 3, 32, 32)
>>> aug = RandomMotionBlur(3, 35., 0.5, p=1.)
>>> (aug(input) == aug(input, params=aug._params)).all()
tensor(True)

class kornia.augmentation.RandomPosterize(bits=3, same_on_batch=False, p=0.5, keepdim=False, return_transform=None)[source]#

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

Parameters
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]]]])

To apply the exact augmenation again, you may take the advantage of the previous parameter state:
>>> input = torch.randn(1, 3, 32, 32)
>>> aug = RandomPosterize(3, p=1.)
>>> (aug(input) == aug(input, params=aug._params)).all()
tensor(True)

class kornia.augmentation.RandomRGBShift(r_shift_limit=0.5, g_shift_limit=0.5, b_shift_limit=0.5, same_on_batch=False, p=0.5, keepdim=False, return_transform=None)[source]#

Randomly shift each channel of an image.

Parameters
• r_shift_limit (float, optional) – maximum value up to which the shift value can be generated for red channel; recommended interval - [0, 1], should always be positive Default: 0.5

• g_shift_limit (float, optional) – maximum value up to which the shift value can be generated for green channel; recommended interval - [0, 1], should always be positive Default: 0.5

• b_shift_limit (float, optional) – maximum value up to which the shift value can be generated for blue channel; recommended interval - [0, 1], should always be positive Default: 0.5

• 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

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

Note

Input tensor must be float and normalized into [0, 1].

Examples

>>> import torch
>>> rng = torch.manual_seed(0)
>>> inp = torch.rand(1, 3, 5, 5)
>>> aug = RandomRGBShift(0, 0, 0)
>>> ((inp == aug(inp)).double()).all()
tensor(True)

>>> rng = torch.manual_seed(0)
>>> inp = torch.rand(1, 3, 5, 5)
>>> inp
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, 0.0362, 0.1852, 0.3734],
[0.3051, 0.9320, 0.1759, 0.2698, 0.1507],
[0.0317, 0.2081, 0.9298, 0.7231, 0.7423],
[0.5263, 0.2437, 0.5846, 0.0332, 0.1387],
[0.2422, 0.8155, 0.7932, 0.2783, 0.4820]],

[[0.8198, 0.9971, 0.6984, 0.5675, 0.8352],
[0.2056, 0.5932, 0.1123, 0.1535, 0.2417],
[0.7262, 0.7011, 0.2038, 0.6511, 0.7745],
[0.4369, 0.5191, 0.6159, 0.8102, 0.9801],
[0.1147, 0.3168, 0.6965, 0.9143, 0.9351]]]])
>>> aug = RandomRGBShift(p=1.)
>>> aug(inp)
tensor([[[[0.9374, 1.0000, 0.5297, 0.5732, 0.7486],
[1.0000, 0.9313, 1.0000, 0.8968, 1.0000],
[0.7901, 0.8429, 0.4635, 0.6100, 0.7351],
[0.9597, 1.0000, 1.0000, 0.6022, 0.7234],
[1.0000, 1.0000, 0.8383, 1.0000, 0.8606]],

[[0.6524, 1.0000, 0.1357, 0.2847, 0.4729],
[0.4046, 1.0000, 0.2754, 0.3693, 0.2502],
[0.1312, 0.3076, 1.0000, 0.8226, 0.8418],
[0.6258, 0.3432, 0.6841, 0.1327, 0.2382],
[0.3417, 0.9150, 0.8927, 0.3778, 0.5815]],

[[0.3850, 0.5623, 0.2636, 0.1328, 0.4005],
[0.0000, 0.1584, 0.0000, 0.0000, 0.0000],
[0.2914, 0.2663, 0.0000, 0.2163, 0.3397],
[0.0021, 0.0843, 0.1811, 0.3754, 0.5453],
[0.0000, 0.0000, 0.2617, 0.4795, 0.5003]]]])

class kornia.augmentation.RandomSharpness(sharpness=0.5, same_on_batch=False, p=0.5, keepdim=False, return_transform=None)[source]#

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

Parameters
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]]]])

To apply the exact augmenation again, you may take the advantage of the previous parameter state:
>>> input = torch.randn(1, 3, 32, 32)
>>> aug = RandomSharpness(1., p=1.)
>>> (aug(input) == aug(input, params=aug._params)).all()
tensor(True)

class kornia.augmentation.RandomSolarize(thresholds=0.1, additions=0.1, same_on_batch=False, p=0.5, keepdim=False, return_transform=None)[source]#

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

Parameters
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]]]])

To apply the exact augmenation again, you may take the advantage of the previous parameter state:
>>> input = torch.randn(1, 3, 32, 32)
>>> aug = RandomSolarize(0.1, 0.1, p=1.)
>>> (aug(input) == aug(input, params=aug._params)).all()
tensor(True)


### Geometric#

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

Crop a given image tensor at the center.

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: Resample.BILINEAR.name

• 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

>>> import torch
>>> 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]]]])
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]]]])

To apply the exact augmenation again, you may take the advantage of the previous parameter state:
>>> input = torch.randn(1, 3, 32, 32)
>>> aug = CenterCrop(2, p=1., cropping_mode="resample")
>>> (aug(input) == aug(input, params=aug._params)).all()
tensor(True)

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

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

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

Parameters
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

>>> import torch
>>> rng = torch.manual_seed(0)
>>> input = torch.rand(1, 1, 3, 3)
>>> aug = RandomAffine((-15., 20.), p=1.)
>>> out = aug(input)
>>> out, aug.transform_matrix
(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]]]])

To apply the exact augmenation again, you may take the advantage of the previous parameter state:
>>> input = torch.randn(1, 3, 32, 32)
>>> aug = RandomAffine((-15., 20.), p=1.)
>>> (aug(input) == aug(input, params=aug._params)).all()
tensor(True)


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

Parameters
• 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, reflect, replicate. Default: 'constant'

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

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

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

• 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

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

>>> import torch
>>> _ = 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.]]]])
tensor([[[[3., 4., 4.],
[3., 4., 4.],
[6., 7., 7.]]]])

To apply the exact augmenation again, you may take the advantage of the previous parameter state:
>>> input = torch.randn(1, 3, 32, 32)
>>> aug = RandomCrop((2, 2), p=1., cropping_mode="resample")
>>> (aug(input) == aug(input, params=aug._params)).all()
tensor(True)

class kornia.augmentation.RandomErasing(scale=(0.02, 0.33), ratio=(0.3, 3.3), value=0.0, same_on_batch=False, p=0.5, keepdim=False, return_transform=None)[source]#

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

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
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)
>>> aug = RandomErasing((.4, .8), (.3, 1/.3), p=0.5)
>>> aug(inputs)
tensor([[[[1., 0., 0.],
[1., 0., 0.],
[1., 0., 0.]]]])

To apply the exact augmenation again, you may take the advantage of the previous parameter state:
>>> input = torch.randn(1, 3, 32, 32)
>>> aug = RandomErasing((.4, .8), (.3, 1/.3), p=1.)
>>> (aug(input) == aug(input, params=aug._params)).all()
tensor(True)

class kornia.augmentation.RandomElasticTransform(kernel_size=(63, 63), sigma=(32.0, 32.0), alpha=(1.0, 1.0), align_corners=False, mode='bilinear', padding_mode='zeros', same_on_batch=False, p=0.5, keepdim=False, return_transform=None)[source]#

Add random elastic transformation to a tensor image.

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'

• padding_mode (str, optional) – The padding used by grid_sample. Either ‘zeros’, ‘border’ or ‘refection’. Default: 'zeros'

• 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

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

Examples

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

To apply the exact augmenation again, you may take the advantage of the previous parameter state:
>>> input = torch.randn(1, 3, 32, 32)
>>> aug = RandomElasticTransform(p=1.)
>>> (aug(input) == aug(input, params=aug._params)).all()
tensor(True)

class kornia.augmentation.RandomFisheye(center_x, center_y, gamma, same_on_batch=False, p=0.5, keepdim=False, return_transform=None)[source]#

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,).

• 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

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

Examples

>>> import torch
>>> 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])

To apply the exact augmenation again, you may take the advantage of the previous parameter state:
>>> input = torch.randn(1, 3, 32, 32)
>>> aug = RandomFisheye(center_x, center_y, gamma, p=1.)
>>> (aug(input) == aug(input, params=aug._params)).all()
tensor(True)

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.

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

• 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

>>> import torch
>>> input = torch.tensor([[[[0., 0., 0.],
...                         [0., 0., 0.],
...                         [0., 1., 1.]]]])
>>> seq = RandomHorizontalFlip(p=1.0)
>>> seq(input), seq.transform_matrix
(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

To apply the exact augmenation again, you may take the advantage of the previous parameter state:
>>> input = torch.randn(1, 3, 32, 32)
>>> seq = RandomHorizontalFlip(p=1.0)
>>> (seq(input) == seq(input, params=seq._params)).all()
tensor(True)

class kornia.augmentation.RandomInvert(max_val=torch.tensor(1.0), same_on_batch=False, p=0.5, keepdim=False, return_transform=None)[source]#

Invert the tensor images values randomly.

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: torch.tensor(1.0)

• 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

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

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]]]])

To apply the exact augmenation again, you may take the advantage of the previous parameter state:
>>> input = torch.randn(1, 3, 32, 32)
>>> aug = RandomInvert(p=1.)
>>> (aug(input) == aug(input, params=aug._params)).all()
tensor(True)

class kornia.augmentation.RandomPerspective(distortion_scale=0.5, resample=Resample.BILINEAR.name, same_on_batch=False, align_corners=False, p=0.5, keepdim=False, sampling_method='basic', return_transform=None)[source]#

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

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

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

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

• 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

• sampling_method (str, optional) – 'basic' | 'area_preserving'. Default: 'basic' If 'basic', samples by translating the image corners randomly inwards. If 'area_preserving', samples by randomly translating the image corners in any direction. Preserves area on average. See https://arxiv.org/abs/2104.03308 for further details.

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]]]])

To apply the exact augmenation again, you may take the advantage of the previous parameter state:
>>> input = torch.randn(1, 3, 32, 32)
>>> aug = RandomPerspective(0.5, p=1.)
>>> (aug(input) == aug(input, params=aug._params)).all()
tensor(True)

class kornia.augmentation.RandomResizedCrop(size, scale=(0.08, 1.0), ratio=(3.0 / 4.0, 4.0 / 3.0), resample=Resample.BILINEAR.name, same_on_batch=False, align_corners=True, p=1.0, keepdim=False, cropping_mode='slice', return_transform=None)[source]#

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

Parameters
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]]]])
tensor([[[[1., 1., 2.],
[4., 4., 5.],
[7., 7., 8.]]]])

To apply the exact augmenation again, you may take the advantage of the previous parameter state:
>>> input = torch.randn(1, 3, 32, 32)
>>> aug = RandomResizedCrop(size=(3, 3), scale=(3., 3.), ratio=(2., 2.), p=1., cropping_mode="resample")
>>> (aug(input) == aug(input, params=aug._params)).all()
tensor(True)

class kornia.augmentation.RandomRotation(degrees, resample=Resample.BILINEAR.name, same_on_batch=False, align_corners=True, p=0.5, keepdim=False, return_transform=None)[source]#

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

Parameters
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, 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]]]])
>>> aug.transform_matrix
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.6824e-03, 1.7263e-02, 1.9305e+00],
[8.6398e-03, 2.9485e-03, 5.8971e-03, 1.7365e-02],
[2.9054e-03, 9.9416e-01, 1.9825e+00, 2.3134e-02],
[2.5777e-05, 1.1640e-02, 9.9992e-01, 1.9392e+00]]]])

To apply the exact augmenation again, you may take the advantage of the previous parameter state:
>>> input = torch.randn(1, 3, 32, 32)
>>> aug = RandomRotation(degrees=45.0, p=1.)
>>> (aug(input) == aug(input, params=aug._params)).all()
tensor(True)

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.

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

• 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)
>>> seq(input), seq.transform_matrix
(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

To apply the exact augmenation again, you may take the advantage of the previous parameter state:
>>> input = torch.randn(1, 3, 32, 32)
>>> seq = RandomVerticalFlip(p=1.0)
>>> (seq(input) == seq(input, params=seq._params)).all()
tensor(True)

class kornia.augmentation.RandomThinPlateSpline(scale=0.2, align_corners=False, same_on_batch=False, p=0.5, keepdim=False, return_transform=None)[source]#

Add random noise to the Thin Plate Spline algorithm.

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’.

• 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

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

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])

To apply the exact augmenation again, you may take the advantage of the previous parameter state:
>>> input = torch.randn(1, 3, 32, 32)
>>> aug = RandomThinPlateSpline(p=1.)
>>> (aug(input) == aug(input, params=aug._params)).all()
tensor(True)


### Mix#

class kornia.augmentation.RandomMosaic(output_size=None, mosaic_grid=(2, 2), start_ratio_range=(0.3, 0.7), min_bbox_size=0.0, data_keys=[DataKey.INPUT], p=0.7, keepdim=False, padding_mode='constant', resample=Resample.BILINEAR.name, align_corners=True, cropping_mode='slice')[source]#

Mosaic augmentation.

Given a certain number of images, mosaic transform combines them into one output image. The output image is composed of the parts from each sub-image.

The mosaic transform steps are as follows:

1. Concate selected images into a super-image.

2. Crop out the outcome image according to the top-left corner and crop size.

Parameters
• output_size (Optional[Tuple[int, int]], optional) – the output tensor width and height after mosaicing. Default: None

• start_ratio_range (Tuple[float, float], optional) – top-left (x, y) position for cropping the mosaic images. Default: (0.3, 0.7)

• mosaic_grid (Tuple[int, int], optional) – the number of images and image arrangement. e.g. (2, 2) means each output will mix 4 images in a 2x2 grid. Default: (2, 2)

• min_bbox_size (float, optional) – minimum area of bounding boxes. Default to 0. Default: 0.0

• data_keys (List[Union[str, int, DataKey]], optional) – the input type sequential for applying augmentations. Accepts “input”, “mask”, “bbox”, “bbox_xyxy”, “bbox_xywh”, “keypoints”. Default: [DataKey.INPUT]

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

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

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

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

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

• 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'

Examples

>>> mosaic = RandomMosaic((300, 300), data_keys=["input", "bbox_xyxy"])
>>> boxes = torch.tensor([[
...     [70, 5, 150, 100],
...     [60, 180, 175, 220],
... ]]).repeat(8, 1, 1)
>>> input = torch.randn(8, 3, 224, 224)
>>> out = mosaic(input, boxes)
>>> out[0].shape, out[1].shape
(torch.Size([8, 3, 300, 300]), torch.Size([8, 8, 4]))

class kornia.augmentation.RandomCutMix(height=None, width=None, 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.

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
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[Tensor, 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()
>>> 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.RandomCutMixV2(num_mix=1, cut_size=None, beta=None, same_on_batch=False, p=1.0, keepdim=False, data_keys=[DataKey.INPUT])[source]#

Apply CutMix augmentation to a batch of tensor images.

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.

Parameters
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[Tensor, 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 = RandomCutMixV2(data_keys=["input", "class"])
>>> 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.RandomMixUp(lambda_val=None, same_on_batch=False, p=1.0, keepdim=False)[source]#

Apply MixUp augmentation to a batch of tensor images.

Implementation for mixup: BEYOND EMPIRICAL RISK MINIMIZATION .

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
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[Tensor, 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.RandomMixUpV2(lambda_val=None, same_on_batch=False, p=1.0, keepdim=False, data_keys=[DataKey.INPUT])[source]#

Apply MixUp augmentation to a batch of tensor images.

Implementation for mixup: BEYOND EMPIRICAL RISK MINIMIZATION .

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
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[Tensor, 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 = RandomMixUpV2(data_keys=["input", "class"])
>>> 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]])]


## Transforms3D#

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

### Geometric#

class kornia.augmentation.RandomDepthicalFlip3D(return_transform=None, 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

• 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

>>> import torch
>>> x = torch.eye(3).repeat(3, 1, 1)
>>> seq = RandomDepthicalFlip3D(p=1.0)
>>> seq(x), seq.transform_matrix
(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.]]]))

To apply the exact augmenation again, you may take the advantage of the previous parameter state:
>>> input = torch.rand(1, 3, 32, 32, 32)
>>> aug = RandomDepthicalFlip3D(p=1.)
>>> (aug(input) == aug(input, params=aug._params)).all()
tensor(True)

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

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

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

• 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

>>> import torch
>>> x = torch.eye(3).repeat(3, 1, 1)
>>> seq = RandomHorizontalFlip3D(p=1.0)
>>> seq(x), seq.transform_matrix
(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.]]]))

To apply the exact augmenation again, you may take the advantage of the previous parameter state:
>>> input = torch.rand(1, 3, 32, 32, 32)
>>> aug = RandomHorizontalFlip3D(p=1.)
>>> (aug(input) == aug(input, params=aug._params)).all()
tensor(True)

class kornia.augmentation.RandomVerticalFlip3D(same_on_batch=False, p=0.5, keepdim=False, return_transform=None)[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

• 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

>>> import torch
>>> x = torch.eye(3).repeat(3, 1, 1)
>>> seq = RandomVerticalFlip3D(p=1.0)
>>> seq(x), seq.transform_matrix
(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.]]]))

To apply the exact augmenation again, you may take the advantage of the previous parameter state:
>>> input = torch.rand(1, 3, 32, 32, 32)
>>> aug = RandomVerticalFlip3D(p=1.)
>>> (aug(input) == aug(input, params=aug._params)).all()
tensor(True)

class kornia.augmentation.RandomRotation3D(degrees, resample=Resample.BILINEAR.name, same_on_batch=False, align_corners=False, p=0.5, keepdim=False, return_transform=None)[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
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

>>> import torch
>>> rng = torch.manual_seed(0)
>>> input = torch.rand(1, 1, 3, 3, 3)
>>> aug = RandomRotation3D((15., 20., 20.), p=1.0)
>>> aug(input), aug.transform_matrix
(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]]]))

To apply the exact augmenation again, you may take the advantage of the previous parameter state:
>>> input = torch.rand(1, 3, 32, 32, 32)
>>> aug = RandomRotation3D((15., 20., 20.), p=1.)
>>> (aug(input) == aug(input, params=aug._params)).all()
tensor(True)

class kornia.augmentation.RandomAffine3D(degrees, translate=None, scale=None, shears=None, resample=Resample.BILINEAR.name, same_on_batch=False, align_corners=False, p=0.5, keepdim=False, return_transform=None)[source]#

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

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

Parameters
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

>>> import torch
>>> rng = torch.manual_seed(0)
>>> input = torch.rand(1, 1, 3, 3, 3)
>>> aug = RandomAffine3D((15., 20., 20.), p=1.)
>>> aug(input), aug.transform_matrix
(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]]]))

To apply the exact augmenation again, you may take the advantage of the previous parameter state:
>>> input = torch.rand(1, 3, 32, 32, 32)
>>> aug = RandomAffine3D((15., 20., 20.), p=1.)
>>> (aug(input) == aug(input, params=aug._params)).all()
tensor(True)


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

Crops random sub-volumes on a given size.

Parameters
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

>>> import torch
>>> 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]]]]])

To apply the exact augmenation again, you may take the advantage of the previous parameter state:
>>> input = torch.rand(1, 3, 32, 32, 32)
>>> aug = RandomCrop3D((24, 24, 24), p=1.)
>>> (aug(input) == aug(input, params=aug._params)).all()
tensor(True)

class kornia.augmentation.CenterCrop3D(size, align_corners=True, resample=Resample.BILINEAR.name, p=1.0, keepdim=False, return_transform=None)[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) – resample mode from “nearest” (0) or “bilinear” (1). Default: Resample.BILINEAR.name

• 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

• 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

>>> import torch
>>> 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]]]]])

To apply the exact augmenation again, you may take the advantage of the previous parameter state:
>>> input = torch.rand(1, 3, 32, 32, 32)
>>> aug = CenterCrop3D(24, p=1.)
>>> (aug(input) == aug(input, params=aug._params)).all()
tensor(True)


### Intensity#

class kornia.augmentation.RandomMotionBlur3D(kernel_size, angle, direction, border_type=BorderType.CONSTANT.name, resample=Resample.NEAREST.name, same_on_batch=False, p=0.5, keepdim=False, return_transform=None)[source]#

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

Parameters
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

>>> import torch
>>> 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]]]]])

To apply the exact augmenation again, you may take the advantage of the previous parameter state:
>>> input = torch.rand(1, 3, 32, 32, 32)
>>> aug = RandomMotionBlur3D(3, 35., 0.5, p=1.)
>>> (aug(input) == aug(input, params=aug._params)).all()
tensor(True)

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

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

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

• 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

>>> import torch
>>> 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]]]]])

To apply the exact augmenation again, you may take the advantage of the previous parameter state:
>>> input = torch.rand(1, 3, 32, 32, 32)
>>> aug = RandomEqualize3D(p=1.)
>>> (aug(input) == aug(input, params=aug._params)).all()
tensor(True)


## Normalizations#

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

class kornia.augmentation.Denormalize(mean, std, p=1.0, keepdim=False, return_transform=None)[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
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, p=1.0, keepdim=False, return_transform=None)[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])


## Image Resize#

class kornia.augmentation.Resize(size, side='short', resample=Resample.BILINEAR.name, align_corners=True, antialias=False, p=1.0, return_transform=None, keepdim=False)[source]#

Resize to size.

Parameters
class kornia.augmentation.LongestMaxSize(max_size, resample=Resample.BILINEAR.name, align_corners=True, p=1.0, return_transform=None)[source]#

Rescale an image so that maximum side is equal to max_size, keeping the aspect ratio of the initial image.

Parameters

max_size (int) – maximum size of the image after the transformation.

class kornia.augmentation.SmallestMaxSize(max_size, resample=Resample.BILINEAR.name, align_corners=True, p=1.0, return_transform=None)[source]#

Rescale an image so that minimum side is equal to max_size, keeping the aspect ratio of the initial image.

Parameters

max_size (int) – maximum size of the image after the transformation.