anomalib.pre_processing

Utilities for pre-processing the input before passing to the model.

Subpackages

Submodules

Package Contents

Classes

PreProcessor

Applies pre-processing and data augmentations to the input and returns the transformed output.

Tiler

Tile Image into (non)overlapping Patches. Images are tiled in order to efficiently process large images.
class anomalib.pre_processing.PreProcessor(config: Optional[Union[str, albumentations.Compose]] = None, image_size: Optional[Union[int, Tuple]] = None, to_tensor: bool = True)[source]

Applies pre-processing and data augmentations to the input and returns the transformed output.

Output could be either numpy ndarray or torch tensor. When PreProcessor class is used for training, the output would be torch.Tensor. For the inference it returns a numpy array.

Parameters

  • config (Optional[Union[str, A.Compose]], optional) – Transformation configurations. When it is None, PreProcessor only applies resizing. When it is str it loads the config via albumentations deserialisation methos . Defaults to None.

  • image_size (Optional[Union[int, Tuple[int, int]]], optional) – When there is no config,

  • None. (image_size resizes the image. Defaults to) –

  • to_tensor (bool, optional) – Boolean to check whether the augmented image is transformed into a tensor or not. Defaults to True.

Examples

>>> import skimage
>>> image = skimage.data.astronaut()

>>> pre_processor = PreProcessor(image_size=256, to_tensor=False)
>>> output = pre_processor(image=image)
>>> output["image"].shape
(256, 256, 3)

>>> pre_processor = PreProcessor(image_size=256, to_tensor=True)
>>> output = pre_processor(image=image)
>>> output["image"].shape
torch.Size([3, 256, 256])
Transforms could be read from albumentations Compose object.
>>> import albumentations as A
>>> from albumentations.pytorch import ToTensorV2
>>> config = A.Compose([A.Resize(512, 512), ToTensorV2()])
>>> pre_processor = PreProcessor(config=config, to_tensor=False)
>>> output = pre_processor(image=image)
>>> output["image"].shape
(512, 512, 3)
>>> type(output["image"])
numpy.ndarray
Transforms could be deserialized from a yaml file.
>>> transforms = A.Compose([A.Resize(1024, 1024), ToTensorV2()])
>>> A.save(transforms, "/tmp/transforms.yaml", data_format="yaml")
>>> pre_processor = PreProcessor(config="/tmp/transforms.yaml")
>>> output = pre_processor(image=image)
>>> output["image"].shape
torch.Size([3, 1024, 1024])
get_transforms() → albumentations.Compose

Get transforms from config or image size.

Returns

List of albumentation transformations to apply to the

input image.

Return type

A.Compose

__call__(*args, **kwargs)

Return transformed arguments.

_get_height_and_width() → Tuple[Optional[int], Optional[int]]

Extract height and width from image size attribute.

class anomalib.pre_processing.Tiler(tile_size: Union[int, Sequence], stride: Optional[Union[int, Sequence]] = None, remove_border_count: int = 0, mode: str = 'padding', tile_count: int = 4)[source]

Tile Image into (non)overlapping Patches. Images are tiled in order to efficiently process large images.

Parameters

  • tile_size – Tile dimension for each patch

  • stride – Stride length between patches

  • remove_border_count – Number of border pixels to be removed from tile before untiling

  • mode – Upscaling mode for image resize.Supported formats: padding, interpolation

Examples

>>> import torch
>>> from torchvision import transforms
>>> from skimage.data import camera
>>> tiler = Tiler(tile_size=256,stride=128)
>>> image = transforms.ToTensor()(camera())
>>> tiles = tiler.tile(image)
>>> image.shape, tiles.shape
(torch.Size([3, 512, 512]), torch.Size([9, 3, 256, 256]))

>>> # Perform your operations on the tiles.

>>> # Untile the patches to reconstruct the image
>>> reconstructed_image = tiler.untile(tiles)
>>> reconstructed_image.shape
torch.Size([1, 3, 512, 512])
static __validate_size_type(parameter: Union[int, Sequence]) → Tuple[int, Ellipsis]
__random_tile(image: torch.Tensor) → torch.Tensor

Randomly crop tiles from the given image.

Parameters

image – input image to be cropped

Returns: Randomly cropped tiles from the image

__unfold(tensor: torch.Tensor) → torch.Tensor

Unfolds tensor into tiles.

This is the core function to perform tiling operation.

Parameters

tensor – Input tensor from which tiles are generated.

Returns: Generated tiles

__fold(tiles: torch.Tensor) → torch.Tensor

Fold the tiles back into the original tensor.

This is the core method to reconstruct the original image from its tiled version.

Parameters

tiles – Tiles from the input image, generated via __unfold method.

Returns

Output that is the reconstructed version of the input tensor.

tile(image: torch.Tensor, use_random_tiling: Optional[bool] = False) → torch.Tensor

Tiles an input image to either overlapping, non-overlapping or random patches.

Parameters

image – Input image to tile.

Examples

>>> from anomalib.data.tiler import Tiler
>>> tiler = Tiler(tile_size=512,stride=256)
>>> image = torch.rand(size=(2, 3, 1024, 1024))
>>> image.shape
torch.Size([2, 3, 1024, 1024])
>>> tiles = tiler.tile(image)
>>> tiles.shape
torch.Size([18, 3, 512, 512])
Returns

Tiles generated from the image.

untile(tiles: torch.Tensor) → torch.Tensor

Untiles patches to reconstruct the original input image.

If patches, are overlapping patches, the function averages the overlapping pixels, and return the reconstructed image.

Parameters

tiles – Tiles from the input image, generated via tile()..

Examples

>>> from anomalib.datasets.tiler import Tiler
>>> tiler = Tiler(tile_size=512,stride=256)
>>> image = torch.rand(size=(2, 3, 1024, 1024))
>>> image.shape
torch.Size([2, 3, 1024, 1024])
>>> tiles = tiler.tile(image)
>>> tiles.shape
torch.Size([18, 3, 512, 512])
>>> reconstructed_image = tiler.untile(tiles)
>>> reconstructed_image.shape
torch.Size([2, 3, 1024, 1024])
>>> torch.equal(image, reconstructed_image)
True
Returns

Output that is the reconstructed version of the input tensor.