doctr.transforms#

Data transformations are part of both training and inference procedure. Drawing inspiration from the design of torchvision, we express transformations as composable modules.

Supported transformations#

Here are all transformations that are available through docTR:

class Resize(
size,
interpolation=F.InterpolationMode.BILINEAR,
preserve_aspect_ratio=False,
symmetric_pad=False,
)[source]#

Resize the input image to the given size

class GaussianNoise(mean=0.0, std=1.0)[source]#

Adds Gaussian Noise to the input tensor

>>> import torch
>>> from doctr.transforms import GaussianNoise
>>> transfo = GaussianNoise(0., 1.)
>>> out = transfo(torch.rand((3, 224, 224)))
Parameters:

  • mean (float) – mean of the gaussian distribution

  • std (float) – std of the gaussian distribution

class ChannelShuffle[source]#

Randomly shuffle channel order of a given image

class RandomHorizontalFlip(p=0.5)[source]#

Randomly flip the input image horizontally

class RandomShadow(opacity_range=None)[source]#

Adds random shade to the input image

>>> import torch
>>> from doctr.transforms import RandomShadow
>>> transfo = RandomShadow((0., 1.))
>>> out = transfo(torch.rand((3, 64, 64)))
Parameters:

opacity_range (tuple[float, float] | None) – minimum and maximum opacity of the shade

class RandomResize(
scale_range=(0.3, 0.9),
preserve_aspect_ratio=False,
symmetric_pad=False,
p=0.5,
)[source]#

Randomly resize the input image and align corresponding targets

>>> import torch
>>> from doctr.transforms import RandomResize
>>> transfo = RandomResize((0.3, 0.9), preserve_aspect_ratio=True, symmetric_pad=True, p=0.5)
>>> out = transfo(torch.rand((3, 64, 64)))
Parameters:

  • scale_range (tuple[float, float]) – range of the resizing factor for width and height (independently)

  • preserve_aspect_ratio (bool | float) – whether to preserve the aspect ratio of the image,

  • value (given a float)

  • probability (the symmetric padding will be applied with this)

  • symmetric_pad (bool | float) – whether to symmetrically pad the image,

  • value

  • probability

  • p (float) – probability to apply the transformation

Composing transformations#

It is common to require several transformations to be performed consecutively.

class SampleCompose(transforms)[source]#

Implements a wrapper that will apply transformations sequentially on both image and target

>>> import numpy as np
>>> import torch
>>> from doctr.transforms import SampleCompose, ImageTransform, ColorInversion, RandomRotate
>>> transfos = SampleCompose([ImageTransform(ColorInversion((32, 32))), RandomRotate(30)])
>>> out, out_boxes = transfos(torch.rand(8, 64, 64, 3), np.zeros((2, 4)))
Parameters:

transforms (list[Callable[[Any, Any], tuple[Any, Any]]]) – list of transformation modules

class ImageTransform(transform)[source]#

Implements a transform wrapper to turn an image-only transformation into an image+target transform

>>> import torch
>>> from doctr.transforms import ImageTransform, ColorInversion
>>> transfo = ImageTransform(ColorInversion((32, 32)))
>>> out, _ = transfo(torch.rand(8, 64, 64, 3), None)
Parameters:

transform (Callable[[Any], Any]) – the image transformation module to wrap

class ColorInversion(min_val=0.5)[source]#

Applies the following tranformation to a tensor (image or batch of images): convert to grayscale, colorize (shift 0-values randomly), and then invert colors

>>> import torch
>>> from doctr.transforms import ColorInversion
>>> transfo = ColorInversion(min_val=0.6)
>>> out = transfo(torch.rand(8, 64, 64, 3))
Parameters:

min_val (float) – range [min_val, 1] to colorize RGB pixels

class OneOf(transforms)[source]#

Randomly apply one of the input transformations

>>> import torch
>>> from doctr.transforms import OneOf
>>> transfo = OneOf([JpegQuality(), Gamma()])
>>> out = transfo(torch.rand(1, 64, 64, 3))
Parameters:

transforms (list[Callable[[Any], Any]]) – list of transformations, one only will be picked

class RandomApply(transform, p=0.5)[source]#

Apply with a probability p the input transformation

>>> import torch
>>> from doctr.transforms import RandomApply
>>> transfo = RandomApply(Gamma(), p=.5)
>>> out = transfo(torch.rand(1, 64, 64, 3))
Parameters:

  • transform (Callable[[Any], Any]) – transformation to apply

  • p (float) – probability to apply

class RandomRotate(max_angle=5.0, expand=False)[source]#

Randomly rotate a tensor image and its boxes

https://doctr-static.mindee.com/models?id=v0.4.0/rotation_illustration.png&src=0
Parameters:

  • max_angle (float) – maximum angle for rotation, in degrees. Angles will be uniformly picked in [-max_angle, max_angle]

  • expand (bool) – whether the image should be padded before the rotation

class RandomCrop(scale=(0.08, 1.0), ratio=(0.75, 1.33))[source]#

Randomly crop a tensor image and its boxes

Parameters:

  • scale (tuple[float, float]) – tuple of floats, relative (min_area, max_area) of the crop

  • ratio (tuple[float, float]) – tuple of float, relative (min_ratio, max_ratio) where ratio = h/w