minerva.transforms.transform

Classes

`CastTo`	Cast the input data to the specified data type.
`ColorJitter`	This class is a base class for all transforms. Transforms is just a
`ContrastiveTransform`	This class is a base class for all transforms. Transforms is just a
`Crop`	This class is a base class for all transforms. Transforms is just a
`Flip`	Flip the input data along the specified axis.
`Gradient`	This class is a base class for all transforms. Transforms is just a
`GrayScale`	This class is a base class for all transforms. Transforms is just a
`Identity`	This class is a dummy transform that does nothing. It is useful when
`Indexer`	This class is a base class for all transforms. Transforms is just a
`Normalize`	This class is a base class for all transforms. Transforms is just a
`PadCrop`	This class is a base class for all transforms. Transforms is just a
`Padding`	This class is a base class for all transforms. Transforms is just a
`PerlinMasker`	Zeroes entries of a tensor according to the sign of Perlin noise. Seed for the noise generator given by torch.randint
`Repeat`	This class is a base class for all transforms. Transforms is just a
`Rotation`	This class is a base class for all transforms. Transforms is just a
`Solarize`	This class is a base class for all transforms. Transforms is just a
`Squeeze`	Remove single-dimensional entries from the shape of an array.
`TransformPipeline`	Apply a sequence of transforms to a single sample of data and return the
`Transpose`	Reorder the axes of numpy arrays.
`Unsqueeze`	Add a new axis to the input data at the specified position.
`_Transform`	This class is a base class for all transforms. Transforms is just a

Module Contents

class minerva.transforms.transform.CastTo(dtype)[source]

Bases: _Transform

Cast the input data to the specified data type.

Parameters

dtypetype: The data type to which the input data will be cast.

__call__(x)[source]

Cast the input data to the specified data type.

Parameters:: x (numpy.ndarray)
Return type:: numpy.ndarray

__str__()[source]

Return type:: str

dtype

Parameters:: dtype (Union[type, str])

class minerva.transforms.transform.ColorJitter(brightness=1.0, contrast=1.0, saturation=1.0, hue=0.0)[source]

Bases: _Transform

This class is a base class for all transforms. Transforms is just a fancy word for a function that takes an input and returns an output. The input and output can be anything. However, transforms operates over a single sample of data and does not require any additional information to perform the transformation. The __call__ method should be overridden in subclasses to define the transformation logic.

Applies fixed adjustments to brightness, contrast, saturation, and hue to an input image.

Parameters

brightnessfloat, optional: Fixed factor for brightness adjustment. A value of 1.0 means no change. Defaults to 1.0.
contrastfloat, optional: Fixed factor for contrast adjustment. A value of 1.0 means no change. Defaults to 1.0.
saturationfloat, optional: Fixed factor for saturation adjustment. A value of 1.0 means no change. Defaults to 1.0.
huefloat, optional: Fixed degree shift for hue adjustment, in the range [-180, 180]. Defaults to 0.0.

Returns

np.ndarray: The transformed image with fixed brightness, contrast, saturation, and hue adjustments applied.

__call__(image)[source]

Implement the transformation logic in this method. Usually, the transformation is applied on a single sample of data.

Parameters:: image (numpy.ndarray)
Return type:: numpy.ndarray

brightness = 1.0

contrast = 1.0

hue = 0.0

saturation = 1.0

Parameters:

brightness (float)
contrast (float)
saturation (float)
hue (float)

class minerva.transforms.transform.ContrastiveTransform(transform)[source]

Bases: _Transform

This class is a base class for all transforms. Transforms is just a fancy word for a function that takes an input and returns an output. The input and output can be anything. However, transforms operates over a single sample of data and does not require any additional information to perform the transformation. The __call__ method should be overridden in subclasses to define the transformation logic.

Parameters:: transform (_Transform)

__call__(x)[source]

Implement the transformation logic in this method. Usually, the transformation is applied on a single sample of data.

Parameters:: x (numpy.ndarray)
Return type:: Tuple

__str__()[source]

Return type:: str

transform

class minerva.transforms.transform.Crop(output_size, pad_mode='reflect', coords=(0, 0))[source]

Bases: _Transform

This class is a base class for all transforms. Transforms is just a fancy word for a function that takes an input and returns an output. The input and output can be anything. However, transforms operates over a single sample of data and does not require any additional information to perform the transformation. The __call__ method should be overridden in subclasses to define the transformation logic.

Crops the input image to a specified output size, with optional padding if needed.

Parameters

output_sizeTuple[int, int]: Desired output size as (height, width).
pad_modestr, optional: Padding mode used if output size is larger than input size. Defaults to ‘reflect’.
coordsTuple[int, int], optional: Top-left coordinates for the crop box. Values must go from 0 to 1 indicating the relative position on where the new top-left corner can be set, taking in consideration the new size

Returns

np.ndarray: Cropped image, padded as necessary.

__call__(image)[source]

Implement the transformation logic in this method. Usually, the transformation is applied on a single sample of data.

Parameters:: image (numpy.ndarray)
Return type:: numpy.ndarray

coords = (0, 0)

output_size

pad_mode = 'reflect'

Parameters:

output_size (Tuple[int, int])
pad_mode (str)
coords (Tuple[float, float])

class minerva.transforms.transform.Flip(axis=0)[source]

Bases: _Transform

Flip the input data along the specified axis.

Parameters

axisint | List[int], optional: One or more axis to flip the input data along, by default 0. If a list of axis is provided, the input data is flipped along all the specified axis in the order they are provided.

__call__(x)[source]

Flip the input data along the specified axis. if axis is an integer, the input data is flipped along the specified axis. if axis is a list of integers, the input data is flipped along all the specified axis in the order they are provided. The input must have the same, or less, number of dimensions as the length of the list of axis.

Parameters:: x (numpy.ndarray)
Return type:: numpy.ndarray

__str__()[source]

Return type:: str

axis = 0

Parameters:: axis (Union[int, List[int]])

class minerva.transforms.transform.Gradient(direction)[source]

Bases: _Transform

This class is a base class for all transforms. Transforms is just a fancy word for a function that takes an input and returns an output. The input and output can be anything. However, transforms operates over a single sample of data and does not require any additional information to perform the transformation. The __call__ method should be overridden in subclasses to define the transformation logic.

direction:: 0 -> Gradient along the x-axis (width) 1 -> Gradient along the y-axis (height)

Parameters:: direction (int)

__call__(x)[source]: Implement the transformation logic in this method. Usually, the transformation is applied on a single sample of data.

direction

generate_gradient(shape)[source]

Inputs in format (H, W) Outputs a gradient from 0 to 1 in either x or y direction based on the direction parameter

Parameters:: shape (tuple[int, int])
Return type:: numpy.ndarray

class minerva.transforms.transform.GrayScale(gray=0.0)[source]

Bases: _Transform

This class is a base class for all transforms. Transforms is just a fancy word for a function that takes an input and returns an output. The input and output can be anything. However, transforms operates over a single sample of data and does not require any additional information to perform the transformation. The __call__ method should be overridden in subclasses to define the transformation logic.

Converts an image to grayscale with a specified gray value.

Parameters

grayfloat, optional: Gray value to use when converting the image. Defaults to 0.0.

Returns

np.ndarray: Grayscale image in RGB format with all channels set to gray.

__call__(image)[source]

Implement the transformation logic in this method. Usually, the transformation is applied on a single sample of data.

Parameters:: image (numpy.ndarray)
Return type:: numpy.ndarray

gray = 0.0

Parameters:: gray (float)

class minerva.transforms.transform.Identity[source]

Bases: _Transform

This class is a dummy transform that does nothing. It is useful when you want to skip a transform in a pipeline.

__call__(x)[source]

Implement the transformation logic in this method. Usually, the transformation is applied on a single sample of data.

Parameters:: x (numpy.ndarray)
Return type:: numpy.ndarray

__str__()[source]

Return type:: str

class minerva.transforms.transform.Indexer(index)[source]

Bases: _Transform

This class is a base class for all transforms. Transforms is just a fancy word for a function that takes an input and returns an output. The input and output can be anything. However, transforms operates over a single sample of data and does not require any additional information to perform the transformation. The __call__ method should be overridden in subclasses to define the transformation logic.

This transform extracts a single channel from a multi-channel image.

Parameters

indexint: The index of the channel to extract.

__call__(x)[source]

Implement the transformation logic in this method. Usually, the transformation is applied on a single sample of data.

Parameters:: x (numpy.ndarray)
Return type:: numpy.ndarray

__str__()[source]

Return type:: str

index

Parameters:: index (int)

class minerva.transforms.transform.Normalize(mean, std, to_rgb=False, normalize_labels=False)[source]

Bases: _Transform

This class is a base class for all transforms. Transforms is just a fancy word for a function that takes an input and returns an output. The input and output can be anything. However, transforms operates over a single sample of data and does not require any additional information to perform the transformation. The __call__ method should be overridden in subclasses to define the transformation logic.

Normalize the input data using the provided means and standard deviations.

Parameters

meanList[float]: List of means for each channel.
stdList[float]: List of standard deviations for each channel.
to_rgbbool, optional: Convert grayscale images to RGB format, by default False.
normalize_labelsbool, optional: Normalize label images, by default False.

__call__(data)[source]: Implement the transformation logic in this method. Usually, the transformation is applied on a single sample of data.

__str__()[source]

Return type:: str

mean

normalize_labels = False

std

to_rgb = False

class minerva.transforms.transform.PadCrop(target_h_size, target_w_size, padding_mode='reflect', seed=None, constant_values=0)[source]

Bases: _Transform

This class is a base class for all transforms. Transforms is just a fancy word for a function that takes an input and returns an output. The input and output can be anything. However, transforms operates over a single sample of data and does not require any additional information to perform the transformation. The __call__ method should be overridden in subclasses to define the transformation logic.

Transforms image and pads or crops it to the target size. If the target size is larger than the input size, the image is padded, else, the image is cropped. The same happens for both height and width. The padding mode can be specified, as well as the seed for the random number generator.

For padding, the padding is applied symmetrically on both sides of the image, thus, image will be centered in the padded image. For cropping, the crop is applied from a random position in the image.

Image is expected to be in C x H x W, or H x W format.

Parameters

target_h_sizeint: Desired height size.
target_w_sizeint: Desired width size.
padding_modestr, optional: The padding mode to use, by default “reflect”
seedint, optional: The seed for the random number generator. It is used to generate the random crop position. By default, None.
constant_valuesint, optional: If padding mode is ‘constant’, the value to use for padding. By default 0.

__call__(x)[source]

Implement the transformation logic in this method. Usually, the transformation is applied on a single sample of data.

Parameters:: x (numpy.ndarray)
Return type:: numpy.ndarray

__str__()[source]

Return type:: str

constant_values = 0

padding_mode = 'reflect'

rng

seed = None

target_h_size

target_w_size

Parameters:

target_h_size (int)
target_w_size (int)
padding_mode (str)
seed (Optional[int])
constant_values (int)

class minerva.transforms.transform.Padding(target_h_size, target_w_size)[source]

Bases: _Transform

This class is a base class for all transforms. Transforms is just a fancy word for a function that takes an input and returns an output. The input and output can be anything. However, transforms operates over a single sample of data and does not require any additional information to perform the transformation. The __call__ method should be overridden in subclasses to define the transformation logic.

Parameters:

target_h_size (int)
target_w_size (int)

__call__(x)[source]

Implement the transformation logic in this method. Usually, the transformation is applied on a single sample of data.

Parameters:: x (numpy.ndarray)
Return type:: numpy.ndarray

target_h_size

target_w_size

class minerva.transforms.transform.PerlinMasker(octaves, scale=1)[source]

Bases: _Transform

Zeroes entries of a tensor according to the sign of Perlin noise. Seed for the noise generator given by torch.randint

Parameters

octaves: int: Level of detail for the Perlin noise generator
scale: float = 1: Optionally rescale the Perlin noise. Default is 1 (no rescaling)

__call__(x)[source]

Zeroes entries of a tensor according to the sign of Perlin noise.

Parameters

x: np.ndarray: The tensor whose entries to zero.

Parameters:: x (numpy.ndarray)
Return type:: numpy.ndarray

octaves

scale = 1

Parameters:

octaves (int)
scale (float)

class minerva.transforms.transform.Repeat(axis, n_repetitions)[source]

Bases: _Transform

This class is a base class for all transforms. Transforms is just a fancy word for a function that takes an input and returns an output. The input and output can be anything. However, transforms operates over a single sample of data and does not require any additional information to perform the transformation. The __call__ method should be overridden in subclasses to define the transformation logic.

This transform repeats the input data along the specified axis.

Parameters

axisint: The axis along which to repeat the input data.
n_repetitionsint: The number of repetitions.

__call__(x)[source]

Implement the transformation logic in this method. Usually, the transformation is applied on a single sample of data.

Parameters:: x (numpy.ndarray)
Return type:: numpy.ndarray

__str__()[source]

Return type:: str

axis

n_repetitions

Parameters:

axis (int)
n_repetitions (int)

class minerva.transforms.transform.Rotation(degrees)[source]

Bases: _Transform

This class is a base class for all transforms. Transforms is just a fancy word for a function that takes an input and returns an output. The input and output can be anything. However, transforms operates over a single sample of data and does not require any additional information to perform the transformation. The __call__ method should be overridden in subclasses to define the transformation logic.

Rotates the image by a specified angle.

Parameters

degreesfloat: Angle in degrees to rotate the image.

Returns

np.ndarray: Rotated image with reflection padding.

__call__(image)[source]

Implement the transformation logic in this method. Usually, the transformation is applied on a single sample of data.

Parameters:: image (numpy.ndarray)
Return type:: numpy.ndarray

degrees

Parameters:: degrees (float)

class minerva.transforms.transform.Solarize(threshold=128)[source]

Bases: _Transform

This class is a base class for all transforms. Transforms is just a fancy word for a function that takes an input and returns an output. The input and output can be anything. However, transforms operates over a single sample of data and does not require any additional information to perform the transformation. The __call__ method should be overridden in subclasses to define the transformation logic.

Solarizes the image by inverting pixel values above a specified threshold.

Parameters

thresholdint, optional: Intensity threshold for inversion, default is 128.

Returns

np.ndarray: Solarized image with inverted pixel values above threshold.

__call__(image)[source]

Implement the transformation logic in this method. Usually, the transformation is applied on a single sample of data.

Parameters:: image (numpy.ndarray)
Return type:: numpy.ndarray

threshold = 128

Parameters:: threshold (int)

class minerva.transforms.transform.Squeeze(axis)[source]

Bases: _Transform

Remove single-dimensional entries from the shape of an array.

Parameters

axisint: The position of the axis to be removed.

__call__(x)[source]

Remove single-dimensional entries from the shape of an array.

Parameters:: x (numpy.ndarray)
Return type:: numpy.ndarray

__str__()[source]

Return type:: str

axis

Parameters:: axis (int)

class minerva.transforms.transform.TransformPipeline(transforms)[source]

Bases: _Transform

Apply a sequence of transforms to a single sample of data and return the transformed data.

Parameters

transformsList[_Transform]: A list of transforms to be applied to the input data.

__add__(other)[source]

Add a transform to the pipeline.

Parameters:: other (_Transform)
Return type:: TransformPipeline

__call__(x)[source]

Apply a sequence of transforms to a single sample of data and return the transformed data.

Parameters:: x (Any)
Return type:: Any

__radd__(other)[source]

Add a transform to the pipeline.

Parameters:: other (_Transform)
Return type:: TransformPipeline

__str__()[source]

Return type:: str

transforms

Parameters:: transforms (Sequence[_Transform])

class minerva.transforms.transform.Transpose(axes)[source]

Bases: _Transform

Reorder the axes of numpy arrays.

Parameters

axesint: The order of the new axes

__call__(x)[source]

Reorder the axes of numpy arrays.

Parameters:: x (numpy.ndarray)
Return type:: numpy.ndarray

__str__()[source]

Return type:: str

axes

Parameters:: axes (Sequence[int])

class minerva.transforms.transform.Unsqueeze(axis)[source]

Bases: _Transform

Add a new axis to the input data at the specified position.

Parameters

axisint: The position of the new axis to be added.

__call__(x)[source]

Add a new axis to the input data at the specified position.

Parameters:: x (numpy.ndarray)
Return type:: numpy.ndarray

__str__()[source]

Return type:: str

axis

Parameters:: axis (int)

class minerva.transforms.transform._Transform[source]

This class is a base class for all transforms. Transforms is just a fancy word for a function that takes an input and returns an output. The input and output can be anything. However, transforms operates over a single sample of data and does not require any additional information to perform the transformation. The __call__ method should be overridden in subclasses to define the transformation logic.

abstract __call__(*args, **kwargs)[source]

Implement the transformation logic in this method. Usually, the transformation is applied on a single sample of data.

Return type:: Any