def get_training_augmentation(type='basic'):
if type == 'basic':
train_transform = [
album.RandomCrop(height=1024, width=1024, always_apply=True),
album.HorizontalFlip(p=0.5),
album.VerticalFlip(p=0.5),
]
elif type == 'advance':
train_transform = [
album.RandomCrop(height=1024, width=1024, always_apply=True),
album.HorizontalFlip(p=0.5),
album.VerticalFlip(p=0.5),
album.RandomBrightnessContrast(brightness_limit=0.25, contrast_limit=0.25),
album.HueSaturationValue(p=0.5),
album.Blur(blur_limit=7, p=0.5),
album.ToGray(p=0.5),
album.IAASharpen(p=0.5),
]
elif type == 'intermediate':
train_transform = [
album.RandomCrop(height=1024, width=1024, always_apply=True),
album.HorizontalFlip(p=0.5),
album.VerticalFlip(p=0.5),
album.Rotate(limit=90, p=0.5),
album.RandomBrightnessContrast(brightness_limit=0.25, contrast_limit=0.25),
album.HueSaturationValue(p=0.5),
]
else:
raise ValueError(f'type {type} is not supported')
return album.Compose(train_transform)
def hard_transforms():
result = [
# miscelaneous
A.IAAAdditiveGaussianNoise(p=0.2),
#A.CoarseDropout(max_holes=10, max_height=50, max_width=50, min_height=15, min_width=15, p=0.25),
# brightness
#A.OneOf(
# [
# A.RandomBrightnessContrast(p=1),
# A.RandomGamma(p=1),
# ],
# p=0.9,
#),
# sharpening / blurring
A.OneOf(
[
A.IAASharpen(p=1),
A.Blur(blur_limit=3, p=1),
],
p=0.9,
),
#
]
return result
def albumentation():
transform = albumentations.Compose([
albumentations.OneOf([
albumentations.GaussNoise(),
albumentations.IAAAdditiveGaussianNoise()
]),
albumentations.OneOf([
albumentations.MotionBlur(blur_limit=3, p=0.2),
albumentations.MedianBlur(blur_limit=3, p=0.1),
albumentations.Blur(blur_limit=2, p=0.1)
]),
albumentations.OneOf([
albumentations.RandomBrightness(limit=(0.1, 0.4)),
albumentations.HueSaturationValue(hue_shift_limit=(0, 128), sat_shift_limit=(0, 60), val_shift_limit=(0, 20)),
albumentations.RGBShift(r_shift_limit=30, g_shift_limit=30, b_shift_limit=30)
]),
albumentations.OneOf([
albumentations.CLAHE(),
albumentations.ChannelShuffle(),
albumentations.IAASharpen(),
albumentations.IAAEmboss(),
albumentations.RandomBrightnessContrast(),
]),
albumentations.OneOf([
albumentations.RandomGamma(gamma_limit=(35,255)),
albumentations.OpticalDistortion(),
albumentations.GridDistortion(),
albumentations.IAAPiecewiseAffine()
]),
A_torch.ToTensor(normalize={
"mean": [0.485, 0.456, 0.406],
"std" : [0.229, 0.224, 0.225]})
])
return transform
def get_train_transform():
crop_height = 256
crop_width = 256
return albu.Compose([
albu.PadIfNeeded(min_height=crop_height, min_width=crop_width, p=1),
albu.RandomSizedCrop((int(0.3 * crop_height), 288), crop_height, crop_width, p=1),
albu.HorizontalFlip(p=0.5),
albu.OneOf([
albu.IAAAdditiveGaussianNoise(p=0.5),
albu.GaussNoise(p=0.5),
], p=0.2),
albu.OneOf([
albu.MotionBlur(p=0.2),
albu.MedianBlur(blur_limit=3, p=0.1),
albu.Blur(blur_limit=3, p=0.1),
], p=0.2),
albu.ShiftScaleRotate(shift_limit=0.0625, scale_limit=0, rotate_limit=20, p=0.1),
albu.OneOf([
albu.OpticalDistortion(p=0.3),
albu.GridDistortion(p=0.1),
albu.IAAPiecewiseAffine(p=0.3),
], p=0.2),
albu.OneOf([
albu.CLAHE(clip_limit=2, p=0.5),
albu.IAASharpen(p=0.5),
albu.IAAEmboss(p=0.5),
albu.RandomBrightnessContrast(p=0.5),
], p=0.3),
albu.HueSaturationValue(p=0.3),
albu.JpegCompression(p=0.2, quality_lower=20, quality_upper=99),
albu.ElasticTransform(p=0.1),
albu.Normalize(p=1)
], p=1)
def augment(self, img0, img1):
transform = A.Compose([
A.IAAAdditiveGaussianNoise(p=0.05),
A.OneOf([
A.IAASharpen(p=1.0),
A.Blur(blur_limit=3, p=1.0),
],
p=0.5),
A.OneOf([
A.RandomBrightnessContrast(p=1.0),
A.HueSaturationValue(p=1.0),
A.RandomGamma(p=1.0),
],
p=0.5),
A.OneOf([
A.RandomFog(p=1.0),
A.RandomRain(p=1.0),
A.RandomShadow(p=1.0),
A.RandomSnow(p=1.0),
A.RandomSunFlare(p=1.0)
],
p=0.05),
],
additional_targets={'img1': 'image'})
transformed = transform(image=img0, img1=img1)
img0 = transformed["image"]
img1 = transformed["img1"]
return img0, img1
def _strong_aug(p=0.5):
import albumentations
return albumentations.Compose([
albumentations.HorizontalFlip(p=0.5),
albumentations.ShiftScaleRotate(shift_limit=0.0625,
scale_limit=0.2,
rotate_limit=0,
p=0.5,
border_mode=cv2.BORDER_CONSTANT),
albumentations.OneOf([
albumentations.OpticalDistortion(p=0.5,
border_mode=cv2.BORDER_CONSTANT),
albumentations.GridDistortion(p=0.5,
border_mode=cv2.BORDER_CONSTANT),
albumentations.IAAPiecewiseAffine(p=0.5),
albumentations.ElasticTransform(p=0.5,
border_mode=cv2.BORDER_CONSTANT),
],
p=0.5),
albumentations.OneOf([
albumentations.CLAHE(clip_limit=2),
albumentations.IAASharpen(),
albumentations.IAAEmboss(),
],
p=0.5),
albumentations.OneOf([
albumentations.RandomBrightnessContrast(p=0.5),
],
p=0.4),
albumentations.HueSaturationValue(p=0.5),
],
p=p)
def get_training_augmentation():
train_transform = [
albu.ShiftScaleRotate(scale_limit=0.1,
rotate_limit=0.,
shift_limit=0.1,
p=1,
border_mode=0),
albu.IAAAdditiveGaussianNoise(p=0.2),
albu.OneOf(
[
albu.CLAHE(p=1),
albu.RandomBrightness(p=1),
albu.RandomGamma(p=1),
],
p=0.6,
),
albu.OneOf(
[
albu.IAASharpen(p=1),
albu.Blur(blur_limit=3, p=1),
albu.MotionBlur(blur_limit=3, p=1),
],
p=0.6,
),
albu.OneOf(
[
albu.RandomContrast(p=1),
albu.HueSaturationValue(p=1),
],
p=0.6,
),
]
return albu.Compose(train_transform)
def album(self): #이미지 변환
transform = A.Compose([
#A.RandomRotate90(),
A.Flip(p=0.2),
#A.Transpose(),
A.ChannelShuffle(p=0.3),
A.ElasticTransform(p=0.3,border_mode=cv2.BORDER_REFLECT_101,alpha_affine=40),
A.OneOf([
A.IAAAdditiveGaussianNoise(),
A.GaussNoise(),
], p=0.2),
A.OneOf([
A.MotionBlur(p=.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=.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),
])
image = cv2.cvtColor(self.srcResize, cv2.COLOR_BGR2RGB)
transformed = transform(image=image)['image']
self.update(transformed)
def get_aug(mode="train"):
if mode == "Nor":
aug = A.Compose([
ToTensor(),
])
elif mode == "train":
aug = A.Compose([
A.Flip(),
A.ShiftScaleRotate(rotate_limit=1.0, p=0.8),
# Pixels
A.OneOf([
A.IAAEmboss(p=1.0),
A.IAASharpen(p=1.0),
A.Blur(p=1.0),
],
p=0.5),
# Affine
A.OneOf(
[A.ElasticTransform(p=1.0),
A.IAAPiecewiseAffine(p=1.0)],
p=0.5),
A.Normalize(p=1.0),
ToTensor(),
])
else:
aug = A.Compose([
A.Normalize(p=1.0),
ToTensor(),
])
return aug
def add_transforms(self):
if self.train:
self.transforms += [
A.Resize(int(self.img_size[0] * 1.1), int(self.img_size[1] * 1.1)),
A.RandomCrop(self.img_size[0], self.img_size[1]),
A.HorizontalFlip(p=0.5),
A.VerticalFlip(p=0.5),
A.Rotate(p=0.5, border_mode=BORDER_REFLECT, value=0),
# Pixels
A.OneOf([
A.IAAEmboss(p=1.0),
A.IAASharpen(p=1.0),
A.Blur(p=1.0),
], p=0.5),
# Affine
A.OneOf([
A.ElasticTransform(p=1.0),
A.IAAPiecewiseAffine(p=1.0)
], p=0.5),
]
else:
self.transforms += [
A.Resize(self.img_size[0], self.img_size[1]),
]
def __init__(self, noisy=False, p=1):
argumentors = [
RandomBrightness(p=0.25),
RandomContrast(p=0.25),
RandomHue(p=0.25),
RandomSaturation(p=0.25),
RandomEqualize(p=0.0625),
RandomAutoContrast(p=0.0625),
RandomAlpha(p=0.25),
]
if noisy:
argumentors.extend(
[
RandomPosterize(p=0.0625),
A.Solarize(threshold=(50, 255 - 50), p=0.0625),
RandomBlur(p=0.125),
RandomUnsharpMask(p=0.125),
A.IAASharpen(alpha=(0, 0.5), p=0.125),
GaussNoise(p=0.125),
SpeckleNoise(p=0.125),
A.ISONoise(color_shift=(0, 0.05), intensity=(0, 0.5), p=0.125),
A.JpegCompression(quality_lower=50, quality_upper=100, p=0.125),
]
)
super().__init__(argumentors, p=p)
def gentle_transform(p):
return albu.Compose(
[
# p=0.5
albu.HorizontalFlip(p=0.5),
albu.VerticalFlip(p=0.5),
albu.OneOf(
[
albu.IAASharpen(p=1),
albu.Blur(blur_limit=3, p=1),
albu.MotionBlur(blur_limit=3, p=1),
],
p=0.5,
),
albu.OneOf(
[
albu.RandomBrightness(p=1),
albu.RandomGamma(p=1),
],
p=0.5,
),
# p=0.2
albu.ShiftScaleRotate(rotate_limit=30,
scale_limit=0.15,
border_mode=cv2.BORDER_CONSTANT,
value=[0, 0, 0],
p=0.2),
albu.IAAAdditiveGaussianNoise(p=0.2),
albu.IAAPerspective(p=0.2),
],
p=p,
additional_targets={
'image{}'.format(_): 'image'
for _ in range(1, 65)
})
def build_transforms(cfg, split='train'):
if split == 'train':
train_transform = [
albu.Resize(cfg.INPUT.SIZE, cfg.INPUT.SIZE),
# albu.HorizontalFlip(p=0.5),
albu.OneOf(
[
# albu.RandomRotate90(p=1),
albu.Rotate(p=1, limit=(-15, 15)),
],
p=0.5),
albu.GaussNoise(p=0.5),
albu.OneOf(
[
# albu.CLAHE(p=1),
albu.RandomBrightnessContrast(p=1),
],
p=0.9,
),
albu.OneOf(
[
albu.IAASharpen(p=1),
albu.Blur(p=1),
albu.MedianBlur(p=1),
],
p=0.9,
),
]
return albu.Compose(train_transform, p=0.6)
else:
test_transform = [albu.Resize(cfg.INPUT.SIZE, cfg.INPUT.SIZE)]
return albu.Compose(test_transform)
def augment(image):
transform = A.Compose([
A.HorizontalFlip(p=0.5),
A.OneOf([
A.IAAAdditiveGaussianNoise(),
A.GaussNoise(),
], p=0.2),
A.OneOf([
A.MotionBlur(p=.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=15,
p=0.2),
A.OneOf([
A.CLAHE(clip_limit=2),
A.IAASharpen(),
A.IAAEmboss(),
A.RandomBrightnessContrast(),
A.RandomGamma(),
],
p=0.5),
A.HueSaturationValue(p=0.3),
])
augmented_image = transform(image=image)['image']
return augmented_image
def augment_image(self, image):
transform = A.Compose([
A.OneOf([
A.IAAAdditiveGaussianNoise(),
A.GaussNoise(),
], p=0.3),
A.OneOf([
A.MotionBlur(p=.4),
A.MedianBlur(blur_limit=3, p=0.3),
A.Blur(blur_limit=3, p=0.3),
],
p=0.4),
A.OneOf([
A.CLAHE(clip_limit=2),
A.IAASharpen(),
A.IAAEmboss(),
A.RandomBrightnessContrast(),
],
p=0.3),
A.HueSaturationValue(p=0.3),
])
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
augmented_image = transform(image=image)['image']
augmented_image = cv2.cvtColor(augmented_image, cv2.COLOR_RGB2BGR)
return augmented_image
def get_training_augmentation():
train_transform = [
A.RandomSizedCrop(min_max_height=(300, 360), height=320, width=320,
always_apply=True),
A.HorizontalFlip(p=0.5),
A.OneOf([
A.CLAHE(),
A.RandomBrightnessContrast(),
A.RandomGamma(),
A.HueSaturationValue(),
A.NoOp()
]),
A.OneOf([
A.IAAAdditiveGaussianNoise(p=0.2),
A.IAASharpen(),
A.Blur(blur_limit=3),
A.MotionBlur(blur_limit=3),
A.NoOp()
]),
A.OneOf([
A.RandomFog(),
A.RandomSunFlare(),
A.RandomRain(),
A.RandomSnow(),
A.NoOp()
]),
A.Normalize(),
]
return A.Compose(train_transform)
def get_training_augmentation():
train_transform = [
albu.HorizontalFlip(p=0.5),
albu.IAAAdditiveGaussianNoise(p=0.2),
albu.IAAPerspective(p=0.5),
albu.PadIfNeeded(min_height=1216,
min_width=512,
always_apply=True,
border_mode=0),
#0.9的機率取出OneOf中的其中一個, 各個抽中的機率皆為1/3( 因為1/(1+1+1) )
albu.OneOf(
[
albu.CLAHE(p=1),
albu.RandomBrightness(p=1),
albu.RandomGamma(p=1),
],
p=0.9,
),
albu.OneOf(
[
albu.IAASharpen(p=1),
albu.Blur(blur_limit=3, p=1),
albu.MotionBlur(blur_limit=3, p=1),
],
p=0.9,
),
albu.OneOf(
[
albu.RandomContrast(p=1),
albu.HueSaturationValue(p=1),
],
p=0.9,
),
]
return albu.Compose(train_transform)
def get_training_augmentation():
train_transform = albu.Compose([
albu.IAAAdditiveGaussianNoise(p=0.2),
albu.IAAPerspective(p=0.5),
albu.OneOf(
[
albu.CLAHE(p=1),
albu.RandomBrightness(p=1),
albu.RandomGamma(p=1),
],
p=0.9,
),
albu.OneOf(
[
albu.IAASharpen(p=1),
albu.Blur(blur_limit=3, p=1),
albu.MotionBlur(blur_limit=3, p=1),
],
p=0.9,
),
albu.OneOf(
[
albu.RandomContrast(p=1),
albu.HueSaturationValue(p=1),
],
p=0.9,
),
],
additional_targets={'depth': 'mask'})
return train_transform
def _strong_aug(p=0.5):
return albumentations.Compose([
albumentations.HorizontalFlip(),
albumentations.VerticalFlip(),
albumentations.ShiftScaleRotate(
shift_limit=0, scale_limit=0, rotate_limit=15, p=0.3),
albumentations.OneOf([
albumentations.OpticalDistortion(p=0.3),
albumentations.GridDistortion(p=0.1),
albumentations.IAAPiecewiseAffine(p=0.3),
],
p=0.2),
albumentations.OneOf([
albumentations.CLAHE(clip_limit=2),
albumentations.IAASharpen(),
albumentations.IAAEmboss(),
],
p=0.3),
albumentations.OneOf([
albumentations.RandomBrightnessContrast(p=0.3),
],
p=0.4),
albumentations.HueSaturationValue(p=0.3),
],
p=p)
def strong_aug(p=.5):
return A.Compose([
A.RandomRotate90(),
A.Flip(),
A.Transpose(),
A.OneOf([
A.IAAAdditiveGaussianNoise(),
A.GaussNoise(),
], p=0.2),
A.OneOf([
A.MotionBlur(p=.2),
A.MedianBlur(blur_limit=3, p=.1),
A.Blur(blur_limit=3, p=.1),
],
p=0.2),
A.ShiftScaleRotate(
shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=.2),
A.OneOf([
A.OpticalDistortion(p=0.3),
A.GridDistortion(p=.1),
A.IAAPiecewiseAffine(p=0.3),
],
p=0.2),
A.OneOf([
A.CLAHE(clip_limit=2),
A.IAASharpen(),
A.IAAEmboss(),
A.RandomContrast(),
A.RandomBrightness(),
],
p=0.3),
A.HueSaturationValue(p=0.3),
],
p=p)
def get_train_transforms(
height: int = 14 * 32, # 14*32 then 28*32
width: int = 18 * 32): #18*32 then 37*32
return A.Compose([
A.HorizontalFlip(p=0.5),
A.IAAAdditiveGaussianNoise(p=0.2),
A.IAAPerspective(p=0.4),
A.OneOf([
A.CLAHE(p=1.0),
A.RandomBrightness(p=1.0),
A.RandomGamma(p=1.0),
],
p=0.5),
A.OneOf([
A.IAASharpen(p=1.0),
A.Blur(blur_limit=3, p=1.0),
A.MotionBlur(blur_limit=3, p=1.0),
],
p=0.5),
A.OneOf([
A.RandomContrast(p=1.0),
A.HueSaturationValue(p=1.0),
],
p=0.5),
A.Resize(height=height, width=width, p=1.0),
],
p=1.0)
def get_aug(mode="train"):
if mode=="Nor":
aug=A.Compose([
ToTensor(),
])
elif mode =="train":
print("train aug")
mean = (0.485,0.456,0.406)
std = (0.229,0.224,0.225)
aug=A.Compose([
A.Flip(),
A.ShiftScaleRotate(rotate_limit=1.0, p=0.8),
# Pixels
A.OneOf([
A.IAAEmboss(p=1.0),
A.IAASharpen(p=1.0),
A.Blur(p=1.0),
], p=0.5),
# Affine
A.OneOf([
A.ElasticTransform(p=1.0),
A.IAAPiecewiseAffine(p=1.0)
], p=0.5),
A.Normalize(mean=mean,std=std,max_pixel_value=255.0,always_apply=True),
])
else:
print("valid/test aug")
mean = (0.485,0.456,0.406)
std = (0.229,0.224,0.225)
aug=A.Compose([
A.Normalize(mean=mean,std=std,max_pixel_value=255.0,always_apply=True),
])
return aug
def _get_dynamic_augmentations(self, leave):
augmentations = []
downscale = random.choice([True, False])
if self._scale:
h, w, c = leave.shape
scale_max = self._max_width/w - 1
scale_min = -(1 - self._min_width/w)
if downscale:
augmentations.append(albu.RandomScale(scale_limit=[scale_min, 0.0], p=1))
else:
augmentations.append(albu.RandomScale(scale_limit=[0.0, scale_max], p=1))
else:
augmentations.append(None)
rand_color = randomcolor.RandomColor()
color = rand_color.generate(hue="green", count=1)
if self._dropout_aug:
augmentations.append(self._get_dropout_aug(leave, color))
else:
augmentations.append(None)
blur_aug = self._blur_aug()
if blur_aug:
augmentations.append(blur_aug)
else:
if self._sharpen:
augmentations.append(albu.IAASharpen(p=0.5))
else:
augmentations.append(None)
return augmentations
def det_train_augs(height: int, width: int) -> albu.Compose:
return albu.Compose([
albu.Resize(height=height, width=width),
albu.ShiftScaleRotate(shift_limit=0.025,
scale_limit=0.1,
rotate_limit=10),
albu.Flip(),
albu.RandomRotate90(),
albu.OneOf(
[
albu.HueSaturationValue(p=1.0),
albu.IAAAdditiveGaussianNoise(p=1.0),
albu.IAASharpen(p=1.0),
albu.RandomBrightnessContrast(
brightness_limit=0.1, contrast_limit=0.1, p=1.0),
albu.RandomGamma(p=1.0),
],
p=1.0,
),
albu.OneOf(
[
albu.Blur(blur_limit=3, p=1.0),
albu.MotionBlur(blur_limit=3, p=1.0)
],
p=1.0,
),
albu.Normalize(),
])
def get_training_augmentation():
train_transform = [
albu.HorizontalFlip(p=0.5),
# albu.ShiftScaleRotate(scale_limit=0.5, rotate_limit=0, shift_limit=0.1, p=1, border_mode=0),
albu.PadIfNeeded(min_height=320, min_width=320, always_apply=True),
# albu.RandomCrop(height=1000, width=1000, always_apply=True),
albu.IAAAdditiveGaussianNoise(p=0.2),
albu.IAAPerspective(p=0.5),
albu.OneOf(
[
albu.CLAHE(p=1),
albu.RandomBrightness(p=1),
albu.RandomGamma(p=1),
],
p=0.9,
),
albu.OneOf(
[
albu.IAASharpen(p=1),
albu.Blur(blur_limit=3, p=1),
albu.MotionBlur(blur_limit=3, p=1),
],
p=0.9,
),
albu.OneOf(
[
albu.RandomContrast(p=1),
albu.HueSaturationValue(p=1),
],
p=0.9,
),
]
return albu.Compose(train_transform)
def apply_training_augmentation():
train_transform = [
A.HorizontalFlip(p=0.5),
A.ShiftScaleRotate(scale_limit=0.5, rotate_limit=0, shift_limit=0.1, p=1, border_mode=0),
A.PadIfNeeded(min_height=320, min_width=320, always_apply=True, border_mode=0),
A.RandomCrop(height=320, width=320, always_apply=True),
A.IAAAdditiveGaussianNoise(p=0.2),
A.IAAPerspective(p=0.5),
A.OneOf(
[
A.CLAHE(p=1),
A.RandomBrightness(p=1),
A.RandomGamma(p=1),
],
p=0.9,
),
A.OneOf(
[
A.IAASharpen(p=1),
A.Blur(blur_limit=3, p=1),
A.MotionBlur(blur_limit=3, p=1),
],
p=0.9,
),
A.OneOf(
[
A.RandomContrast(p=1),
A.HueSaturationValue(p=1),
],
p=0.9,
),
A.Lambda(mask=round_clip_0_1)
]
return A.Compose(train_transform)
def get_next_augmentation():
train_transform = [
albu.ChannelShuffle(p=0.1),
albu.IAAAdditiveGaussianNoise(p=0.2),
albu.OneOf(
[
albu.CLAHE(p=1),
albu.RandomBrightness(p=1),
albu.RandomGamma(p=1),
],
p=0.9,
),
albu.OneOf(
[
albu.IAASharpen(p=1),
albu.Blur(blur_limit=3, p=1),
albu.MotionBlur(blur_limit=3, p=1),
],
p=0.9,
),
albu.OneOf(
[
albu.RandomContrast(p=1),
albu.HueSaturationValue(p=1),
],
p=0.9,
),
]
return albu.Compose(train_transform)
def aug_medium(prob=1):
return aug.Compose([
aug.Flip(),
aug.OneOf([
aug.CLAHE(clip_limit=2, p=.5),
aug.IAASharpen(p=.25),
],
p=0.35),
aug.OneOf([
aug.RandomContrast(),
aug.RandomGamma(),
aug.RandomBrightness(),
],
p=0.3),
aug.OneOf([
aug.ElasticTransform(
alpha=120, sigma=120 * 0.05, alpha_affine=120 * 0.03),
aug.GridDistortion(),
aug.OpticalDistortion(distort_limit=2, shift_limit=0.5),
],
p=0.3),
aug.ShiftScaleRotate(rotate_limit=12),
aug.OneOf([
aug.GaussNoise(p=.35),
SaltPepperNoise(level_limit=0.0002, p=.7),
aug.ISONoise(p=.7),
],
p=.5),
aug.Cutout(num_holes=3, p=.25),
],
p=prob)
def get_train_transform():
transforms = []
if args.hflip:
transforms.append(A.VerticalFlip(p=args.hflip))
if args.vflip:
transforms.append(A.HorizontalFlip(p=args.vflip))
if args.sharpen:
transforms.append(A.IAASharpen(p=args.sharpen))
if args.ssr:
transforms.append(A.ShiftScaleRotate(p=args.ssr))
if args.channelshuffle:
transforms.append(A.ChannelShuffle(p=args.channelshuffle))
# if args.clahe:
# transforms.append(A.CLAHE(p=args.clahe))
if args.oneofcgb:
transforms.append(
A.OneOf([
A.RandomContrast(),
A.RandomGamma(),
A.RandomBrightness(),
],
p=args.oneofcgb))
transforms.append(A.Resize(256, 256))
transforms.append(A.Normalize())
transforms.append(ToTensorV2(p=1))
return A.Compose(transforms)
def augmentations(image_size: int):
channel_augs = [
A.HueSaturationValue(p=0.5),
A.ChannelShuffle(p=0.5),
]
result = [
# *pre_transform(image_size),
A.OneOf([
A.IAAAdditiveGaussianNoise(),
A.GaussNoise(),
], p=0.5),
A.OneOf([
A.MotionBlur(blur_limit=3, p=0.7),
A.MedianBlur(blur_limit=3, p=1.0),
A.Blur(blur_limit=3, p=0.7),
],
p=0.5),
A.OneOf(channel_augs),
A.OneOf([
A.CLAHE(clip_limit=2),
A.IAASharpen(),
A.IAAEmboss(),
],
p=0.5),
A.RandomBrightnessContrast(brightness_limit=0.5,
contrast_limit=0.5,
p=0.5),
A.RandomGamma(p=0.5),
A.OneOf([A.MedianBlur(p=0.5), A.MotionBlur(p=0.5)]),
A.RandomGamma(gamma_limit=(85, 115), p=0.5),
]
return A.Compose(result, bbox_params=BBOX_PARAMS)
