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_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 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 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, 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 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 hard_augmentations2(use_d4=False):
d4 = Compose([RandomRotate90(p=1), HorizontalFlip(p=1), VerticalFlip(p=1)])
fliplr = HorizontalFlip()
aug = Compose(
[
RandomBrightness(p=1),
# OneOf([IAAAdditiveGaussianNoise(), , ], p=0.2),
# GaussNoise(p=1),
IAAAdditiveGaussianNoise(p=1),
OneOf([
MotionBlur(p=1),
MedianBlur(blur_limit=3, p=1),
Blur(blur_limit=3, p=1)
],
p=0.5),
ShiftScaleRotate(
shift_limit=0.0625, scale_limit=0.1, rotate_limit=5, p=1),
# OneOf([GridDistortion(p=0.1), IAAPiecewiseAffine(p=0.3)], p=0.2),
# GridDistortion(p=1),
# IAAPiecewiseAffine(p=1)
],
p=1)
default = default_transforms()
return Compose([d4 if use_d4 else fliplr, aug, default])
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(p=1):
return Compose(
[
# albumentations supports uint8 and float32 inputs. For the latter, all
# values must lie in the range [0.0, 1.0]. To apply augmentations, we
# first use a `ToFloat()` transformation, which will inspect the data
# type of the input image and convert the image to a float32 ndarray where
# all values lie in the required range [0.0, 1.0].
ToFloat(),
RandomBrightness(limit=(0, 0.2), p=0.2),
# Alternatively, you can specify the maximum possible value for your input
# and all values will be divided by it instead of using a predefined value
# for a specific data type.
# ToFloat(max_value=65535.0),
# Then we will apply augmentations
HorizontalFlip(p=0.1),
ShiftScaleRotate(
shift_limit=1 / 14, scale_limit=0.1, rotate_limit=15, p=0.9),
OpticalDistortion(distort_limit=0.1, shift_limit=0.05, p=0.5),
# You can convert the augmented image back to its original
# data type by using `FromFloat`.
# FromFloat(dtype='uint16'),
# As in `ToFloat` you can specify a `max_value` argument and all input values
# will be multiplied by it.
FromFloat(dtype='uint16', max_value=65535.0),
],
p=p,
additional_targets={"image1": "image"})
def augment_3d(img, input_channel=3):
"""
input_channel==1 : img: slice_num x W x H
input_channel==3 : img: 3 x slice_num x W x H
"""
transform = Compose(
[
HorizontalFlip(p=0.1),
ShiftScaleRotate(
shift_limit=0.1,
scale_limit=0.1,
rotate_limit=15,
border_mode=cv2.BORDER_REPLICATE,
p=0.5,
),
# RandomSizedCrop(min_max_height=(h-int(h*0.1), h), height=h, width=w, p=p),
RandomBrightness(limit=0.2, p=0.5),
GaussNoise(var_limit=0.001, mean=0.0, p=0.5),
],
p=1,
additional_targets={
"image1": "image",
"image2": "image"
},
)
if input_channel == 1:
img = img.transpose((1, 2, 0))
augment = transform(image=img)
img = augment["image"]
img = img.transpose((2, 0, 1))
elif input_channel == 3:
# t0 = time.time()
img0 = img[0].transpose((1, 2, 0))
img1 = img[1].transpose((1, 2, 0))
img2 = img[2].transpose((1, 2, 0))
# print("transpose: ", time.time() - t0)
# t0 = time.time()
augment = transform(image=img0, image1=img1, image2=img2)
# print("augment: ", time.time() - t0)
# t0 = time.time()
img0, img1, img2 = augment["image"], augment["image1"], augment[
"image2"]
img = np.concatenate(
(
img0.transpose((2, 0, 1))[np.newaxis],
img1.transpose((2, 0, 1))[np.newaxis],
img2.transpose((2, 0, 1))[np.newaxis],
),
axis=0,
)
# print("transpose2: ", time.time() - t0)
return img
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 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 train_transform(p=1):
return Compose(
[
# Rescale(SIZE),
RandomCrop(SIZE),
RandomBrightness(0.2),
OneOf([
IAAAdditiveGaussianNoise(),
GaussNoise(),
], p=0.15),
# OneOf([
# OpticalDistortion(p=0.3),
# GridDistortion(p=.1),
# IAAPiecewiseAffine(p=0.3),
# ], p=0.1),
# OneOf([
# IAASharpen(),
# IAAEmboss(),
# RandomContrast(),
# RandomBrightness(),
# ], p=0.15),
HueSaturationValue(p=0.15),
HorizontalFlip(p=0.5),
Normalize(p=1),
],
p=p)
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(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 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 augmentation(img, n):
"""
Make random augmentations with image n times.
:rtype: ndarray
:param img: image in matrix form
:param n: how many augmentations need to apply
:return: list of augmented versions of image
"""
methods = [ElasticTransform(**elastic_params),
RandomGamma(**gamma_params),
GridDistortion(**all_other),
RGBShift(**r_shift_params),
Rotate(**rotate_params),
RandomBrightness(**brightness_params)
]
for i in range(len(methods)):
methods[i] = Compose([methods[i], ], p=1)
chosen = np.random.choice(methods, replace=False, size=n)
augmented = np.empty((n,), dtype=np.object)
for i, method in enumerate(chosen):
transformed = transform_image(method(image=img)["image"])
if to_normalize:
transformed = normalize(transformed)
augmented[i] = transformed
return augmented
def train_pipeline(cache, mask_db, path):
image, mask = read_image_and_mask_cached(cache, mask_db, (101, 101), path)
args = Compose([
LabelMaskBorder(),
HorizontalFlip(p=0.5),
OneOf([
ShiftScaleRotate(rotate_limit=15,
border_mode=cv2.BORDER_REPLICATE),
RandomSizedCrop(min_max_height=(70, 100), height=101, width=101)
],
p=0.2),
GaussNoise(p=0.2),
OneOf([
RandomBrightness(limit=0.4),
RandomGamma(),
], p=0.5),
OneOf([Blur(), MedianBlur(), MotionBlur()], p=0.2),
OneOf([
ElasticTransform(alpha=10, sigma=10, alpha_affine=10),
GridDistortion()
],
p=0.2),
Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
PadIfNeeded(128, 128, cv2.BORDER_REPLICATE),
ChannelsFirst()
])(image=image, mask=mask)
return args['image'], args.get('mask')
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 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 __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 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 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=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 __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 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 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 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 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)
