def case3_cls_train_augs(name, **kwargs): return [ A.Compose([ A.ISONoise(), A.GridDistortion(distort_limit=0.1), A.HorizontalFlip(), A.VerticalFlip(), A.RandomRotate90(), A.ShiftScaleRotate( rotate_limit=30, border_mode=cv2.BORDER_CONSTANT, value=0), A.Normalize() ], p=1.0), A.Compose([ A.ISONoise(), A.OpticalDistortion(), A.HorizontalFlip(), A.VerticalFlip(), A.RandomRotate90(), A.ShiftScaleRotate( rotate_limit=30, border_mode=cv2.BORDER_CONSTANT, value=0), A.Normalize() ], p=1.0), ]
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 get_augmentation(config): normalize = A.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) to_tensor = ToTensorV2() transforms = {} train_transform = A.Compose([ A.CenterCrop(p=1, height=config.TRAIN.HEIGHT, width=config.TRAIN.WIDTH), A.Cutout(num_holes=4, max_h_size=10, max_w_size=10, p=0.3), A.OneOf([ A.HueSaturationValue(hue_shift_limit=0.2, sat_shift_limit=0.2, val_shift_limit=0.2, p=0.9), A.RandomBrightnessContrast( brightness_limit=0.2, contrast_limit=0.2, p=0.9), ], p=0.5), A.HorizontalFlip(p=0.5), A.ISONoise(p=0.3), normalize, to_tensor ]) transforms['train'] = train_transform valid_transform = A.Compose([ A.CenterCrop(p=1, height=config.TRAIN.HEIGHT, width=config.TRAIN.WIDTH), normalize, to_tensor ]) transforms['valid'] = valid_transform return transforms
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_individual_transforms(): transforms = A.Compose([ A.OneOf( [ A.Transpose(p=1.0), A.VerticalFlip(p=1.0), A.HorizontalFlip(p=1.0), A.RandomRotate90(p=1.0), A.NoOp(), ], p=1.0, ), A.OneOf( [ A.ElasticTransform(p=1.0), A.GridDistortion(p=1.0), A.OpticalDistortion(p=1.0), A.NoOp(), ], p=1.0, ), A.OneOf( [ A.GaussNoise(p=1.0), A.GaussianBlur(p=1.0), A.ISONoise(p=1.0), A.CoarseDropout( p=1.0, max_holes=16, max_height=16, max_width=16), A.NoOp(), ], p=1.0, ), ]) return transforms
def __init__(self, root_dir, is_train): super(FaceDataset, self).__init__() #self.local_rank = local_rank self.is_train = is_train self.input_size = 256 self.num_kps = 68 transform_list = [] if is_train: transform_list += \ [ A.ColorJitter(brightness=0.8, contrast=0.5, p=0.5), A.ToGray(p=0.1), A.ISONoise(p=0.1), A.MedianBlur(blur_limit=(1,7), p=0.1), A.GaussianBlur(blur_limit=(1,7), p=0.1), A.MotionBlur(blur_limit=(5,12), p=0.1), A.ImageCompression(quality_lower=50, quality_upper=90, p=0.05), A.ShiftScaleRotate(shift_limit=0.1, scale_limit=0.2, rotate_limit=40, interpolation=cv2.INTER_LINEAR, border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0, p=0.8), A.HorizontalFlip(p=0.5), RectangleBorderAugmentation(limit=0.33, fill_value=0, p=0.2), ] transform_list += \ [ A.geometric.resize.Resize(self.input_size, self.input_size, interpolation=cv2.INTER_LINEAR, always_apply=True), A.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]), ToTensorV2(), ] self.transform = A.ReplayCompose(transform_list, keypoint_params=A.KeypointParams( format='xy', remove_invisible=False)) self.root_dir = root_dir with open(osp.join(root_dir, 'annot.pkl'), 'rb') as f: annot = pickle.load(f) self.X, self.Y = annot train_size = int(len(self.X) * 0.99) if is_train: self.X = self.X[:train_size] self.Y = self.Y[:train_size] else: self.X = self.X[train_size:] self.Y = self.Y[train_size:] #if local_rank==0: # logging.info('data_transform_list:%s'%transform_list) flip_parts = ([1, 17], [2, 16], [3, 15], [4, 14], [5, 13], [6, 12], [7, 11], [8, 10], [18, 27], [19, 26], [20, 25], [21, 24], [22, 23], [32, 36], [33, 35], [37, 46], [38, 45], [39, 44], [40, 43], [41, 48], [42, 47], [49, 55], [50, 54], [51, 53], [62, 64], [61, 65], [68, 66], [59, 57], [60, 56]) self.flip_order = np.arange(self.num_kps) for pair in flip_parts: self.flip_order[pair[1] - 1] = pair[0] - 1 self.flip_order[pair[0] - 1] = pair[1] - 1 logging.info('len:%d' % len(self.X)) print('!!!len:%d' % len(self.X))
def aug_train(): ''' augmentation for training a FR-system ''' aug = alt.Compose([ alt.Resize(height=112, width=112), alt.HorizontalFlip(p=0.5), alt.HueSaturationValue(hue_shift_limit=10, sat_shift_limit=20, val_shift_limit=10, p=0.2), alt.RGBShift(r_shift_limit=20, g_shift_limit=20, b_shift_limit=20, p=0.2), alt.RandomBrightnessContrast(brightness_limit=0.2, contrast_limit=0.2, p=0.3), alt.ToGray(p=0.01), alt.MotionBlur(blur_limit=7, p=0.2), # default=11 alt.GaussianBlur(blur_limit=7, p=0.2), # default=11 alt.GaussNoise(var_limit=(5.0, 20.0), mean=0, p=0.1), # defalt var_limit=(10.0, 30.0) alt.ISONoise(p=0.2), alt.Normalize(), ToTensor() ]) return aug
def get_training_augmentation(min_area=0., min_visibility=0.): train_transform = [ albu.OneOf([ albu.ISONoise(p=.5), albu.GaussNoise(p=0.4), albu.Blur(blur_limit=3, p=0.1), ]), albu.OneOf([ albu.CLAHE(clip_limit=2), ], p=0.2), albu.OneOf([ albu.RandomSnow(snow_point_lower=0., snow_point_upper=0.2, brightness_coeff=2., p=0.5), albu.RandomSunFlare(p=0.5), ]), albu.OneOf([ albu.RGBShift(p=0.1), albu.ChannelShuffle(p=0.2), ]) ] return albu.Compose(train_transform, bbox_params={ 'format': 'coco', 'min_area': min_area, 'min_visibility': min_visibility, 'label_fields': ['category_id'] })
def __iso_noise(self,img): transform = A.Compose([ A.ISONoise(color_shift=(0.01,0.1),intensity=(1.5,2.3)) ]) transformed = transform(image=img) transformed_image = transformed["image"] return transformed_image
def get_transformer(face_policy: str, patch_size: int, net_normalizer: transforms.Normalize, train: bool): # Transformers and traindb if face_policy == 'scale': # The loader crops the face isotropically then scales to a square of size patch_size_load loading_transformations = [ A.PadIfNeeded(min_height=patch_size, min_width=patch_size, border_mode=cv2.BORDER_CONSTANT, value=0,always_apply=True), A.Resize(height=patch_size,width=patch_size,always_apply=True), ] if train: downsample_train_transformations = [ A.Downscale(scale_max=0.5, scale_min=0.5, p=0.5), # replaces scaled dataset ] else: downsample_train_transformations = [] elif face_policy == 'tight': # The loader crops the face tightly without any scaling loading_transformations = [ A.LongestMaxSize(max_size=patch_size, always_apply=True), A.PadIfNeeded(min_height=patch_size, min_width=patch_size, border_mode=cv2.BORDER_CONSTANT, value=0,always_apply=True), ] if train: downsample_train_transformations = [ A.Downscale(scale_max=0.5, scale_min=0.5, p=0.5), # replaces scaled dataset ] else: downsample_train_transformations = [] else: raise ValueError('Unknown value for face_policy: {}'.format(face_policy)) if train: aug_transformations = [ A.Compose([ A.HorizontalFlip(), A.OneOf([ A.RandomBrightnessContrast(), A.HueSaturationValue(hue_shift_limit=10, sat_shift_limit=30, val_shift_limit=20), ]), A.OneOf([ A.ISONoise(), A.IAAAdditiveGaussianNoise(scale=(0.01 * 255, 0.03 * 255)), ]), A.Downscale(scale_min=0.7, scale_max=0.9, interpolation=cv2.INTER_LINEAR), A.ImageCompression(quality_lower=50, quality_upper=99), ], ) ] else: aug_transformations = [] # Common final transformations final_transformations = [ A.Normalize(mean=net_normalizer.mean, std=net_normalizer.std, ), ToTensorV2(), ] transf = A.Compose( loading_transformations + downsample_train_transformations + aug_transformations + final_transformations) return transf
def get_hard_augmentations(image_size): return A.Compose([ A.OneOf([ A.ShiftScaleRotate(shift_limit=0.05, scale_limit=0.1, rotate_limit=45, border_mode=cv2.BORDER_CONSTANT, value=0), A.ElasticTransform(alpha_affine=0, alpha=35, sigma=5, border_mode=cv2.BORDER_CONSTANT, value=0), A.OpticalDistortion(distort_limit=0.11, shift_limit=0.15, border_mode=cv2.BORDER_CONSTANT, value=0), A.GridDistortion(border_mode=cv2.BORDER_CONSTANT, value=0), A.NoOp() ]), A.OneOf([ A.RandomSizedCrop(min_max_height=(int(image_size[0] * 0.75), image_size[0]), height=image_size[0], width=image_size[1], p=0.3), A.NoOp() ]), A.ISONoise(p=0.5), # Brightness/contrast augmentations A.OneOf([ A.RandomBrightnessContrast(brightness_limit=0.5, contrast_limit=0.4), IndependentRandomBrightnessContrast(brightness_limit=0.25, contrast_limit=0.24), A.RandomGamma(gamma_limit=(50, 150)), A.NoOp() ]), A.OneOf([ A.RGBShift(r_shift_limit=40, b_shift_limit=30, g_shift_limit=30), A.HueSaturationValue(hue_shift_limit=10, sat_shift_limit=10), A.ToGray(p=0.2), A.NoOp() ]), A.ChannelDropout(), A.RandomGridShuffle(p=0.3), # D4 A.Compose([ A.RandomRotate90(), A.Transpose() ]) ])
def __init__(self): distortions = [ A.RGBShift(p=0.1), A.RandomBrightness(limit=0.5, p=0.1), A.RandomContrast(limit=0.5, p=0.1), ] random.shuffle(distortions) total_dist = distortions + [A.ISONoise()] self.distort_transform = A.Compose(total_dist)
def __init__(self): self.augmentor = A.Compose( [ A.MotionBlur(p=0.25), A.ColorJitter(p=0.5), A.RandomRain(p=0.1), # random occlusion A.RandomSunFlare(p=0.1), A.JpegCompression(p=0.25), A.ISONoise(p=0.25) ], p=1.0)
def get_gray_aug_trans(use_color_aug, use_shape_aug, mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5)): transform = transforms.Compose([ transforms.ToTensor(), # range [0, 255] -> [0.0,1.0] # range [0.0, 1.0] -> [-1.0,1.0] transforms.Normalize(mean=mean, std=std) ]) if use_color_aug: c_aug = A.Compose([ A.RandomBrightnessContrast(p=0.7, brightness_limit=0.5, contrast_limit=0.5), A.CoarseDropout(p=0.5, max_holes=8, max_height=16, max_width=16, min_height=8, min_width=8, fill_value=0), A.OneOf([ A.Blur(p=1, blur_limit=7), A.MotionBlur(p=1, blur_limit=7), A.MedianBlur(p=1, blur_limit=7), A.GaussianBlur(p=1, blur_limit=7) ], p=0.5), A.OneOf([ A.RandomGamma(p=1, gamma_limit=(80, 120)), A.GaussNoise(p=1, var_limit=(10.0, 50.0)), A.ISONoise(p=1, color_shift=(0.01, 0.05), intensity=(0.1, 0.5)), ], p=0.3), A.JpegCompression(quality_lower=10, quality_upper=30, p=0.3), # A.JpegCompression(quality_lower=50, quality_upper=100, p=1), ]) else: c_aug = None # crop_size = (args.train_input_h, args.train_input_w) if use_shape_aug: shape_aug = EzImageBaseAug() else: shape_aug = None return transform, c_aug, shape_aug
def faceaug(): ''' choose the augmentation for face-recognition ''' aug = alt.Compose([ alt.HorizontalFlip(p=0.5), alt.HueSaturationValue(hue_shift_limit=10, sat_shift_limit=20, val_shift_limit=10, p=0.2), alt.RGBShift(r_shift_limit=20, g_shift_limit=20, b_shift_limit=20, p=0.2), alt.RandomBrightnessContrast(brightness_limit=0.2, contrast_limit=0.2, p=0.3), alt.ToGray(p=0.01), alt.MotionBlur(blur_limit=7, p=0.2), # default=11 alt.GaussianBlur(blur_limit=7, p=0.2), # default=11 alt.GaussNoise(var_limit=(5.0, 20.0), mean=0, p=0.1), # default var_limit=(10.0, 30.0) alt.ISONoise(p=0.2), # alt.Normalize(), ToTensor()]) return aug
def hard_color_augmentations(): return A.Compose([ A.RandomBrightnessContrast(brightness_limit=0.3, contrast_limit=0.3, brightness_by_max=True), A.RandomGamma(gamma_limit=(90, 110)), A.OneOf( [A.NoOp(), A.MultiplicativeNoise(), A.GaussNoise(), A.ISONoise()]), A.OneOf([A.RGBShift(), A.HueSaturationValue(), A.NoOp()]), A.RandomFog(fog_coef_lower=0.05, fog_coef_upper=0.3), ])
def main(): size = (432,432) color_dic = {1:[255,255,255]} img_paths = [p.replace('\\', '/') for p in glob('dataset/train/img_aug/**', recursive=True) if os.path.isfile(p)] mask_paths = list(map(lambda x: x.replace('/img_aug/', '/mask_aug/'), img_paths)) batch_size = 16 splits = math.ceil(len(img_paths)/batch_size) empty = [] # albumentation # https://qiita.com/kurilab/items/b69e1be8d0224ae139ad transforms = albu.OneOf([ albu.ShiftScaleRotate(shift_limit=0.2, scale_limit=0.2, rotate_limit=90), albu.GaussNoise(), albu.ISONoise(intensity=(0.7,0.9)), albu.Downscale(), albu.ElasticTransform(), albu.GaussianBlur(), albu.MultiplicativeNoise(multiplier=(2.0,3.0)), ]) for i in range(splits): tfrecord_fname = '_record_' + str(i) + '.tfrecord' save_path = os.path.join('dataset', tfrecord_fname) # tfrecordのファイルは(画像データ数 / バッチサイズ)分作成する with tf.io.TFRecordWriter(tfrecord_fname) as writer: for img_d, mask_d in zip(img_paths[i::splits], mask_paths[i::splits]): # 画像変形 img = cv2.imread(img_d) mask = cv2.imread(mask_d) #augmented = transforms(image=img, mask=mask) #img, mask = augmented['image'], augmented['mask'] img = cv2.resize(img, (size[0], size[1]), cv2.INTER_NEAREST) mask = cv2.resize(mask, (size[0], size[1]), cv2.INTER_NEAREST) # byte列に変換 img = np2byte(img) mask = np2byte(mask) #img = np2byte(np.float32(img/127.5 - 1)) #mask = np2byte(convert_mask(mask, color_dic)) # シリアライズして書き出し proto = serialize_example(img, mask) writer.write(proto.SerializeToString()) if i>2 : break
def get_augmentation(save_path=None, load_path=None): if load_path: return A.load(load_path) else: aug_seq1 = A.OneOf([ A.Rotate(limit=(-90, 90), p=1.0), A.Flip(p=1.0), A.OpticalDistortion(always_apply=False, p=1.0, distort_limit=(-0.3, 0.3), shift_limit=(-0.05, 0.05), interpolation=3, border_mode=3, value=(0, 0, 0), mask_value=None), ], p=1.0) aug_seq2 = A.OneOf([ # A.ChannelDropout(always_apply=False, p=1.0, channel_drop_range=(1, 1), fill_value=0), A.RGBShift(r_shift_limit=15, g_shift_limit=15, b_shift_limit=15, p=1.0), A.RandomBrightnessContrast(always_apply=False, p=1.0, brightness_limit=( -0.2, 0.2), contrast_limit=(-0.2, 0.2), brightness_by_max=True) ], p=1.0) aug_seq3 = A.OneOf([ A.GaussNoise(always_apply=False, p=1.0, var_limit=(10, 50)), A.ISONoise(always_apply=False, p=1.0, intensity=( 0.1, 1.0), color_shift=(0.01, 0.3)), A.MultiplicativeNoise(always_apply=False, p=1.0, multiplier=( 0.8, 1.6), per_channel=True, elementwise=True), ], p=1.0) aug_seq4 = A.OneOf([ A.Equalize(always_apply=False, p=1.0, mode='pil', by_channels=True), A.InvertImg(always_apply=False, p=1.0), A.MotionBlur(always_apply=False, p=1.0, blur_limit=(3, 7)), A.RandomFog(always_apply=False, p=1.0, fog_coef_lower=0.01, fog_coef_upper=0.2, alpha_coef=0.2) ], p=1.0) aug_seq = A.Compose([ # A.Resize(self.img_size, self.img_size), # aug_seq1, aug_seq2, aug_seq3, aug_seq4, # A.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), # A.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]), ]) # aug_path = '/home/jitesh/prj/classification/test/bolt/aug/aug_seq.json' if save_path: A.save(aug_seq, save_path) # loaded_transform = A.load(aug_path) return aug_seq
def setup_augmentors(self, augmentations): self.augmentors = [] for aug_name, aug_config in augmentations.items(): aug = None def get_albu(aug): return albu.Compose(aug) if aug_name == 'image_compression': aug = get_albu([ albu.ImageCompression( quality_lower=aug_config.get('quality_lower', 90), quality_upper=aug_config.get('quality_upper'), p=aug_config.get('probabilty', 0.5)) ]) elif aug_name == 'posterize': aug = get_albu([ albu.Posterize(num_bits=aug_config.get('num_bits', 4), p=aug_config.get('probability', 0.5)) ]) elif aug_name == 'blur': aug = get_albu([ albu.Blur(blur_limit=aug_config.get('blur_limit', 7), p=aug_config.get('probabilty', 0.5)) ]) elif aug_name == 'median_blur': aug = get_albu([ albu.MedianBlur(blur_limit=aug_config.get('blur_limit', 7), p=aug_config.get('probabilty', 0.5)) ]) elif aug_name == 'iso_noise': aug = get_albu([ albu.ISONoise( color_shift=(aug_config.get('min_color_shift', 0.01), aug_config.get('max_color_shift', 0.05)), intensity=(aug_config.get('min_intensity', 0.1), aug_config.get('min_intensity', 0.5)), p=aug_config.get('probabilty', 0.5)) ]) if not aug: continue aug.name, aug.p, aug.base = aug_name, aug_config[ 'probability'], self self.augmentors.append(aug) return
def __init__(self): self.policy = A.Compose([ A.OneOf([ A.Rotate(180), A.Flip(), ], p=0.3), A.ShiftScaleRotate(shift_limit=0.2, scale_limit=0.5, rotate_limit=0, p=0.2), A.OneOf([ A.CoarseDropout(max_holes=16, max_height=16, max_width=16, p=0.3), A.GridDropout(ratio=0.3, p=0.3), ]), A.OneOf([ A.ElasticTransform(sigma=10, alpha_affine=25, p=0.3), A.RandomFog(fog_coef_lower=0.2, fog_coef_upper=0.7, p=0.2), ], p=0.2), A.OneOf([ A.IAAAdditiveGaussianNoise(), A.GaussNoise(), A.ISONoise() ], p=0.2), A.OneOf([ A.MotionBlur(p=.3), A.MedianBlur(blur_limit=5, p=0.3), A.Blur(blur_limit=5, p=0.3), A.GaussianBlur(p=0.3) ], p=0.2), A.OneOf([ A.ChannelShuffle(p=.3), A.HueSaturationValue(p=0.3), A.ToGray(p=0.3), A.ChannelDropout(p=0.3), A.InvertImg(p=0.1) ], p=0.2), A.OneOf([ A.OpticalDistortion(p=0.3), A.GridDistortion(p=.2), A.IAAPiecewiseAffine(p=0.3), ], p=0.2), A.OneOf([ A.CLAHE(clip_limit=2), A.IAASharpen(), A.IAAEmboss(), ], p=0.2), A.RandomBrightnessContrast(brightness_limit=0.3, contrast_limit=0.3, p=0.3), A.Solarize(p=0.2), ])
def aug_medium(prob=1): return aug.Compose([ aug.HorizontalFlip(p=.5), aug.OneOf([ aug.CLAHE(clip_limit=2, p=.5), aug.IAASharpen(p=.25), ], p=0.35), aug.RandomBrightnessContrast(p=.7), aug.OneOf([ aug.GaussNoise(p=.35), aug.ISONoise(p=.7), aug.ImageCompression(quality_lower=70, quality_upper=100, p=.7) ], p=.6), aug.RGBShift(p=.5), aug.HueSaturationValue(hue_shift_limit=8, sat_shift_limit=12, val_shift_limit=8, p=.5), aug.ToGray(p=.3) ], p=prob)
def create_datasets(train_file_list, val_file_list): train_transform = A.Compose([ A.RandomBrightnessContrast(p=0.5), A.GaussNoise(p=.25), A.ISONoise(p=.15), A.RandomShadow(p=.2), A.MotionBlur(p=.1), #A.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)), ToTensorV2(), ]) train_dataset = GroundDataset(images_filepaths=train_file_list, transform=train_transform) val_transform = A.Compose([ #A.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)), ToTensorV2(), ]) val_dataset = GroundDataset(images_filepaths=val_file_list, transform=val_transform) return train_dataset, val_dataset
def aug_heavy(prob=0.9): return aug.Compose([ aug.Flip(), aug.OneOf([ aug.CLAHE(clip_limit=2, p=.5), aug.IAASharpen(p=.25), aug.IAAEmboss(p=.25), ], p=.35), aug.OneOf([ aug.IAAAdditiveGaussianNoise(p=.3), aug.GaussNoise(p=.7), SaltPepperNoise(level_limit=0.0002, p=.7), aug.ISONoise(p=.3), ], p=.5), aug.OneOf([ aug.MotionBlur(p=.2), aug.MedianBlur(blur_limit=3, p=.3), aug.Blur(blur_limit=3, p=.5), ], p=.4), aug.OneOf([ aug.RandomContrast(p=.5), aug.RandomBrightness(p=.5), aug.RandomGamma(p=.5), ], p=.4), aug.ShiftScaleRotate( shift_limit=.0625, scale_limit=0.1, rotate_limit=12, p=.7), aug.OneOf([ aug.GridDistortion(p=.2), aug.ElasticTransform( alpha=120, sigma=120 * 0.05, alpha_affine=120 * 0.03, p=.2), aug.OpticalDistortion(distort_limit=2, shift_limit=0.5, p=.2), ], p=.6), aug.HueSaturationValue(p=.5), ], p=prob)
def albumentations_list(MAGN: int = 4): """ Returns standard list of albumentations transforms, each of mangitude `MAGN`. Args: MAGN (int): Magnitude of each transform in the returned list. """ M = MAGN transform_list = [ # PIXEL-LEVEL A.RandomContrast(limit=M * .1, always_apply=True), A.RandomBrightness(limit=M * .1, always_apply=True), A.Equalize(always_apply=True), A.OpticalDistortion(distort_limit=M * .2, shift_limit=M * .1, always_apply=True), A.RGBShift(r_shift_limit=M * 10, g_shift_limit=M * 10, b_shift_limit=M * 10, always_apply=True), A.ISONoise(color_shift=(M * .01, M * .1), intensity=(M * .02, M * .2), always_apply=True), A.RandomFog(fog_coef_lower=M * .01, fog_coef_upper=M * .1, always_apply=True), A.CoarseDropout(max_holes=M * 10, always_apply=True), A.GaussNoise(var_limit=(M, M * 50), always_apply=True), # SPATIAL A.Rotate(always_apply=True), A.Transpose(always_apply=True), A.NoOp(always_apply=True), A.ElasticTransform(alpha=M * .25, sigma=M * 3, alpha_affine=M * 3, always_apply=True), A.GridDistortion(distort_limit=M * .075, always_apply=True) ] return transform_list
def get_unlabel_aug(use_color_aug, use_shape_aug): if use_color_aug: c_aug = A.Compose([ A.RandomBrightnessContrast(p=0.8, brightness_limit=0.5, contrast_limit=0.5), A.CoarseDropout(p=0.8, max_holes=16, max_height=20, max_width=20, min_height=8, min_width=8, fill_value=0), A.OneOf([ A.Blur(p=1, blur_limit=7), A.MotionBlur(p=1, blur_limit=7), A.MedianBlur(p=1, blur_limit=7), A.GaussianBlur(p=1, blur_limit=7) ], p=0.8), A.OneOf([ A.RandomGamma(p=1, gamma_limit=(80, 120)), A.GaussNoise(p=1, var_limit=(10.0, 50.0)), A.ISONoise(p=1, color_shift=(0.1, 0.5), intensity=(0.3, 1.0)), ], p=0.8), # A.CLAHE(p=0.7, clip_limit=4.0, tile_grid_size=(8, 8)), A.JpegCompression(quality_lower=10, quality_upper=30, p=0.8), ]) else: c_aug = None # crop_size = (args.train_input_h, args.train_input_w) if use_shape_aug: shape_aug = EzImageBaseAug() else: shape_aug = None return c_aug, shape_aug
def get_image_augmentation(): """ Augmentations just for input and output images (not for masks) """ image_transform = [ albu.OneOf([ albu.Blur(p=0.2, blur_limit=(3, 5)), albu.GaussNoise(p=0.2, var_limit=(10.0, 50.0)), albu.ISONoise(p=0.2, intensity=(0.1, 0.5), color_shift=(0.01, 0.05)), albu.ImageCompression(p=0.2, quality_lower=90, quality_upper=100, compression_type=0), albu.MultiplicativeNoise(p=0.2, multiplier=(0.9, 1.1), per_channel=True, elementwise=True), ], p=1), albu.OneOf([ albu.HueSaturationValue(p=0.2, hue_shift_limit=(-10, 10), sat_shift_limit=(-10, 10), val_shift_limit=(-10, 10)), albu.RandomBrightness(p=0.3, limit=(-0.1, 0.1)), albu.RandomGamma(p=0.3, gamma_limit=(80, 100), eps=1e-07), albu.ToGray(p=0.1), albu.ToSepia(p=0.1), ], p=1) ] return albu.Compose(image_transform, additional_targets={ 'image1': 'image', 'image2': 'image' })
def __init__(self, noisy: bool = False, grayscale: bool = False, p=1): argumentors = [ RandomBrightness(p=0.25), RandomContrast(p=0.25), RandomHue(p=0.25), RandomSaturation(p=0.25), RandomAlpha(p=0.25), ] if noisy: argumentors.extend([ RandomEqualize(p=0.0625), RandomAutoContrast(p=0.0625), RandomPosterize(p=0.0625), A.Solarize(threshold=(50, 255 - 50), p=0.0625), RandomBlur(p=0.125), RandomUnsharpMask(p=0.125), GaussNoise(p=0.125), ]) if not grayscale and noisy: argumentors.extend([ A.ISONoise(color_shift=(0, 0.05), intensity=(0, 0.5), p=0.125) ]) super().__init__(argumentors, p=p)
def __init__(self, args: argparse.Namespace) -> None: super().__init__(args) self.data_folder = Path(self.args.get('data_folder', DATA_FOLDER)) self.height = self.args.get('height', IMG_HEIGHT) self.width = self.args.get('width', IMG_WIDTH) self.patch_size = self.args.get('patch_size', PATCH_SIZE) self.n_classes = self.args.get('n_classes', N_CLASSES) self.dims = (3, self.height, self.width) self.output_dims = (self.n_classes, self.height, self.width) self.metadata = parse_metadata(self.data_folder / 'metainfo.json') self.train_val_transform = A.Compose([ A.Resize(self.height, self.width), A.HorizontalFlip(p=0.5), A.ISONoise(), A.ColorJitter(), A.Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5)), ToTensorV2() ]) self.test_transform = A.Compose([ A.Resize(self.height, self.width), A.Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5)), ToTensorV2() ])
import cv2 import os import random import numpy as np from random import randint import albumentations as A import numpy as np import cv2 import sys import os from tqdm import tqdm from utils import GetOverlappingBlocks, getListOfFiles, ImageResize transform = A.Compose([ A.OneOf([ A.ISONoise(p=0.4), A.JpegCompression( quality_lower=50, quality_upper=70, always_apply=False, p=0.8), ], p=0.6), A.OneOf([ A.MotionBlur(blur_limit=10, p=.8), A.MedianBlur(blur_limit=3, p=0.75), A.GaussianBlur(blur_limit=7, p=0.75), ], p=0.8), A.OneOf([ A.RandomBrightnessContrast( brightness_limit=0.3, contrast_limit=0.3, p=0.75), A.RandomShadow(num_shadows_lower=1, num_shadows_upper=18,
def __init__(self, mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5), pad_dim=(0, 0), random_crop_dim=(0, 0), resize=(0, 0), horizontal_flip=0, vertical_flip=0, rotate_degree=0, rotation=0, cutout=0, cutout_dim=(1, 1), hsv=0, iso_noise=0, bright_contrast=0, gaussian_blur=0, train=False, modest_input=True): """Transformations to be applied on the data Arguments: mean : Tuple of mean values for each channel (default: (0.5,0.5,0.5)) std : Tuple of standard deviation values for each channel (default: (0.5,0.5,0.5)) pad_dim (tuple, optional): Pad side of the image pad_dim[0]: minimal result image height (int) pad_dim[1]: minimal result image width (int) (default: (0,0)) random_crop_dim (tuple, optional): Crop a random part of the input random_crop_dim[0]: height of the crop (int) random_crop_dim[1]: width of the crop (int) (default: (0,0)) resize (tuple, optional): Resize input resize[0]: new height of the input (int) resize[1]: new width of the input (int) (default: (0,0)) horizontal_flip (float, optional): Probability of image being flipped horizontaly (default: 0) vertical_flip (int, optional): Probability of image being flipped vertically (default: 0) rotation (int, optional): Probability of image being rotated (default: 0) cutout (int, optional): Probability of image being cutout (default: 0) cutout_dim (list, optional): Cutout a random part of the image cutout_dimtransformations.append(ToTensor())[0]: height of the cutout (int) cutout_dim[1]: width of the cutout (int) (default: (1,1)) transform_train : If True, transformations for training data else for testing data (default : False) Returns: Transformations that is to applied on the data """ transformations = [] if train: if sum(pad_dim) > 0: transformations.append( A.PadIfNeeded(min_height=pad_dim[0], min_width=pad_dim[1], p=1.0)) if sum(random_crop_dim) > 0: transformations.append( A.RandomCrop(height=random_crop_dim[0], width=random_crop_dim[1], p=1.0)) if horizontal_flip: transformations.append(A.HorizontalFlip(p=horizontal_flip)) if vertical_flip: transformations.append(A.VerticalFlip(p=vertical_flip)) if gaussian_blur: transformations.append(A.GaussianBlur(p=gaussian_blur)) if rotation: transformations.append( A.Rotate(limit=rotate_degree, p=rotation)) if cutout: transformations.append( A.CoarseDropout(max_holes=1, fill_value=tuple(x * 255 for x in mean), max_height=cutout_dim[0], max_width=cutout_dim[1], min_height=1, min_width=1, p=cutout)) if hsv: transformations.append( A.HueSaturationValue(hue_shift_limit=20, sat_shift_limit=30, val_shift_limit=20, always_apply=False, p=hsv)) if iso_noise: transformations.append( A.ISONoise(color_shift=(0.01, 0.05), intensity=(0.1, 0.5), always_apply=False, p=iso_noise)) if bright_contrast: transformations.append( A.RandomBrightnessContrast(brightness_limit=0.2, contrast_limit=0.2, brightness_by_max=True, always_apply=False, p=bright_contrast)) if modest_input: transformations.append( A.Normalize(mean=mean, std=std, always_apply=True)) if sum(resize) > 0: transformations.append( A.Resize(height=resize[0], width=resize[1], interpolation=1, always_apply=False, p=1)) transformations.append(ToTensor()) self.transform = A.Compose(transformations)