builder

data.transform.augmentation.builder

_types module-attribute

_types = {None: {__name__: _Wp31for _type in _types}, None: {pascal_to_snake(__name__): _3XCqfor _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

transforms instance-attribute

transforms = transforms

prob instance-attribute

prob = prob

__call__

__call__(*args, force_apply: bool = False, **data) -> Dict

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

def __call__(self, *args, force_apply: bool = False, **data) -> Dict:
    if args:
        raise KeyError("Data must be passed as named arguments, for example: aug(image=image)")

    if (random.random() < self.prob) or force_apply:
        data = self.apply(**data)

    return data

apply

apply(**data) -> Dict

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

def apply(self, **data) -> Dict:
    raise NotImplementedError

__len__

__len__() -> int

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

def __len__(self) -> int:
    return len(self.transforms)

__getitem__

__getitem__(index: int) -> Union[BaseTransform, BaseCompose]

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

def __getitem__(self, index: int) -> Union[BaseTransform, BaseCompose]:
    return self.transforms[index]

add_targets

add_targets(additional_targets: Dict[str, str]) -> None

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

def add_targets(self, additional_targets: Dict[str, str]) -> None:
    for t in self.transforms:
        t.add_targets(additional_targets)

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

apply

apply(**data) -> Dict

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

def apply(self, **data) -> Dict:
    for t in self.transforms:
        data = t(**data)

    return data

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

k instance-attribute

k = k

replacement instance-attribute

replacement = replacement

apply

apply(**data) -> Dict

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

def apply(self, **data) -> Dict:
    if self.replacement:
        cur_transforms = random.choices(self.transforms, k=self.k)
    else:
        cur_transforms = random.sample(self.transforms, k=min(len(self.transforms), self.k))

    for t in cur_transforms:
        data = t(**data)

    return data

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 = {}

targets property

targets: Dict[str, Callable]

apply_to_image

apply_to_image(image: ImageType, **params) -> ImageType

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

def apply_to_image(self, image: ImageType, **params) -> ImageType:
    return image

apply_to_mask

apply_to_mask(mask: MaskType, **params) -> MaskType

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

def apply_to_mask(self, mask: MaskType, **params) -> MaskType:
    return mask

apply_to_bboxes

apply_to_bboxes(bboxes: BBoxesType, **params) -> BBoxesType

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

def apply_to_bboxes(self, bboxes: BBoxesType, **params) -> BBoxesType:
    return bboxes

apply_to_polygons

apply_to_polygons(polygons: PolygonType, **params) -> PolygonType

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

def apply_to_polygons(self, polygons: PolygonType, **params) -> PolygonType:
    return polygons

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 = {}

apply_to_image

apply_to_image(image: ImageType, **params) -> ImageType

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

def apply_to_image(self, image: ImageType, **params) -> ImageType:
    return to_numpy(image=image)

apply_to_mask

apply_to_mask(mask: MaskType, **params) -> MaskType

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

def apply_to_mask(self, mask: MaskType, **params) -> MaskType:
    return to_numpy(image=mask)

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 = {}

apply_to_image

apply_to_image(image: ImageType, **params) -> ImageType

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

def apply_to_image(self, image: ImageType, **params) -> ImageType:
    return to_pil(image=image)

apply_to_mask

apply_to_mask(mask: MaskType, **params) -> MaskType

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

def apply_to_mask(self, mask: MaskType, **params) -> MaskType:
    return to_pil(image=mask)

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 = {}

apply_to_image

apply_to_image(image: ImageType, **params) -> ImageType

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

def apply_to_image(self, image: ImageType, **params) -> ImageType:
    return vertical_flip(image=image)

apply_to_mask

apply_to_mask(mask: MaskType, **params) -> MaskType

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

def apply_to_mask(self, mask: MaskType, **params) -> MaskType:
    return vertical_flip(image=mask)

apply_to_bboxes

apply_to_bboxes(bboxes: BBoxesType, image_size: Tuple[int], **params) -> BBoxesType

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

def apply_to_bboxes(self, bboxes: BBoxesType, image_size: Tuple[int], **params) -> BBoxesType:
    return box_function.vflip_box(bboxes=bboxes, image_size=image_size)

apply_to_polygons

apply_to_polygons(polygons: PolygonType, image_size: Tuple[int], **params) -> PolygonType

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

def apply_to_polygons(self, polygons: PolygonType, image_size: Tuple[int], **params) -> PolygonType:
    return polygon_function.vertical_flip(polygons=polygons, image_size=image_size)

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 = {}

apply_to_image

apply_to_image(image: ImageType, **params) -> ImageType

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

def apply_to_image(self, image: ImageType, **params) -> ImageType:
    return horizontal_flip(image=image)

apply_to_mask

apply_to_mask(mask: MaskType, **params) -> MaskType

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

def apply_to_mask(self, mask: MaskType, **params) -> MaskType:
    return horizontal_flip(image=mask)

apply_to_bboxes

apply_to_bboxes(bboxes: BBoxesType, image_size: Tuple[int], **params) -> BBoxesType

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

def apply_to_bboxes(self, bboxes: BBoxesType, image_size: Tuple[int], **params) -> BBoxesType:
    return box_function.hflip_box(bboxes=bboxes, image_size=image_size)

apply_to_polygons

apply_to_polygons(polygons: PolygonType, image_size: Tuple[int], **params) -> PolygonType

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

def apply_to_polygons(self, polygons: PolygonType, image_size: Tuple[int], **params) -> PolygonType:
    return polygon_function.horizontal_flip(polygons=polygons, image_size=image_size)

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

angle_limit instance-attribute

angle_limit = angle_limit

interpolation instance-attribute

interpolation = interpolation

border_mode instance-attribute

border_mode = border_mode

value instance-attribute

value = value

mask_value instance-attribute

mask_value = mask_value

crop_border instance-attribute

crop_border = crop_border

get_apply_params

get_apply_params() -> ParamsType

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

def get_apply_params(self) -> ParamsType:
    return {"angle": random.uniform(*self.angle_limit)}

apply_to_image

apply_to_image(image: ImageType, angle: float = 0, **params) -> ImageType

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

def apply_to_image(self, image: ImageType, angle: float = 0, **params) -> ImageType:
    return rotate(
        image=image,
        angle=angle,
        interpolation=self.interpolation,
        border_mode=self.border_mode,
        value=self.value,
        crop_border=self.crop_border,
    )

apply_to_mask

apply_to_mask(mask: MaskType, angle: float = 0, **params) -> MaskType

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

def apply_to_mask(self, mask: MaskType, angle: float = 0, **params) -> MaskType:
    return rotate(
        image=mask,
        angle=angle,
        interpolation=cv2.INTER_NEAREST,
        border_mode=self.border_mode,
        value=self.mask_value,
        crop_border=self.crop_border,
    )

apply_to_bboxes

apply_to_bboxes(bboxes: BBoxesType, image_size: Tuple[int], angle: float = 0, **params) -> BBoxesType

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

def apply_to_bboxes(
    self,
    bboxes: BBoxesType,
    image_size: Tuple[int],
    angle: float = 0,
    **params,
) -> BBoxesType:
    return box_function.rotate(bboxes=bboxes, angle=angle, image_size=image_size)

apply_to_polygons

apply_to_polygons(polygons: PolygonType, angle: float, image_size: Tuple[int], **params) -> PolygonType

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

def apply_to_polygons(
    self,
    polygons: PolygonType,
    angle: float,
    image_size: Tuple[int],
    **params,
) -> PolygonType:
    return polygon_function.rotate(polygons=polygons, angle=angle, image_size=image_size)

RandomRotate90

RandomRotate90(**kwargs)

Bases: ImageSizeParams, ImageTransform

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

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

get_apply_params

get_apply_params() -> ParamsType

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

def get_apply_params(self) -> ParamsType:
    return {"factor": random.randint(0, 3)}

apply_to_image

apply_to_image(image: ImageType, factor: int = 0, **params) -> ImageType

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

def apply_to_image(self, image: ImageType, factor: int = 0, **params) -> ImageType:
    return random_rotate90(
        image=image,
        factor=factor,
    )

apply_to_mask

apply_to_mask(mask: MaskType, factor: int = 0, **params) -> MaskType

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

def apply_to_mask(self, mask: MaskType, factor: int = 0, **params) -> MaskType:
    return random_rotate90(
        image=mask,
        factor=factor,
    )

apply_to_bboxes

apply_to_bboxes(bboxes: BBoxesType, image_size: Tuple[int], factor: int = 0, **params) -> BBoxesType

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

def apply_to_bboxes(
    self,
    bboxes: BBoxesType,
    image_size: Tuple[int],
    factor: int = 0,
    **params,
) -> BBoxesType:
    return box_function.rotate90(bboxes=bboxes, factor=factor, image_size=image_size)

apply_to_polygons

apply_to_polygons(polygons: PolygonType, image_size: Tuple[int], factor: int = 0, **params) -> PolygonType

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

def apply_to_polygons(
    self,
    polygons: PolygonType,
    image_size: Tuple[int],
    factor: int = 0,
    **params,
) -> PolygonType:
    return polygon_function.rotate90(polygons=polygons, factor=factor, image_size=image_size)

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

brightness_limit instance-attribute

brightness_limit = brightness_limit

contrast_limit instance-attribute

contrast_limit = contrast_limit

saturation_limit instance-attribute

saturation_limit = saturation_limit

hue_limit instance-attribute

hue_limit = hue_limit

get_apply_params

get_apply_params() -> ParamsType

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

def get_apply_params(self) -> ParamsType:
    order = [0, 1, 2, 3]
    random.shuffle(order)

    return {
        "brightness": random.uniform(*self.brightness_limit),
        "contrast": random.uniform(*self.contrast_limit),
        "saturation": random.uniform(*self.saturation_limit),
        "hue": random.uniform(*self.hue_limit),
        "order": order,
    }

apply_to_image

apply_to_image(image: ImageType, brightness: float = 1.0, contrast: float = 1.0, saturation: float = 1.0, hue: float = 0, order: List[int] = [0, 1, 2, 3], **params) -> ImageType

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

def apply_to_image(
    self,
    image: ImageType,
    brightness: float = 1.0,
    contrast: float = 1.0,
    saturation: float = 1.0,
    hue: float = 0,
    order: List[int] = [0, 1, 2, 3],
    **params,
) -> ImageType:
    return color_jitter(
        image=image,
        brightness=brightness,
        contrast=contrast,
        saturation=saturation,
        hue=hue,
        order=order,
    )

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

ksize_limit instance-attribute

ksize_limit = ksize_limit

get_apply_params

get_apply_params() -> ParamsType

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

def get_apply_params(self) -> ParamsType:
    return {"ksize": random.randint(*self.ksize_limit)}

apply_to_image

apply_to_image(image: ImageType, ksize: int = 3, **params) -> ImageType

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

def apply_to_image(self, image: ImageType, ksize: int = 3, **params) -> ImageType:
    return blur(image=image, ksize=ksize)

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

ksize_limit instance-attribute

ksize_limit = ksize_limit

sigma_limit instance-attribute

sigma_limit = sigma_limit

get_apply_params

get_apply_params() -> ParamsType

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

def get_apply_params(self) -> ParamsType:
    return {
        "ksize": random.randint(*self.ksize_limit),
        "sigma": random.uniform(*self.sigma_limit),
    }

apply_to_image

apply_to_image(image: ImageType, ksize: int = 3, sigma: float = 0.0, **params) -> ImageType

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

def apply_to_image(
    self, image: ImageType, ksize: int = 3, sigma: float = 0.0, **params
) -> ImageType:
    return gaussian_blur(image=image, ksize=ksize, sigma=sigma)

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

brightness_limit instance-attribute

brightness_limit = brightness_limit

get_apply_params

get_apply_params() -> ParamsType

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

def get_apply_params(self) -> ParamsType:
    return {"brightness": random.uniform(*self.brightness_limit)}

apply_to_image

apply_to_image(image: ImageType, brightness: float = 0.0, **params) -> ImageType

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

def apply_to_image(self, image: ImageType, brightness: float = 0.0, **params) -> ImageType:
    return adjust_brightness(image=image, brightness=brightness)

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

contrast_limit instance-attribute

contrast_limit = contrast_limit

get_apply_params

get_apply_params() -> ParamsType

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

def get_apply_params(self) -> ParamsType:
    return {"contrast": random.uniform(*self.contrast_limit)}

apply_to_image

apply_to_image(image: ImageType, contrast: float = 0.0, **params) -> ImageType

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

def apply_to_image(self, image: ImageType, contrast: float = 0.0, **params) -> ImageType:
    return adjust_contrast(image=image, contrast=contrast)

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

hue_limit instance-attribute

hue_limit = hue_limit

get_apply_params

get_apply_params() -> ParamsType

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

def get_apply_params(self) -> ParamsType:
    return {"hue": random.uniform(*self.hue_limit)}

apply_to_image

apply_to_image(image: ImageType, hue: float = 0.0, **params) -> ImageType

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

def apply_to_image(self, image: ImageType, hue: float = 0.0, **params) -> ImageType:
    return adjust_hue(image=image, hue=hue)

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

saturation_limit instance-attribute

saturation_limit = saturation_limit

get_apply_params

get_apply_params() -> ParamsType

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

def get_apply_params(self) -> ParamsType:
    return {"saturation": random.uniform(*self.saturation_limit)}

apply_to_image

apply_to_image(image: ImageType, saturation: float = 0.0, **params) -> ImageType

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

def apply_to_image(self, image: ImageType, saturation: float = 0.0, **params) -> ImageType:
    return adjust_saturation(image=image, saturation=saturation)

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

gamma_limit instance-attribute

gamma_limit = gamma_limit

get_apply_params

get_apply_params() -> ParamsType

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

def get_apply_params(self) -> ParamsType:
    return {"gamma": random.uniform(*self.gamma_limit)}

apply_to_image

apply_to_image(image: ImageType, gamma: float = 0.0, **params) -> ImageType

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

def apply_to_image(self, image: ImageType, gamma: float = 0.0, **params) -> ImageType:
    return adjust_gamma(image=image, gamma=gamma)

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

brightness_limit instance-attribute

brightness_limit = brightness_limit

contrast_limit instance-attribute

contrast_limit = contrast_limit

brightness_by_max instance-attribute

brightness_by_max = brightness_by_max

get_apply_params

get_apply_params() -> ParamsType

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

def get_apply_params(self) -> ParamsType:
    return {
        "brightness": random.uniform(*self.brightness_limit),
        "contrast": random.uniform(*self.contrast_limit),
    }

apply_to_image

apply_to_image(image: ImageType, brightness: float = 0.0, contrast: float = 0.0, **params) -> ImageType

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

def apply_to_image(
    self, image: ImageType, brightness: float = 0.0, contrast: float = 0.0, **params
) -> ImageType:
    return adjust_brightness_contrast(
        image=image,
        brightness=brightness,
        contrast=contrast,
        brightness_by_max=self.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

color_shift_limit instance-attribute

color_shift_limit = color_shift_limit

intensity_limit instance-attribute

intensity_limit = intensity_limit

get_apply_params

get_apply_params() -> ParamsType

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

def get_apply_params(self) -> ParamsType:
    return {
        "color_shift": random.uniform(*self.color_shift_limit),
        "intensity": random.uniform(*self.intensity_limit),
        "random_state": random.randint(0, 65536),
    }

apply_to_image

apply_to_image(image: ImageType, color_shift: float = 0.05, intensity: float = 0.5, random_state: Optional[int] = None, **params) -> ImageType

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

def apply_to_image(
    self,
    image: ImageType,
    color_shift: float = 0.05,
    intensity: float = 0.50,
    random_state: Optional[int] = None,
    **params,
) -> ImageType:
    return iso_noise(
        image=image, color_shift=color_shift, intensity=intensity, random_state=random_state
    )

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

quality_limit instance-attribute

quality_limit = quality_limit

get_apply_params

get_apply_params() -> ParamsType

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

def get_apply_params(self) -> ParamsType:
    return {"quality": random.randint(*self.quality_limit)}

apply_to_image

apply_to_image(image: ImageType, quality: int = 100) -> ImageType

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

def apply_to_image(
    self,
    image: ImageType,
    quality: int = 100,
) -> ImageType:
    return image_compression(image=image, quality=quality, image_type=".jpeg")

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

alpha_limit instance-attribute

alpha_limit = alpha_limit

lightness_limit instance-attribute

lightness_limit = lightness_limit

_generate_sharpening_matrix

_generate_sharpening_matrix(alpha: float, lightness: float) -> ndarray

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

def _generate_sharpening_matrix(self, alpha: float, lightness: float) -> np.ndarray:
    matrix_nochange = np.array([[0, 0, 0], [0, 1, 0], [0, 0, 0]], dtype=np.float32)
    matrix_effect = np.array(
        [[-1, -1, -1], [-1, 8 + lightness, -1], [-1, -1, -1]],
        dtype=np.float32,
    )
    matrix = (1 - alpha) * matrix_nochange + alpha * matrix_effect
    return matrix

get_apply_params

get_apply_params() -> ParamsType

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

def get_apply_params(self) -> ParamsType:
    sharpening_matrix = self._generate_sharpening_matrix(
        random.uniform(*self.alpha_limit), random.uniform(*self.lightness_limit)
    )
    return {"sharpening_matrix": sharpening_matrix}

apply_to_image

apply_to_image(image: ImageType, sharpening_matrix: ndarray) -> ImageType

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

def apply_to_image(
    self,
    image: ImageType,
    sharpening_matrix: np.ndarray,
) -> ImageType:
    return sharpen(image=image, sharpening_matrix=sharpening_matrix)

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

multiplier instance-attribute

multiplier = multiplier

per_channel instance-attribute

per_channel = per_channel

_generate_multiplier

_generate_multiplier(image: ImageType, multiplier: ndarray, random_seed: int) -> ndarray

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

def _generate_multiplier(
    self, image: ImageType, multiplier: np.ndarray, random_seed: int
) -> np.ndarray:
    if multiplier[0] == multiplier[1]:
        return np.array([multiplier[0]])

    height, width = image.shape[:2]
    num_channels = 3

    result_multiplier = np.random.RandomState(seed=random_seed).uniform(
        multiplier[0], multiplier[1], [height, width, num_channels]
    )
    return result_multiplier

get_apply_params

get_apply_params() -> ParamsType

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

def get_apply_params(self) -> ParamsType:
    def _shrink_range(low: int, high: int) -> List[int]:
        lower_bound = random.uniform(low, high)
        upper_bound = random.uniform(lower_bound, high)
        return [lower_bound, upper_bound]

    return {
        "multiplier": np.array(_shrink_range(*self.multiplier)),
        "random_seed": random.randint(0, 65536),
    }

apply_to_image

apply_to_image(image: ImageType, multiplier: ndarray, random_seed: int) -> ImageType

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

def apply_to_image(self, image: ImageType, multiplier: np.ndarray, random_seed: int) -> ImageType:
    _multiplier = self._generate_multiplier(image, multiplier, random_seed)
    return multiplicative_noise(image=image, multiplier=_multiplier)

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

proportion_limit instance-attribute

proportion_limit = proportion_limit

resampling instance-attribute

resampling = resampling

border_mode instance-attribute

border_mode = border_mode

value instance-attribute

value = value

mask_value instance-attribute

mask_value = mask_value

get_apply_params

get_apply_params() -> ParamsType

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

def get_apply_params(self) -> ParamsType:
    return {
        "proportion_left": random.uniform(*self.proportion_limit),
        "proportion_right": random.uniform(*self.proportion_limit),
        "proportion_top": random.uniform(*self.proportion_limit),
        "proportion_bottom": random.uniform(*self.proportion_limit),
    }

apply_to_image

apply_to_image(image: ImageType, proportion_left: float, proportion_right: float, proportion_top: float, proportion_bottom: float, **params) -> ImageType

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

def apply_to_image(
    self,
    image: ImageType,
    proportion_left: float,
    proportion_right: float,
    proportion_top: float,
    proportion_bottom: float,
    **params,
) -> ImageType:
    return ratio_jitter(
        image=image,
        proportion_left=proportion_left,
        proportion_right=proportion_right,
        proportion_top=proportion_top,
        proportion_bottom=proportion_bottom,
        resampling=self.resampling,
        border_mode=self.border_mode,
        value=self.value,
    )

apply_to_mask

apply_to_mask(mask: MaskType, proportion_left: float, proportion_right: float, proportion_top: float, proportion_bottom: float, **params) -> MaskType

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

def apply_to_mask(
    self,
    mask: MaskType,
    proportion_left: float,
    proportion_right: float,
    proportion_top: float,
    proportion_bottom: float,
    **params,
) -> MaskType:
    return ratio_jitter(
        image=mask,
        proportion_left=proportion_left,
        proportion_right=proportion_right,
        proportion_top=proportion_top,
        proportion_bottom=proportion_bottom,
        resampling="nearest",
        border_mode=self.border_mode,
        value=self.mask_value,
    )

apply_to_bboxes

apply_to_bboxes(bboxes: BBoxesType, image_size: Tuple[int], proportion_left: float, proportion_right: float, proportion_top: float, proportion_bottom: float, **params) -> BBoxesType

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

def apply_to_bboxes(
    self,
    bboxes: BBoxesType,
    image_size: Tuple[int],
    proportion_left: float,
    proportion_right: float,
    proportion_top: float,
    proportion_bottom: float,
    **params,
) -> BBoxesType:
    return box_function.ratio_jitter(
        bboxes=bboxes,
        image_size=image_size,
        proportion_left=proportion_left,
        proportion_right=proportion_right,
        proportion_top=proportion_top,
        proportion_bottom=proportion_bottom,
    )

apply_to_polygons

apply_to_polygons(polygons: PolygonType, image_size: Tuple[int], proportion_left: float, proportion_right: float, proportion_top: float, proportion_bottom: float, **params) -> PolygonType

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

def apply_to_polygons(
    self,
    polygons: PolygonType,
    image_size: Tuple[int],
    proportion_left: float,
    proportion_right: float,
    proportion_top: float,
    proportion_bottom: float,
    **params,
) -> PolygonType:
    return polygon_function.ratio_jitter(
        polygons=polygons,
        image_size=image_size,
        proportion_left=proportion_left,
        proportion_right=proportion_right,
        proportion_top=proportion_top,
        proportion_bottom=proportion_bottom,
    )

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

ratio_limit instance-attribute

ratio_limit = ratio_limit

resampling instance-attribute

resampling = resampling

border_mode instance-attribute

border_mode = border_mode

value instance-attribute

value = value

mask_value instance-attribute

mask_value = mask_value

get_apply_params

get_apply_params() -> ParamsType

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

def get_apply_params(self) -> ParamsType:
    log_ratio = (math.log(self.ratio_limit[0]), math.log(self.ratio_limit[1]))
    return {
        "ratio": math.exp(random.uniform(*log_ratio)),
        "h_start": random.random(),
        "w_start": random.random(),
    }

apply_to_image

apply_to_image(image: ImageType, ratio: float, h_start: float, w_start: float, **params) -> ImageType

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

def apply_to_image(
    self,
    image: ImageType,
    ratio: float,
    h_start: float,
    w_start: float,
    **params,
) -> ImageType:
    return zoom(
        image=image,
        ratio=ratio,
        h_start=h_start,
        w_start=w_start,
        resampling=self.resampling,
        border_mode=self.border_mode,
        value=self.value,
    )

apply_to_mask

apply_to_mask(mask: MaskType, ratio: float, h_start: float, w_start: float, **params) -> MaskType

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

def apply_to_mask(
    self,
    mask: MaskType,
    ratio: float,
    h_start: float,
    w_start: float,
    **params,
) -> MaskType:
    return zoom(
        image=mask,
        ratio=ratio,
        h_start=h_start,
        w_start=w_start,
        resampling="nearest",
        border_mode=self.border_mode,
        value=self.mask_value,
    )

apply_to_bboxes

apply_to_bboxes(bboxes: BBoxesType, image_size: Tuple[int], ratio: float, h_start: float, w_start: float, **params) -> BBoxesType

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

def apply_to_bboxes(
    self,
    bboxes: BBoxesType,
    image_size: Tuple[int],
    ratio: float,
    h_start: float,
    w_start: float,
    **params,
) -> BBoxesType:
    return box_function.zoom(
        bboxes=bboxes,
        image_size=image_size,
        ratio=ratio,
        h_start=h_start,
        w_start=w_start,
    )

apply_to_polygons

apply_to_polygons(polygons: PolygonType, image_size: Tuple[int], ratio: float, h_start: float, w_start: float, **params) -> PolygonType

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

def apply_to_polygons(
    self,
    polygons: PolygonType,
    image_size: Tuple[int],
    ratio: float,
    h_start: float,
    w_start: float,
    **params,
) -> PolygonType:
    return polygon_function.zoom(
        polygons=polygons,
        image_size=image_size,
        ratio=ratio,
        h_start=h_start,
        w_start=w_start,
    )

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

scale_limit instance-attribute

scale_limit = scale_limit

aspect_ratio_limit instance-attribute

aspect_ratio_limit = aspect_ratio_limit

resampling instance-attribute

resampling = resampling

targets property

targets: Dict[str, Callable]

get_apply_params

get_apply_params() -> ParamsType

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

def get_apply_params(self) -> ParamsType:
    log_aspect_ratio = (math.log(self.aspect_ratio_limit[0]), math.log(self.aspect_ratio_limit[1]))
    w_scale, h_scale = 1.0, 1.0
    num_attempts = 10
    for _ in range(num_attempts):
        scale = random.uniform(*self.scale_limit)
        aspect_ratio = math.exp(random.uniform(*log_aspect_ratio))
        _w_scale = scale * math.sqrt(aspect_ratio)
        _h_scale = scale / math.sqrt(aspect_ratio)
        if _w_scale <= 1.0 and _h_scale <= 1.0:
            w_scale, h_scale = _w_scale, _h_scale
            break

    return {
        "w_scale": w_scale,
        "h_scale": h_scale,
        "h_start": random.random(),
        "w_start": random.random(),
    }

apply_to_image

apply_to_image(image: ImageType, h_scale: float, w_scale: float, h_start: float, w_start: float, **params) -> ImageType

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

def apply_to_image(
    self,
    image: ImageType,
    h_scale: float,
    w_scale: float,
    h_start: float,
    w_start: float,
    **params,
) -> ImageType:
    return random_resized_crop(
        image=image,
        h_scale=h_scale,
        w_scale=w_scale,
        h_start=h_start,
        w_start=w_start,
        resampling=self.resampling,
    )

apply_to_mask

apply_to_mask(mask: MaskType, h_scale: float, w_scale: float, h_start: float, w_start: float, **params) -> MaskType

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

def apply_to_mask(
    self,
    mask: MaskType,
    h_scale: float,
    w_scale: float,
    h_start: float,
    w_start: float,
    **params,
) -> MaskType:
    return random_resized_crop(
        image=mask,
        h_scale=h_scale,
        w_scale=w_scale,
        h_start=h_start,
        w_start=w_start,
        resampling="nearest",
    )

apply_to_bboxes

apply_to_bboxes(bboxes: BBoxesType, **params) -> BBoxesType

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

def apply_to_bboxes(self, bboxes: BBoxesType, **params) -> BBoxesType:
    raise NotImplementedError

apply_to_polygons

apply_to_polygons(polygons: PolygonType, **params) -> PolygonType

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

def apply_to_polygons(self, polygons: PolygonType, **params) -> PolygonType:
    raise NotImplementedError

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

height instance-attribute

height = height

width instance-attribute

width = width

scale_limit instance-attribute

scale_limit = scale_limit

aspect_ratio_limit instance-attribute

aspect_ratio_limit = aspect_ratio_limit

resampling instance-attribute

resampling = resampling

border_mode instance-attribute

border_mode = border_mode

value instance-attribute

value = value

mask_value instance-attribute

mask_value = mask_value

get_apply_params

get_apply_params() -> ParamsType

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

def get_apply_params(self) -> ParamsType:
    log_aspect_ratio = (math.log(self.aspect_ratio_limit[0]), math.log(self.aspect_ratio_limit[1]))
    return {
        "scale": random.uniform(*self.scale_limit),
        "aspect_ratio": math.exp(random.uniform(*log_aspect_ratio)),
        "h_start": random.random(),
        "w_start": random.random(),
    }

apply_to_image

apply_to_image(image: ImageType, scale: float, aspect_ratio: float, h_start: float, w_start: float, **params) -> ImageType

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

def apply_to_image(
    self,
    image: ImageType,
    scale: float,
    aspect_ratio: float,
    h_start: float,
    w_start: float,
    **params,
) -> ImageType:
    return random_resized_crop_and_pad(
        image=image,
        scale=scale,
        aspect_ratio=aspect_ratio,
        h_start=h_start,
        w_start=w_start,
        height=self.height,
        width=self.width,
        resampling=self.resampling,
        border_mode=self.border_mode,
        value=self.value,
    )

apply_to_mask

apply_to_mask(mask: MaskType, scale: float, aspect_ratio: float, h_start: float, w_start: float, **params) -> MaskType

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

def apply_to_mask(
    self,
    mask: MaskType,
    scale: float,
    aspect_ratio: float,
    h_start: float,
    w_start: float,
    **params,
) -> MaskType:
    return random_resized_crop_and_pad(
        image=mask,
        scale=scale,
        aspect_ratio=aspect_ratio,
        h_start=h_start,
        w_start=w_start,
        height=self.height,
        width=self.width,
        resampling="nearest",
        border_mode=self.border_mode,
        value=self.mask_value,
    )

apply_to_bboxes

apply_to_bboxes(bboxes: BBoxesType, image_size: Tuple[int], scale: float, aspect_ratio: float, h_start: float, w_start: float, **params) -> BBoxesType

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

def apply_to_bboxes(
    self,
    bboxes: BBoxesType,
    image_size: Tuple[int],
    scale: float,
    aspect_ratio: float,
    h_start: float,
    w_start: float,
    **params,
) -> BBoxesType:
    return box_function.random_resized_crop_and_pad(
        bboxes=bboxes,
        image_size=image_size,
        scale=scale,
        aspect_ratio=aspect_ratio,
        h_start=h_start,
        w_start=w_start,
        height=self.height,
        width=self.width,
    )

apply_to_polygons

apply_to_polygons(polygons: PolygonType, image_size: Tuple[int], scale: float, aspect_ratio: float, h_start: float, w_start: float, **params) -> PolygonType

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

def apply_to_polygons(
    self,
    polygons: PolygonType,
    image_size: Tuple[int],
    scale: float,
    aspect_ratio: float,
    h_start: float,
    w_start: float,
    **params,
) -> PolygonType:
    return polygon_function.random_resized_crop_and_pad(
        polygons=polygons,
        image_size=image_size,
        scale=scale,
        aspect_ratio=aspect_ratio,
        h_start=h_start,
        w_start=w_start,
    )

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

radius_limit instance-attribute

radius_limit = radius_limit

get_apply_params

get_apply_params() -> ParamsType

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

def get_apply_params(self) -> ParamsType:
    return {
        "xc": random.random(),
        "yc": random.random(),
        "x_radius": random.uniform(*self.radius_limit),
        "y_radius": random.uniform(*self.radius_limit),
        "angle": random.uniform(0.00, 360.00),
    }

apply_to_image

apply_to_image(image: ImageType, xc: float, yc: float, x_radius: float, y_radius: float, angle: float, **params) -> ImageType

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

def apply_to_image(
    self,
    image: ImageType,
    xc: float,
    yc: float,
    x_radius: float,
    y_radius: float,
    angle: float,
    **params,
) -> ImageType:
    return light_reflect(
        image=image, xc=xc, yc=yc, x_radius=x_radius, y_radius=y_radius, angle=angle
    )

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

intensity_limit instance-attribute

intensity_limit = intensity_limit

get_apply_params

get_apply_params() -> ParamsType

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

def get_apply_params(self) -> ParamsType:
    intensity = random.uniform(*self.intensity_limit)
    return {
        "offset_top_left": tuple((random.uniform(0, intensity), random.uniform(0, intensity))),
        "offset_top_right": tuple((random.uniform(0, intensity), random.uniform(0, intensity))),
        "offset_bottom_right": tuple((random.uniform(0, intensity), random.uniform(0, intensity))),
        "offset_bottom_left": tuple((random.uniform(0, intensity), random.uniform(0, intensity))),
    }

apply_to_image

apply_to_image(image: ImageType, offset_top_left: OffsetType, offset_top_right: OffsetType, offset_bottom_right: OffsetType, offset_bottom_left: OffsetType, **params) -> ImageType

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

def apply_to_image(
    self,
    image: ImageType,
    offset_top_left: OffsetType,
    offset_top_right: OffsetType,
    offset_bottom_right: OffsetType,
    offset_bottom_left: OffsetType,
    **params,
) -> ImageType:
    return perspective_transform(
        image=image,
        offset_top_left=offset_top_left,
        offset_top_right=offset_top_right,
        offset_bottom_right=offset_bottom_right,
        offset_bottom_left=offset_bottom_left,
        interpolate_method="linear",
    )

apply_to_mask

apply_to_mask(mask: MaskType, offset_top_left: OffsetType, offset_top_right: OffsetType, offset_bottom_right: OffsetType, offset_bottom_left: OffsetType, **params) -> MaskType

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

def apply_to_mask(
    self,
    mask: MaskType,
    offset_top_left: OffsetType,
    offset_top_right: OffsetType,
    offset_bottom_right: OffsetType,
    offset_bottom_left: OffsetType,
    **params,
) -> MaskType:
    return perspective_transform(
        image=mask,
        offset_top_left=offset_top_left,
        offset_top_right=offset_top_right,
        offset_bottom_right=offset_bottom_right,
        offset_bottom_left=offset_bottom_left,
        interpolate_method="nearest",
    )

apply_to_bboxes

apply_to_bboxes(bboxes: BBoxesType, image_size: Tuple[int], offset_top_left: OffsetType, offset_top_right: OffsetType, offset_bottom_right: OffsetType, offset_bottom_left: OffsetType, **params) -> BBoxesType

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

def apply_to_bboxes(
    self,
    bboxes: BBoxesType,
    image_size: Tuple[int],
    offset_top_left: OffsetType,
    offset_top_right: OffsetType,
    offset_bottom_right: OffsetType,
    offset_bottom_left: OffsetType,
    **params,
) -> BBoxesType:
    return box_function.perspective_transform(
        bboxes=bboxes,
        image_size=image_size,
        offset_top_left=offset_top_left,
        offset_top_right=offset_top_right,
        offset_bottom_right=offset_bottom_right,
        offset_bottom_left=offset_bottom_left,
    )

apply_to_polygons

apply_to_polygons(polygons: PolygonType, image_size: Tuple[int], offset_top_left: OffsetType, offset_top_right: OffsetType, offset_bottom_right: OffsetType, offset_bottom_left: OffsetType, **params) -> PolygonType

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

def apply_to_polygons(
    self,
    polygons: PolygonType,
    image_size: Tuple[int],
    offset_top_left: OffsetType,
    offset_top_right: OffsetType,
    offset_bottom_right: OffsetType,
    offset_bottom_left: OffsetType,
    **params,
) -> PolygonType:
    return polygon_function.perspective_transform(
        polygons=polygons,
        image_size=image_size,
        offset_top_left=offset_top_left,
        offset_top_right=offset_top_right,
        offset_bottom_right=offset_bottom_right,
        offset_bottom_left=offset_bottom_left,
    )

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

scale instance-attribute

scale = scale

ratio instance-attribute

ratio = ratio

_value instance-attribute

_value = value

randomly_select_values instance-attribute

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

get_apply_params

get_apply_params() -> ParamsType

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

def get_apply_params(self) -> ParamsType:
    value = self._value
    if self.randomly_select_values:
        value_options = {
            "erase": 0,
            "rgb": (random.randint(0, 255), random.randint(0, 255), random.randint(0, 255)),
            "random": "random",
        }
        value = value_options[random.choice(list(value_options.keys()))]

    x_in_ratio, y_in_ratio, h_in_ratio, w_in_ratio = self._get_random_erase_params()

    return dict(
        x_in_ratio=x_in_ratio,
        y_in_ratio=y_in_ratio,
        h_in_ratio=h_in_ratio,
        w_in_ratio=w_in_ratio,
        value=value,
    )

apply_to_image

apply_to_image(image: ImageType, x_in_ratio: float, y_in_ratio: float, h_in_ratio: float, w_in_ratio: float, value: Union[int, Tuple[int, int, int], str], **params) -> ImageType

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

def apply_to_image(
    self,
    image: ImageType,
    x_in_ratio: float,
    y_in_ratio: float,
    h_in_ratio: float,
    w_in_ratio: float,
    value: Union[int, Tuple[int, int, int], str],
    **params,
) -> ImageType:
    is_gray = image.ndim == 2
    if is_gray:
        img_height, img_width = image.shape
    else:
        img_height, img_width, _ = image.shape

    x = int(min(x_in_ratio * img_width, img_width))
    y = int(min(y_in_ratio * img_height, img_height))
    h = int(min(h_in_ratio * img_height, img_height))
    w = int(min(w_in_ratio * img_width, img_width))

    # cast value to script acceptable type
    if isinstance(value, (int, float)):
        value = np.array([float(value)]).astype("uint8")[None, None, :]
    elif isinstance(value, str):
        value = (np.random.normal(size=(h, w, 3)) * 255).astype("uint8")
    elif isinstance(value, (list, tuple)):
        value = np.array([float(v) for v in value]).astype("uint8")[None, None, :]

    return erase(image=image, x=x, y=y, w=w, h=h, v=value)

Grayscale

Grayscale(**kwargs)

Bases: ImageTransform

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

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

apply_to_image

apply_to_image(image: ImageType, **params) -> ImageType

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

def apply_to_image(self, image: ImageType, **params) -> ImageType:
    return grayscale(image=image)

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

to_numpy instance-attribute

to_numpy = ToNumpy()

to_pil instance-attribute

to_pil = ToPil()

transform instance-attribute

transform = transform

__call__

__call__(**data) -> Dict

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

def __call__(self, **data) -> Dict:
    # XXX: image는 np.ndarray, mask는 PIL.Image.Image 인 경우 에러 발생할 수 있음
    # 현재는 해당 케이스로 사용하지 않기 때문에 해결하지 않음
    # 추후 해결 시 고려 사항: Transform의 add_targets 에서 image 혹은 mask 타입이 추가된 경우 모두 함께 처리되어야함
    pil = False
    if "image" in data:
        image = data["image"]
        if isinstance(image, List):
            image = image[0]
        pil = isinstance(image, Image.Image)

    if pil:
        data = self.to_numpy(**data, force_apply=True)

    data = self.transform(**data)

    if pil:
        data = self.to_pil(**data, force_apply=True)

    return data

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)