def __init__(self, csv_path, data_path): self.data = pd.read_csv(csv_path) self.groups = { x: y.tolist() for x, y in self.data.groupby('sdocid').groups.items() } self.ids = list(self.groups.keys()) self.ad_imgs_list = dict( zip( self.data.index.tolist(), self.data.cars_images.map( lambda x: ast.literal_eval(x)).tolist())) self.path = data_path self.transform = transforms.ToTensor() self.class_dict = dict( zip(self.data['sdocid'].unique().tolist(), range(0, self.data['sdocid'].nunique()))) self.aug = albu.Compose([ albu.HorizontalFlip(), albu.RandomSizedCrop( min_max_height=(200, 215), height=224, width=224, p=0.2), albu.Cutout(num_holes=4, max_h_size=20, max_w_size=20, p=0.3) ], p=1.)
def cutout_shift_transform(size: tuple, num_holes: int = 4, cut_ratio: float = 0.2, shift: float = 0.25, **kwargs): cut_h = int(size[0] * cut_ratio) cut_w = int(size[1] * cut_ratio) transform = [ A.Resize(*size, interpolation=cv2.INTER_NEAREST), A.Cutout(num_holes=num_holes, max_h_size=cut_h, max_w_size=cut_w, fill_value=0, p=kwargs.get('cutout_p', 0.5)), A.ShiftScaleRotate(shift_limit=shift, scale_limit=0, rotate_limit=0, interpolation=cv2.INTER_NEAREST, border_mode=cv2.BORDER_CONSTANT, value=0, p=1.0), ToWBM(), ] return transform
def cifar_alb11(): '''Applies image augmentations to image dataset RandomCrop 32, 32 (after padding of 4) >> FlipLR >> Followed by CutOut(8, 8) Returns: list of transforms''' mean = (0.491, 0.482, 0.446) mean = np.mean(mean) train_transforms = [ A.Normalize(mean=mean, std=std), A.PadIfNeeded(min_height=40, min_width=40, border_mode=4, always_apply=True, p=1.0), A.RandomCrop(32, 32, always_apply=True, p=1.0), A.HorizontalFlip(p=0.5), A.Cutout(num_holes=1, max_h_size=8, max_w_size=8, fill_value=mean, always_apply=False, p=1), ToTensor() ] transforms_result = A.Compose(train_transforms) return lambda img: transforms_result(image=np.array(img))["image"]
def on_epoch_start(self, trainer, pl_module): if pl_module.hparams.progressive: ind = int(trainer.current_epoch / 5) if trainer.current_epoch < 5*3 else 3 prog = [512, 1024, 1536, 2048] #batch = [32, 16, 8, 4] batch = [64, 32, 16, 8] # For Progressive Resizing train_transform = A.Compose([ A.RandomResizedCrop(height=prog[ind], width=prog[ind], scale=(0.8, 1.0), ratio=(1, 1), interpolation=1, always_apply=False, p=1.0), A.Flip(always_apply=False, p=0.5), A.RandomGridShuffle(grid=(4, 4), always_apply=False, p=1.0), A.HueSaturationValue(hue_shift_limit=10, sat_shift_limit=10, val_shift_limit=10, always_apply=False, p=0.5), A.RandomBrightnessContrast(brightness_limit=0.2, contrast_limit=0.2, brightness_by_max=True, always_apply=False, p=0.5), A.GaussNoise(var_limit=(10.0, 50.0), mean=0, always_apply=False, p=0.5), #A.Rotate(limit=90, interpolation=1, border_mode=4, value=None, mask_value=None, always_apply=False, p=0.5), A.ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.0, rotate_limit=45, interpolation=1, border_mode=4, value=255, mask_value=None, always_apply=False, p=0.5), A.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), max_pixel_value=255.0, always_apply=False, p=1.0), A.Cutout(num_holes=8, max_h_size=8, max_w_size=8, fill_value=0, always_apply=False, p=0.5), ]) valid_transform = A.Compose([A.Resize(height=prog[ind], width=prog[ind], interpolation=1, always_apply=False, p=1.0), A.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), max_pixel_value=255.0, always_apply=False, p=1.0) ]) pl_module.train_dataset = PANDADataset(pl_module.train_df, pl_module.hparams.data_dir, pl_module.hparams.image_format, transform=train_transform, tile=pl_module.hparams.tile, layer=pl_module.hparams.image_layer) pl_module.val_dataset = PANDADataset(pl_module.val_df, pl_module.hparams.data_dir, pl_module.hparams.image_format, transform=valid_transform, tile=pl_module.hparams.tile, layer=pl_module.hparams.image_layer) trainer.train_dataloader = DataLoader(pl_module.train_dataset, batch_size=batch[ind], shuffle=True, num_workers=4, drop_last=True) trainer.val_dataloaders = [DataLoader(pl_module.val_dataset, batch_size=batch[ind], shuffle=True, num_workers=4, drop_last=True)] trainer.num_training_batches = len(trainer.train_dataloader)#float('inf') trainer.num_val_batches = len(trainer.val_dataloaders[0])#float('inf') trainer.val_check_batch = trainer.num_training_batches
def __init__(self,Normalize_mean_std=None, H_F=None, Padding = None, R_Crop = None, Rotate=None, cutout=None): print("in the init of Albumentation" ) self.transforms=[] if H_F is not None: self.transforms.append(A.HorizontalFlip(p=0.7)) if Padding is not None: self.transforms.append(A.PadIfNeeded(min_height=70, min_width=70, border_mode=4, value=None, mask_value=None, always_apply=False, p=1.0)) if R_Crop is not None: self.transforms.append(A.RandomCrop(64,64, always_apply = False, p = 1.0)) if Rotate is not None: self.transforms.append(A.Rotate(limit=30, interpolation=1, border_mode=4, value=None, mask_value=None, always_apply=False, p=0.5)) if cutout is not None: self.transforms.append(A.Cutout(num_holes=1, max_h_size=32,max_w_size = 32,p=0.7)) if Normalize_mean_std is not None: self.transforms.append(A.Normalize(Normalize_mean_std[0],Normalize_mean_std[1], always_apply=True)) self.transforms.append(ToTensor()) print("The transformations done are:{}".format(self.transforms)) self.Transforms=A.Compose(self.transforms)
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 get_augmentations(p=0.5, image_size=224): imagenet_stats = { "mean": [0.485, 0.456, 0.406], "std": [0.229, 0.224, 0.225] } train_tfms = A.Compose([ # A.Resize(image_size, image_size), A.RandomResizedCrop(image_size, image_size), A.ShiftScaleRotate(shift_limit=0.15, scale_limit=0.4, rotate_limit=45, p=p), A.Cutout(p=p), A.RandomRotate90(p=p), A.Flip(p=p), A.OneOf( [ A.RandomBrightnessContrast( brightness_limit=0.2, contrast_limit=0.2, ), A.HueSaturationValue(hue_shift_limit=20, sat_shift_limit=50, val_shift_limit=50), ], p=p, ), A.OneOf( [ A.IAAAdditiveGaussianNoise(), A.GaussNoise(), ], p=p, ), A.CoarseDropout(max_holes=10, p=p), A.OneOf( [ A.MotionBlur(p=0.2), A.MedianBlur(blur_limit=3, p=0.1), A.Blur(blur_limit=3, p=0.1), ], p=p, ), A.OneOf( [ A.OpticalDistortion(p=0.3), A.GridDistortion(p=0.1), A.IAAPiecewiseAffine(p=0.3), ], p=p, ), ToTensor(normalize=imagenet_stats), ]) valid_tfms = A.Compose([ A.CenterCrop(image_size, image_size), ToTensor(normalize=imagenet_stats) ]) return train_tfms, valid_tfms
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 __init__(self, batch_size, num_classes, data_dir, img_size=(256, 256)): super().__init__() self.data_dir = data_dir self.batch_size = batch_size self.train_transform = A.Compose( [ A.RandomResizedCrop(img_size, img_size, p=1.0), A.Transpose(p=0.5), A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5), A.ShiftScaleRotate(p=0.5), A.HueSaturationValue(hue_shift_limit=0.2, sat_shift_limit=0.2, val_shift_limit=0.2, p=0.5), A.RandomBrightnessContrast(brightness_limit=(-0.1, 0.1), contrast_limit=(-0.1, 0.1), p=0.5), A.Normalize( mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], max_pixel_value=255.0, p=1.0, ), A.CoarseDropout(p=0.5), A.Cutout(p=0.5), ToTensorV2(p=1.0), ], p=1.0, )
def get_transforms(phase, crop_type=0, size=512): list_transforms = [] if phase == "train": list_transforms.extend([ aug.Flip(), aug.Cutout(num_holes=4, p=0.5), aug.OneOf([ aug.RandomContrast(), aug.RandomGamma(), aug.RandomBrightness(), ], p=1), aug.ShiftScaleRotate(rotate_limit=90), aug.OneOf([ aug.GaussNoise(p=.35), ], p=.5), ]) if crop_type == 0: list_transforms.extend([ CropNonEmptyMaskIfExists(size, size), ]) elif crop_type == 1: list_transforms.extend([ RandomCrop(size, size, p=1.0), ]) list_transforms.extend([ Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], p=1), ToTensor(), ]) list_trfms = Compose(list_transforms) return list_trfms
def get_transforms(image_size): transforms_train = albumentations.Compose([ albumentations.HorizontalFlip(p=0.5), albumentations.ImageCompression(quality_lower=99, quality_upper=100), albumentations.ShiftScaleRotate(shift_limit=0.2, scale_limit=0.2, rotate_limit=10, border_mode=0, p=0.7), albumentations.Resize(image_size, image_size), albumentations.Cutout( max_h_size=int(image_size * 0.4), max_w_size=int(image_size * 0.4), num_holes=1, p=0.5, ), albumentations.Normalize(), ]) transforms_val = albumentations.Compose([ albumentations.Resize(image_size, image_size), albumentations.Normalize() ]) return transforms_train, transforms_val
def get_transforms(img_size=256, trans_type='train'): if trans_type == 'train': return A.Compose([ A.HorizontalFlip(p=0.5), A.ShiftScaleRotate(shift_limit=0.2, scale_limit=0.2, rotate_limit=10, border_mode=0, p=0.7), A.Resize(img_size, img_size), A.Cutout(max_h_size=int(img_size * 0.4), max_w_size=int(img_size * 0.4), num_holes=1, p=0.5), A.Normalize(), ToTensorV2(p=1.0), ]) # A.Compose([ # A.Resize(height=img_size, width=img_size, p=1), # A.RandomSizedCrop(min_max_height=(int(img_size * 0.8), int(img_size * 0.8)), height=img_size, width=img_size, p=0.5), # A.RandomRotate90(p=0.5), # A.ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.1, rotate_limit=15), # A.HorizontalFlip(p=0.5), # A.VerticalFlip(p=0.5), # A.Cutout(num_holes=8, max_h_size=64, max_w_size=64, fill_value=0, p=0.5), # A.Normalize(), # ToTensorV2(p=1.0), #], p=1.0) return A.Compose( [A.Resize(img_size, img_size), A.Normalize(), ToTensorV2(p=1.0)])
def get_album_transforms(norm_mean, norm_std): """get the train and test transform by albumentations""" album_train_transform = A.Compose([ A.PadIfNeeded( min_height=36, min_width=36, border_mode=cv2.BORDER_REFLECT, always_apply=True, ), A.RandomCrop(height=32, width=32, always_apply=True), A.HorizontalFlip(p=0.5), A.Cutout(1, 8, 8, .5, p=0.4), A.Normalize( mean=norm_mean, std=norm_std, ), AP.transforms.ToTensor() ]) album_test_transform = A.Compose([ A.Normalize( mean=norm_mean, std=norm_std, ), AP.transforms.ToTensor() ]) return (album_train_transform, album_test_transform)
def get_train_transforms(): return A.Compose( [ A.RandomSizedCrop( min_max_height=(650, 1024), height=1024, width=1024, p=0.5), #A.OneOf([ A.HueSaturationValue( hue_shift_limit=0.014, #=0.2, sat_shift_limit=0.68, #0.2, val_shift_limit=0.36, #0.2, p=0.75), A.RandomBrightnessContrast( brightness_limit=0.1, contrast_limit=0.1, p=0.3), #],p=0.9), #A.ToGray(p=0.01), A.ShiftScaleRotate(scale_limit=(-0.5, 0.5), rotate_limit=0, shift_limit=0., p=0.5, border_mode=0), #A.RandomRotate90(p=0.5), A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5), A.Resize(height=1024, width=1024, p=1), A.Cutout( num_holes=8, max_h_size=64, max_w_size=64, fill_value=0, p=0.5), ToTensorV2(p=1.0), ], p=1.0, bbox_params=A.BboxParams(format='pascal_voc', min_area=0, min_visibility=0, label_fields=['labels']))
def get_train_transforms(): return A.Compose([ A.HueSaturationValue(hue_shift_limit=0.4, sat_shift_limit=0.4, val_shift_limit=0.4, p=0.5), A.OneOf([ A.RandomGamma(p=0.5), A.RandomBrightnessContrast( brightness_limit=0.4, contrast_limit=0.85, p=0.5) ], p=0.5), A.Blur(p=0.5), A.ToGray(p=0.1), A.RandomRotate90(p=0.5), A.Resize(height=1024, width=1024, p=1), A.Cutout( num_holes=10, max_h_size=64, max_w_size=64, fill_value=0, p=0.5), ToTensorV2(p=1.0), ], p=1.0, bbox_params=A.BboxParams(format='pascal_voc', min_area=0, min_visibility=0, label_fields=['labels']))
def get_augmentations_transform(crop_size=128, p=0.5, phase="train"): imagenet_stats = {'mean':[0.485, 0.456, 0.406], 'std':[0.229, 0.224, 0.225]} if phase == "train" or "test": aug_factor_list = [ A.RandomResizedCrop(height=crop_size, width=crop_size, scale=(0.8, 1.0)), A.Cutout(num_holes=8, p=p), A.RandomRotate90(p=p), A.HorizontalFlip(p=p), A.VerticalFlip(p=p), A.HueSaturationValue(hue_shift_limit=20, sat_shift_limit=50, val_shift_limit=50), A.RandomBrightnessContrast(brightness_limit=0.2, contrast_limit=0.2), A.ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=p), A.OneOf([ A.IAAAdditiveGaussianNoise(), A.GaussNoise(), ], p=p), A.OneOf([ A.MotionBlur(p=0.2), A.MedianBlur(blur_limit=3, p=0.1), A.Blur(blur_limit=3, p=0.1), ], p=p), A.OneOf([ A.OpticalDistortion(p=0.3), A.GridDistortion(p=0.1), A.IAAPiecewiseAffine(p=0.3), ], p=p), ToTensor(normalize=imagenet_stats) ] transformed_image = A.Compose(aug_factor_list) return transformed_image elif phase == "valid": transformed_image = A.Compose([ToTensor(normalize=imagenet_stats)]) return transformed_image else: TypeError("Invalid phase type.")
def get_train_transforms(): return A.Compose([ A.JpegCompression(p=0.5), A.Rotate(limit=80, p=1.0), A.OneOf([ A.OpticalDistortion(), A.GridDistortion(), A.IAAPiecewiseAffine(), ]), A.RandomSizedCrop(min_max_height=(int(resolution * 0.7), input_res), height=resolution, width=resolution, p=1.0), A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5), A.GaussianBlur(p=0.3), A.OneOf([ A.RandomBrightnessContrast(), A.HueSaturationValue(), ]), A.Cutout(num_holes=8, max_h_size=resolution // 8, max_w_size=resolution // 8, fill_value=0, p=0.3), A.Normalize(), ToTensorV2(), ], p=1.0)
def get_data_transform(path): mean, stdev = find_stats(path) input_size = 32 train_albumentation_transform = A.Compose([ A.Cutout(num_holes=2, max_h_size=8, max_w_size=8, fill_value=[i * 255 for i in mean], always_apply=True, p=0.5), #A.RandomCrop(height=8,width=8,p=0.020,always_apply=False), A.HorizontalFlip(p=0.7, always_apply=True), #A.CoarseDropout(max_holes=1,max_height=16,max_width=16,min_holes=None,min_height=4,min_width=4,fill_value=[i*255 for i in mean],always_apply=True,p=0.7,), A.Normalize(mean=tuple(mean), std=tuple(stdev), max_pixel_value=255, always_apply=True, p=1.0), A.Resize(input_size, input_size), A.RGBShift(r_shift_limit=50, g_shift_limit=50, b_shift_limit=50, p=0.5), ToTensor() ]) # Test Phase transformation test_transforms = transforms.Compose([ transforms.ToTensor(), transforms.Normalize(tuple(mean), tuple(stdev)) ]) train_transforms = AlbumCompose(train_albumentation_transform) # test_transforms = AlbumCompose(test_transforms) return train_transforms, test_transforms
def cifar10_albumentations(mean, std): train_transforms = A.Compose([ # A.OneOf([ # A.GridDistortion(distort_limit=(-0.3, 0.3), p=0.5), # A.Rotate(limit=(-10, 10), p=0.5) # ]), A.GridDistortion(distort_limit=(-0.3, 0.3), p=0.5), A.Rotate(limit=(-10, 10), p=0.5), A.HorizontalFlip(p=0.25), A.Cutout(num_holes=1, max_h_size=12, max_w_size=12), A.Normalize( mean=mean, std=std ), # Here, the order of normalization and ToTensor() methods matters. Same goes for test_transforms APT.ToTensor() # APT.ToTensorV2() ]) test_transforms = A.Compose([ A.Normalize(mean=mean, std=std), APT.ToTensor() # APT.ToTensorV2() ]) return Albumentation_Transforms( train_transforms), Albumentation_Transforms(test_transforms)
def get_training_augmentation(): return A.Compose([ A.RandomSizedCrop(min_max_height=(300, 360), height=320, width=320, always_apply=True), A.HorizontalFlip(p=0.5), A.OneOf([ A.CLAHE(), A.RandomBrightnessContrast(), A.RandomGamma(), A.HueSaturationValue(), A.NoOp() ]), A.OneOf([ A.IAASharpen(), A.Blur(blur_limit=3), A.MotionBlur(blur_limit=3), A.NoOp() ]), A.OneOf([ A.RandomFog(), A.RandomSunFlare(src_radius=100), A.RandomRain(), A.RandomSnow(), A.NoOp() ]), A.Cutout(), A.Normalize(), ])
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 create_train_transforms(args, size=224): if args.model == 'vit_small_patch16_224': return Compose([albumentations.Resize(224, 224)]) else: translist = [] if args.gaussnoise: #translist += [albumentations.GaussNoise(var_limit=(5.0, 30.0), p=0.4)] translist += [ 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=args.noise_p) ] if args.clahe: translist += [albumentations.CLAHE(clip_limit=4.0, p=0.1)] if args.cutout: translist += [ albumentations.Cutout(max_h_size=int(270 * 0.375), max_w_size=int(480 * 0.375), num_holes=1, p=0.8) ] transform = Compose(translist) return transform
def __init__(self): self.extra_transform = A.Compose([ A.HorizontalFlip(p=0.5), A.RandomRotate90(p=1), A.Cutout(num_holes=8, max_h_size=20, max_w_size=20), ], p=1)
def get_pseudo_transforms(): return A.Compose([ A.RandomSizedCrop( min_max_height=(800, 1024), height=1024, width=1024, p=0.5), 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.9), A.ToGray(p=0.01), A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5), A.RandomRotate90(p=0.5), A.Transpose(p=0.5), A.JpegCompression(quality_lower=85, quality_upper=95, p=0.2), A.OneOf( [A.Blur(blur_limit=3, p=1.0), A.MedianBlur(blur_limit=3, p=1.0)], p=0.1), A.Resize(height=SIZE, width=SIZE, p=1), A.Cutout( num_holes=8, max_h_size=64, max_w_size=64, fill_value=0, p=0.5), ToTensorV2(p=1.0), ], p=1.0, bbox_params=A.BboxParams(format='pascal_voc', min_area=0, min_visibility=0, label_fields=['labels']))
def albumentations_transforms_old(p=1.0, is_train=False): # Mean and standard deviation of train dataset mean = np.array([0.4914, 0.4822, 0.4465]) std = np.array([0.2023, 0.1994, 0.2010]) #transforms_list = [] # Use data aug only for train data if is_train: train_transforms = [ A.Normalize(mean=mean, std=std), A.PadIfNeeded(min_height=40, min_width=40, border_mode=4, always_apply=True, p=1.0), A.RandomCrop(32, 32, always_apply=True, p=1.0), A.HorizontalFlip(p=0.5), A.Cutout(num_holes=1, max_h_size=8, max_w_size=8, always_apply=False, p=1), ToTensorV2() ] data_transforms = Compose(train_transforms, p=p) return lambda img: data_transforms(image=np.array(img))["image"]
def __init__(self, image_list, is_test=False): self.image_list = image_list self.is_test = is_test mean = np.array([0.4914, 0.4822, 0.4465]) SD = np.array([0.2023, 0.1994, 0.2010]) self.aug_train = A.Compose([ A.PadIfNeeded(min_height=40, min_width=40, border_mode=BORDER_CONSTANT, value=mean * 255.0, p=1.0), A.RandomCrop(height=32, width=32, p=1.0), A.HorizontalFlip(p=0.5), #A.Rotate(limit=(-90, 90)), #A.VerticalFlip(p=0.5), A.Cutout(num_holes=1, max_h_size=8, max_w_size=8, fill_value=mean * 255, p=0.5), #A.Blur(blur_limit=16), A.Normalize(mean=mean, std=SD, max_pixel_value=255, p=1.0), ToTensor() ]) self.aug_test = A.Compose([ToTensor()])
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 get_train_transform(): return A.Compose([ A.RandomSizedCrop( min_max_height=(800, 800), height=1024, width=1024, p=0.5), 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.9), A.ToGray(p=0.01), A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5), A.Resize(height=our_image_size, width=our_image_size, p=1), A.Cutout(num_holes=8, max_h_size=our_image_size // 8, max_w_size=our_image_size // 8, fill_value=0, p=0.5) ], bbox_params={ 'format': 'pascal_voc', 'label_fields': ['labels'] })
def get_train_transforms(): return A.Compose([ A.RandomSizedCrop( min_max_height=(800, 800), height=1024, width=1024, p=0.5), 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.9), A.ToGray(p=0.01), A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5), A.Resize(height=512, width=512, p=1), A.Cutout( num_holes=8, max_h_size=64, max_w_size=64, fill_value=0, p=0.5), ToTensorV2(p=1.0), ], p=1.0, bbox_params=A.BboxParams(format='pascal_voc', min_area=0, min_visibility=0, label_fields=['labels']))
def get_album_transforms(norm_mean, norm_std): ''' get the train and test transform by albumentations ''' train_transform = A.Compose([ A.PadIfNeeded(min_height=36, min_width=36, border_mode=4, value=[0, 0, 0], always_apply=True), A.RandomResizedCrop(height=32, width=32, always_apply=True), A.Flip(0.5), A.Cutout(num_holes=1, max_h_size=8, max_w_size=8, fill_value=0, always_apply=False, p=0.5), A.Normalize(mean=norm_mean, std=norm_std), ToTensorV2() ]) test_transform = A.Compose( [A.Normalize(mean=norm_mean, std=norm_std), ToTensorV2()]) return train_transform, test_transform