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_training_augmentation(): return albu.Compose([ albu.HorizontalFlip(p=0.5), albu.VerticalFlip(p=0.5), albu.Transpose(p=0.5), albu.ShiftScaleRotate(scale_limit=0.5, rotate_limit=0, shift_limit=0.1, p=0.3, border_mode=0), #albu.RandomCrop(height=320, width=320, always_apply=True), albu.IAAAdditiveGaussianNoise(p=0.2), albu.IAAPerspective(p=0.5), albu.RandomContrast(p=0.5), albu.HueSaturationValue(p=0.5), albu.OneOf( [ albu.CLAHE(p=1), albu.RandomGamma(p=1), ], p=0.3, ), albu.OneOf( [ albu.IAASharpen(p=1), albu.Blur(blur_limit=3, p=1), albu.MotionBlur(blur_limit=3, p=1), ], p=0.3, ), ])
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 __init__(self, width, height): super().__init__() max_size = int(max(width, height) * 1.05) self.transforms = AL.Compose([ AL.LongestMaxSize(max_size), AL.IAAPerspective(scale=(0.02, 0.04), keep_size=True, p=0.3), AL.OneOf([ AL.HorizontalFlip(p=1), AL.VerticalFlip(p=1), AL.Transpose(p=1) ], p=0.7), AL.RandomRotate90(p=0.5), AL.OneOf([ AL.RandomBrightnessContrast(p=0.8), AL.RandomGamma(p=0.8), AL.HueSaturationValue(p=0.3) ]), Filling(max_size), AL.CoarseDropout(max_holes=12, max_height=24, max_width=24, min_holes=4, min_height=8, min_width=8, p=0.3), AL.OneOf([AL.Resize(height, width), AL.RandomCrop(height, width)], p=1), ])
def __init__(self, images, labels, batch_size=16, image_shape=(256, 512, 1), do_shuffle_at_epoch_end=True, length=None, do_augment=True): super().__init__(images, labels, batch_size, image_shape, do_shuffle_at_epoch_end, length, do_augment) self.augmenting_pipeline = A.Compose([ A.HorizontalFlip(), A.IAAAffine(translate_percent={"x": (-1, 1)}, mode="reflect", p=1), A.PadIfNeeded(min_width=int(self.input_shape[1] * 2), min_height=self.input_shape[0]), A.GridDistortion(p=0.8, distort_limit=0.5), A.ElasticTransform(p=0.5, alpha=10, sigma=100 * 0.03, alpha_affine=0), A.CenterCrop(width=self.input_shape[1], height=self.input_shape[0]), A.IAAPerspective(scale=(0, 0.10), p=1), A.ShiftScaleRotate(shift_limit=0, scale_limit=(.0, 0.4), rotate_limit=0, p=0.5), A.CLAHE(clip_limit=2.0, p=0.5), A.Lambda( image=self.convert_image, mask=self.convert_segmentations, ), ])
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_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(): """Builds random transformations we want to apply to our dataset. Arguments: Returns: A albumentation functions to pass our images to. Raises: """ train_transform = [ 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_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 augmentation(image_size, train=True): max_crop = image_size // 5 if train: data_transform = A.Compose([ A.Resize(image_size, image_size), A.Compose([ A.OneOf([ A.RandomRain(p=0.1), A.GaussNoise(mean=15), A.GaussianBlur(blur_limit=10, p=0.4), A.MotionBlur(p=0.2) ]), A.OneOf([ A.RGBShift(p=1.0, r_shift_limit=(-10, 10), g_shift_limit=(-10, 10), b_shift_limit=(-10, 10)), A.RandomBrightnessContrast( brightness_limit=0.3, contrast_limit=0.1, p=1), A.HueSaturationValue(hue_shift_limit=20, p=1), ], p=0.6), A.OneOf([ A.CLAHE(clip_limit=2), A.IAASharpen(), A.IAAEmboss(), ]), A.OneOf([A.IAAPerspective(p=0.3), A.ElasticTransform(p=0.1)]), A.OneOf([ A.Rotate(limit=25, p=0.6), A.IAAAffine( scale=0.9, translate_px=15, rotate=25, shear=0.2, ) ], p=1), A.Cutout(num_holes=1, max_h_size=max_crop, max_w_size=max_crop, p=0.2) ], p=1), A.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), AT.ToTensor() ]) else: data_transform = transforms.Compose([ transforms.ToPILImage(), transforms.Resize((image_size, image_size)), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) return data_transform
def __init__(self): self.aug = A.Compose([ A.IAAPerspective(scale=(0.05, 0.2), p=0.5), A.ShiftScaleRotate(scale_limit=0.5, p=0.5), A.OpticalDistortion(distort_limit=0.5, p=0.5), A.GridDistortion(distort_limit=0.5, p=0.5), A.ElasticTransform(p=0.5) ], p=1) pass
def spatial_and_noise(p): return albu.Compose([ albu.ShiftScaleRotate(rotate_limit=30, scale_limit=15, border_mode=cv2.BORDER_CONSTANT, value=-1024, p=0.5), albu.IAAAdditiveGaussianNoise(p=0.2), albu.IAAPerspective(p=0.2), albu.IAAPiecewiseAffine(p=0.2) ], p=p, additional_targets={'image{}'.format(_) : 'image' for _ in range(1, 101)})
def DistortionBase(): return A.Compose([ A.OneOf( [ A.IAAPerspective(), A.IAAPiecewiseAffine(), A.GridDistortion(), A.OpticalDistortion(distort_limit=2, shift_limit=0.5), ], p=0.50, ) ])
def aug_img(img, blur_limit=7): annotations = {'image': img} aug = albumentations.Compose([ albumentations.GaussNoise(p=1), albumentations.MotionBlur(p=1, blur_limit=blur_limit), albumentations.Rotate(5), albumentations.OpticalDistortion(p=1), albumentations.IAAPerspective(scale=(0.005, 0.01), p=1), albumentations.CLAHE(p=1), albumentations.RandomBrightnessContrast(p=1) ]) augmented = aug(**annotations) return augmented['image']
def train_transforms(self): return A.Compose([ 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=self.args.arch.image_height, min_width=self.args.arch.image_width, always_apply=True, border_mode=0, ), A.RandomCrop( height=self.args.arch.image_height, width=self.args.arch.image_width, always_apply=True, ), A.IAAAdditiveGaussianNoise(p=0.2), A.IAAPerspective(p=0.5), A.OneOf( [ A.CLAHE(p=1), A.RandomBrightnessContrast(contrast_limit=0.0, 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.RandomBrightnessContrast(brightness_limit=0.0, p=1), A.HueSaturationValue(p=1), ], p=0.9, ), A.Normalize( mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], max_pixel_value=255.0, ), ToTensorV2(), ])
def __init__(self, cfg, phase='train'): self.phase = phase self.size = cfg['image_size'] self.root_dir = cfg['root_dir'] cls_names = cfg['class_names'] self.category_id_to_name = {k: v for k, v in enumerate(cls_names)} self.category_name_to_id = { v: k for k, v in self.category_id_to_name.items() } if self.phase == 'train': self.data_list = self.load_annos(cfg['train_data_file'], self.category_name_to_id) else: self.data_list = self.load_annos(cfg['val_data_file'], self.category_name_to_id) self.aug = A.Compose( [ # A.RandomScale(scale_limit=0.1, p=0.5), A.ShiftScaleRotate( shift_limit=0.2, scale_limit=0.4, rotate_limit=45), A.PadIfNeeded(self.size[0], self.size[1]), # A.RandomSizedCrop(min_max_height=(int(self.size[0]*0.8), self.size[0]*1.2), # height=self.size[0], # width=self.size[1], # w2h_ratio=self.size[1]/self.size[0]), A.RandomResizedCrop( self.size[0], self.size[1], scale=(0.8, 1.0)), A.IAAPerspective(scale=(0.05, 0.1)), A.Rotate(), A.Flip(), # A.RandomSizedBBoxSafeCrop(height=self.size[1], width=self.size[0]), # A.RandomBrightnessContrast(p=0.5), # A.HueSaturationValue(p=0.5), A.ColorJitter() ], bbox_params=A.BboxParams(format='pascal_voc', label_fields=['cls_ids'], min_area=0.3, min_visibility=0.3)) self.to_tensor = T.Compose([ T.ToTensor(), T.Normalize(cfg['imagenet_default_mean'], cfg['imagenet_default_std']) ])
def light_augmentations(): return A.Compose([ A.HorizontalFlip(), A.RandomBrightnessContrast(), A.OneOf([ A.ShiftScaleRotate(scale_limit=0.05, rotate_limit=15, border_mode=cv2.BORDER_CONSTANT), A.IAAAffine(), A.IAAPerspective(), A.NoOp() ]), A.HueSaturationValue(), A.Normalize() ])
def generate_transforms3(img_size): train_transform = Compose([ A.RandomResizedCrop(img_size, img_size, scale=(0.9, 1), p=1), A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5), A.ShiftScaleRotate(p=0.5), A.HueSaturationValue(hue_shift_limit=10, sat_shift_limit=10, val_shift_limit=10, p=0.7), A.RandomBrightnessContrast(brightness_limit=(-0.2, 0.2), contrast_limit=(-0.2, 0.2), p=0.7), A.CLAHE(clip_limit=(1, 4), p=0.5), A.OneOf([ A.OpticalDistortion(distort_limit=1.0), A.GridDistortion(num_steps=5, distort_limit=1.0), A.ElasticTransform(alpha=3), ], p=0.2), A.Resize(img_size, img_size), A.OneOf([ A.JpegCompression(), A.Downscale(scale_min=0.1, scale_max=0.15), ], p=0.2), A.IAAPerspective(p=0.2), A.IAASharpen(p=0.2), A.Cutout(max_h_size=int(img_size * 0.1), max_w_size=int(img_size * 0.1), num_holes=5, p=0.5), Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), max_pixel_value=255.0, p=1.0), ToTensorV2(), ]) val_transform = Compose([ Resize(height=img_size, width=img_size), Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), max_pixel_value=255.0, p=1.0), ToTensorV2(), ]) return {"train": train_transform, "val": val_transform}
def get_training_augmentation(): train_transform = [ albu.HorizontalFlip(p=0.5), albu.VerticalFlip(p=0.2), albu.ShiftScaleRotate(scale_limit=0.5, rotate_limit=50, shift_limit=0.1, p=1, border_mode=0), #320 384 448 512 640 # albu.GridDistortion(num_steps=2, distort_limit=0.2, interpolation=1, border_mode=0, value=None, always_apply=False, p=0.5), albu.PadIfNeeded(min_height=padheight, min_width=padwidth, always_apply=True, border_mode=0), albu.Resize(height=padheight, width=padwidth), albu.RandomCrop(height=inputheight, width=inputwidth, always_apply=True), #the last size albu.ChannelShuffle(p=0.1), 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 build_transforms(cfg, is_train, debug=False): to_compose = [albu.Resize(*cfg.inputs.size)] if is_train and cfg.augmentation.enable: to_compose.extend([ albu.HorizontalFlip(p=0.5), albu.VerticalFlip(p=0.5), albu.RandomRotate90(p=0.5), albu.Transpose(p=0.5), albu.ShiftScaleRotate(scale_limit=0.2, rotate_limit=0, shift_limit=0.2, p=0.2, border_mode=0), 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, ), albu.Compose( [albu.VerticalFlip(p=0.5), albu.RandomRotate90(p=0.5)]) ]) if debug: return albu.Compose(to_compose) to_compose.append(albu.Normalize(**cfg.inputs.normalize)) to_compose.append(ToTensorV2(transpose_mask=True)) return albu.Compose(to_compose)
def create_augmentations(img_height=224,img_width=224,p=0.1): AUGMENTATIONS = albumentations.Compose([ albumentations.Resize(img_height, img_width, p=1.), albumentations.HorizontalFlip(p=0.5), albumentations.IAAPerspective(p=p, scale=(0.01, 0.05)), albumentations.GridDistortion(p=p, distort_limit=0.2), albumentations.GridDistortion(p=p,distort_limit=0.2), albumentations.CoarseDropout(p=p, max_holes=10, max_height=25, max_width=25), albumentations.GaussNoise(p=p,var_limit=(40.0, 70.0)), albumentations.ShiftScaleRotate(shift_limit=0.1, scale_limit=0.1, rotate_limit=10, interpolation=1,border_mode=4, always_apply=False, p=2*p), albumentations.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.4, hue=0.2, p=2*p), albumentations.Blur(p=p,blur_limit=10), albumentations.ToGray(p=p), albumentations.ChannelShuffle(p=0.05), albumentations.RandomGamma(p=p,gamma_limit=(20,200)), AddShadow(p=p), ]) return AUGMENTATIONS
def default_adjusted(image, mask): alpha = randrange(30, 45) sigma = randrange(5, 7) scale = uniform(0.015, 0.075) train_transform = [ albu.ShiftScaleRotate(scale_limit=0.2, rotate_limit=0, shift_limit=0.1, p=1, border_mode=0), albu.PadIfNeeded(min_height=512, min_width=512, always_apply=True, border_mode=0), albu.IAAAdditiveGaussianNoise(p=0.2), albu.IAAPerspective(p=0.5), albu.OneOf( [ albu.CLAHE(p=1), albu.RandomBrightnessContrast(p=1), albu.RandomGamma(p=1), ], p=0.9, ), albu.OneOf( [ albu.RandomBrightnessContrast(brightness_limit=0, p=1), albu.HueSaturationValue(p=1), ], p=0.9, ), albu.OneOf( [ albu.ElasticTransform(alpha=alpha, sigma=sigma, p=1, border_mode=cv2.BORDER_CONSTANT), albu.IAAAffine(scale=scale, p=1, mode="constant"), ], p=0.7, ), ] aug_func = albu.Compose(train_transform) augmented = aug_func(image=image, mask=mask) return augmented['image'], augmented['mask']
def augmentation(image, bboxes, classes_ids): transform = A.Compose( [ A.HorizontalFlip(p=0.5), A.ShiftScaleRotate(p=0.5), A.Blur(blur_limit=4, p=0.5), A.RandomCrop(200, 200, p=0.5), A.IAAPerspective(p=0.5), A.Resize(420, 420, p=1.0) ], bbox_params=A.BboxParams(format='pascal_voc', label_fields=['classes_ids']), ) transformed = transform(image=image, bboxes=bboxes, classes_ids=classes_ids) return transformed['image'], transformed['bboxes'], transformed[ 'classes_ids']
def get_preprocessing(preprocessing_fn, apply_augmentation=False): """Construct preprocessing transform Args: preprocessing_fn (callable): data normalization function (can be specific for each pretrained neural network) apply_augmentation (boolean): apply data augmentation or not Return: transform: albumentations.Compose """ _transform = [A.Resize(384, 480)] if apply_augmentation: _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.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) ] _transform += [ A.Lambda(image=preprocessing_fn), A.Lambda(image=to_CHW, mask=to_CHW) ] return A.Compose(_transform)
def hard_transforms(border_reflect=2): result = [ albu.HorizontalFlip(p=0.5), albu.VerticalFlip(p=0.5), albu.ShiftScaleRotate(shift_limit=0.1, scale_limit=0.1, rotate_limit=15, border_mode=border_reflect, p=0.5), albu.IAAPerspective(scale=(0.02, 0.05), p=0.3), albu.RandomBrightnessContrast(brightness_limit=0.2, contrast_limit=0.2, p=0.3), albu.RandomGamma(gamma_limit=(85, 115), p=0.3), albu.HueSaturationValue(p=0.3), albu.ImageCompression(quality_lower=80, p=0.5), ] return result
def __init__(self): super().__init__() self.transforms = AL.Compose([ AL.IAAPerspective(scale=(0.02, 0.04), keep_size=True, p=0.3), AL.RandomBrightnessContrast(p=0.3), AL.RandomGamma(p=0.3), AL.GaussianBlur(blur_limit=9, p=0.4), AL.GaussNoise(p=0.3), AL.RandomRotate90(p=0.6), AL.Rotate(limit=15, border_mode=cv2.BORDER_CONSTANT, p=0.2), AL.CoarseDropout(max_holes=24, max_height=24, max_width=24, min_holes=8, min_height=8, min_width=8, p=0.4), ])
def get_training_augmentation(height, width, downsample_factor=1): downsample_fn = partial(downsample, factor=downsample_factor) train_transform = [ albu.Lambda(image=downsample_fn, mask=downsample_fn), 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=height, min_width=width, always_apply=True, border_mode=0), albu.RandomCrop(height=height, width=width, 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 get_training_augmentation(): SIZE = 320 # default here is 320, 640 is too large train_transform = [ albu.HorizontalFlip(p=0.5), # p = probability of applying this transform albu.ShiftScaleRotate(scale_limit=0.5, rotate_limit=0, shift_limit=0.1, p=1, border_mode=0), # Can we play with different sizes? albu.PadIfNeeded(min_height=SIZE, min_width=SIZE, always_apply=True, border_mode=0), albu.RandomCrop(height=SIZE, width=SIZE, always_apply=True), albu.IAAAdditiveGaussianNoise(p=0.2), albu.IAAPerspective(p=0.5), albu.OneOf( [ albu.CLAHE(p=1), albu.RandomBrightnessContrast(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.RandomBrightnessContrast(p=1), albu.HueSaturationValue(p=1), ], p=0.9, ), ] return albu.Compose(train_transform)
def __get_transform(self): transform = [ albu.HorizontalFlip(p=0.5), albu.ShiftScaleRotate(scale_limit=0.2, rotate_limit=0, shift_limit=0.1, p=1, border_mode=0), albu.PadIfNeeded(min_height=self.size, min_width=self.size, always_apply=True, border_mode=0), albu.RandomCrop(height=self.size, width=self.size, always_apply=True), albu.IAAAdditiveGaussianNoise(p=0.2), albu.IAAPerspective(p=0.5) ] return albu.Compose(transform)