def aug_image(image):
from albumentations import (
HorizontalFlip, IAAPerspective, ShiftScaleRotate, CLAHE, RandomRotate90, RandomGamma, VerticalFlip,
Transpose, ShiftScaleRotate, Blur, OpticalDistortion, GridDistortion, HueSaturationValue,
IAAAdditiveGaussianNoise, GaussNoise, MotionBlur, MedianBlur, RandomBrightnessContrast, IAAPiecewiseAffine,
IAASharpen, IAAEmboss, Flip, OneOf, Compose, Rotate, RandomContrast, RandomBrightness, RandomCrop, Resize, OpticalDistortion
)
transforms = Compose([
#Rotate(limit=30, p=0.5),
#Rotate(limit=180, p=0.5),
#RandomRotate90(p=1.0)
#Transpose(p=1.0)
# Resize(248,248, p=1), # resize 후 크롭
# RandomCrop(224,224, p=1), # 위에꺼랑 세트
OneOf([
RandomContrast(p=1, limit=(-0.5,2)), # -0.5 ~ 2 까지가 현장과 가장 비슷함 -- RandomBrightnessContrast
RandomBrightness(p=1, limit=(-0.2,0.4)),
RandomGamma(p=1, gamma_limit=(80,200)),
], p=1),
# OneOf([
# Rotate(limit=30, p=0.3),
# RandomRotate90(p=0.3),
# VerticalFlip(p=0.3)
# ], p=0.3),
MotionBlur(p=0.2), # 움직일때 흔들리는 것 같은 이미지
#ShiftScaleRotate(shift_limit=0.001, scale_limit=0.1, rotate_limit=30, p=0.3, border_mode=1),
#Resize(224,224, p=1),
],
p=1)
return transforms(image=image)['image']
def get_train_transform(smallest_max_size: int, size: int):
return Compose([
SmallestMaxSize(smallest_max_size),
RandomScale(scale_limit=0.125),
# PadIfNeeded(256, 256, border_mode=cv2.BORDER_CONSTANT., value=0, p=1.),
# ShiftScaleRotate(
# shift_limit=0.0625, scale_limit=0.1, rotate_limit=30,
# border_mode=cv2.BORDER_REFLECT_101, p=1.),
Rotate(limit=20, border_mode=cv2.BORDER_REFLECT_101, p=1.),
OneOf([
RandomCrop(size, size, p=0.9),
CenterCrop(size, size, p=0.1),
],
p=1.),
HorizontalFlip(p=0.5),
RandomContrast(limit=0.2, p=0.5),
RandomGamma(gamma_limit=(80, 120), p=0.5),
RandomBrightness(limit=0.2, p=0.5),
# HueSaturationValue(hue_shift_limit=5, sat_shift_limit=20,
# val_shift_limit=10, p=1.),
# OneOf([
# OpticalDistortion(p=0.3),
# GridDistortion(p=0.1),
# IAAPiecewiseAffine(p=0.3),
# ], p=0.2),
# OneOf([
# IAAAdditiveGaussianNoise(
# loc=0, scale=(1., 6.75), per_channel=False, p=0.3),
# GaussNoise(var_limit=(5.0, 20.0), p=0.6),
# ], p=0.5),
# Cutout(num_holes=4, max_h_size=30, max_w_size=50, p=0.75),
# JpegCompression(quality_lower=50, quality_upper=100, p=0.5)
])
def strong_aug(p=.5):
return Compose([
HorizontalFlip(),
OneOf([
IAAAdditiveGaussianNoise(),
GaussNoise(),
], p=0.4),
OneOf([
MotionBlur(p=.2),
MedianBlur(blur_limit=3, p=.1),
Blur(blur_limit=3, p=.1),
],
p=0.3),
OneOf([
OpticalDistortion(p=0.3),
GridDistortion(p=.1),
IAAPiecewiseAffine(p=0.3),
],
p=0.2),
OneOf([
CLAHE(clip_limit=2),
IAASharpen(),
RandomContrast(),
RandomBrightness(),
],
p=0.3),
HueSaturationValue(p=0.3),
ChannelShuffle(),
Cutout(num_holes=20, max_h_size=16, max_w_size=16)
],
p=p)
def get_transforms(config, mode):
if (mode == "val") or (mode =="test"):
transform = [
Resize(config["model"]["image_size"], config["model"]["image_size"]),
# Normalize(mean=phase_config.mean, std=phase_config.std, p=1),
ToTensor(),
]
return transform
elif mode == "train":
list_transforms = []
config_tarnsform = config[mode]["transform"]
if config_tarnsform["HorizontalFlip"]:
list_transforms.append(HorizontalFlip())
if config_tarnsform["VerticalFlip"]:
list_transforms.append(VerticalFlip())
if config_tarnsform["Contrast"]:
list_transforms.append(
OneOf([
RandomContrast(0.5),
RandomBrightness(),
], p=0.5),
)
if config_tarnsform["ShiftScaleRotate"]:
list_transforms.append(ShiftScaleRotate(shift_limit=(-0.05, 0.05), scale_limit=(-0.05, 0.05), rotate_limit=(-30,30), p=0.5))
list_transforms.extend(
[
Resize(config["model"]["image_size"], config["model"]["image_size"]),
# Normalize(mean=phase_config.mean, std=phase_config.std, p=1),
ToTensor(),
]
)
return list_transforms
def get_transforms1(*, data, CFG):
if data == 'train':
return Compose([
#RandomCrop(512,512,p=1),
HorizontalFlip(p=CFG.augmentation.augmix_p),
VerticalFlip(p=CFG.augmentation.augmix_p),
RandomContrast(p=CFG.augmentation.contrast_p),
#GaussNoise(p=0.5),
RandomRotate90(p=CFG.augmentation.rotate_90_p),
#RandomGamma(p=0.5),
RandomBrightnessContrast(p=CFG.augmentation.bright_contrast_p),
RandomAugMix(severity=CFG.augmentation.augmix_s,
width=3,
alpha=1.,
p=CFG.augmentation.augmix_p),
#GaussianBlur(p=0.5),
GridMask(num_grid=CFG.augmentation.grdimask_n,
p=CFG.augmentation.grdimask_p),
Cutout(p=CFG.augmentation.cutout_p,
max_h_size=CFG.augmentation.cutout_h,
max_w_size=CFG.augmentation.cutout_w),
Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])
elif data == 'valid':
return Compose([
Normalize(
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225],
)
])
def aug_image(image):
from albumentations import (
HorizontalFlip, IAAPerspective, ShiftScaleRotate, CLAHE,
RandomRotate90, RandomGamma, VerticalFlip, Transpose, ShiftScaleRotate,
Blur, OpticalDistortion, GridDistortion, HueSaturationValue,
IAAAdditiveGaussianNoise, GaussNoise, MotionBlur, MedianBlur,
RandomBrightnessContrast, IAAPiecewiseAffine, IAASharpen, IAAEmboss,
Flip, OneOf, Compose, Rotate, RandomContrast, RandomBrightness,
RandomCrop, Resize, OpticalDistortion)
transforms = Compose(
[
OneOf(
[
RandomContrast(
p=1, limit=(-0.5, 1.5)
), # -0.5 ~ 2 까지가 현장과 가장 비슷함 -- RandomBrightnessContrast
RandomBrightness(p=1, limit=(-0.2, 0.2)),
RandomGamma(p=1, gamma_limit=(80, 150)),
],
p=1),
MotionBlur(p=0.2), # 움직일때 흔들리는 것 같은 이미지
],
p=1)
return transforms(image=image)['image']
def strong_aug(p=.5):
return Compose([
JpegCompression(p=0.9),
HorizontalFlip(p=0.5),
OneOf([
IAAAdditiveGaussianNoise(),
GaussNoise(),
], p=0.5),
OneOf([
MotionBlur(p=.2),
MedianBlur(blur_limit=3, p=.1),
Blur(blur_limit=3, p=.1),
],
p=0.5),
ShiftScaleRotate(
shift_limit=0.0625, scale_limit=0.2, rotate_limit=15, p=.5),
OneOf([
CLAHE(clip_limit=2),
IAASharpen(),
IAAEmboss(),
RandomContrast(),
RandomBrightness(),
],
p=0.5),
HueSaturationValue(p=0.5),
],
p=p)
def strong_aug(p=1):
return Compose(
[
HorizontalFlip(p=0.5),
OneOf([
RandomCrop(94, 94, p=0.6),
ShiftScaleRotate(shift_limit=(0.1, 0.1),
scale_limit=(0.05, 0.05),
rotate_limit=10,
p=0.4),
],
p=0.6),
OneOf([
ElasticTransform(p=0.2,
alpha=120,
sigma=120 * 0.05,
alpha_affine=120 * 0.03),
IAAPiecewiseAffine(p=.4),
GridDistortion(p=0.4),
],
p=.4),
OneOf(
[
# CLAHE(clip_limit=2),
RandomGamma((90, 110)),
IAAEmboss((0.1, 0.4), (0.1, 0.6)),
RandomContrast(0.1),
RandomBrightness(0.1),
],
p=0.5),
],
p=p)
def __init__(self,
root_path,
file_list,
is_test=False,
is_val=False,
augment=False):
self.is_test = is_test
self.augment = augment
self.root_path = root_path
self.file_list = file_list
self.pad = Compose([
PadIfNeeded(p=1, min_height=PAD_SIZE, min_width=PAD_SIZE),
ToTensor(),
])
original_height, original_width = 101, 101
self.augmentation = Compose([
RandomSizedCrop(min_max_height=(50, 101),
height=original_height,
width=original_width,
p=0.9),
HorizontalFlip(p=0.5),
GridDistortion(p=0.8),
RandomContrast(p=0.8),
RandomBrightness(p=0.8),
RandomGamma(p=0.8)
])
def light_aug():
return Compose([
RandomBrightness(limit=0.1, p=0.2),
RandomContrast(limit=0.1, p=0.2),
Blur(blur_limit=3, p=0.2),
HorizontalFlip(p=0.7),
])
def get_photometric(self):
coeff = int(3 * self.strength)
k = max(1, coeff if coeff % 2 else coeff - 1)
return Compose([
OneOf(
[
# CLAHE(clip_limit=2, p=.4),
IAASharpen(p=.5),
IAAEmboss(p=.5),
],
p=0.2),
OneOf([
IAAAdditiveGaussianNoise(p=.3),
GaussNoise(p=.7),
], p=.2),
OneOf([
MotionBlur(p=.2),
MedianBlur(blur_limit=k, p=.3),
Blur(blur_limit=k, p=.5),
],
p=.2),
OneOf([
RandomContrast(),
RandomBrightness(),
], p=.2)
])
def img_augment(p=1.):
return Compose(
[
#RandomSizedCrop((300, 300), img_sz, img_sz, p=1.),
Resize(img_sz, img_sz),
HorizontalFlip(p=0.8),
#RandomRotate90(p=0.25),
OneOf([
CLAHE(clip_limit=2),
IAASharpen(),
IAAEmboss(),
RandomContrast(),
RandomBrightness(),
],
p=0.3),
#
ShiftScaleRotate(
shift_limit=0.0625, scale_limit=0.1, rotate_limit=10, p=.75),
RandomBrightnessContrast(p=0.2),
#GaussNoise(),
#Blur(blur_limit=3, p=.33),
#OpticalDistortion(p=.33),
#GridDistortion(p=.33),
#HueSaturationValue(p=.33)
],
p=p)
def generate_transforms(image_size):
train_transform = Compose(
[
Resize(height=image_size[0], width=image_size[1]),
OneOf([RandomBrightness(limit=0.1, p=1), RandomContrast(limit=0.1, p=1)]),
OneOf([MotionBlur(blur_limit=3), MedianBlur(blur_limit=3), GaussianBlur(blur_limit=3)], p=0.5),
VerticalFlip(p=0.5),
HorizontalFlip(p=0.5),
ShiftScaleRotate(
shift_limit=0.2,
scale_limit=0.2,
rotate_limit=20,
interpolation=cv2.INTER_LINEAR,
border_mode=cv2.BORDER_REFLECT_101,
p=1,
),
Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), max_pixel_value=255.0, p=1.0),
]
)
val_transform = Compose(
[
Resize(height=image_size[0], width=image_size[1]),
Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), max_pixel_value=255.0, p=1.0),
]
)
return {"train_transforms": train_transform, "val_transforms": val_transform}
def augment(self): #p=.5):
return Compose([
RandomRotate90(),
Flip(),
Transpose(),
ShiftScaleRotate(
shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=.2),
OneOf([
OpticalDistortion(p=0.3),
GridDistortion(p=.1),
IAAPiecewiseAffine(p=0.3),
],
p=0.2),
OneOf([
IAAAdditiveGaussianNoise(),
GaussNoise(),
], p=0.2),
RandomCrop(256, 256, p=1),
OneOf([
MedianBlur(blur_limit=3, p=.1),
Blur(blur_limit=3, p=.1),
],
p=0.2),
OneOf([
CLAHE(clip_limit=2),
IAASharpen(),
IAAEmboss(),
RandomContrast(),
RandomBrightness(),
],
p=0.3),
HueSaturationValue(p=0.7),
],
p=1)
def albumentations_transform(self, img):
# 训练集的增强
trans_train = Compose([
# 随机更改输入图像的色相，饱和度和值
# HueSaturationValue(hue_shift_limit=20, sat_shift_limit=30, val_shift_limit=20, always_apply=False, p=0.5),
# 通过用255减去像素值来反转输入图像。
# InvertImg(always_apply=False, p=1),
# 随机改变RGB三个通道的顺序
# ChannelShuffle(always_apply=False, p=0.5),
# 随机出现小黑点
# Cutout(num_holes=8, max_h_size=8, max_w_size=8, fill_value=0, always_apply=False, p=0.5),
# RandomCrop(224, 224),
OneOf([
RandomBrightness(limit=0.1, p=1),
RandomContrast(limit=0.1, p=1)
]),
# OneOf([MotionBlur(blur_limit=3),MedianBlur(blur_limit=3), GaussianBlur(blur_limit=3),], p=0.5,),
VerticalFlip(p=0.5),
HorizontalFlip(p=0.5),
# ShiftScaleRotate(
# shift_limit=0.2,
# scale_limit=0.2,
# rotate_limit=20,
# interpolation=cv2.INTER_LINEAR,
# border_mode=cv2.BORDER_REFLECT_101,
# p=1,
# ),
])
augmented = trans_train(image=img)
return augmented['image']
def strong_aug(config, aug_prob):
return Compose(
[
# Resize(config.image_height, config.image_width, always_apply=True),
RandomSizedCrop(
p=config.random_sized_crop_prob,
min_max_height=(int(
config.image_height * config.min_max_height),
config.image_height),
height=config.image_height,
width=config.image_width,
w2h_ratio=config.image_width / config.image_height),
HorizontalFlip(p=config.horizontal_flip_prob),
RandomGamma(p=config.random_gamma_prob),
RandomContrast(p=config.random_contrast_prob,
limit=config.random_contrast_limit),
RandomBrightness(p=config.random_brightness_prob,
limit=config.random_brightness_limit),
OneOf([
MotionBlur(p=config.motion_blur_prob),
MedianBlur(blur_limit=config.median_blur_limit,
p=config.median_blur_prob),
Blur(blur_limit=config.blur_limit, p=config.blur_prob),
],
p=config.one_of_blur_prob),
CLAHE(clip_limit=config.clahe_limit, p=config.clahe_prob),
IAAEmboss(p=config.iaaemboss_prob),
HueSaturationValue(p=config.hue_saturation_value_prob,
hue_shift_limit=config.hue_shift_limit,
sat_shift_limit=config.sat_shift_limit,
val_shift_limit=config.val_shift_limit)
],
p=aug_prob)
def __init__(self, root_dir, partition, augment=True):
self.root_dir = root_dir
self.list_IDs = os.listdir(
os.path.join(self.root_dir, 'x_{}'.format(partition)))
self.partition = partition
self.augment = augment
self.augmentator = Compose([
# Non destructive transformations
VerticalFlip(p=0.6),
HorizontalFlip(p=0.6),
RandomRotate90(),
Transpose(p=0.6),
ShiftScaleRotate(p=0.45, scale_limit=(0.1, 0.3)),
# # Non-rigid transformations
ElasticTransform(p=0.25,
alpha=160,
sigma=180 * 0.05,
alpha_affine=120 * 0.03),
Blur(blur_limit=3, p=0.2),
# Color augmentation
RandomBrightness(p=0.5),
RandomContrast(p=0.5),
RandomGamma(p=0.5),
CLAHE(p=0.5)
])
def get_transforms(phase, size, mean, std):
list_transforms = []
if phase == "train":
list_transforms.extend(
[
HorizontalFlip(p=0.5),
# OneOf([
# RandomBrightnessContrast(),
# RandomGamma(),
# RandomBrightness(),
# ], p=0.5),
RandomBrightness(p=0.2, limit=0.2),
RandomContrast(p=0.1, limit=0.2),
ShiftScaleRotate(
shift_limit=0, # no resizing
scale_limit=0.1,
rotate_limit=10, # rotate
p=0.5,
border_mode=cv2.BORDER_CONSTANT
),
]
)
list_transforms.extend(
[
Normalize(mean=mean, std=std, p=1),
Resize(size, size),
ToTensor(),
]
)
list_trfms = Compose(list_transforms)
return list_trfms
def augment_big(image, mask):
original_height, original_width = image.shape[:2]
aug = Compose([
RandomSizedCrop(p=0.5,
min_max_height=(original_height // 2, original_height),
height=original_height,
width=original_width),
OpticalDistortion(p=0.5, distort_limit=0.25, shift_limit=0.5),
OneOf([
CLAHE(p=1., clip_limit=4.),
RandomContrast(p=1., limit=0.25),
RandomGamma(p=1., gamma_limit=(50, 200))
],
p=0.5),
],
p=0.5)
augmented = aug(image=image, mask=mask)
image_heavy = augmented['image']
mask_heavy = augmented['mask']
return image_heavy, mask_heavy
def __init__(self, to_tensor=True):
augs = [
RandomSizedBBoxSafeCrop(height=512, width=512),
RandomBrightness(p=0.5),
RandomContrast(p=0.5),
#RandomSunFlare(p=0.5, flare_roi=(0, 0, 1, 0.5), angle_lower=0.5,src_radius= 150),
RandomShadow(p=0.5,
num_shadows_lower=1,
num_shadows_upper=1,
shadow_dimension=5,
shadow_roi=(0, 0.5, 1, 1)),
HorizontalFlip(p=0.5),
GaussianBlur(p=0.5),
]
if to_tensor:
augs.append(
ToTensor(normalize={
"mean": [0.485, 0.456, 0.406],
"std": [0.229, 0.224, 0.225]
}))
self.transform = Compose(augs,
bbox_params={
"format": "albumentations",
"min_area": 0,
"min_visibility": 0.2,
'label_fields': ['category_id']
})
def transforms_train(aug_proba=1.):
return Compose(transforms=[
HorizontalFlip(p=0.5),
Rotate(limit=25,
p=0.5,
border_mode=cv2.BORDER_CONSTANT,
value=0,
interpolation=cv2.INTER_CUBIC),
OneOf([
IAAAdditiveGaussianNoise(p=1),
GaussNoise(p=1),
], p=0.2),
OneOf([
HueSaturationValue(hue_shift_limit=10,
sat_shift_limit=15,
val_shift_limit=10,
p=1),
RGBShift(r_shift_limit=10, g_shift_limit=10, b_shift_limit=10, p=1)
]),
OneOf([RandomContrast(p=1), RandomBrightness(p=1)], p=0.3),
OpticalDistortion(p=0.1),
Resize(*SIZE),
Normalize()
],
p=aug_proba,
additional_targets={'trimap': 'mask'})
def train_aug(self, image, label):
aug = Compose(
[
OneOf(
[CLAHE(), IAASharpen(), IAAEmboss()], p=0.5),
# OneOf([IAAAdditiveGaussianNoise(), GaussNoise()], p=0.2),
# OneOf([MotionBlur(p=0.2), MedianBlur(blur_limit=3, p=0.1), Blur(blur_limit=3, p=0.1)], p=0.2),
RandomContrast(),
RandomBrightness(),
# ChannelShuffle(),
RandomRotate90(),
Flip(),
# RandomScale(scale_limit=(0.0, 0.1)),
OneOf([
ElasticTransform(),
OpticalDistortion(),
GridDistortion(),
IAAPiecewiseAffine()
],
p=0.5),
# HueSaturationValue(p=0.3),
],
p=0.9)
augmented = aug(image=image, mask=label)
augmented = ToGray(p=1)(image=augmented['image'],
mask=augmented['mask'])
augmented = RandomCrop(256, 256)(image=augmented['image'],
mask=augmented['mask'])
image, label = augmented['image'], augmented['mask']
return image, label
def strong_aug(p=1.0):
return Compose(
[
Cutout(num_holes=1,
max_h_size=16,
max_w_size=16,
fill_value=[0.4914 * 255, 0.4822 * 255, 0.4465 * 255],
p=1.),
HorizontalFlip(p=0.5),
# RandomGamma(p=0.5),
# ElasticTransform(value=10),
ShiftScaleRotate(
shift_limit=0.0625, scale_limit=0.2, rotate_limit=20, p=1.),
# Below are Required
OneOf([
CLAHE(clip_limit=2),
IAASharpen(),
IAAEmboss(),
RandomContrast(),
RandomBrightness(),
],
p=0.3),
# HueSaturationValue(p=0.3),
ToTensor(normalize={
'mean': (0.4914, 0.4822, 0.4465),
'std': (0.2023, 0.1994, 0.2010)
})
],
p=p)
def __init__(self, data, img_size=384, aug=True, mode='train'):
self.data = data
self.mode = mode
if mode is 'train':
self.images = data.ImageId.unique()
self._aug = Compose([
HorizontalFlip(),
VerticalFlip(),
OneOf([
RandomRotate90(),
ShiftScaleRotate(shift_limit=0.2, scale_limit=0.2, rotate_limit=0),
], p=1),
OneOf([
CLAHE(),
RandomBrightness(),
RandomContrast(),
RandomGamma()
], p=1),
Normalize(),
RandomCrop(img_size, img_size)
# Resize(256, 256),
# Resize(img_size, img_size),
])
elif mode is 'test' or mode is 'val':
self.images = data.ImageId.unique()
self._aug = Compose([
Normalize(),
# Resize(256, 256),
# Resize(img_size, img_size),
# RandomCrop(img_size, img_size)
# PadIfNeeded(768, 768)
])
else:
raise RuntimeError()
def strong_aug(p=0.5):
return Compose([
RandomRotate90(),
Flip(),
Transpose(),
OneOf([
IAAAdditiveGaussianNoise(),
GaussNoise(),
], p=p),
OneOf([
MotionBlur(p=p),
], p=p),
ShiftScaleRotate(
shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=p),
OneOf([
OpticalDistortion(p=p),
GridDistortion(p=p),
IAAPiecewiseAffine(p=p),
],
p=p),
OneOf([
IAASharpen(),
IAAEmboss(),
RandomContrast(),
RandomBrightness(),
],
p=p),
HueSaturationValue(p=p),
],
p=p)
def train_transform(p=1):
return Compose([
HorizontalFlip(p=0.5),
OneOf([
RandomSizedCrop((92, 98), 101, 101, p=0.6),
ShiftScaleRotate(shift_limit=(0, 0.1), scale_limit=(0, 0.05), rotate_limit=10, p=0.4),
], p=0.6),
#OneOf([
# IAAAdditiveGaussianNoise(), #may by
# GaussNoise(),#may by
#], p=0.2),
#OneOf([
# MotionBlur(p=0.2),
# MedianBlur(blur_limit=3, p=0.3),
# Blur(blur_limit=3, p=0.5),
#], p=0.4),
OneOf([
ElasticTransform(p=0.2, alpha=120, sigma=120 * 0.05, alpha_affine=120 * 0.03),
IAAPiecewiseAffine(p=.4),
GridDistortion(p=0.4),
], p=.4),
OneOf([
#CLAHE(clip_limit=2),
RandomGamma((90,110)),
ShiftBrightness((5, 20)),
IAAEmboss((0.1, 0.4), (0.1, 0.6)),
RandomContrast(0.08),
RandomBrightness(0.08),
], p=0.5),
], p=p)
def alb_transform_train(imsize = 256, p=1):
albumentations_transform = Compose([
# RandomCrop(imsize),
# RandomRotate90(),
Flip(),
# Transpose(),
OneOf([
IAAAdditiveGaussianNoise(),
GaussNoise(),
], p=0.2),
OneOf([
MotionBlur(p=.2),
MedianBlur(blur_limit=3, p=.1),
Blur(blur_limit=3, p=.1),
], p=0.2),
ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=.2),
OneOf([
OpticalDistortion(p=0.3),
GridDistortion(p=.1),
IAAPiecewiseAffine(p=0.3),
], p=0.2),
OneOf([
# CLAHE(clip_limit=2),
IAASharpen(),
IAAEmboss(),
RandomContrast(),
RandomBrightness(),
], p=0.3),
Normalize(
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225]
)
], p=p)
return albumentations_transform
def aug_daniel(prob=0.8):
return Compose(
[
RandomRotate90(p=0.5),
Transpose(p=0.5),
Flip(p=0.5),
OneOf(
[
IAAAdditiveGaussianNoise(),
GaussNoise(),
#Blur(),
],
p=0.3),
OneOf(
[
CLAHE(clip_limit=2),
IAASharpen(),
IAAEmboss(),
OneOf([
RandomContrast(),
RandomBrightness(),
]),
#Blur(),
#GaussNoise()
],
p=0.5),
HueSaturationValue(p=0.5)
],
p=prob)
def strong_aug(p=.5):
return Compose([
HorizontalFlip(p=0.5),
ToGray(p=0.1),
OneOf([
IAAAdditiveGaussianNoise(),
GaussNoise(),
], p=0.4),
OneOf([
MotionBlur(p=.2),
MedianBlur(blur_limit=3, p=.1),
Blur(blur_limit=3, p=.1),
],
p=0.2),
OneOf([
OpticalDistortion(p=0.3),
GridDistortion(p=.1),
IAAPiecewiseAffine(p=0.3),
],
p=0.2),
OneOf([
CLAHE(clip_limit=2),
IAASharpen(),
RandomContrast(),
RandomBrightness(),
],
p=0.3),
HueSaturationValue(p=0.3),
],
p=p)
def build_train(self):
return Compose([
HorizontalFlip(p=0.5),
VerticalFlip(p=0.5),
Normalize(mean=self.MEAN, std=self.STD),
RandomContrast(p=0.1),
RandomBrightness(p=0.1),
ToTensor(),
])
