def __init__(self):
self.policy = A.Compose([
A.OneOf([
A.Rotate(180),
A.Flip(),
], p=0.3),
A.ShiftScaleRotate(shift_limit=0.2, scale_limit=0.5, rotate_limit=0, p=0.2),
A.OneOf([
A.CoarseDropout(max_holes=16, max_height=16, max_width=16, p=0.3),
A.GridDropout(ratio=0.3, p=0.3),
]),
A.OneOf([
A.ElasticTransform(sigma=10, alpha_affine=25, p=0.3),
A.RandomFog(fog_coef_lower=0.2, fog_coef_upper=0.7, p=0.2),
], p=0.2),
A.OneOf([
A.IAAAdditiveGaussianNoise(),
A.GaussNoise(),
A.ISONoise()
], p=0.2),
A.OneOf([
A.MotionBlur(p=.3),
A.MedianBlur(blur_limit=5, p=0.3),
A.Blur(blur_limit=5, p=0.3),
A.GaussianBlur(p=0.3)
], p=0.2),
A.OneOf([
A.ChannelShuffle(p=.3),
A.HueSaturationValue(p=0.3),
A.ToGray(p=0.3),
A.ChannelDropout(p=0.3),
A.InvertImg(p=0.1)
], p=0.2),
A.OneOf([
A.OpticalDistortion(p=0.3),
A.GridDistortion(p=.2),
A.IAAPiecewiseAffine(p=0.3),
], p=0.2),
A.OneOf([
A.CLAHE(clip_limit=2),
A.IAASharpen(),
A.IAAEmboss(),
], p=0.2),
A.RandomBrightnessContrast(brightness_limit=0.3, contrast_limit=0.3, p=0.3),
A.Solarize(p=0.2),
])
def aug(p=0.5):
return Compose(
[
ShiftScaleRotate(border_mode=cv2.BORDER_CONSTANT,
rotate_limit=20,
shift_limit=0.2,
scale_limit=0.2,
p=1), ## interpolation=cv2.INTER_CUBIC
HorizontalFlip(p=0.5),
# VerticalFlip(p=0.5),
# RandomBrightnessContrast(brightness_limit=0.25, contrast_limit=0.25, p=1),
RandomGamma(p=0.5), # (gamma_limit=(50, 150), p=1)
albumentations.IAASharpen(p=0.5),
albumentations.OpticalDistortion(p=0.5),
albumentations.RandomBrightnessContrast(p=0.2)
],
p=p)
def get_training_augmentation1(image_size: tuple = (320, 640)):
"""
Args:
image_size:
Returns:
"""
train_transform = [
albu.HorizontalFlip(p=0.5),
albu.ShiftScaleRotate(scale_limit=0.3, rotate_limit=15, shift_limit=0.1, p=0.5, border_mode=0),
albu.GridDistortion(p=0.5),
albu.OpticalDistortion(p=0.5, distort_limit=0.1, shift_limit=0.2),
albu.Resize(*image_size),
]
return albu.Compose(train_transform)
def get_augmentations(pretrained, img_size, segmentation_problem, randaug_n, randaug_m, cutout_size):
train_aug, val_aug, train_albumentation, val_albumentation = None, None, None, None
if not segmentation_problem:
train_aug = transforms.Compose([
transforms.ToPILImage(), # because the input dtype is numpy.ndarray
transforms.Resize(img_size, interpolation=Image.BICUBIC),
transforms.RandomHorizontalFlip(),
transforms.ToTensor()
])
val_aug = transforms.Compose([
transforms.ToPILImage(), # because the input dtype is numpy.ndarray
transforms.Resize(img_size, interpolation=Image.BICUBIC),
transforms.ToTensor(),
])
if pretrained:
#train_aug.transforms.append(Lighting(0.1, _IMAGENET_PCA['eigval'], _IMAGENET_PCA['eigvec']), )
train_aug.transforms.append(transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]))
val_aug.transforms.append(transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]))
if randaug_n > 0 and randaug_m > 0:
train_aug.transforms.insert(1, RandAugment(randaug_n, randaug_m))
if cutout_size > 0:
train_aug.transforms.append(CutoutDefault(cutout_size))
else: # Segmentation problem
train_albumentation = [
albumentations.Resize(img_size, img_size),
albumentations.ElasticTransform(p=0.72, alpha=177, sigma=177 * 0.05, alpha_affine=176 * 0.03),
albumentations.GridDistortion(p=0.675, distort_limit=0.3),
albumentations.OpticalDistortion(p=0.2, distort_limit=0.2, shift_limit=0.2),
albumentations.ShiftScaleRotate(p=0.56, shift_limit=0.2, scale_limit=0.0, rotate_limit=0), # shift
albumentations.ShiftScaleRotate(p=0.25, shift_limit=0.0, scale_limit=0.2, rotate_limit=0), # scale
albumentations.VerticalFlip(p=0.325),
albumentations.HorizontalFlip(p=0.3),
]
val_albumentation = [
albumentations.Resize(img_size, img_size),
]
return train_aug, val_aug, train_albumentation, val_albumentation
def aug_wo_crop():
transform = A.Compose([
A.HorizontalFlip(p=1.0),
A.VerticalFlip(p=1.0),
A.RandomRotate90(p=1.0),
A.Transpose(p=1.0),
A.ShiftScaleRotate(shift_limit=0.01, scale_limit=0.04, rotate_limit=0, p=1.0),
A.Blur(p=1.0, blur_limit = 3),
A.OneOf([
A.ElasticTransform(p=1.0, alpha=120, sigma=120 * 0.05, alpha_affine=120 * 0.03),
A.GridDistortion(p=1.0),
A.OpticalDistortion(p=1.0, distort_limit=1, shift_limit=0.1)
],
p=1.0)
], p = 1)
return transform
def get_training_augmentation_large():
train_transform = [
# albu.ShiftScaleRotate(scale_limit=0.5, rotate_limit=0, shift_limit=0.1, p=0.5, border_mode=0),
albu.ShiftScaleRotate(scale_limit=0.5,
rotate_limit=0,
shift_limit=0.1,
p=0.5,
border_mode=0),
albu.OpticalDistortion(p=0.5, distort_limit=2, shift_limit=0.5),
#albu.RandomGridShuffle(p=0.5, grid=(3,3)),
#albu.RandomCrop(p=0.5, height=250, width=325),# ADD
#albu.GridDistortion(p=0.5),# ADD
# albu.RandomBrightnessContrast(p=0.5),
#albu.ToGray(p=1.0),
albu.Resize(640, 960) #640)
]
return albu.Compose(train_transform)
def aug_flip_and_rotate(load_path=None):
if load_path:
return A.load(load_path)
else:
aug_seq = A.Compose([
A.Rotate(limit=(-90, 90), p=0.5),
A.Flip(p=0.5),
A.OpticalDistortion(distort_limit=0.05,
shift_limit=0.05,
interpolation=cv2.INTER_LINEAR,
border_mode=cv2.BORDER_REFLECT_101,
value=None,
mask_value=None,
always_apply=False,
p=0.5)
])
return aug_seq
def create_train_transform(flip, noise, cutout, resize, size=112, bright=True):
translist = []
if resize:
if size == 112:
translist += [albumentations.Resize(128, 128)]
elif size == 224:
translist += [albumentations.Resize(256, 256)]
translist += [albumentations.RandomCrop(size, size, always_apply=True)]
if flip:
translist += [
albumentations.OneOf([albumentations.HorizontalFlip()], p=0.5)
]
if noise:
translist += [
albumentations.OneOf([
albumentations.MotionBlur(blur_limit=5),
albumentations.MedianBlur(blur_limit=5),
albumentations.OpticalDistortion(),
albumentations.GaussNoise(var_limit=(5.0, 30.0))
],
p=0.5)
]
if bright:
translist += [
albumentations.RandomBrightness(limit=0.2, always_apply=False)
]
if cutout:
translist += [
albumentations.Cutout(max_h_size=int(size * 0.2),
max_w_size=int(size * 0.2),
num_holes=1,
p=0.3)
]
#translist+=[albumentations.Normalize(mean=(0.2481, 0.2292, 0.2131), std = (0.2167,0.2071,0.2014))]
#trainlist+=[albumentations.Normalize(mean=(0.2539, 0.2348, 0.2189), std = (0.2195,0.2110,0.2061))]
translist += [
albumentations.Normalize(mean=(0.2580, 0.2360, 0.2215),
std=(0.2235, 0.2132, 0.2100))
]
transform = albumentations.Compose(translist)
return transform
def __init__(self, input_shape, train):
self.transform = None
try:
import albumentations as A
check_version(A.__version__, '1.0.3',
hard=True) # version requirement
if train:
# lane mark used
# self.transform = A.Compose([
# A.Resize(height=input_shape[0],width=input_shape[0],interpolation=cv2.INTER_AREA),
# # A.RandomRotate90(p=0.5),
# # A.VerticalFlip(p=0.5),
# # A.HorizontalFlip(p=0.5),
# # A.ChannelShuffle(p=0.5),
# A.OpticalDistortion(p=0.5),
# A.GridDistortion(p=0.5),
# A.HueSaturationValue(p=0.5),
# A.RandomBrightnessContrast(0.5),
# # A.Transpose(p=0.5)
# ])
# normal
self.transform = A.Compose([
A.Resize(height=input_shape[0],
width=input_shape[0],
interpolation=cv2.INTER_AREA),
A.RandomRotate90(p=0.5),
A.VerticalFlip(p=0.5),
A.HorizontalFlip(p=0.5),
A.ChannelShuffle(p=0.5),
A.OpticalDistortion(p=0.5),
A.GridDistortion(p=0.5),
A.HueSaturationValue(p=0.5),
A.RandomBrightnessContrast(0.5),
A.Transpose(p=0.5)
])
else:
self.transform = A.Compose(
[A.Resize(input_shape[0], input_shape[1])], )
# LOGGER.info(colorstr('albumentations: ') + ', '.join(f'{x}' for x in self.transform.transforms if x.p))
except ImportError: # package not installed, skip
pass
except Exception as e:
LOGGER.info(colorstr('albumentations: ') + f'{e}')
def get_transforms(image_size):
transforms_train = albumentations.Compose([
albumentations.Transpose(p=0.5),
albumentations.VerticalFlip(p=0.5),
albumentations.HorizontalFlip(p=0.5),
albumentations.RandomBrightness(limit=0.2, p=0.75),
albumentations.RandomContrast(limit=0.2, p=0.75),
albumentations.OneOf([
albumentations.MotionBlur(blur_limit=5),
albumentations.MedianBlur(blur_limit=5),
albumentations.GaussianBlur(blur_limit=5),
albumentations.GaussNoise(var_limit=(5.0, 30.0)),
],
p=0.7),
albumentations.OneOf([
albumentations.OpticalDistortion(distort_limit=1.0),
albumentations.GridDistortion(num_steps=5, distort_limit=1.),
albumentations.ElasticTransform(alpha=3),
],
p=0.7),
albumentations.CLAHE(clip_limit=4.0, p=0.7),
albumentations.HueSaturationValue(hue_shift_limit=10,
sat_shift_limit=20,
val_shift_limit=10,
p=0.5),
albumentations.ShiftScaleRotate(shift_limit=0.1,
scale_limit=0.1,
rotate_limit=15,
border_mode=0,
p=0.85),
albumentations.Resize(image_size, image_size),
albumentations.Cutout(max_h_size=int(image_size * 0.375),
max_w_size=int(image_size * 0.375),
num_holes=1,
p=0.7),
albumentations.Normalize()
])
transforms_val = albumentations.Compose([
albumentations.Resize(image_size, image_size),
albumentations.Normalize()
])
return transforms_train, transforms_val
def get_training_augmentation(width=525, height=350):
train_transform = [
albu.Resize(height=1024, width=704),
# albu.PadIfNeeded(min_height=640, min_width=480),
albu.HorizontalFlip(p=0.5),
albu.ShiftScaleRotate(scale_limit=0.5,
rotate_limit=0,
shift_limit=0.1,
p=0.5,
border_mode=0),
albu.GridDistortion(p=0.5),
albu.OpticalDistortion(p=0.5, distort_limit=2, shift_limit=0.5),
# albu.Resize(width=width, height=height)
# albu.Resize(1050, 700),
# albu.RandomCrop(672,672),
#
]
return albu.Compose(train_transform)
def get_training_augmentation(p=0.5, size=(320, 640)):
train_transform = [
albu.Resize(*size),
albu.HorizontalFlip(p=p),
albu.ShiftScaleRotate(scale_limit=0.5,
rotate_limit=15,
shift_limit=0.1,
border_mode=0,
p=p),
albu.GridDistortion(p=p),
albu.OpticalDistortion(distort_limit=0.1,
shift_limit=0.5,
p=p),
# albu.Cutout(p=p),
albu.OneOf([albu.Blur(p=p),
albu.GaussianBlur(p=p)], p=p),
]
return albu.Compose(train_transform)
def albumentation(output_folder_name, main_path, original_height, original_width, input_path):
'''
- output_folder_name : you should give just the name of the output folder, it will be created by function
- main_path : the folder that output folder will be created and results will be saved
- input_path : the folder that includes images and labels in seperate folders
'''
os.mkdir(main_path + '/'+ output_folder_name)
os.mkdir(main_path + '/'+ output_folder_name +'/images')
os.mkdir(main_path + '/'+ output_folder_name +'/labels')
for img in sorted(os.listdir(input_path + '/images')):
image = cv2.imread(input_path +'/images/' + img, 0)
mask = cv2.imread(input_path +'/labels/' + img, 0)
##############################################################
aug = A.Compose([
A.OneOf([
A.RandomSizedCrop(min_max_height=(50, 101), height=original_height, width=original_width, p=0.5),
A.PadIfNeeded(min_height=original_height, min_width=original_width, p=0.5)
], p=1),
A.VerticalFlip(p=0.5),
A.RandomRotate90(p=0.5),
A.OneOf([
A.ElasticTransform(alpha=120, sigma=120 * 0.05, alpha_affine=120 * 0.03, p=0.5),
A.GridDistortion(p=0.5),
A.OpticalDistortion(distort_limit=2, shift_limit=0.5, p=1)
], p=0.8),
A.CLAHE(p=0.8),
A.RandomBrightnessContrast(p=0.8),
A.RandomGamma(p=0.8)])
##############################################################
augmented = aug(image=image, mask=mask)
image = augmented['image']
mask = augmented['mask']
cv2.imwrite(main_path +'/'+ output_folder_name +'/images/' + img, image)
cv2.imwrite(main_path +'/' + output_folder_name +'/labels/' + img, mask)
print("Results are saved in output directory.")
def load_agumentation_pipelines():
# Define the augmentation pipeline
augmentation_pipeline_train = A.Compose(
[
A.Resize(width=512, height=512),
A.HorizontalFlip(p=0.5), # apply horizontal flip to 50% of images
A.Rotate(limit=90,
p=0.5), # apply random with limit of 90° to 50% of images
A.OneOf(
[
# apply one of transforms to 30% of images
A.RandomBrightnessContrast(
), # apply random contrast & brightness
A.RandomGamma(), # apply random gamma
],
p=0.3,
),
A.OneOf(
[
# apply one of transforms to 30% images
A.ElasticTransform(
alpha=120, sigma=120 * 0.05, alpha_affine=120 * 0.03),
A.GridDistortion(),
A.OpticalDistortion(distort_limit=2, shift_limit=0.5),
],
p=0.3,
),
A.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
ToTensorV2(), # convert the image to PyTorch tensor
],
p=1,
)
# Define the transformation pipeline for test
tranformation_pipeline_test = A.Compose(
[
A.Resize(width=512, height=512),
A.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
ToTensorV2(), # convert the image to PyTorch tensor
],
p=1,
)
return augmentation_pipeline_train, tranformation_pipeline_test
def get_training_augmentation(size=480):
train_transform = [
# albu.HorizontalFlip(p=0.5),
# albu.VerticalFlip(p=0.5),
albu.RandomBrightnessContrast(p=0.3),
albu.CLAHE(p=0.3),
albu.ShiftScaleRotate(scale_limit=0.75,
rotate_limit=0,
shift_limit=0.1,
p=0.5,
border_mode=0),
albu.GridDistortion(p=0.5),
albu.OpticalDistortion(p=0.5, distort_limit=2, shift_limit=0.5),
# albu.RandomResizedCrop( 320, 640, scale=(0.5, 1.0), p=0.75),
# albu.RandomResizedCrop( 350, 525, scale=(0.5, 1.0), p=0.75),
# albu.Resize(350, 525)
albu.Resize(size, size)
]
return albu.Compose(train_transform)
def augmentation(img_size):
return albu.Compose([
#spatial wise
#albu.RandomCrop(img_size[0],img_size[1]),
albu.RandomResizedCrop(img_size[0],img_size[1],
interpolation=cv2.INTER_NEAREST),
albu.Rotate(interpolation=cv2.INTER_NEAREST),
albu.HorizontalFlip(),
albu.ElasticTransform(alpha_affine=10,interpolation=cv2.INTER_NEAREST),
albu.OpticalDistortion(interpolation=cv2.INTER_NEAREST),
#pixel transform
albu.RandomGamma((100,180),p=0.8),
albu.Blur(5),
albu.RandomBrightness(limit=(0.05,0.20)),
albu.RandomContrast(limit=(0,0.20),p=0.5),
albu.MotionBlur( blur_limit =7),
])
def get_training_augmentation():
train_transform = [
albu.Resize(320, 640),
albu.HorizontalFlip(p=0.5),
albu.VerticalFlip(p=0.5),
albu.ShiftScaleRotate(scale_limit=0.5, rotate_limit=15, shift_limit=0.15, p=0.9, border_mode=cv2.BORDER_REFLECT),
#albu.GridDistortion(p=0.5),
albu.OpticalDistortion(p=0.5, distort_limit=2, shift_limit=0.5),
#albu.OneOf([
# albu.CLAHE(clip_limit=2),
# albu.IAASharpen(),
# albu.IAAEmboss(),
# albu.RandomContrast(),
# albu.RandomBrightness(),
#], p=0.3),
albu.RandomBrightnessContrast(p=0.5),
albu.GaussNoise(p=0.5)
]
return albu.Compose(train_transform)
def get_training_augmentation():
train_transform = [
A.HorizontalFlip(p=0.5),
A.VerticalFlip(p=0.5),
A.Rotate(limit=3, p=0.5),
A.OpticalDistortion(p=0.2),
A.OneOf([
CropNonEmptyMaskIfExists(256,320, p=0.3),
A.RandomCrop(256, 320, p=0.7),
], p=1.0),
A.PadIfNeeded(min_height=256, min_width=550,
border_mode=cv2.BORDER_CONSTANT,
value=0, p=0.3),
A.RandomCrop(256, 320, p=1.0)
]
return A.Compose(train_transform)
def build_Transform(self):
self.as_tensor = T.Compose([
T.ToTensor(),
T.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
# T.Normalize([0.66406784, 0.50002077, 0.7019763],
# [0.15964855, 0.24647547, 0.13597253]),
])
self.identity = rasterio.Affine(1, 0, 0, 0, 1, 0)
self.resizefunc = A.Compose(
[A.Resize(self.imgsize[0], self.imgsize[1])])
if self.transform is None:
self.transform = A.Compose([
A.HorizontalFlip(p=0.5),
A.VerticalFlip(p=0.5),
A.ChannelShuffle(p=0.25),
A.OneOf([
A.HueSaturationValue(12, 12, 12, p=0.8),
A.CLAHE(clip_limit=2),
A.RandomBrightnessContrast(),
],
p=0.5),
A.OneOf([
A.RandomContrast(),
A.RandomGamma(),
A.RandomBrightness(),
A.ColorJitter(brightness=0.07,
contrast=0.07,
saturation=0.1,
hue=0.1,
always_apply=False,
p=0.6),
],
p=0.5),
A.OneOf([
A.ElasticTransform(
alpha=120, sigma=120 * 0.05, alpha_affine=120 * 0.03),
A.GridDistortion(),
A.OpticalDistortion(distort_limit=2, shift_limit=0.5),
],
p=0.3),
A.ShiftScaleRotate(p=0.5),
])
def classification_augmentation():
"""Rationalized version of the one above.
"""
return alb.Compose(
[
alb.HorizontalFlip(p=.5), # 128 mus
alb.OneOf(
[
# These two do the same thing I think. Keeping only
# the faster one.
alb.IAAAdditiveGaussianNoise(p=1.), # 484 mus
# alb.GaussNoise(p=1.), # 1.11 ms
],
p=0.2), # 1.03 ms with both
alb.OneOf([
alb.MotionBlur(p=1.),
alb.MedianBlur(blur_limit=3, p=1.),
alb.Blur(blur_limit=3, p=1.),
],
p=0.2), # 40 mus
alb.ShiftScaleRotate(
shift_limit=0.1, scale_limit=0.1, rotate_limit=30, p=0.8),
# (above) 348 mus
alb.OneOf(
[
alb.OpticalDistortion(p=1.), # 95 mus
alb.GridDistortion(p=1.), # 101 mus
# alb.IAAPiecewiseAffine(p=1.), # 5.61 ms
],
p=0.2), # 2.48 ms -> 113 mus with the 2 first ones
alb.OneOf([
alb.CLAHE(clip_limit=2, p=1.),
alb.IAASharpen(p=1.),
alb.IAAEmboss(p=1.),
alb.RandomContrast(p=1.),
alb.RandomBrightness(p=1.),
],
p=0.3), # 257 mus
alb.HueSaturationValue(p=0.3), # 395 mus
],
p=0.9) # 3.84 ms -> 1.52 ms
def get_training_augmentation(x: int = 320, y: int = 640):
train_transform = [
albu.HorizontalFlip(p=0.5),
albu.ShiftScaleRotate(scale_limit=0.5,
rotate_limit=0,
shift_limit=0.1,
p=0.5,
border_mode=0),
# albu.RandomGamma(p=0.75),
albu.GridDistortion(p=0.25),
albu.OpticalDistortion(p=0.5, distort_limit=2, shift_limit=0.5),
albu.Resize(x, y),
# albu.Normalize(always_apply=True),
]
return albu.Compose(train_transform,
additional_targets={
"image2": "image",
"image3": "image",
"image4": "image"
})
def get_transforms(phase, width=1600, height=256):
list_transforms = []
if phase == "train":
list_transforms.extend([
albu.HorizontalFlip(p=0.5),
albu.ShiftScaleRotate(scale_limit=0.5,
rotate_limit=0,
shift_limit=0.1,
p=0.5,
border_mode=0),
albu.GridDistortion(p=0.5),
albu.OpticalDistortion(p=0.5, distort_limit=2, shift_limit=0.5),
])
list_transforms.extend([
albu.Resize(width, height),
# albu.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), p=1),
# ToTensor(),
])
list_trfms = albu.Compose(list_transforms)
return list_trfms
def get_train_transforms_v2():
return A.Compose(
[
A.Resize(config.SIZE, config.SIZE),
A.OneOf(
[
A.GaussNoise(var_limit=1.15),
A.MultiplicativeNoise(multiplier=1.1),
],
p=0.2,
),
A.RandomBrightnessContrast(
contrast_limit=0.12, brightness_limit=0.12, p=0.2
),
A.OpticalDistortion(distort_limit=0.07, shift_limit=0.07, p=0.25),
A.GaussianBlur(p=0.15),
A.RandomGridShuffle(grid=(4, 4), p=0.2),
ToTensorV2(),
]
)
def generate_ds(size):
trfm = A.Compose([
A.Resize(size, size, p=1.0),
A.HorizontalFlip(),
A.VerticalFlip(),
A.RandomRotate90(),
A.ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.2, rotate_limit=20, p=0.9,
border_mode=cv2.BORDER_REFLECT),
A.OneOf([
A.OpticalDistortion(p=0.4),
A.GridDistortion(p=.1),
A.IAAPiecewiseAffine(p=0.4),
], p=0.3),
A.OneOf([
A.HueSaturationValue(10,15,10),
A.CLAHE(clip_limit=3),
A.RandomBrightnessContrast(),
], p=0.5)
], p=1.0)
return HubDataset(DATA_PATH, window=WINDOW, overlap=MIN_OVERLAP, transform=trfm)
def data_augmentation(image_path, aug_num):
image = cv2.imread(image_path, cv2.IMREAD_COLOR)
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
augmentation = A.Compose(
[
A.RandomRotate90(),
A.Flip(),
A.Transpose(),
A.OneOf([
A.IAAAdditiveGaussianNoise(),
A.GaussNoise(),
], p=0.2),
A.OneOf([
A.MotionBlur(p=0.2),
A.MedianBlur(blur_limit=3, p=0.1),
A.Blur(blur_limit=3, p=0.1),
],
p=0.2),
A.ShiftScaleRotate(
shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=0.2),
A.OneOf([
A.OpticalDistortion(p=0.3),
A.GridDistortion(p=0.1),
A.IAAPiecewiseAffine(p=0.3),
],
p=0.2),
A.OneOf([
A.CLAHE(clip_limit=2),
A.IAASharpen(),
A.IAAEmboss(),
A.RandomBrightnessContrast(),
],
p=0.3),
# A.HueSaturationValue(p=0.3),
],
p=0.5)
patches = []
for _ in range(aug_num):
patches.append(augmentation(image=image)['image'])
return patches
def get_medium_augmentations(image_size):
return A.Compose([
A.OneOf([
A.ShiftScaleRotate(shift_limit=0.05,
scale_limit=0.1,
rotate_limit=15,
border_mode=cv2.BORDER_CONSTANT,
value=0),
A.OpticalDistortion(distort_limit=0.11,
shift_limit=0.15,
border_mode=cv2.BORDER_CONSTANT,
value=0),
A.NoOp()
]),
ZeroTopAndBottom(p=0.3),
A.RandomSizedCrop(min_max_height=(int(image_size[0] * 0.75),
image_size[0]),
height=image_size[0],
width=image_size[1],
p=0.3),
A.OneOf([
A.RandomBrightnessContrast(brightness_limit=0.5,
contrast_limit=0.4),
IndependentRandomBrightnessContrast(brightness_limit=0.25,
contrast_limit=0.24),
A.RandomGamma(gamma_limit=(50, 150)),
A.NoOp()
]),
A.OneOf([
FancyPCA(alpha_std=4),
A.RGBShift(r_shift_limit=20, b_shift_limit=15, g_shift_limit=15),
A.HueSaturationValue(hue_shift_limit=5, sat_shift_limit=5),
A.NoOp()
]),
A.OneOf([ChannelIndependentCLAHE(p=0.5),
A.CLAHE(),
A.NoOp()]),
A.HorizontalFlip(p=0.5),
A.VerticalFlip(p=0.5)
])
def albumentations_list(MAGN: int = 4):
"""
Returns standard list of albumentations transforms, each of mangitude `MAGN`.
Args:
MAGN (int): Magnitude of each transform in the returned list.
"""
M = MAGN
transform_list = [
# PIXEL-LEVEL
A.RandomContrast(limit=M * .1, always_apply=True),
A.RandomBrightness(limit=M * .1, always_apply=True),
A.Equalize(always_apply=True),
A.OpticalDistortion(distort_limit=M * .2,
shift_limit=M * .1,
always_apply=True),
A.RGBShift(r_shift_limit=M * 10,
g_shift_limit=M * 10,
b_shift_limit=M * 10,
always_apply=True),
A.ISONoise(color_shift=(M * .01, M * .1),
intensity=(M * .02, M * .2),
always_apply=True),
A.RandomFog(fog_coef_lower=M * .01,
fog_coef_upper=M * .1,
always_apply=True),
A.CoarseDropout(max_holes=M * 10, always_apply=True),
A.GaussNoise(var_limit=(M, M * 50), always_apply=True),
# SPATIAL
A.Rotate(always_apply=True),
A.Transpose(always_apply=True),
A.NoOp(always_apply=True),
A.ElasticTransform(alpha=M * .25,
sigma=M * 3,
alpha_affine=M * 3,
always_apply=True),
A.GridDistortion(distort_limit=M * .075, always_apply=True)
]
return transform_list
def _setup_transform(self, cfg):
# Albumentation example: https://albumentations.readthedocs.io/en/latest/examples.html
self.img_mask_transform = A.Compose([
A.ShiftScaleRotate(shift_limit=0.1, scale_limit=0.2, rotate_limit=175, p=0.8, border_mode=cv2.BORDER_CONSTANT),
A.Flip(),
A.Transpose(),
A.OneOf([
A.ElasticTransform(),
A.OpticalDistortion(),
A.GridDistortion(),
A.IAAPiecewiseAffine(),
]),
A.OneOf([
A.RandomCrop(height=self.size_crop,width=self.size_crop,p=0.5),
A.CenterCrop(height=self.size_crop,width=self.size_crop,p=0.5)
]),
A.Cutout(num_holes=8, max_h_size=8, max_w_size=8, fill_value=0,p=0.5),
],p=0.8)
self.img_pixel_transform = A.Compose([
A.OneOf([
A.IAAAdditiveGaussianNoise(),
A.GaussNoise(),
], p=0.2),
A.OneOf([
A.MotionBlur(p=0.2),
A.MedianBlur(blur_limit=3, p=0.1),
A.Blur(blur_limit=3, p=0.1),
], p=0.2),
A.OneOf([
A.IAASharpen(),
A.IAAEmboss(),
# A.RandomBrightnessContrast(),
], p=0.3),
A.HueSaturationValue(hue_shift_limit=3,sat_shift_limit=20,val_shift_limit=3 ,p=0.2),
],p=0.5)
# Torch transform
self.resize_transform = transforms.Resize(cfg.MODEL.IMAGE_SIZE, Image.NEAREST)
self.to_tensor_transform = transforms.ToTensor()
self.normalize_transform = transforms.Normalize(mean=cfg.TRAIN.NORMALIZE_MEAN, std=cfg.TRAIN.NORMALIZE_STD)
def aug_heavy(prob=0.9):
return aug.Compose([
aug.Flip(),
aug.OneOf([
aug.CLAHE(clip_limit=2, p=.5),
aug.IAASharpen(p=.25),
aug.IAAEmboss(p=.25),
],
p=.35),
aug.OneOf([
aug.IAAAdditiveGaussianNoise(p=.3),
aug.GaussNoise(p=.7),
SaltPepperNoise(level_limit=0.0002, p=.7),
aug.ISONoise(p=.3),
],
p=.5),
aug.OneOf([
aug.MotionBlur(p=.2),
aug.MedianBlur(blur_limit=3, p=.3),
aug.Blur(blur_limit=3, p=.5),
],
p=.4),
aug.OneOf([
aug.RandomContrast(p=.5),
aug.RandomBrightness(p=.5),
aug.RandomGamma(p=.5),
],
p=.4),
aug.ShiftScaleRotate(
shift_limit=.0625, scale_limit=0.1, rotate_limit=12, p=.7),
aug.OneOf([
aug.GridDistortion(p=.2),
aug.ElasticTransform(
alpha=120, sigma=120 * 0.05, alpha_affine=120 * 0.03, p=.2),
aug.OpticalDistortion(distort_limit=2, shift_limit=0.5, p=.2),
],
p=.6),
aug.HueSaturationValue(p=.5),
],
p=prob)
def __init__(self, args):
MEAN, STD = get_stat(args.mix_window)
self.transform = A.Compose([
A.RandomResizedCrop(args.image_size,
args.image_size,
interpolation=cv2.INTER_LINEAR,
scale=(0.8, 1)),
# A.Resize(args.image_size, args.image_size),
A.HorizontalFlip(),
A.VerticalFlip(), # add this -> freebie in tta stage
################################
# Test augmentation
################################
A.OneOf([
A.ShiftScaleRotate(shift_limit=0.0625,
scale_limit=0.1,
rotate_limit=30,
border_mode=cv2.BORDER_CONSTANT,
value=0),
A.GridDistortion(distort_limit=0.2,
border_mode=cv2.BORDER_CONSTANT,
value=0),
A.OpticalDistortion(distort_limit=0.2,
shift_limit=0.15,
border_mode=cv2.BORDER_CONSTANT,
value=0),
A.NoOp()
]),
A.OneOf([
A.IAAAdditiveGaussianNoise(),
A.GaussNoise(),
A.MedianBlur(blur_limit=3),
A.Blur(blur_limit=3),
],
p=0.15),
A.Normalize(MEAN, STD),
ToTensor()
])
