def get_transform(train, augmentation_ver=None, imageclassidentifier=None): if augmentation_ver is None or augmentation_ver == 0: data_transforms = albumentations.Compose([ albumentations.Flip(), #albumentations.RandomBrightness(0.2), albumentations.ShiftScaleRotate(rotate_limit=90, scale_limit=0.10), #ToTensorV2() ], bbox_params=albumentations.BboxParams(format='pascal_voc', label_fields=['class_labels'])) # min_visibility=0.2 elif augmentation_ver == 1: if imageclassidentifier is None: imageclassidentifier = preprocess.ImageClassIdentifier() def ifpred(**kwargs): img = kwargs['image'] predicted_class = imageclassidentifier.detect(np.array(img)) if predicted_class == 2: return True return False data_transforms = albumentations.Compose([ IfThenElse(ifpred, albumentations.Compose([ albumentations.RandomSizedCrop((256, 1024), 1024, 1024) #albumentations.RandomSizedBBoxSafeCrop(height=1024, width=1024) ]), albumentations.Compose([ # do nothing ])), albumentations.Flip(), albumentations.VerticalFlip(), albumentations.RandomRotate90(p=0.5), albumentations.ShiftScaleRotate(rotate_limit=15, scale_limit=0.10), #ToTensorV2() ], bbox_params=albumentations.BboxParams(format='pascal_voc', label_fields=['class_labels'])) # min_visibility=0.2 return data_transforms
def create_tsfm(args, mean, std, normalize=True, tsfms=None): """ Create transform based on configuration :param args: the argument parameters defined in config.py :param mean: mean of the dataset :param std: std of the dataset :param normalize: if True, will normalize the dataset :param tsfms: transforms used to augment the data, if None, will use the default ones :return: corresponding train and validation transforms """ input_size = eval(args['dataset']['input_size']) crop_size = eval(args['dataset']['crop_size']) if tsfms is None: if normalize: tsfms = [ A.Flip(), A.RandomRotate90(), A.Normalize(mean=mean, std=std), ToTensorV2() ] else: tsfms = [A.Flip(), A.RandomRotate90(), ToTensorV2()] if input_size[0] > crop_size[0] and input_size[1] > crop_size[1]: tsfm_train = A.Compose([A.RandomCrop(*crop_size)] + tsfms) tsfm_valid = A.Compose([A.RandomCrop(*crop_size)] + tsfms[2:]) elif input_size[0] < crop_size[0] or input_size[1] < crop_size[1]: tsfm_train = A.Compose([A.RandomResizedCrop(*crop_size)] + tsfms) tsfm_valid = A.Compose([A.RandomResizedCrop(*crop_size)] + tsfms[2:]) else: tsfm_train = A.Compose(tsfms) tsfm_valid = A.Compose(tsfms[-2:]) return tsfm_train, tsfm_valid
def get_aug(aug_type="val", size=512): """Return augmentations by type Args: aug_type (str): one of `val`, `test`, `light`, `medium` size (int): final size of the crop """ NORM_TO_TENSOR = albu.Compose( [albu.Normalize(mean=MEAN, std=STD), albu_pt.ToTensorV2()]) # CROP_AUG = albu.Compose([albu.RandomCrop(size, size)]) VAL_AUG = albu.Compose([ # albu.CenterCrop(size, size), NORM_TO_TENSOR ]) LIGHT_AUG = albu.Compose( [ albu.Flip(), albu.Cutout(num_holes=12, max_h_size=size // 16, max_w_size=size // 16, fill_value=0, p=0.5), NORM_TO_TENSOR ], p=1.0, ) # aug from github.com/lyakaap/Landmark2019-1st-and-3rd-Place-Solution/ HARD_AUG = albu.Compose( [ albu.Flip(p=0.5), albu.IAAAffine(rotate=0.2, shear=0.2, mode='constant', p=0.5), albu.RandomBrightnessContrast( brightness_limit=0.3, contrast_limit=0.3, p=0.5), albu.MotionBlur(p=0.5), albu.CLAHE(p=0.5), albu.Cutout(num_holes=16, max_h_size=size // 16, max_w_size=size // 16, fill_value=0, p=0.5), RandomCropThenScaleToOriginalSize(limit=0.3, p=1.0), NORM_TO_TENSOR, ], p=1.0, ) types = { "val": VAL_AUG, "test": VAL_AUG, "light": LIGHT_AUG, "hard": HARD_AUG, } return types[aug_type]
def get_tta_transform(tta_idx): if tta_idx == 0: # original tta_test_transform = A.Compose([ ColorConstancy(p=1), A.Normalize(), ToTensor(), ]) elif tta_idx == 1: # horizontal flip tta_test_transform = A.Compose([ ColorConstancy(p=1), A.HorizontalFlip(p=1), A.Normalize(), ToTensor(), ]) elif tta_idx == 2: # vertical flip tta_test_transform = A.Compose([ ColorConstancy(p=1), A.VerticalFlip(p=1), A.Normalize(), ToTensor(), ]) elif tta_idx == 3: # random rotate 90 degree tta_test_transform = A.Compose([ ColorConstancy(p=1), A.RandomRotate90(p=1), A.Normalize(), ToTensor(), ]) elif tta_idx == 4: # flip and transpose tta_test_transform = A.Compose([ ColorConstancy(p=1), A.Flip(p=0.5), A.Transpose(p=1), A.Normalize(), ToTensor(), ]) else: # train transform tta_test_transform = A.Compose([ ColorConstancy(p=1), A.OneOf([ A.Flip(p=0.5), A.IAAFliplr(p=0.5), A.Transpose(p=0.5), A.IAAFlipud(p=0.5), ], p=0.5), A.OneOf([ A.Rotate(limit=365, p=0.75), A.ShiftScaleRotate(p=0.75), ], p=0.75), A.Blur(blur_limit=3, p=0.5), A.Normalize(), ToTensor(), ]) return tta_test_transform
def __call__(self, img): self.img = img min_val = torch.min(torch.flatten(self.img)) if self.img.shape[0] == 1: # 2D images self.img = torch.squeeze(self.img) pipeline = A.Compose([ A.Flip(p=0.5), A.Rotate(self.params["rot"], interpolation=1, border_mode=0, value=min_val.item(), p=0.5), A.RandomBrightnessContrast( brightness_limit=self.params["bright"], contrast_limit=self.params["contrast"], p=0.5) ], p=0.5) data = {"image": np.float32(self.img)} out = pipeline(**data) out = np.expand_dims(out["image"], 0) elif self.img.shape[0] > 1: # 2.5D images pipeline = A.Compose([ A.Flip(p=0.5), A.RandomBrightnessContrast( brightness_limit=self.params["bright"], contrast_limit=self.params["contrast"], p=0.5) ], p=0.75) data = {"image": np.float32(self.img)} out = pipeline(**data) out = out["image"] # Elastic deformations with library elasticdeform if random.uniform(0, 1) < 0.5: elasticdeform.deform_random_grid( out, self.params["sigma"], self.params["points"], order=self.params["resample_order"]) return torch.from_numpy(out).float()
def get_aug(mode="train"): if mode=="Nor": aug=A.Compose([ ToTensor(), ]) elif mode =="train": print("train aug") mean = (0.485,0.456,0.406) std = (0.229,0.224,0.225) aug=A.Compose([ A.Flip(), A.ShiftScaleRotate(rotate_limit=1.0, p=0.8), # Pixels A.OneOf([ A.IAAEmboss(p=1.0), A.IAASharpen(p=1.0), A.Blur(p=1.0), ], p=0.5), # Affine A.OneOf([ A.ElasticTransform(p=1.0), A.IAAPiecewiseAffine(p=1.0) ], p=0.5), A.Normalize(mean=mean,std=std,max_pixel_value=255.0,always_apply=True), ]) else: print("valid/test aug") mean = (0.485,0.456,0.406) std = (0.229,0.224,0.225) aug=A.Compose([ A.Normalize(mean=mean,std=std,max_pixel_value=255.0,always_apply=True), ]) return aug
def prepare_data(self): train_df = pd.read_csv(os.path.join(self.hparams.data_dir, 'train.csv')) train_df, val_df = train_test_split(train_df, stratify=train_df['isup_grade']) transform = A.Compose([ A.Resize(height=self.hparams.image_size, width=self.hparams.image_size, interpolation=1, always_apply=False, p=1.0), A.Flip(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) ]) self.train_dataset = PANDADataset(train_df, self.hparams.data_dir, self.hparams.image_format, transform=transform) self.val_dataset = PANDADataset(val_df, self.hparams.data_dir, self.hparams.image_format, transform=transform)
def __init__(self, outputs=6): super().__init__() self.net = models.resnet34(True) self.linear = Sequential(ReLU(), Dropout(), Linear(1000, outputs)) df = pd.read_csv( "/home/dipet/kaggle/prostate/input/prostate-cancer-grade-assessment/train.csv" ) self.train_df, self.valid_df = train_test_split(df, test_size=0.2) self.data_dir = "/datasets/panda/train_128_100" self.train_transforms = A.Compose([ A.InvertImg(p=1), A.RandomGridShuffle(grid=(10, 10)), A.RandomScale(0.1), A.PadIfNeeded(1280, 1280), A.RandomSizedCrop([1000, 1280], 1280, 1280), A.Flip(), A.Rotate(90), A.RandomBrightnessContrast(0.02, 0.02), A.HueSaturationValue(0, 10, 10), A.Normalize(mean, std, 1), ]) self.valid_transforms = A.Compose([ A.InvertImg(p=1), A.Normalize(mean, std, 1), ])
def __init__(self, metadata: DataFrame, params: dict, transform, data_filter, frame_num=8): self.metadata_df = metadata self.real_filename = list(data_filter(metadata).index) self.transform = transform self.frame_num = frame_num self.same_transform = params['same_transform'] self.smooth = params['label_smoothing'] self.trans = aug.OneOf([ aug.Downscale(0.5, 0.5, p=0.666), aug.JpegCompression(quality_lower=20, quality_upper=20, p=0.666), aug.Flip(p=0) ]) self.video_path = pathlib.Path(params['data_path']) self.cached_path = pathlib.Path(params['cache_path']) self.cached_path.mkdir(exist_ok=True) self.data_dropout = params['data_dropout'] self.input_mix = params['input_mix'] np.random.shuffle(self.real_filename) self.real_filename = self.real_filename[:int( len(self.real_filename) * (1 - self.data_dropout))] self.real2fakes = {fn: [] for fn in self.real_filename} filename_set = set(self.real_filename) for fn, row in metadata.iterrows(): if row['label'] == 'FAKE' and row['original'] in filename_set: self.real2fakes[row['original']].append(fn)
def __init__(self, outputs=6): super().__init__() self.net = models.resnet34(True) self.linear = Linear(1000, outputs) df = pd.read_csv("/home/dipet/kaggle/prostate/input/prostate-cancer-grade-assessment/train.csv") self.train_df, self.valid_df = train_test_split(df, test_size=0.2) self.data_dir = "/datasets/panda/train_64_100" self.train_transforms = A.Compose( [ A.Compose( [ A.OneOf([A.GaussNoise(), A.MultiplicativeNoise(elementwise=True)]), A.RandomBrightnessContrast(0.02, 0.02), A.HueSaturationValue(0, 10, 10), A.Flip(), A.RandomGridShuffle(grid=(10, 10)), A.GridDistortion(), A.Rotate() ], p=0.5, ), A.ToFloat(), ] ) self.valid_transforms = A.Compose([A.ToFloat()])
def det_train_augs(height: int, width: int) -> albu.Compose: return albu.Compose([ albu.Resize(height=height, width=width), albu.ShiftScaleRotate(shift_limit=0.025, scale_limit=0.1, rotate_limit=10), albu.Flip(), albu.RandomRotate90(), albu.OneOf( [ albu.HueSaturationValue(p=1.0), albu.IAAAdditiveGaussianNoise(p=1.0), albu.IAASharpen(p=1.0), albu.RandomBrightnessContrast( brightness_limit=0.1, contrast_limit=0.1, p=1.0), albu.RandomGamma(p=1.0), ], p=1.0, ), albu.OneOf( [ albu.Blur(blur_limit=3, p=1.0), albu.MotionBlur(blur_limit=3, p=1.0) ], p=1.0, ), albu.Normalize(), ])
def preprocess_image(cls, images_path, image_file): preprocessed_dir = os.path.join('../../images/dogscats500/preprocessed', cls) image_filepath = os.path.join(images_path, image_file) print(" ", image_filepath) image = cv.imread(image_filepath) if not os.path.exists(preprocessed_dir): os.makedirs(preprocessed_dir) aug = A.Compose( transforms=[ A.RandomRotate90(), A.Flip()], p=0.5) image_file_name, image_file_ext = os.path.splitext(image_file)[:2] print(image_file_name, image_file_ext) preprocessed_name = image_file_name + '.aug' + image_file_ext preprocessed_image_file = os.path.join(preprocessed_dir, preprocessed_name) print(preprocessed_name) print(preprocessed_image_file) preprocessed_image = aug(image=image)['image'] cv.imwrite(preprocessed_image_file, preprocessed_image)
def get_train_transforms(): # noinspection PyTypeChecker return A.Compose([ A.RandomSizedCrop( min_max_height=(850, 850), height=1024, width=1024, p=0.3), A.OneOf([ A.HueSaturationValue(hue_shift_limit=0.2, sat_shift_limit=0.2, val_shift_limit=0.2, p=0.8), A.RandomBrightnessContrast( brightness_limit=0.2, contrast_limit=0.2, p=0.9) ], p=0.5), A.OneOf([ A.RandomRain(rain_type='drizzle', p=0.2), A.GaussianBlur(blur_limit=7, p=0.5), A.GaussNoise((0.2, 0.25), p=0.3), A.RandomShadow(p=0.2) ], p=0.4), A.ToGray(p=0.01), A.Flip(p=0.5), A.CoarseDropout(max_height=64, max_width=64, min_holes=3, min_height=32, min_width=32, p=0.5), A.Resize(Config.Train.img_size, Config.Train.img_size, p=1.0), ToTensorV2(p=1.0), ], bbox_params=BboxParams('pascal_voc', label_fields=['labels'], min_visibility=0.0))
def affine_transform( self): # Affine Transforms: Scale & Translation & Rotation return A.Compose( [ # Transpose the input by swapping rows and columns. A.Transpose(p=self.p), A.OneOf( [ # Randomly rotate the input by 90 degrees zero or more times. A.RandomRotate90(p=self.p), # Rotate the input by an angle selected randomly from the uniform distribution. A.Rotate(limit=90, p=self.p), # Randomly apply affine transforms: translate, scale and rotate the input. A.ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.1, rotate_limit=45, p=self.p) ], p=1), A.OneOf( [ A.HorizontalFlip( p=self.p ), # Flip the input vertically around the x-axis. A.VerticalFlip( p=self.p ), # Flip the input horizontally around the y-axis. A.Flip( p=self.p ) # Flip the input either horizontally, vertically or both horizontally and vertically. ], p=1) ], p=1)
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 __init__(self, metadata: DataFrame, bbox: DataFrame, params: dict, transform, data_filter, diff): self.metadata_df = metadata self.real_filename = list(data_filter(metadata).index) self.bbox_df = bbox self.bbox_index_fn = set(bbox.index.get_level_values(0)) self.transform = transform self.same_transform = params['same_transform'] self.diff = diff self.video_path = pathlib.Path(params['data_path']) self.cached_path = pathlib.Path(params['cache_path']) self.cached_path.mkdir(exist_ok=True) self.real2fakes = {fn: [] for fn in self.real_filename} filename_set = set(self.real_filename) for fn, row in metadata.iterrows(): if row['label'] == 'FAKE' and row['original'] in filename_set: self.real2fakes[row['original']].append(fn) import albumentations as aug self.trans = aug.OneOf([ aug.Downscale(0.5, 0.5, p=0.66), aug.JpegCompression(quality_lower=20, quality_upper=20, p=0.66), aug.Flip(p=0) ])
def on_epoch_start(self, trainer, pl_module): if pl_module.hparams.progressive: ind = int(trainer.current_epoch / 3) if trainer.current_epoch < 3*7 else 7 prog = [256, 512, 768, 1024, 1280, 1536, 1792, 2048] batch = [32, 32, 32, 16, 8, 8, 4, 4] # For Progressive Resizing train_transform = A.Compose([ A.RandomResizedCrop(height=prog[ind], width=prog[ind], scale=(0.8, 1.0), ratio=(0.75, 1.3333333333333333), interpolation=1, always_apply=False, p=1.0), A.Flip(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.1, rotate_limit=45, interpolation=1, border_mode=4, value=None, 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) ]) 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, outputs=5): super().__init__() self.net = EfficientNet.from_pretrained('efficientnet-b0') self.linear = Sequential(ReLU(), Dropout(), Linear(1000, outputs)) df = pd.read_csv("../input/prostate-cancer-grade-assessment/train.csv") self.train_df, self.valid_df = train_test_split(df, test_size=0.2) self.data_dir = "../input/prostate-cancer-grade-assessment/train_images" self.train_transforms = A.Compose( [ A.InvertImg(p=1), A.RandomSizedCrop([int(IMAGE_SIZE * 0.9), IMAGE_SIZE], IMAGE_SIZE, IMAGE_SIZE), A.Transpose(), A.Flip(), A.Rotate(90, border_mode=cv.BORDER_CONSTANT, value=(0, 0, 0)), A.RandomBrightnessContrast(0.02, 0.02), A.HueSaturationValue(0, 10, 10), A.Normalize(mean, std, 1), ] ) self.valid_transforms = A.Compose([A.InvertImg(p=1), A.Normalize(mean, std, 1),]) self.criterion = BCEWithLogitsLoss() if False and BATCH_SIZE == 1: for m in self.modules(): if isinstance(m, nn.BatchNorm2d): m.weight.requires_grad = False m.bias.requires_grad = False
def get_train_augm(size=Tuple[int, int], p=0.5): return albu.Compose([ albu.Flip(p=p), albu.ToFloat(255), ToTensorV2() # albu.Lambda(image=to_tensor) ])
def __init__(self, outputs=5): super().__init__() self.net = EfficientNet.from_pretrained('efficientnet-b0') self.linear = Sequential(ReLU(), Dropout(), Linear(1000, outputs)) df = pd.read_csv("../input/prostate-cancer-grade-assessment/train.csv") self.train_df, self.valid_df = train_test_split(df, test_size=0.2) self.data_dir = "/datasets/panda/train_128_100" self.train_transforms = A.Compose([ A.InvertImg(p=1), A.RandomSizedCrop([100, 128], 128, 128), A.Transpose(), A.Flip(), A.Rotate(90), # A.RandomBrightnessContrast(0.02, 0.02), # A.HueSaturationValue(0, 10, 10), A.Normalize(mean, std, 1), ]) self.valid_transforms = A.Compose([ A.InvertImg(p=1), A.Normalize(mean, std, 1), ]) self.criterion = BCEWithLogitsLoss()
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 strong_aug(p=1): return A.Compose([ A.RandomRotate90(p=0.5), A.Flip(p=0.5), A.CLAHE(p=0.5), ], p=p)
def classification_augmentations(height: int, width: int) -> albumentations.Compose: return albumentations.Compose([ albumentations.Resize(height=height, width=width), albumentations.Flip(), albumentations.Normalize(), ])
def album(self): #이미지 변환 transform = A.Compose([ #A.RandomRotate90(), A.Flip(p=0.2), #A.Transpose(), A.ChannelShuffle(p=0.3), A.ElasticTransform(p=0.3,border_mode=cv2.BORDER_REFLECT_101,alpha_affine=40), A.OneOf([ A.IAAAdditiveGaussianNoise(), A.GaussNoise(), ], p=0.2), A.OneOf([ A.MotionBlur(p=.2), A.MedianBlur(blur_limit=3, p=0.1), A.Blur(blur_limit=3, p=0.1), ], p=0.2), A.ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=0.2), A.OneOf([ A.OpticalDistortion(p=0.3), A.GridDistortion(p=.1), A.IAAPiecewiseAffine(p=0.3), ], p=0.2), A.OneOf([ A.CLAHE(clip_limit=2), A.IAASharpen(), A.IAAEmboss(), A.RandomBrightnessContrast(), ], p=0.3), A.HueSaturationValue(p=0.3), ]) image = cv2.cvtColor(self.srcResize, cv2.COLOR_BGR2RGB) transformed = transform(image=image)['image'] self.update(transformed)
def get_aug(mode="train"): if mode == "Nor": aug = A.Compose([ ToTensor(), ]) elif mode == "train": aug = A.Compose([ A.Flip(), A.ShiftScaleRotate(rotate_limit=1.0, p=0.8), # Pixels A.OneOf([ A.IAAEmboss(p=1.0), A.IAASharpen(p=1.0), A.Blur(p=1.0), ], p=0.5), # Affine A.OneOf( [A.ElasticTransform(p=1.0), A.IAAPiecewiseAffine(p=1.0)], p=0.5), A.Normalize(p=1.0), ToTensor(), ]) else: aug = A.Compose([ A.Normalize(p=1.0), ToTensor(), ]) return aug
def strong_aug(p=.5): return A.Compose([ A.RandomRotate90(), A.Flip(), A.Transpose(), A.OneOf([ A.IAAAdditiveGaussianNoise(), A.GaussNoise(), ], p=0.2), A.OneOf([ A.MotionBlur(p=.2), A.MedianBlur(blur_limit=3, p=.1), A.Blur(blur_limit=3, p=.1), ], p=0.2), A.ShiftScaleRotate( shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=.2), A.OneOf([ A.OpticalDistortion(p=0.3), A.GridDistortion(p=.1), A.IAAPiecewiseAffine(p=0.3), ], p=0.2), A.OneOf([ A.CLAHE(clip_limit=2), A.IAASharpen(), A.IAAEmboss(), A.RandomContrast(), A.RandomBrightness(), ], p=0.3), A.HueSaturationValue(p=0.3), ], p=p)
def get_train_transform(): return A.Compose([ A.Flip(p=0.5), A.Rotate(20, p=0.9), A.RandomSizedBBoxSafeCrop(1024, 1024, 0.2), ToTensorV2(p=1.0) ], bbox_params={'format': 'pascal_voc', 'label_fields': ['labels']})
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 hard_transforms(): result = [ # random flip albu.Flip(), # add random brightness and contrast, 70% prob albu.RandomBrightnessContrast(brightness_limit=0.2, contrast_limit=0.2, p=0.7), # Random gamma changes with a 30% probability albu.RandomGamma(gamma_limit=(85, 115), p=0.3), # Randomly changes the hue, saturation, and color value of the input image albu.HueSaturationValue(p=0.3), # apply compression to lower the image quality albu.JpegCompression(quality_lower=80), # add cutout with 0.5 prob on the image albu.Cutout(num_holes=15, max_h_size=20, max_w_size=20, fill_value=5, p=0.5), # randomly select of these operations 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), ] return result
def get_default_augmentor(): list_ops = [ aug.Flip(always_apply=True), aug.RandomRotate90(always_apply=True) ] augmentor = aug.Compose(list_ops) return augmentor