builder

data.transform.augmentation.builder

_types module-attribute

_types = {None: {__name__: _C3eufor _type in _types}, None: {pascal_to_snake(__name__): _fBwTfor _type in _types}}

logger module-attribute

logger = getLogger('SaigeResearch')

BaseCompose

BaseCompose(transforms: Sequence[Union[BaseTransform, BaseCompose]], prob: float = 1.0)

여러 Data Transform들을 하나로 묶어서 관리해주는 Compose의 기본 interface를 정의합니다.

Source code in SaigeToolkit/data/transform/augmentation/compose/base_compose.py

def __init__(
    self, transforms: Sequence[Union[BaseTransform, BaseCompose]], prob: float = 1.0
) -> None:
    self.transforms = transforms
    self.prob = prob

Compose

Compose(transforms: Sequence[Union[BaseTransform, BaseCompose]], prob: float = 1.0)

Bases: BaseCompose

Source code in SaigeToolkit/data/transform/augmentation/compose/base_compose.py

def __init__(
    self, transforms: Sequence[Union[BaseTransform, BaseCompose]], prob: float = 1.0
) -> None:
    self.transforms = transforms
    self.prob = prob

SomeOf

SomeOf(k: int, replacement: bool = False, **kwargs)

Bases: BaseCompose

Source code in SaigeToolkit/data/transform/augmentation/compose/compose.py

def __init__(self, k: int, replacement: bool = False, **kwargs) -> None:
    super().__init__(**kwargs)
    self.k = k
    self.replacement = replacement

ImageTransform

ImageTransform(prob: float = 0.5)

Bases: BaseTransform

Image와 라벨에 적용되는 Transform 입니다.

Source code in SaigeToolkit/data/transform/augmentation/base_transform.py

def __init__(self, prob: float = 0.5) -> None:
    self.prob = prob
    self._additional_targets = {}

ToNumpy

ToNumpy(prob: float = 0.5)

Bases: ImageTransform

Source code in SaigeToolkit/data/transform/augmentation/base_transform.py

def __init__(self, prob: float = 0.5) -> None:
    self.prob = prob
    self._additional_targets = {}

ToPil

ToPil(prob: float = 0.5)

Bases: ImageTransform

Source code in SaigeToolkit/data/transform/augmentation/base_transform.py

def __init__(self, prob: float = 0.5) -> None:
    self.prob = prob
    self._additional_targets = {}

VerticalFlip

VerticalFlip(prob: float = 0.5)

Bases: ImageSizeParams, ImageTransform

Source code in SaigeToolkit/data/transform/augmentation/base_transform.py

def __init__(self, prob: float = 0.5) -> None:
    self.prob = prob
    self._additional_targets = {}

HorizontalFlip

HorizontalFlip(prob: float = 0.5)

Bases: ImageSizeParams, ImageTransform

Source code in SaigeToolkit/data/transform/augmentation/base_transform.py

def __init__(self, prob: float = 0.5) -> None:
    self.prob = prob
    self._additional_targets = {}

Rotate

Rotate(angle_limit: Optional[List[float]] = None, interpolation: int = cv2.INTER_LINEAR, border_mode: int = cv2.BORDER_CONSTANT, value: Union[int, float, List[int], List[float]] = 0, mask_value: Union[int, float] = 0, crop_border: bool = False, **kwargs)

Bases: ImageSizeParams, ImageTransform

Source code in SaigeToolkit/data/transform/augmentation/augment_transform.py

def __init__(
    self,
    angle_limit: Optional[List[float]] = None,
    interpolation: int = cv2.INTER_LINEAR,
    border_mode: int = cv2.BORDER_CONSTANT,
    value: Union[int, float, List[int], List[float]] = 0,
    mask_value: Union[int, float] = 0,
    crop_border: bool = False,
    **kwargs,
) -> None:
    super().__init__(**kwargs)

    if angle_limit is None:
        angle_limit = [-30.0, 30.0]

    check_range(angle_limit, -360.0, 360.0)

    self.angle_limit = angle_limit
    self.interpolation = interpolation
    self.border_mode = border_mode
    self.value = value
    self.mask_value = mask_value
    self.crop_border = crop_border

RandomRotate90

RandomRotate90(**kwargs)

Bases: ImageSizeParams, ImageTransform

Source code in SaigeToolkit/data/transform/augmentation/augment_transform.py

def __init__(self, **kwargs) -> None:
    super().__init__(**kwargs)

ColorJitter

ColorJitter(brightness_limit: Optional[List[float]] = None, contrast_limit: Optional[List[float]] = None, saturation_limit: Optional[List[float]] = None, hue_limit: Optional[List[float]] = None, **kwargs)

Bases: ImageTransform

Source code in SaigeToolkit/data/transform/augmentation/augment_transform.py

def __init__(
    self,
    brightness_limit: Optional[List[float]] = None,
    contrast_limit: Optional[List[float]] = None,
    saturation_limit: Optional[List[float]] = None,
    hue_limit: Optional[List[float]] = None,
    **kwargs,
) -> None:
    super().__init__(**kwargs)

    if brightness_limit is None:
        brightness_limit = [0.8, 1.2]
    if contrast_limit is None:
        contrast_limit = [0.8, 1.2]
    if saturation_limit is None:
        saturation_limit = [0.8, 1.2]
    if hue_limit is None:
        hue_limit = [-0.2, 0.2]

    check_range(brightness_limit, 0.01, 10.00)
    check_range(contrast_limit, 0.01, 10.00)
    check_range(saturation_limit, 0.01, 10.00)
    check_range(hue_limit, -0.50, 0.50)

    self.brightness_limit = brightness_limit
    self.contrast_limit = contrast_limit
    self.saturation_limit = saturation_limit
    self.hue_limit = hue_limit

Blur

Blur(ksize_limit: Optional[List[int]] = None, **kwargs)

Bases: ImageTransform

Source code in SaigeToolkit/data/transform/augmentation/augment_transform.py

def __init__(self, ksize_limit: Optional[List[int]] = None, **kwargs) -> None:
    super().__init__(**kwargs)

    if ksize_limit is None:
        ksize_limit = [3, 7]

    check_range(ksize_limit, 1, 100)

    self.ksize_limit = ksize_limit

GaussianBlur

GaussianBlur(ksize_limit: Optional[List[int]] = None, sigma_limit: Optional[List[float]] = None, **kwargs)

Bases: ImageTransform

Source code in SaigeToolkit/data/transform/augmentation/augment_transform.py

def __init__(
    self,
    ksize_limit: Optional[List[int]] = None,
    sigma_limit: Optional[List[float]] = None,
    **kwargs,
) -> None:
    super().__init__(**kwargs)

    if ksize_limit is None:
        ksize_limit = [3, 7]
    if sigma_limit is None:
        sigma_limit = [0.0, 0.0]

    check_range(ksize_limit, 1, 100)
    check_range(sigma_limit, 0.00, 100.00)

    self.ksize_limit = ksize_limit
    self.sigma_limit = sigma_limit

AdjustBrightness

AdjustBrightness(brightness_limit: Optional[List[float]] = None, **kwargs)

Bases: ImageTransform

Source code in SaigeToolkit/data/transform/augmentation/augment_transform.py

def __init__(self, brightness_limit: Optional[List[float]] = None, **kwargs) -> None:
    super().__init__(**kwargs)

    if brightness_limit is None:
        brightness_limit = [-0.2, 0.2]

    check_range(brightness_limit, -1.0, 1.0)

    self.brightness_limit = brightness_limit

AdjustContrast

AdjustContrast(contrast_limit: Optional[List[float]] = None, **kwargs)

Bases: ImageTransform

Source code in SaigeToolkit/data/transform/augmentation/augment_transform.py

def __init__(self, contrast_limit: Optional[List[float]] = None, **kwargs) -> None:
    super().__init__(**kwargs)

    if contrast_limit is None:
        contrast_limit = [-0.2, 0.2]

    check_range(contrast_limit, -1.0, 1.0)

    self.contrast_limit = contrast_limit

AdjustHue

AdjustHue(hue_limit: Optional[List[float]] = None, **kwargs)

Bases: ImageTransform

Source code in SaigeToolkit/data/transform/augmentation/augment_transform.py

def __init__(self, hue_limit: Optional[List[float]] = None, **kwargs) -> None:
    super().__init__(**kwargs)

    if hue_limit is None:
        hue_limit = [-0.2, 0.2]

    check_range(hue_limit, -1.0, 1.0)

    self.hue_limit = hue_limit

AdjustSaturation

AdjustSaturation(saturation_limit: Optional[List[float]] = None, **kwargs)

Bases: ImageTransform

Source code in SaigeToolkit/data/transform/augmentation/augment_transform.py

def __init__(self, saturation_limit: Optional[List[float]] = None, **kwargs) -> None:
    super().__init__(**kwargs)

    if saturation_limit is None:
        saturation_limit = [-0.2, 0.2]

    check_range(saturation_limit, -1.0, 1.0)

    self.saturation_limit = saturation_limit

AdjustGamma

AdjustGamma(gamma_limit: Optional[List[float]] = None, **kwargs)

Bases: ImageTransform

Source code in SaigeToolkit/data/transform/augmentation/augment_transform.py

def __init__(self, gamma_limit: Optional[List[float]] = None, **kwargs) -> None:
    super().__init__(**kwargs)

    if gamma_limit is None:
        gamma_limit = [-0.2, 0.2]

    check_range(gamma_limit, -1.0, 1.0)

    self.gamma_limit = gamma_limit

AdjustBrightnessContrast

AdjustBrightnessContrast(brightness_limit: Optional[List[float]] = None, contrast_limit: Optional[List[float]] = None, brightness_by_max: bool = True, **kwargs)

Bases: ImageTransform

Source code in SaigeToolkit/data/transform/augmentation/augment_transform.py

def __init__(
    self,
    brightness_limit: Optional[List[float]] = None,
    contrast_limit: Optional[List[float]] = None,
    brightness_by_max: bool = True,
    **kwargs,
) -> None:
    super().__init__(**kwargs)

    if brightness_limit is None:
        brightness_limit = [-0.2, 0.2]
    if contrast_limit is None:
        contrast_limit = [-0.2, 0.2]

    check_range(brightness_limit, -1.00, 1.00)
    check_range(contrast_limit, -1.00, 1.00)

    self.brightness_limit = brightness_limit
    self.contrast_limit = contrast_limit
    self.brightness_by_max = brightness_by_max

IsoNoise

IsoNoise(color_shift_limit: Optional[List[float]] = None, intensity_limit: Optional[List[float]] = None, **kwargs)

Bases: ImageTransform

Source code in SaigeToolkit/data/transform/augmentation/augment_transform.py

def __init__(
    self,
    color_shift_limit: Optional[List[float]] = None,
    intensity_limit: Optional[List[float]] = None,
    **kwargs,
) -> None:
    super().__init__(**kwargs)

    if color_shift_limit is None:
        color_shift_limit = [0.01, 0.05]
    if intensity_limit is None:
        intensity_limit = [0.1, 0.5]

    check_range(color_shift_limit, 0.00, 1.00)
    check_range(intensity_limit, 0.00, 2.00)

    self.color_shift_limit = color_shift_limit
    self.intensity_limit = intensity_limit

JpegCompression

JpegCompression(quality_limit: Optional[List[int]] = None, **kwargs)

Bases: ImageTransform

Source code in SaigeToolkit/data/transform/augmentation/augment_transform.py

def __init__(
    self,
    quality_limit: Optional[List[int]] = None,
    **kwargs,
) -> None:
    super().__init__(**kwargs)

    if quality_limit is None:
        quality_limit = [5, 30]

    check_range(quality_limit, 0, 100)

    self.quality_limit = quality_limit

Sharpen

Sharpen(alpha_limit: Optional[List[int]] = None, lightness_limit: Optional[List[int]] = None, **kwargs)

Bases: ImageTransform

Source code in SaigeToolkit/data/transform/augmentation/augment_transform.py

def __init__(
    self,
    alpha_limit: Optional[List[int]] = None,
    lightness_limit: Optional[List[int]] = None,
    **kwargs,
) -> None:
    super().__init__(**kwargs)

    if alpha_limit is None:
        alpha_limit = [0.20, 0.50]

    if lightness_limit is None:
        lightness_limit = [0.80, 1.20]

    check_range(alpha_limit, 0.00, 1.00)
    check_range(lightness_limit, 0.00, 10.00)

    self.alpha_limit = alpha_limit
    self.lightness_limit = lightness_limit

MultiplicativeNoise

MultiplicativeNoise(multiplier: Optional[List[float]] = None, per_channel: bool = True, **kwargs)

Bases: ImageTransform

Source code in SaigeToolkit/data/transform/augmentation/augment_transform.py

def __init__(
    self,
    multiplier: Optional[List[float]] = None,
    per_channel: bool = True,
    **kwargs,
) -> None:
    super().__init__(**kwargs)

    if multiplier is None:
        multiplier = [0.80, 1.20]

    check_range(multiplier, 0.00, 5.00)

    self.multiplier = multiplier
    self.per_channel = per_channel

RatioJitter

RatioJitter(proportion_limit: Optional[Union[List[float], int, float]] = None, resampling: str = 'bilinear', border_mode: int = cv2.BORDER_CONSTANT, value: Union[int, float, List[int], List[float]] = 0, mask_value: Union[int, float] = 0, **kwargs)

Bases: ImageSizeParams, ImageTransform

crop, pad, and resize to original image size

Source code in SaigeToolkit/data/transform/augmentation/augment_transform.py

def __init__(
    self,
    proportion_limit: Optional[Union[List[float], int, float]] = None,
    resampling: str = "bilinear",
    border_mode: int = cv2.BORDER_CONSTANT,
    value: Union[int, float, List[int], List[float]] = 0,
    mask_value: Union[int, float] = 0,
    **kwargs,
) -> None:
    super().__init__(**kwargs)

    if proportion_limit is None:
        proportion_limit = [-0.10, 0.10]

    if isinstance(proportion_limit, int):
        # NOTE: int 입력은 백분율로 적용.
        proportion_limit = [-abs(proportion_limit) / 100, abs(proportion_limit) / 100]

    if isinstance(proportion_limit, float):
        # NOTE: float 입력은 0~1 스케일로 적용.
        proportion_limit = [-abs(proportion_limit), abs(proportion_limit)]

    check_range(proportion_limit, -0.50, 0.50)

    self.proportion_limit = proportion_limit
    self.resampling = resampling
    self.border_mode = border_mode
    self.value = value
    self.mask_value = mask_value

Zoom

Zoom(ratio_limit: Optional[List[float]] = None, resampling: str = 'bilinear', border_mode: int = cv2.BORDER_CONSTANT, value: Union[int, float, List[int], List[float]] = 0, mask_value: Union[int, float] = 0, **kwargs)

Bases: ImageSizeParams, ImageTransform

Source code in SaigeToolkit/data/transform/augmentation/augment_transform.py

def __init__(
    self,
    ratio_limit: Optional[List[float]] = None,
    resampling: str = "bilinear",
    border_mode: int = cv2.BORDER_CONSTANT,
    value: Union[int, float, List[int], List[float]] = 0,
    mask_value: Union[int, float] = 0,
    **kwargs,
) -> None:
    super().__init__(**kwargs)

    if ratio_limit is None:
        ratio_limit = [0.50, 2.00]

    check_range(ratio_limit, 0.01, 100.00)

    self.ratio_limit = ratio_limit
    self.resampling = resampling
    self.border_mode = border_mode
    self.value = value
    self.mask_value = mask_value

RandomResizedCrop

RandomResizedCrop(scale_limit: Optional[List[float]] = None, aspect_ratio_limit: Optional[List[float]] = None, resampling: str = 'bilinear', **kwargs)

Bases: ImageSizeParams, ImageTransform

Crop a random part of the input and rescale it to original size

Parameters:

• scale_limit (Optional[List[float]], default: None ) –

  range of size of the origin size cropped. Defaults to [0.45, 1.00].

• aspect_ratio_limit (Optional[List[float]], default: None ) –

  range of aspect ratio of the origin aspect ratio cropped. Defaults to [0.50, 2.00].

• resampling (str, default: 'bilinear' ) –

  interpolation method. Defaults to "bilinear".

Source code in SaigeToolkit/data/transform/augmentation/augment_transform.py

def __init__(
    self,
    scale_limit: Optional[List[float]] = None,
    aspect_ratio_limit: Optional[List[float]] = None,
    resampling: str = "bilinear",
    **kwargs,
) -> None:
    """
    Args:
        scale_limit (Optional[List[float]], optional): range of size of the origin size cropped. Defaults to [0.45, 1.00].
        aspect_ratio_limit (Optional[List[float]], optional): range of aspect ratio of the origin aspect ratio cropped. Defaults to [0.50, 2.00].
        resampling (str, optional): interpolation method. Defaults to "bilinear".
    """
    super().__init__(**kwargs)

    if scale_limit is None:
        scale_limit = [0.45, 1.00]
    if aspect_ratio_limit is None:
        aspect_ratio_limit = [0.50, 2.00]

    check_range(scale_limit, 0.01, 1.00)
    check_range(aspect_ratio_limit, 0.10, 10.00)

    self.scale_limit = scale_limit
    self.aspect_ratio_limit = aspect_ratio_limit
    self.resampling = resampling

RandomResizedCropAndPad

RandomResizedCropAndPad(scale_limit: Optional[List[float]] = None, aspect_ratio_limit: Optional[List[float]] = None, height: Optional[int] = None, width: Optional[int] = None, resampling: str = 'bilinear', border_mode: int = cv2.BORDER_CONSTANT, value: Union[int, float, List[int], List[float]] = 0, mask_value: Union[int, float] = 0, **kwargs)

Bases: ImageSizeParams, ImageTransform

pad, crop and resize to original image size

Source code in SaigeToolkit/data/transform/augmentation/augment_transform.py

def __init__(
    self,
    scale_limit: Optional[List[float]] = None,
    aspect_ratio_limit: Optional[List[float]] = None,
    height: Optional[int] = None,
    width: Optional[int] = None,
    resampling: str = "bilinear",
    border_mode: int = cv2.BORDER_CONSTANT,
    value: Union[int, float, List[int], List[float]] = 0,
    mask_value: Union[int, float] = 0,
    **kwargs,
) -> None:
    super().__init__(**kwargs)

    if scale_limit is None:
        scale_limit = [0.45, 1.00]
    if aspect_ratio_limit is None:
        aspect_ratio_limit = [0.50, 2.00]

    check_range(scale_limit, 0.01, 1.00)
    check_range(aspect_ratio_limit, 0.10, 10.00)

    self.height = height
    self.width = width
    self.scale_limit = scale_limit
    self.aspect_ratio_limit = aspect_ratio_limit
    self.resampling = resampling
    self.border_mode = border_mode
    self.value = value
    self.mask_value = mask_value

LightReflect

LightReflect(radius_limit: Optional[List[float]] = None, **kwargs)

Bases: ImageTransform

Source code in SaigeToolkit/data/transform/augmentation/augment_transform.py

def __init__(self, radius_limit: Optional[List[float]] = None, **kwargs) -> None:
    super().__init__(**kwargs)

    if radius_limit is None:
        radius_limit = [0.10, 0.50]

    check_range(radius_limit, 0.00, 1.00)

    self.radius_limit = radius_limit

PerspectiveTransform

PerspectiveTransform(intensity_limit: Optional[List[float]] = None, **kwargs)

Bases: ImageSizeParams, ImageTransform

Source code in SaigeToolkit/data/transform/augmentation/augment_transform.py

def __init__(
    self,
    intensity_limit: Optional[List[float]] = None,
    **kwargs,
) -> None:
    super().__init__(**kwargs)

    if intensity_limit is None:
        intensity_limit = [0, 30]

    check_range(intensity_limit, 0, 49)

    self.intensity_limit = intensity_limit

RandomErasing

RandomErasing(scale: Tuple[float, float] = (0.02, 0.33), ratio: Tuple[float, float] = (0.2, 3.3), value: Union[int, Tuple[int, int, int], str] = 0, randomly_select_values: bool = False, **kwargs)

Bases: ImageTransform

Source code in SaigeToolkit/data/transform/augmentation/augment_transform.py

def __init__(
    self,
    scale: Tuple[float, float] = (0.02, 0.33),
    ratio: Tuple[float, float] = (0.2, 3.3),
    value: Union[int, Tuple[int, int, int], str] = 0,
    randomly_select_values: bool = False,
    **kwargs,
) -> None:
    super().__init__(**kwargs)
    self.scale = scale
    self.ratio = ratio
    self._value = value
    self.randomly_select_values = randomly_select_values

_get_random_erase_params

_get_random_erase_params()

This is modified version of get_params of random erasing see: https://pytorch.org/vision/main/_modules/torchvision/transforms/transforms.html#RandomErasing.forward

Source code in SaigeToolkit/data/transform/augmentation/augment_transform.py

def _get_random_erase_params(self):
    """
    This is modified version of get_params of random erasing
    see: https://pytorch.org/vision/main/_modules/torchvision/transforms/transforms.html#RandomErasing.forward
    """
    area = 1

    log_ratio = torch.log(torch.tensor(self.ratio))
    for _ in range(10):
        erase_area = area * torch.empty(1).uniform_(self.scale[0], self.scale[1]).item()
        aspect_ratio = torch.exp(torch.empty(1).uniform_(log_ratio[0], log_ratio[1])).item()

        h_in_ratio = math.sqrt(erase_area * aspect_ratio)
        w_in_ratio = math.sqrt(erase_area / aspect_ratio)

        if not (h_in_ratio < 1 and w_in_ratio < 1):
            continue

        x_in_ratio = random.uniform(0, 1 - w_in_ratio)
        y_in_ratio = random.uniform(0, 1 - h_in_ratio)

        return x_in_ratio, y_in_ratio, h_in_ratio, w_in_ratio

    # Return Original Image
    return 0, 0, 1.0, 1.0

Grayscale

Grayscale(**kwargs)

Bases: ImageTransform

Source code in SaigeToolkit/data/transform/augmentation/augment_transform.py

def __init__(self, **kwargs) -> None:
    super().__init__(**kwargs)

Augmentation

Augmentation(transform)

Source code in SaigeToolkit/data/transform/augmentation/builder.py

def __init__(self, transform) -> None:
    self.to_numpy = ToNumpy()
    self.to_pil = ToPil()
    self.transform = transform

build_compose

build_compose(_target_: str, transforms: List[BaseTransform], **config) -> BaseCompose

Source code in SaigeToolkit/data/transform/augmentation/compose/builder.py

def build_compose(_target_: str, transforms: List[BaseTransform], **config) -> BaseCompose:
    return _types[_target_](transforms=transforms, **config)

build_augmentation

build_augmentation(config: Dict) -> Augmentation

Source code in SaigeToolkit/data/transform/augmentation/builder.py

def build_augmentation(config: Dict) -> Augmentation:
    logger.info(f"[AUGMENTATION]\n{pprint.pformat(config, sort_dicts=False)}")

    config = dict(config.items())
    _target_ = config.pop("_target_")
    target_class = _types[_target_]

    # Build transform
    if issubclass(target_class, ImageTransform):
        transform = target_class(**config)

    # Build compose
    elif issubclass(target_class, BaseCompose):
        transform_configs = config.pop("transforms", [])

        _transforms = []
        for transform_config in transform_configs:
            _transform = build_transform(**transform_config)
            _transforms.append(_transform)
        config["transforms"] = _transforms

        transform = build_compose(_target_, **config)

    else:
        raise NotImplementedError(f"Unsupported augmentation type: {_target_}")

    return Augmentation(transform)

build_transform

build_transform(_target_: str, **config)

Source code in SaigeToolkit/data/transform/augmentation/builder.py

def build_transform(_target_: str, **config):
    transform = _types[_target_]
    return transform(**config)