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 __init__(self, image_size=(112, 112), augmentation=False): self.image_size = image_size if augmentation: self.crop_func = RandomCropAndResize(size=image_size) w, h = image_size self.aug_func = alb.Compose([ alb.RGBShift(), alb.RandomBrightnessContrast(), alb.OneOf([ alb.Rotate(limit=5), alb.GridDistortion(distort_limit=0.2), alb.ElasticTransform(alpha=50, sigma=10, alpha_affine=2), ], p=0.7), alb.OneOf([alb.GaussNoise(), alb.IAAAdditiveGaussianNoise()]), alb.CoarseDropout(max_holes=1, max_height=h // 2, max_width=w // 2, min_height=h // 4, min_width=w // 4, fill_value=128) ]) else: self.crop_func = CenterCropAndResize(size=image_size) self.aug_func = None
def __init__(self, Config, anno, swap_size=[7,7], unswap=None, swap=None, totensor=None, train=False, train_val=False, test=False): self.root_path = Config.rawdata_root self.numcls = Config.numcls self.dataset = Config.dataset if isinstance(anno, pandas.core.frame.DataFrame): self.paths = anno['ImageName'].tolist() self.labels = anno['label'].tolist() elif isinstance(anno, dict): self.paths = anno['img_name'] self.labels = anno['label'] self.cls_dict = get_sample_dict(self.paths, self.labels) if train: self.update_sample() if train_val: self.paths, self.labels = random_sample(self.paths, self.labels) self.unswap = unswap self.swap = swap self.totensor = totensor self.cfg = Config self.train = train self.swap_size = swap_size self.test = test #self.cutout = albu.Compose([albu.CoarseDropout(max_holes=7, max_height=20, max_width=20, p=1)]) resize_reso = 256 crop_reso = 224 self.cutout = albu.Compose([albu.Resize(resize_reso, resize_reso), albu.Rotate(limit=15), albu.RandomCrop(crop_reso, crop_reso), albu.HorizontalFlip(p=0.5), albu.CoarseDropout(max_holes=7, max_height=20, max_width=20, p=1), albu.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)), ])
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.68, sat_shift_limit=0.68, val_shift_limit=0.1, p=0.9), A.RandomGamma(p=0.9), A.RandomBrightnessContrast( brightness_limit=0.1, contrast_limit=0.1, p=0.9), ], p=0.9), # A.CLAHE(p=1.0), A.ToGray(p=0.01), A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5), A.RandomRotate90(p=0.5), A.Resize(height=512, width=512, p=1), A.CoarseDropout(max_holes=20, max_height=32, max_width=32, fill_value=0, p=0.25), ToTensorV2(p=1.0), ], p=1.0, bbox_params=A.BboxParams(format='pascal_voc', min_area=0, min_visibility=0, label_fields=['labels']))
def __init__(self, img_size=224, mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)): super(ImageTransform_7, self).__init__() self.transform = { 'train': albu.Compose([ albu.RandomResizedCrop(img_size, img_size), albu.ColorJitter(p=0.5), albu.HorizontalFlip(p=0.5), albu.VerticalFlip(p=0.5), albu.Transpose(p=0.5), albu.CLAHE(p=0.5), albu.MotionBlur(p=0.5), albu.Normalize(mean, std), albu.CoarseDropout( max_height=15, max_width=15, max_holes=8, p=0.5), ToTensorV2(), ], p=1.0), 'val': albu.Compose([ albu.Resize(img_size, img_size), albu.Normalize(mean, std), ToTensorV2(), ], p=1.0) }
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 medium_3(image_size, p=1.0): cutout_crop = int(0.25 * image_size) return A.Compose( [ # RandomCrop(input_size) / RandomResizedCrop (0.08, 1) A.HorizontalFlip(p=0.5), # vflip A.VerticalFlip(p=0.5), # hflip A.ShiftScaleRotate( shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=0.3), A.OneOf([ A.RandomFog( fog_coef_lower=0.3, fog_coef_upper=1.0, alpha_coef=.1), A.ImageCompression(quality_lower=20, quality_upper=99), ], p=0.3), A.RandomBrightnessContrast(brightness_limit=0.125, contrast_limit=0.2, p=0.5), # contrast_limit=0.5 A.HueSaturationValue(hue_shift_limit=5, sat_shift_limit=30, val_shift_limit=20, p=0.2), A.GaussNoise(var_limit=(1, 50), p=0.4), A.CoarseDropout(min_holes=1, max_holes=2, max_height=cutout_crop, max_width=cutout_crop, p=0.5), ], p=p)
def get_transforms(*, data_type): if data_type == "light_train": return Compose([ Resize(CFG.size, CFG.size), Transpose(p=0.5), HorizontalFlip(p=0.5), VerticalFlip(p=0.5), ShiftScaleRotate(scale_limit=(0, 0), p=0.5), ToTensorV2(), ]) if data_type == "train": return Compose([ Resize(CFG.size, CFG.size), Transpose(p=0.5), HorizontalFlip(p=0.5), VerticalFlip(p=0.5), albumentations.OneOf([ albumentations.ElasticTransform( alpha=1, sigma=20, alpha_affine=10), albumentations.GridDistortion(num_steps=6, distort_limit=0.1), albumentations.OpticalDistortion(distort_limit=0.05, shift_limit=0.05), ], p=0.2), albumentations.core.composition.PerChannel(albumentations.OneOf([ albumentations.MotionBlur(p=.05), albumentations.MedianBlur(blur_limit=3, p=.05), albumentations.Blur(blur_limit=3, p=.05), ]), p=1.0), albumentations.OneOf([ albumentations.CoarseDropout(max_holes=16, max_height=CFG.size // 16, max_width=CFG.size // 16, fill_value=0, p=0.5), albumentations.GridDropout(ratio=0.09, p=0.5), albumentations.Cutout(num_holes=8, max_h_size=CFG.size // 16, max_w_size=CFG.size // 16, p=0.2), ], p=0.5), albumentations.ShiftScaleRotate( shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=0.5), ToTensorV2(), ], additional_targets={ 'r': 'image', 'g': 'image', 'b': 'image', 'y': 'image', }) elif data_type == 'valid': return Compose([ Resize(CFG.size, CFG.size), ToTensorV2(), ])
def __init__(self, scale_range: float = (0.35, 0.65), input_size: int = (416, 416), augmentation: bool = False) -> None: if augmentation: self.crop_func = RandomCropAndResize(scale_range, input_size) self.aug_func = alb.Compose([ alb.OneOf([ alb.RGBShift(), alb.ToGray(), alb.NoOp(), ]), alb.RandomBrightnessContrast(), alb.OneOf([ alb.GaussNoise(), alb.IAAAdditiveGaussianNoise(), alb.CoarseDropout(fill_value=100), ]) ]) else: scale = (scale_range[0] + scale_range[1]) / 2. self.crop_func = CenterCropAndResize(scale, input_size) self.aug_func = None self.heatmap_stride = 4 self.heatmap_size = (input_size[0] // self.heatmap_stride, input_size[1] // self.heatmap_stride)
def __init__( self, horizontal_flip_prob=0.0, vertical_flip_prob=0.0, gaussian_blur_prob=0.0, rotate_degree=0.0, cutout=0.0, cutout_height=0, cutout_width=0, mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5), train=True ): transforms_list = [] if train: if horizontal_flip_prob > 0: # Horizontal Flip transforms_list += [A.HorizontalFlip(p=horizontal_flip_prob)] if vertical_flip_prob > 0: # Vertical Flip transforms_list += [A.VerticalFlip(p=vertical_flip_prob)] if gaussian_blur_prob > 0: # Patch Gaussian Augmentation transforms_list += [A.GaussianBlur(p=gaussian_blur_prob)] if rotate_degree > 0: # Rotate image transforms_list += [A.Rotate(limit=rotate_degree)] if cutout > 0: # CutOut transforms_list += [A.CoarseDropout( p=cutout, max_holes=1, fill_value=tuple([x * 255.0 for x in mean]), max_height=cutout_height, max_width=cutout_width, min_height=1, min_width=1 )] transforms_list += [ A.Normalize(mean=mean, std=std, always_apply=True), ToTensor() Cutout() ] self.transform = A.Compose(transforms_list)
def apply_transforms(mean, std): train_transforms = A.Compose([ A.HorizontalFlip(p=0.2), A.ShiftScaleRotate(shift_limit=0.1, scale_limit=0.1, rotate_limit=10, p=0.2), A.CoarseDropout( max_holes=1, max_height=16, max_width=16, min_holes=1, min_height=16, min_width=16, fill_value=tuple((x * 255.0 for x in mean)), p=0.2, ), A.ToGray(p=0.15), A.Normalize(mean=mean, std=std, always_apply=True), ToTensorV2(), ]) test_transforms = A.Compose([ A.Normalize(mean=mean, std=std, always_apply=True), ToTensorV2(), ]) return lambda img: train_transforms(image=np.array(img))[ "image"], lambda img: test_transforms(image=np.array(img))["image"] # if __name__ == "__main__": # pass
def albumentations_transforms(p=1.0, is_train=False): '''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) std = (0.2302, 0.2265, 0.2262) 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.CoarseDropout(max_holes=1, max_height=16, max_width=16, min_holes=1, min_height=16, min_width=16, fill_value=(0.4914, 0.4822, 0.4465), mask_fill_value=None), ToTensorV2() ] transforms_result = A.Compose(train_transforms) return lambda img: transforms_result(image=np.array(img))["image"]
def build_transforms(args, n_classes): train_transforms = A.Compose([ A.HorizontalFlip(), A.RandomResizedCrop(width=args.image_size, height=args.image_size, scale=(0.7, 1.2)), A.CoarseDropout(max_height=int(args.image_size / 5), max_width=int(args.image_size / 5)), A.OneOf([ A.RandomBrightnessContrast(), A.RandomGamma(), A.Blur(blur_limit=5), ]), ToTensorV2(), ]) train_transforms = AlbumentationsSegmentationWrapperTransform( train_transforms, class_num=n_classes, ignore_indices=[ 255, ]) test_transforms = A.Compose([ A.Resize(width=args.image_size, height=args.image_size), ToTensorV2(), ]) test_transforms = AlbumentationsSegmentationWrapperTransform( test_transforms, class_num=n_classes, ignore_indices=[ 255, ]) return train_transforms, test_transforms
def get_train_transform(mu, sigma): """ Args: tensor (Tensor): Tensor image of size (C, H, W) to be normalized. Returns: Tensor: Normalized image. """ train_transform = A.Compose([ A.HorizontalFlip(p=0.4), A.ShiftScaleRotate(), A.Normalize(mean=(mu), std=(sigma)), A.CoarseDropout(max_holes=1, max_height=16, max_width=16, min_holes=1, min_height=16, min_width=16, fill_value=(mu)), A.ToGray(), ToTensorV2(), ]) return(train_transform)
def medium_augmentations(): return A.Compose([ A.HorizontalFlip(), A.ShiftScaleRotate(scale_limit=0.1, rotate_limit=15, border_mode=cv2.BORDER_CONSTANT), # Add occasion blur/sharpening A.OneOf([A.GaussianBlur(), A.IAASharpen(), A.NoOp()]), # Spatial-preserving augmentations: A.OneOf([A.CoarseDropout(), A.MaskDropout(max_objects=5), A.NoOp()]), A.GaussNoise(), A.OneOf([ A.RandomBrightnessContrast(), A.CLAHE(), A.HueSaturationValue(), A.RGBShift(), A.RandomGamma() ]), # Weather effects A.RandomFog(fog_coef_lower=0.01, fog_coef_upper=0.3, p=0.1), A.Normalize(), ])
def get_train_transform(self): # fill values for cutout or cropping portion fill_value = [255. * mean for mean in self.means] rc_padding = 32 rc_pval = 0.2 randomCrop = [albumentations.PadIfNeeded(min_height=self.size+rc_padding, min_width=self.size+rc_padding, border_mode=cv2.BORDER_REPLICATE, value=fill_value, p=1.0), albumentations.OneOf([ albumentations.RandomCrop(height=self.size, width=self.size, p=rc_pval), albumentations.CenterCrop(height=self.size, width=self.size, p=1-rc_pval), ], p=1.0) ] train_tf = albumentations.Compose([ albumentations.Resize(self.size,self.size), albumentations.RandomBrightness(limit=0.2, p=0.5), albumentations.RandomContrast(limit=0.2, p=0.5), albumentations.Rotate(limit=(-10,10), p=0.70), randomCrop[0], randomCrop[1], albumentations.HorizontalFlip(p=0.7), albumentations.ElasticTransform(sigma=50, alpha=1, alpha_affine=10,p=0.10), albumentations.CoarseDropout(max_holes=1, max_height=64, max_width=64, min_height=16, min_width=16, fill_value=fill_value, p=0.70), albumentations.Normalize(mean=self.means, std=self.stds), ToTensor() ]) train_tf = AlbumCompose(train_tf) return train_tf
def da_policy_DA7b(crop_size): # additional_aug = [* # zoom_crop(scale=(0.85, 1.15), do_rand=True), # cutout(n_holes=(1, 2), length=(32, 84), p=.5), # brightness(change=(0.33, 0.68), p=.5), # contrast(scale=(0.7, 1.4), p=.5), # ] # return get_transforms(do_flip=False, max_warp=0.25, max_zoom=1.25, max_rotate=17, xtra_tfms=additional_aug) train_da = albumentations.Compose([ albumentations.ShiftScaleRotate(scale_limit=0.15, rotate_limit=0), albumentations.Resize(crop_size, crop_size), albumentations.CoarseDropout(p=0.5, min_holes=1, max_holes=2, min_width=16, min_height=16, max_width=64, max_height=64), albumentations.RandomBrightnessContrast(p=0.5, brightness_limit=0.2, contrast_limit=0.25), albumentations.Rotate(p=0.5, limit=17) ]) val_da = albumentations.Compose( [albumentations.Resize(crop_size, crop_size)]) return train_da, val_da
def train_image_augmentation(image, img_size): image = np.array(image) augmentation = A.Compose( [ A.Resize(img_size, img_size), A.CenterCrop(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.Blur(blur_limit=3), A.OpticalDistortion(p=0.5), A.GridDistortion(p=0.5), A.HueSaturationValue(hue_shift_limit=0.2, sat_shift_limit=0.2, val_shift_limit=0.2, p=0.5), A.CoarseDropout(p=0.5), A.Cutout(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, ) ], p=1.0, ) augmented_image = augmentation(image=image) return augmented_image['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 __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 __init__(self): self.aug = A.Compose([ A.OneOf([ A.Blur(blur_limit=10, p=0.5), A.MedianBlur(blur_limit=5, p=0.5), ]), A.OneOf([ A.CoarseDropout(max_holes=7, min_holes=3, min_height=3, min_width=1, max_height=16, max_width=4, fill_value=255, p=0.5), A.CoarseDropout(max_holes=7, min_holes=3, min_height=3, min_width=1, max_height=16, max_width=4, fill_value=170, p=0.5), A.CoarseDropout(max_holes=7, min_holes=3, min_height=3, min_width=1, max_height=16, max_width=4, fill_value=85, p=0.5), A.CoarseDropout(max_holes=7, min_holes=3, min_height=3, min_width=1, max_height=16, max_width=4, fill_value=0, p=0.5), ]), # A.RandomContrast(limit=0.05, p=0.75), # A.RandomBrightness(limit=0.05, p=0.75), # A.RandomBrightnessContrast(contrast_limit=0.05, brightness_limit=0.05, p=0.75), ])
def _as_cutout_transform(self, value, p, image_shape): hole_size = self._calculate_hole_size(value, image_shape) return A.CoarseDropout( min_holes=self.num_holes, max_holes=self.num_holes, max_height=hole_size, max_width=hole_size, p=p, )
def get_train_augmentations(image_size: int = 224): return A.Compose([ A.CoarseDropout(20), A.Rotate(30), A.RandomCrop(image_size, image_size, p=0.5), A.LongestMaxSize(image_size), A.PadIfNeeded(image_size, image_size, 0), A.Normalize(), ToTensor(), ])
def build_train(self): return A.Compose([ A.Flip(p=0.55), A.ShiftScaleRotate(scale_limit=0.5, rotate_limit=0, border_mode=0), A.Resize(self.height, self.width), A.RandomBrightness(), A.RandomContrast(), A.OneOf( [ A.CoarseDropout(max_holes=2, max_height=128, max_width=128), A.CoarseDropout(max_holes=4, max_height=64, max_width=64), ], p=0.5, ), DistortionBase(), A.Normalize(self.MEANS, self.STDS), ToTensorV2(), ])
def hard_transforms(): result = [ albu.RandomRotate90(), albu.CoarseDropout(p=0.3), albu.RandomBrightnessContrast(brightness_limit=0.1, contrast_limit=0.1, p=0.3), albu.GridDistortion(p=0.3), ] return result
def get_transform(mode): transforms = [] if mode == 'train': transforms.append(A.OneOf([ A.Blur(blur_limit=3, p=1.0), A.MedianBlur(blur_limit=3, p=1.0) ], p=0.25)) transforms.append(A.CoarseDropout(min_holes=3, min_height=4, min_width=4, max_height=12, max_width=12, p=0.25)) transforms.append(ToTensorV2(p=1.0)) return A.Compose(transforms=transforms)
def __init__(self): self.trans=A.Compose( [ A.HorizontalFlip(p=0.5), #A.Cutout(num_holes=2, max_h_size=4, max_w_size=4,fill_value=0.5*255, p=0.5), A.CoarseDropout(max_holes=1, max_height=16, max_width=16, min_height=4, min_width=4, fill_value=(np.array([0.4914, 0.4822, 0.4465]))*255.0, p=0.75), A.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), ToTensor() ])
def hard_transforms(): result = [ # albu.RandomRotate90(), albu.CoarseDropout(), albu.RandomBrightnessContrast( brightness_limit=0.2, contrast_limit=0.2, p=0.3 ), albu.GridDistortion(p=0.3, border_mode=0, value=255, mask_value=[255, 255, 255]), ] return result
def get_training_augmentation(grayscale=False, height=320, width=640, crop_mode=0): mea = mean st = std if grayscale: mea = (mean[0] + mean[1] + mean[2]) / 3 st = (std[0] + std[1] + std[2]) / 3 if crop_mode == 0: train_transform = [ albu.PadIfNeeded(height * 3 // 2, width * 3 // 2), albu.RandomCrop(height * 3 // 2, width * 3 // 2), albu.HorizontalFlip(p=0.5), albu.VerticalFlip(p=0.5), albu.CoarseDropout(p=0.1), albu.ShiftScaleRotate(scale_limit=0.4, rotate_limit=45, shift_limit=0.1, p=0.5, border_mode=0), albu.GridDistortion(p=0.3), albu.OpticalDistortion(p=0.3, distort_limit=2, shift_limit=0.5), albu.RGBShift(p=0.3), albu.Blur(p=0.3), albu.MotionBlur(p=0.3), albu.PadIfNeeded(height, width), albu.RandomCrop(height, width) ] else: train_transform = [ albu.HorizontalFlip(p=0.5), albu.VerticalFlip(p=0.5), albu.ShiftScaleRotate(scale_limit=0.4, rotate_limit=45, shift_limit=0.1, p=0.5, border_mode=0), albu.GridDistortion(p=0.5), albu.OpticalDistortion(p=0.5, distort_limit=2, shift_limit=0.5), albu.RGBShift(p=0.5), albu.ToGray(p=0.5), albu.Resize(height, width) ] train_transform.extend([ #Equalize(p=1.0, by_channels=False), albu.Normalize(mean=mea, std=st, p=1), ToTensor(), ]) return albu.Compose(train_transform)
def create_train_transform(flip, noise, cutout, resize, size = 112, bright = True): translist = [] if flip: translist+=[albumentations.OneOf([ albumentations.Rotate(limit=30), albumentations.IAAPiecewiseAffine(), albumentations.ShiftScaleRotate( shift_limit=0.02, scale_limit=0.3, rotate_limit=10, ), albumentations.HorizontalFlip()],p=0.7)] if noise: translist+=[albumentations.OneOf([ albumentations.MotionBlur(blur_limit=6), albumentations.MedianBlur(blur_limit=5), albumentations.OpticalDistortion(), albumentations.CLAHE(), albumentations.GaussNoise(var_limit=(5.0,20.0))], p=0.75)] if bright: translist+=[albumentations.OneOf([ albumentations.RandomBrightness(limit=0.6), #albumentations.Sharpen(), albumentations.ColorJitter(), albumentations.RandomBrightnessContrast(brightness_limit=0.6, contrast_limit=0.6)],p=0.7)] if cutout: translist+=[albumentations.OneOf([ albumentations.CoarseDropout(), albumentations.Cutout(max_h_size = int(size * np.random.rand(1)*0.5), max_w_size = int(size * np.random.rand(1)*0.5), num_holes=np.random.randint(1,3)) ],p=0.75)] if resize: translist+=[albumentations.Resize(size+10, size+10, interpolation=2)] translist+=[albumentations.RandomCrop(size,size,always_apply=True)] #translist+=[albumentations.Normalize(mean=(0.2481, 0.2292, 0.2131), std = (0.2167,0.2071,0.2014))] #translist+=[albumentations.Normalize(mean=(0.2248, 0.2080, 0.1929), std = (0.2231, 0.2140, 0.2083))] #trainlist+=[albumentations.Normalize(mean=(0.2539, 0.2348, 0.2189), std = (0.2195,0.2110,0.2061))] #translist+=[albumentations.Normalize(mean=(0.2580, 0.2360, 0.2215), std = (0.2235, 0.2132, 0.2100))] translist+=[albumentations.Normalize(mean=(0.1977, 0.2115, 0.2275), std = (0.2177, 0.2227, 0.2317))] #translist+=[albumentations.Normalize(mean=(0.2527, 0.2343, 0.2177), std = (0.2171, 0.2082, 0.2026))] transform = albumentations.Compose(translist) return transform