def augmentations_factory(hparams: str):
mean, std = 0.485, 0.229
# TODO: find more elegant way to do this
try:
input_image_sz = int(hparams.train_data.name.split("_")[1])
except AttributeError:
input_image_sz = int(hparams.test_data.name.split("_")[1])
if hparams.aug == "baseline":
train_augmentation = albumentations.Compose(
[
albumentations.CLAHE(p=1),
albumentations.HorizontalFlip(p=0.25),
albumentations.RandomBrightnessContrast(
brightness_limit=0.1, contrast_limit=0.1, p=0.5
),
albumentations.OneOf(
[
albumentations.OpticalDistortion(),
albumentations.ElasticTransform(),
],
p=0.25,
),
albumentations.Cutout(
num_holes=8,
max_h_size=int(hparams.sz * 0.1),
max_w_size=int(hparams.sz * 0.1),
p=0.25,
),
albumentations.ShiftScaleRotate(
shift_limit=0.0625, scale_limit=0.0, rotate_limit=10, p=0.8
),
albumentations.RandomCrop(
int(input_image_sz * 0.9), int(input_image_sz * 0.9), p=1
),
albumentations.Resize(height=hparams.sz, width=hparams.sz),
albumentations.Normalize(
mean, std, max_pixel_value=255.0, always_apply=True
),
transforms.ToTensorV2(),
]
)
valid_augmentation = albumentations.Compose(
[
albumentations.CLAHE(p=1),
albumentations.CenterCrop(
int(input_image_sz * 0.9), int(input_image_sz * 0.9)
),
albumentations.Resize(height=hparams.sz, width=hparams.sz),
albumentations.Normalize(
mean, std, max_pixel_value=255.0, always_apply=True
),
transforms.ToTensorV2(),
]
)
test_augmentation = valid_augmentation
return train_augmentation, valid_augmentation, test_augmentation
raise ValueError("Augmentation config not recognized")
def get_aug(name='default', input_shape=[48, 48, 3]):
if name == 'default':
augmentations = A.Compose([
A.RandomBrightnessContrast(p=0.4),
A.RandomGamma(p=0.4),
A.HueSaturationValue(hue_shift_limit=20,
sat_shift_limit=30, val_shift_limit=30, p=0.4),
A.CLAHE(p=0.4),
A.Blur(blur_limit=1, p=0.3),
A.GaussNoise(var_limit=(50, 80), p=0.3)
], p=1)
elif name == 'plates':
augmentations = A.Compose([
A.RandomBrightnessContrast(p=0.4),
A.RandomGamma(p=0.4),
A.HueSaturationValue(hue_shift_limit=20,
sat_shift_limit=30,
val_shift_limit=30,
p=0.4),
A.CLAHE(p=0.4),
A.HorizontalFlip(p=0.5),
A.VerticalFlip(p=0.5),
A.Blur(blur_limit=1, p=0.3),
A.GaussNoise(var_limit=(50, 80), p=0.3),
A.RandomCrop(p=0.8, height=2*input_shape[1]/3, width=2*input_shape[0]/3)
], p=1)
elif name == 'deepfake':
augmentations = A.Compose([
A.HorizontalFlip(p=0.5),
], p=1)
elif name == 'plates2':
augmentations = A.Compose([
A.CLAHE(clip_limit=(1,4),p=0.3),
A.HorizontalFlip(p=0.5),
A.VerticalFlip(p=0.5),
A.RandomBrightness(limit=0.2, p=0.3),
A.RandomContrast(limit=0.2, p=0.3),
# A.Rotate(limit=360, p=0.9),
A.RandomRotate90(p=0.3),
A.HueSaturationValue(hue_shift_limit=(-50,50),
sat_shift_limit=(-15,15),
val_shift_limit=(-15,15),
p=0.5),
# A.Blur(blur_limit=(5,7), p=0.3),
A.GaussNoise(var_limit=(10, 50), p=0.3),
A.CenterCrop(p=1, height=2*input_shape[1]//3, width=2*input_shape[0]//3),
A.Resize(p=1, height=input_shape[1], width=input_shape[0])
], p=1)
else:
augmentations = None
return augmentations
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 __init__(self, dataset_dir, names, mode='train', image_size=512):
# Get image and mask pair names
self.dataset_dir = dataset_dir
self.names = [
name for name in names if name.endswith(('.jpg', '.JPG', '.png'))
]
# Get class values
self.classes_dict = {
'egg': 128,
'pan': 255,
}
# Misc info
self.image_size = image_size
self.mode = mode
assert mode in ('train', 'val',
'test'), 'Mode is unknown: {}'.format(mode)
# Initialize augmentations
self.augs = albu.Compose([
albu.HorizontalFlip(p=0.5),
albu.VerticalFlip(p=0.5),
albu.RandomRotate90(p=0.5),
albu.CLAHE(p=0.5),
albu.RandomBrightnessContrast(p=0.5),
albu.RandomGamma(p=0.5)
])
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 test_dataloader(self):
"""Summary
Returns:
TYPE: Description
"""
ds_test = MultiLabelDataset(folder=self.hparams.data_path,
is_train='test',
fname='test.csv',
types=self.hparams.types,
pathology=self.hparams.pathology,
resize=int(self.hparams.shape))
ds_test.reset_state()
ag_test = [
imgaug.Albumentations(
AB.SmallestMaxSize(self.hparams.shape, p=1.0)),
iimgaug.ColorSpace(mode=cv2.COLOR_GRAY2RGB),
imgaug.Albumentations(AB.CLAHE(p=1)),
imgaug.ToFloat32(),
]
ds_test = AugmentImageComponent(ds_test, ag_test, 0)
ds_test = BatchData(ds_test, self.hparams.batch, remainder=True)
# ds_test = MultiProcessRunner(ds_test, num_proc=4, num_prefetch=16)
ds_test = PrintData(ds_test)
ds_test = MapData(ds_test,
lambda dp: [torch.tensor(np.transpose(dp[0], (0, 3, 1, 2))),
torch.tensor(dp[1]).float()])
return ds_test
def get_medium_augmentations(image_size):
min_size = min(image_size[0], image_size[1])
return A.Compose([
A.OneOf([A.RandomSizedCrop(min_max_height=(int(min_size* 0.85), min_size),
height=image_size[0],
width=image_size[1]),
A.Resize(image_size[0], image_size[1]),
A.CenterCrop(image_size[0], image_size[1])
], p = 1.0),
A.OneOf([
A.RandomBrightnessContrast(brightness_limit=0.15,
contrast_limit=0.5),
A.RandomGamma(gamma_limit=(50, 150)),
A.NoOp()
], p = 1.0),
A.OneOf([A.CLAHE(p=0.5, clip_limit=(10, 10), tile_grid_size=(3, 3)),
A.FancyPCA(alpha=0.4),
A.NoOp(),
], p = 1.0),
A.OneOf([A.HorizontalFlip(),
A.VerticalFlip(),
A.RandomRotate90(),
A.NoOp()
], p = 1.0)
])
def transform(train=True, mean=None, std=None):
normalize = alb.Compose([
alb.Normalize(mean=mean or _mean, std=std or _std),
ToTensorV2(),
])
if not train:
return normalize
return alb.Compose([
alb.HorizontalFlip(),
alb.VerticalFlip(),
alb.RandomRotate90(),
alb.ShiftScaleRotate(shift_limit=0.0625,
scale_limit=0.2,
rotate_limit=15,
p=0.9,
border_mode=cv2.BORDER_REFLECT),
alb.OneOf([
alb.OpticalDistortion(p=0.3),
alb.GridDistortion(p=.1),
alb.IAAPiecewiseAffine(p=0.3),
],
p=0.3),
alb.OneOf([
alb.HueSaturationValue(10, 15, 10),
alb.CLAHE(clip_limit=2),
alb.RandomBrightnessContrast(),
],
p=0.3),
normalize,
])
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 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_train_transforms(config):
return A.Compose(
[
A.OneOf([
A.HueSaturationValue(hue_shift_limit=0.1, sat_shift_limit= 0.1,
val_shift_limit=0.1, p=0.8),
A.RandomBrightnessContrast(brightness_limit=0.3,
contrast_limit=0.2, p=0.8),
],p=0.7),
A.Rotate (limit=15, interpolation=1, border_mode=4, value=None, mask_value=None, p=0.8),
A.HorizontalFlip(p=0.5),
A.VerticalFlip(p=0.5),
A.RandomResizedCrop (config.preprocess.height, config.preprocess.width, scale=(0.8, 0.8), ratio=(0.75, 1.3333333333333333), interpolation=1, always_apply=False, p=0.1),
A.OneOf([
A.Resize(height=config.preprocess.height, width=config.preprocess.width, p=0.2),
A.LongestMaxSize(max_size=config.preprocess.longest_max_size, p=0.2),
A.SmallestMaxSize(max_size=config.preprocess.smallest_max_size, p=0.2),
], p=1),
A.CLAHE(clip_limit=[1,4],p=1),
],
p=1.0,
bbox_params=A.BboxParams(
format='coco',
min_area=0.5,
min_visibility=0.5,
label_fields=['category_id']
)
)
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 cifar_alb_trainData():
'''Apply Albumentations data transforms to the dataset and returns iterable'''
train_transform = [
A.HorizontalFlip(p=0.15),
A.ShiftScaleRotate(shift_limit=0.05,
scale_limit=0.05,
rotate_limit=15,
p=0.25),
A.RGBShift(r_shift_limit=15, g_shift_limit=15, b_shift_limit=15,
p=0.5),
A.RandomBrightnessContrast(p=0.25),
A.RandomGamma(p=0.25),
A.CLAHE(p=0.25),
A.ChannelShuffle(p=0.1),
A.ElasticTransform(p=0.1),
A.MotionBlur(blur_limit=17, p=0.1),
A.Cutout(num_holes=1,
max_h_size=16,
max_w_size=16,
fill_value=mean,
always_apply=False,
p=0.5),
A.Normalize(mean=mean, std=std),
ToTensor()
]
transforms_result = A.Compose(train_transform)
return lambda img: transforms_result(image=np.array(img))["image"]
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 __init__(self, n, m):
self.n = n
self.m = m
m_ratio = self.m / 30.0
self.augment_list = (
A.CLAHE(always_apply=True),
A.Equalize(always_apply=True),
A.InvertImg(always_apply=True),
A.Rotate(limit=30 * m_ratio, always_apply=True),
A.Posterize(num_bits=int(4 * m_ratio), always_apply=True),
A.Solarize(threshold=m_ratio, always_apply=True),
A.RGBShift(r_shift_limit=110 * m_ratio,
g_shift_limit=110 * m_ratio,
b_shift_limit=110 * m_ratio,
always_apply=True),
A.HueSaturationValue(hue_shift_limit=20 * m_ratio,
sat_shift_limit=30 * m_ratio,
val_shift_limit=20 * m_ratio,
always_apply=True),
A.RandomContrast(limit=m_ratio, always_apply=True),
A.RandomBrightness(limit=m_ratio, always_apply=True),
# A.Sharpen(always_apply=True), 0.1, 1.9),
A.ShiftScaleRotate(shift_limit=0.3 * m_ratio,
shift_limit_y=0,
rotate_limit=0,
always_apply=True),
A.ShiftScaleRotate(shift_limit=0.3 * m_ratio,
shift_limit_x=0,
rotate_limit=0,
always_apply=True),
A.Cutout(num_holes=int(8 * m_ratio), always_apply=True),
A.IAAAffine(shear=0.3 * m_ratio, always_apply=True))
assert self.n <= len(self.augment_list)
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 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 __init__(self, image_size):
self.data_transform = {
'train_transform':A.Compose([
A.Transpose(p=0.5),
A.VerticalFlip(p=0.5),
A.HorizontalFlip(p=0.5),
A.RandomBrightness(limit=0.2, p=0.75),
A.RandomContrast(limit=0.2, p=0.75),
A.OneOf([
A.MotionBlur(blur_limit=5),
A.MedianBlur(blur_limit=5),
A.GaussianBlur(blur_limit=5),
A.GaussNoise(var_limit=(5.0, 30.0)),], p=0.7),
A.OneOf([
A.OpticalDistortion(distort_limit=1.0),
A.GridDistortion(num_steps=5, distort_limit=1.),
A.ElasticTransform(alpha=3),], p=0.7),
A.CLAHE(clip_limit=4.0, p=0.7),
A.HueSaturationValue(hue_shift_limit=10, sat_shift_limit=20, val_shift_limit=10, p=0.5),
A.ShiftScaleRotate(shift_limit=0.1, scale_limit=0.1, rotate_limit=15, border_mode=0, p=0.85),
A.Resize(image_size, image_size),
A.Cutout(max_h_size=int(image_size * 0.375), max_w_size=int(image_size * 0.375), num_holes=1, p=0.7),
A.Normalize()
]),
'test_transform': A.Compose([
A.Resize(image_size, image_size),
A.Normalize(),
A.Resize(image_size, image_size)
])}
def val_dataloader(self):
"""Summary
Returns:
TYPE: Description
"""
ds_valid = CustomDataSet(folder=self.hparams.data,
train_or_valid='valid',
size=np.inf,
hparams=self.hparams)
ds_valid.reset_state()
ag_valid = [
imgaug.Resize(self.hparams.shape, interp=cv2.INTER_NEAREST),
imgaug.ToFloat32(),
]
ds_valid = AugmentImageComponent(ds_valid, [
imgaug.Albumentations(
AB.CLAHE(tile_grid_size=(32, 32), always_apply=True, p=1), ),
], 0)
ds_valid = AugmentImageComponents(ds_valid, ag_valid, [0, 1])
ds_valid = BatchData(ds_valid, self.hparams.batch, remainder=True)
ds_valid = MultiProcessRunner(ds_valid, num_proc=4, num_prefetch=16)
ds_valid = PrintData(ds_valid)
ds_valid = MapData(
ds_valid, lambda dp: [
torch.tensor(dp[0][:, np.newaxis, :, :]).float(),
torch.tensor(dp[1][:, np.newaxis, :, :]).float(),
])
return ds_valid
def transformer(self):
"""TRANSFORMATION DE NOTRE IMAGE AFIN DE REDUIRE LE BIAIS"""
if self.is_train:
transform = A.Compose([
A.CLAHE(),
A.RandomRotate90(),
A.DualTransform(), # adding
A.Transpose(),
A.Resize(height=self.img_size,
width=self.img_size,
interpolation=cv2.INTER_AREA), # RESIZE
A.ShiftScaleRotate(shift_limit=0.0625,
scale_limit=0.50,
rotate_limit=45,
p=.75),
A.Blur(blur_limit=3),
A.OpticalDistortion(),
A.GridDistortion(),
A.HueSaturationValue(),
])
else:
transform = A.Compose([
A.Resize(height=self.img_size,
width=self.img_size,
interpolation=cv2.INTER_AREA), # RESIZE
])
return transform
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 _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 __init__(self):
self.transform = None
try:
import albumentations as A
check_version(A.__version__, '1.0.3',
hard=True) # version requirement
self.transform = A.Compose([
A.Blur(p=0.01),
A.MedianBlur(p=0.01),
A.ToGray(p=0.01),
A.CLAHE(p=0.01),
A.RandomBrightnessContrast(p=0.0),
A.RandomGamma(p=0.0),
A.ImageCompression(quality_lower=75, p=0.0)
],
bbox_params=A.BboxParams(
format='yolo',
label_fields=['class_labels']))
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 Albumentations(params):
augmentation = A.Compose([
A.HorizontalFlip(p=0.5),
A.VerticalFlip(p=0.5),
A.Transpose(p=0.5),
A.OneOf([
A.CLAHE(p=1.),
A.RandomBrightnessContrast(0.15, 0.15, p=1.),
A.RandomGamma(p=1.),
A.HueSaturationValue(p=1.)],
p=0.5),
A.OneOf([
A.Blur(3, p=1.),
A.MotionBlur(3, p=1.),
A.Sharpen(p=1.)],
p=0.5),
A.ShiftScaleRotate(
shift_limit=0.05, scale_limit=0.05, rotate_limit=15,
border_mode=cv2.BORDER_CONSTANT, p=0.75)
# IMPORTANT: You MUST add A.Normalize(...) in the list.
A.Normalize(mean=params.mean, std=params.std, max_pixel_value=255., always_apply=True)
], bbox_params=A.BboxParams(format='coco', label_fields=['category_ids'], min_visibility=0.2))
return augmentation
def compose_albumentations(gamma_limit_lower=0,
gamma_limit_upper=0,
CLAHE_clip_limit=0.,
brightness_limit=0,
contrast_limit=0.,
distort_limit=0.):
'Compose albumentations augmentations'
augs = []
if sum([gamma_limit_lower, gamma_limit_upper]) > 0:
augs.append(
A.RandomGamma(gamma_limit=(gamma_limit_lower, gamma_limit_upper),
p=0.5))
if CLAHE_clip_limit > 0:
augs.append(A.CLAHE(clip_limit=CLAHE_clip_limit))
if sum([brightness_limit, contrast_limit]) > 0:
augs.append(
A.RandomBrightnessContrast(brightness_limit=brightness_limit,
contrast_limit=contrast_limit))
if distort_limit > 0:
augs.append(
A.GridDistortion(num_steps=5,
distort_limit=distort_limit,
interpolation=1,
border_mode=4,
p=0.5))
return augs
def get_train_data_loader(path,
classes_list,
batch_size,
shuffle=True,
num_workers=4):
aug = get_aug([
A.HorizontalFlip(p=.5),
A.RandomSizedBBoxSafeCrop(width=448,
height=448,
erosion_rate=0,
interpolation=cv2.INTER_CUBIC),
A.RGBShift(p=.5),
A.Blur(blur_limit=5, p=0.5),
A.RandomBrightnessContrast(p=0.5),
A.CLAHE(p=0.5),
A.Normalize(),
ToTensorV2()
])
voc = VOCDataset(path,
classes_list=classes_list,
image_set='train',
transforms=aug)
dataloader = torch.utils.data.DataLoader(voc,
batch_size,
shuffle=shuffle,
num_workers=num_workers)
return dataloader
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 main():
aug = get_aug([
A.HorizontalFlip(p=.5),
A.RandomSizedBBoxSafeCrop(width=448,
height=448,
erosion_rate=0,
interpolation=cv2.INTER_CUBIC),
A.RGBShift(p=.5),
A.Blur(blur_limit=5, p=0.5),
A.RandomBrightnessContrast(p=0.5),
A.CLAHE(p=0.5),
])
voc = VOCDataset(cfg.DATASET_PATH,
classes_list=cfg.CLASSES,
image_set='train',
transforms=aug)
for i in range(1000):
image, out = voc[i]
boxes = post_processing(out)
im_size = image.shape[0]
for det in boxes:
pt1 = (det[0] - det[2] / 2, det[1] - det[3] / 2)
pt2 = (det[0] + det[2] / 2, det[1] + det[3] / 2)
pt1 = (int(pt1[0] * im_size), int(pt1[1] * im_size))
pt2 = (int(pt2[0] * im_size), int(pt2[1] * im_size))
cv2.rectangle(image, pt1, pt2, (255, 33, 44))
image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
cv2.imshow("test", image)
cv2.waitKeyEx(-1)
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 _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)
