def __jpeg_compression(self,img): transform = A.Compose([ A.JpegCompression(quality_lower=5,quality_upper=10), A.JpegCompression(quality_lower=3,quality_upper=5), A.JpegCompression(quality_lower=2,quality_upper=4), ]) transformed = transform(image=img) transformed_image = transformed["image"] return transformed_image
def get_transform(training, width=512, height=512): t = A.Compose([ A.Resize(width, height), # Augmentation A.Compose( [ A.ShiftScaleRotate(shift_limit=0.05, scale_limit=0.05, rotate_limit=5, border_mode=cv2.BORDER_CONSTANT), A.RandomRotate90(), A.HorizontalFlip(), A.JpegCompression(quality_lower=90), A.RandomBrightness(), A.RandomContrast(), # A.RandomGamma(), A.HueSaturationValue( hue_shift_limit=5, sat_shift_limit=30, val_shift_limit=20), A.CLAHE(), A.MedianBlur(), A.MotionBlur(), A.GaussNoise() ], p=float(training)), ]) return t
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 __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 __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 hard_transforms(): result = [ # random flip albu.RandomRotate90(), # Random shifts, stretches and turns with a 50% probability albu.ShiftScaleRotate(shift_limit=0.1, scale_limit=0.1, rotate_limit=15, border_mode=0, p=0.5), # add random brightness and contrast, 30% prob albu.RandomBrightnessContrast(brightness_limit=0.2, contrast_limit=0.2, p=0.3), # 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), albu.JpegCompression(quality_lower=80), 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), albu.OneOf([ albu.OpticalDistortion(p=0.3), albu.GridDistortion(p=0.1), albu.IAAPiecewiseAffine(p=0.3), ], p=0.2), ] return result
def get_transform(is_train): if is_train: return albumentations.Compose( [ albumentations.Resize(224,224), albumentations.OneOf([ albumentations.JpegCompression(quality_lower=20, quality_upper=70, p=0.5), albumentations.Downscale(scale_min=0.25, scale_max=0.50, interpolation=1, p=0.5), ], p=0.6), albumentations.HorizontalFlip(p=0.5), albumentations.VerticalFlip(p=0.5), # albumentations.ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.1, rotate_limit=45), albumentations.GaussNoise(p=0.2), albumentations.RandomBrightnessContrast(0.3,0.3, p=0.7), albumentations.RandomGamma(p=0.2), albumentations.CLAHE(p=0.2), albumentations.ChannelShuffle(p=0.2), albumentations.MultiplicativeNoise(multiplier=[0.5, 1.5], elementwise=True, p=0.3), albumentations.HueSaturationValue(hue_shift_limit=10, sat_shift_limit=10, val_shift_limit=10, p=0.7), albumentations.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), max_pixel_value=255.0) ]) else: return albumentations.Compose( [ albumentations.Resize(224,224), albumentations.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), max_pixel_value=255.0) ])
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.use_diff = params["img_diff"] self.smooth = params["smooth"] self.fix_fake = params["fix_fake"] 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) if self.fix_fake == 1: for key in self.real2fakes.keys(): if len(self.real2fakes[key]) > 0: self.real2fakes[key] = np.random.choice( self.real2fakes[key]) import albumentations as aug self.trans1 = aug.Downscale(0.5, 0.5, p=1) self.trans2 = aug.JpegCompression(quality_lower=20, quality_upper=20, p=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 get_train_transform(): crop_height = 256 crop_width = 256 return albu.Compose([ albu.PadIfNeeded(min_height=crop_height, min_width=crop_width, p=1), albu.RandomSizedCrop((int(0.3 * crop_height), 288), crop_height, crop_width, p=1), albu.HorizontalFlip(p=0.5), albu.OneOf([ albu.IAAAdditiveGaussianNoise(p=0.5), albu.GaussNoise(p=0.5), ], p=0.2), 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), albu.ShiftScaleRotate(shift_limit=0.0625, scale_limit=0, rotate_limit=20, p=0.1), albu.OneOf([ albu.OpticalDistortion(p=0.3), albu.GridDistortion(p=0.1), albu.IAAPiecewiseAffine(p=0.3), ], p=0.2), albu.OneOf([ albu.CLAHE(clip_limit=2, p=0.5), albu.IAASharpen(p=0.5), albu.IAAEmboss(p=0.5), albu.RandomBrightnessContrast(p=0.5), ], p=0.3), albu.HueSaturationValue(p=0.3), albu.JpegCompression(p=0.2, quality_lower=20, quality_upper=99), albu.ElasticTransform(p=0.1), albu.Normalize(p=1) ], p=1)
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_train_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=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 preprocessing_augmentation_function(param_p=0.0): transform = [ A.Rotate(limit=10, interpolation=1, border_mode=4, value=None, mask_value=None, p=param_p), A.OpticalDistortion(distort_limit=0.5, shift_limit=0.1, interpolation=1, border_mode=4, p=param_p), A.ElasticTransform(alpha=1, sigma=5, alpha_affine=5, interpolation=1, border_mode=4, p=param_p), A.JpegCompression(quality_lower=0, quality_upper=20, p=param_p), ] augmentation_function = A.Compose(transform) def augmentation(x): augmentation_image = augmentation_function(image=x) return augmentation_image['image'] return augmentation
def getDataLoader(df, image_folder, process, batch_size = 64, image_size = 224, train_weights = None, replacement = True, option_da = []): if process == 'train': trnsfms = albumentations.Compose([ albumentations.Resize(height=image_size, width=image_size), RGBToGray(always_apply = True) if 'gray' in option_da else Empty(), albumentations.HorizontalFlip(), albumentations.OneOf([ albumentations.RandomContrast(), albumentations.RandomBrightness(), ]), albumentations.ShiftScaleRotate(rotate_limit=20, scale_limit=0.2), albumentations.JpegCompression(80), albumentations.HueSaturationValue(), albumentations.Normalize(), AT.ToTensor() ]) elif process == 'val' or process =='test': trnsfms = albumentations.Compose([ albumentations.Resize(height=image_size, width=image_size), RGBToGray(always_apply = True) if 'gray' in option_da else Empty(), albumentations.Normalize(), AT.ToTensor() ]) dataset = WhaleDataLoader(image_folder = image_folder, process=process, df=df, transform=trnsfms) if process == 'train': tr_ind = np.arange(0, df.shape[0], 1) train_sampler = WeightedSubsetRandomSampler(tr_ind, train_weights, replacement = replacement) loader = DataLoader(dataset, batch_size=batch_size, num_workers=4, pin_memory=True, sampler=train_sampler) else: loader = DataLoader(dataset, batch_size=batch_size, num_workers=4, pin_memory=True, shuffle=False) return loader
def medium_augmentations(image_size: Tuple[int, int], rot_angle=15): return A.Compose([ A.OneOf([ A.RandomSizedCrop((image_size[0], int(image_size[0] * 1.25)), image_size[0], image_size[1], p=0.05), A.RandomSizedCrop((image_size[0], int(image_size[0] * 1.5)), image_size[0], image_size[1], p=0.10), A.RandomSizedCrop((image_size[0], int(image_size[0] * 2)), image_size[0], image_size[1], p=0.15), A.Resize(image_size[0], image_size[1], p=0.7), ], p=1.0), A.HorizontalFlip(p=0.5), A.ShiftScaleRotate(shift_limit=0.1, scale_limit=0.05, rotate_limit=15, border_mode=cv2.BORDER_REFLECT, p=0.3), A.RandomBrightnessContrast(brightness_limit=0.2, contrast_limit=0.2, p=0.2), A.RandomGamma(gamma_limit=(85, 115), p=0.2), A.HueSaturationValue(p=0.2), A.CLAHE(p=0.2), A.JpegCompression(quality_lower=50, p=0.2), A.Normalize(), ToTensor() ])
def __init__(self, prob=0.5): import albumentations self.transform = albumentations.Compose([ albumentations.Blur(blur_limit=3, p=prob), albumentations.JpegCompression(quality_lower=30, quality_upper=100, p=prob), ])
def compression(quality_lower=4, quality_upper=100, p=0.5): """ :param quality_lower: :param quality_upper: :param p: probability of applying the transform. :return: albumentations JpegCompression """ return album.JpegCompression(quality_lower=quality_lower, quality_upper=quality_upper, p=p)
def __init__(self): import albumentations self.transform = albumentations.Compose([ albumentations.Blur(blur_limit=3), albumentations.JpegCompression(quality_lower=30, quality_upper=100, p=0.5), albumentations.RandomBrightnessContrast(), albumentations.RandomGamma(gamma_limit=(80, 120)), albumentations.CLAHE(), ])
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_train_transforms(): return A.Compose([ A.OneOf([ A.HueSaturationValue(hue_shift_limit=20, sat_shift_limit= 20, val_shift_limit=20, p=1), A.RandomBrightnessContrast(brightness_limit=0.2, contrast_limit=0.2, p=1), ],p=0.5), A.JpegCompression (quality_lower=90, quality_upper=100, always_apply=False, p=0.5), A.RandomSizedCrop(min_max_height=(164, 256), height=256, width=512, p=0.5), A.ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.1, rotate_limit=30, interpolation=1, border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=None, always_apply=False, p=0.5), A.Cutout(num_holes=8, max_h_size=28, max_w_size=28, fill_value=0, p=0.5), A.HorizontalFlip(p=0.5), ], p=1.0)
def generate_transforms2(img_size): train_transform = Compose([ # A.RandomCrop(p=1, height=img_size, width=img_size), A.Resize(height=img_size, width=img_size), A.RandomSunFlare(p=1), A.RandomFog(p=1), A.RandomBrightness(p=1), A.Rotate(p=1, limit=90), A.RGBShift(p=1), A.RandomSnow(p=1), A.HorizontalFlip(p=1), A.VerticalFlip(p=1), A.RandomContrast(limit=0.5, p=1), A.HueSaturationValue(p=1, hue_shift_limit=20, sat_shift_limit=30, val_shift_limit=50), # A.Cutout(p=1), # A.Transpose(p=1), A.JpegCompression(p=1), A.CoarseDropout(p=1), A.IAAAdditiveGaussianNoise(loc=0, scale=(2.5500000000000003, 12.75), per_channel=False, p=1), A.IAAAffine(scale=1.0, translate_percent=None, translate_px=None, rotate=0.0, shear=0.0, order=1, cval=0, mode='reflect', p=1), A.IAAAffine(rotate=90., p=1), A.IAAAffine(rotate=180., p=1), Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), max_pixel_value=255.0, p=1.0), ToTensorV2() ]) val_transform = Compose([ Resize(height=img_size, width=img_size), Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), max_pixel_value=255.0, p=1.0), ToTensorV2(), ]) return {"train": train_transform, "val": val_transform}
def get_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 hard_augmentations(image_size: Tuple[int, int], rot_angle=30): pad_h, pad_w = padding_for_rotation(image_size, rot_angle) crop_height = int(image_size[0] + pad_h * 2) crop_width = int(image_size[1] + pad_w * 2) crop_transform = A.Compose([ A.RandomSizedCrop((int(crop_height * 0.75), int(crop_height * 1.25)), crop_height, crop_width), A.ShiftScaleRotate(shift_limit=0, scale_limit=0, rotate_limit=rot_angle, border_mode=cv2.BORDER_CONSTANT), A.CenterCrop(image_size[0], image_size[1]), ]) return A.Compose([ # spatial transform A.PadIfNeeded(int(crop_height * 1.25), int(crop_height * 1.25)), A.OneOf([ crop_transform, A.RandomSizedCrop((image_size[0], int(image_size[0] * 1.25)), image_size[0], image_size[1], p=0.25), A.RandomSizedCrop((image_size[0], int(image_size[0] * 1.5)), image_size[0], image_size[1], p=0.25), A.RandomSizedCrop((image_size[0], int(image_size[0] * 2)), image_size[0], image_size[1], p=0.25), A.Resize(image_size[0], image_size[1], p=0.75) ], p=1.0), # add occasion blur/sharpening A.OneOf([ A.GaussianBlur(), A.MotionBlur(), A.IAASharpen(), A.JpegCompression(quality_lower=75, p=0.25), ]), # D4 augmentations A.Compose([ A.HorizontalFlip(), ]), # spatial-preserving augmentations A.OneOf([ A.Cutout(), A.GaussNoise(), ]), A.OneOf([ A.RandomBrightnessContrast(), A.CLAHE(), A.HueSaturationValue(), A.RGBShift(), A.RandomGamma() ]), A.Normalize(), ToTensor() ])
def color_augment_pool(): augs = [ A.RGBShift(), A.ToGray(), A.ChannelShuffle(), A.CLAHE(), A.HueSaturationValue(), A.RandomContrast(), A.RandomGamma(), A.Blur(), A.MedianBlur(), A.JpegCompression() ] return augs
def get_tta_transforms(): return A.Compose([ A.JpegCompression(p=0.5), A.RandomSizedCrop(min_max_height=(int( resolution * 0.9), int(resolution * 1.1)), height=resolution, width=resolution, p=1.0), A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5), A.Transpose(p=0.5), A.Normalize(), ToTensorV2(), ], p=1.0)
def generate_transforms3(img_size): train_transform = Compose([ A.RandomResizedCrop(img_size, img_size, scale=(0.9, 1), p=1), A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5), A.ShiftScaleRotate(p=0.5), A.HueSaturationValue(hue_shift_limit=10, sat_shift_limit=10, val_shift_limit=10, p=0.7), A.RandomBrightnessContrast(brightness_limit=(-0.2, 0.2), contrast_limit=(-0.2, 0.2), p=0.7), A.CLAHE(clip_limit=(1, 4), p=0.5), A.OneOf([ A.OpticalDistortion(distort_limit=1.0), A.GridDistortion(num_steps=5, distort_limit=1.0), A.ElasticTransform(alpha=3), ], p=0.2), A.Resize(img_size, img_size), A.OneOf([ A.JpegCompression(), A.Downscale(scale_min=0.1, scale_max=0.15), ], p=0.2), A.IAAPerspective(p=0.2), A.IAASharpen(p=0.2), A.Cutout(max_h_size=int(img_size * 0.1), max_w_size=int(img_size * 0.1), num_holes=5, p=0.5), Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), max_pixel_value=255.0, p=1.0), ToTensorV2(), ]) val_transform = Compose([ Resize(height=img_size, width=img_size), Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), max_pixel_value=255.0, p=1.0), ToTensorV2(), ]) return {"train": train_transform, "val": val_transform}
def make_augmentation_transforms(args): transforms = [] for transform_name in args.augmentation_list: if transform_name == "HorizontalFlip": transform = albumentations.HorizontalFlip(p=0.5) elif transform_name == "VerticalFlip": transform = albumentations.VerticalFlip(p=0.5) elif transform_name == "ElasticTransform": transform = albumentations.ElasticTransform( alpha=args.elastic_alpha, sigma=args.elastic_sigma, alpha_affine=args.elastic_alpha_affine, interpolation=cv2.INTER_NEAREST, border_mode=cv2.BORDER_CONSTANT, ) elif transform_name == "ShiftScaleRotate": transform = albumentations.ShiftScaleRotate( shift_limit=args.shift_limit, scale_limit=args.scale_limit, rotate_limit=args.rotate_limit, border_mode=cv2.BORDER_CONSTANT, p=args.p_shift_scale_rotate, ) elif transform_name == "RandomBrightnessContrast": transform = albumentations.RandomBrightnessContrast( brightness_limit=args.brightness_limit, contrast_limit=args.contrast_limit, ) elif transform_name == "GridDistortion": transform = albumentations.GridDistortion( num_steps=args.grid_distortion_steps, distort_limit=args.distort_limit, border_mode=cv2.BORDER_CONSTANT, ) elif transform_name == "Cutout": transform = albumentations.CoarseDropout( max_holes=args.cutout_max_holes, max_width=args.cutout_max_width, max_height=args.cutout_max_height, ) elif transform_name == "JpegCompression": transform = albumentations.JpegCompression() else: raise ValueError(f"Unrecognized transform type: {transform_name}") transforms.append(transform) bboxes_params = albumentations.BboxParams("pascal_voc", label_fields=["labels"]) return albumentations.Compose(transforms, bboxes_params)
def __initialize_image_augmentation(image_shape): pipeline = augmentator.Compose([ augmentator.VerticalFlip(p=0.5), augmentator.HorizontalFlip(p=0.5), augmentator.RandomBrightness(limit=1.2, p=0.5), augmentator.RandomGamma(gamma_limit=37, p=0.5), augmentator.ElasticTransform( alpha=203, sigma=166, alpha_affine=106, p=0.5), augmentator.JpegCompression( quality_lower=25, quality_upper=100, p=0.5), augmentator.RandomContrast(limit=1, p=0.5), augmentator.Resize(image_shape[0], image_shape[1], p=1) ], bbox_params={ 'format': 'coco', 'label_fields': ["category_id"] }) return pipeline
def hard_transforms(crop_size=512): return albu.Compose([ albu.ShiftScaleRotate(shift_limit=0, scale_limit=0.1, rotate_limit=180, border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0), albu.CropNonEmptyMaskIfExists(crop_size, crop_size, p=1), albu.RandomShadow(shadow_roi=(0, 0, 1, 1), num_shadows_lower=1, num_shadows_upper=4, shadow_dimension=7, always_apply=False, p=0.5), albu.HueSaturationValue(p=0.3), albu.OneOf([ albu.IAAAdditiveGaussianNoise(), albu.GaussNoise(), albu.MultiplicativeNoise( multiplier=[0.5, 1.5], per_channel=True, p=1) ], p=0.3), 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), albu.OneOf([ albu.CLAHE(clip_limit=2), albu.IAASharpen(), albu.IAAEmboss(), albu.RandomBrightnessContrast( brightness_limit=0.2, contrast_limit=0.2, p=0.3), albu.RandomGamma(gamma_limit=(85, 115), p=0.3), ], p=0.3), albu.JpegCompression(quality_lower=40, quality_upper=100, p=0.5), albu.Cutout( num_holes=25, max_h_size=5, max_w_size=5, fill_value=0, p=0.3), ], p=1)
def __init__(self, phase, train_file, image_file_path, image_height, image_width, mean, std, binclass): self.image_file_path = image_file_path df = pd.read_csv(train_file) if binclass == 'A': class_map = {'A':1,'B':0,'C':0} elif binclass == 'B': class_map = {'A':0,'B':1,'C':0} elif binclass == 'C': class_map = {'A':0,'B':0,'C':1} else: class_map = {'A':0,'B':1,'C':2} self.img_id = df['image_id'].apply(lambda x: x.split('.')[0]).values # just take id of image_id self.labels = df['label'].apply(lambda x: x[-1]).map(class_map).values # encoding labels if phase == 'valid': # validation set self.aug = albumentations.Compose([ albumentations.Resize(image_height, image_width), albumentations.Normalize(mean, std), # albumentations.ToFloat() ]) elif phase == 'train': # training set self.aug = albumentations.Compose([ albumentations.Resize(image_height, image_width), albumentations.RandomRotate90(p=0.5), albumentations.Transpose(p=0.5), albumentations.Flip(p=0.5), albumentations.OneOf([ albumentations.CLAHE(clip_limit=2), albumentations.IAASharpen(), albumentations.IAAEmboss(), albumentations.RandomBrightness(), albumentations.RandomContrast(), albumentations.JpegCompression(), albumentations.Blur(), albumentations.GaussNoise()], p=0.5), # albumentations.HueSaturationValue(p=0.5), albumentations.ShiftScaleRotate(shift_limit=0.15, scale_limit=0.15, rotate_limit=45, p=0.5), albumentations.Normalize(mean, std), # albumentations.ToFloat() ])