def get_training_augmentation(): train_transform = [ albu.HorizontalFlip(p=0.5), albu.VerticalFlip(p=0.2), albu.ShiftScaleRotate(scale_limit=0.5, rotate_limit=50, shift_limit=0.1, p=1, border_mode=0), #320 384 448 512 640 # albu.GridDistortion(num_steps=2, distort_limit=0.2, interpolation=1, border_mode=0, value=None, always_apply=False, p=0.5), albu.PadIfNeeded(min_height=padheight, min_width=padwidth, always_apply=True, border_mode=0), albu.Resize(height=padheight, width=padwidth), albu.RandomCrop(height=inputheight, width=inputwidth, always_apply=True), #the last size albu.ChannelShuffle(p=0.1), albu.IAAAdditiveGaussianNoise(p=0.2), albu.IAAPerspective(p=0.5), albu.OneOf( [ albu.CLAHE(p=1), albu.RandomBrightness(p=1), albu.RandomGamma(p=1), ], p=0.9, ), albu.OneOf( [ albu.IAASharpen(p=1), albu.Blur(blur_limit=3, p=1), albu.MotionBlur(blur_limit=3, p=1), ], p=0.9, ), albu.OneOf( [ albu.RandomContrast(p=1), albu.HueSaturationValue(p=1), ], p=0.9, ), ] return albu.Compose(train_transform)
def build_transforms(cfg, is_train, debug=False): to_compose = [albu.Resize(*cfg.inputs.size)] if is_train and cfg.augmentation.enable: to_compose.extend([ albu.HorizontalFlip(p=0.5), albu.VerticalFlip(p=0.5), albu.RandomRotate90(p=0.5), albu.Transpose(p=0.5), albu.ShiftScaleRotate(scale_limit=0.2, rotate_limit=0, shift_limit=0.2, p=0.2, border_mode=0), albu.IAAAdditiveGaussianNoise(p=0.2), albu.IAAPerspective(p=0.5), albu.OneOf( [ albu.CLAHE(p=1), albu.RandomBrightness(p=1), albu.RandomGamma(p=1), ], p=0.9, ), albu.OneOf( [ albu.IAASharpen(p=1), albu.Blur(blur_limit=3, p=1), albu.MotionBlur(blur_limit=3, p=1), ], p=0.9, ), albu.OneOf( [ albu.RandomContrast(p=1), albu.HueSaturationValue(p=1), ], p=0.9, ), albu.Compose( [albu.VerticalFlip(p=0.5), albu.RandomRotate90(p=0.5)]) ]) if debug: return albu.Compose(to_compose) to_compose.append(albu.Normalize(**cfg.inputs.normalize)) to_compose.append(ToTensorV2(transpose_mask=True)) return albu.Compose(to_compose)
def create_train_transform(flip, noise, cutout, resize, size=112, bright=True): translist = [] if resize: if size == 112: translist += [albumentations.Resize(128, 128)] elif size == 224: translist += [albumentations.Resize(256, 256)] translist += [albumentations.RandomCrop(size, size, always_apply=True)] if flip: translist += [ albumentations.OneOf([albumentations.HorizontalFlip()], p=0.5) ] if noise: translist += [ albumentations.OneOf([ albumentations.MotionBlur(blur_limit=5), albumentations.MedianBlur(blur_limit=5), albumentations.OpticalDistortion(), albumentations.GaussNoise(var_limit=(5.0, 30.0)) ], p=0.65) ] if bright: translist += [ albumentations.RandomBrightness(limit=0.2, always_apply=False) ] if cutout: translist += [ albumentations.Cutout(max_h_size=int(size * 0.2), max_w_size=int(size * 0.2), num_holes=1, p=0.5) ] #translist+=[albumentations.Normalize(mean=(0.2481, 0.2292, 0.2131), std = (0.2167,0.2071,0.2014))] #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.2527, 0.2343, 0.2177), std=(0.2171, 0.2082, 0.2026)) ] transform = albumentations.Compose(translist) return transform
def bboxes_augmentation(cfg): ''' ''' transforms = [] if cfg['smallest'] > 0: transforms += [ albumentations.SmallestMaxSize(max_size=cfg['smallest'], p=1.0) ] if cfg.get('random_crop', 0): # transforms += [OneOf([albumentations.RandomCrop(height=1024, width=1024, p=0.8), # albumentations.RandomCrop(height=720, width=720, p=0.8),], p=1.),] if cfg.get('safe_crop', 0): transforms += [ albumentations.RandomSizedBBoxSafeCrop(height=cfg['height'], width=cfg['width'], p=1.) ] else: transforms += [ albumentations.RandomSizedCrop(cfg['min_max_height'], height=cfg['height'], width=cfg['width'], p=1.0) ] if cfg.get('flip', 0): transforms += [albumentations.HorizontalFlip(p=0.5)] transforms += [ albumentations.RandomBrightness(limit=0.2, p=0.3), albumentations.RandomContrast(limit=0.2, p=0.3), albumentations.Blur(blur_limit=5, p=0.2), albumentations.GaussNoise(var_limit=(5, 20), p=0.2), albumentations.ChannelShuffle(p=0.2), ] bbox_params = { 'format': 'pascal_voc', 'min_visibility': cfg['min_visibility'], 'label_fields': ['labels'], 'min_area': cfg['min_area'] } if cfg['bbox'] else {} return Compose(transforms, bbox_params=bbox_params, p=1.)
def aug_train(p=1): return aug.Compose([ aug.HorizontalFlip(p=0.5), aug.OneOf([ aug.Compose([ aug.ShiftScaleRotate(rotate_limit=0, p=1), aug.RandomSizedCrop((88, 128), 128, 128) ]), aug.GridDistortion(num_steps=10, distort_limit=np.random.uniform(0, 0.1), p=1), aug.ShiftScaleRotate(scale_limit=0, rotate_limit=10, p=1) ], p=0.5), aug.OneOf([ aug.RandomBrightness(limit=0.08, p=1), aug.RandomContrast(limit=0.08, p=1), aug.RandomGamma(gamma_limit=(92, 108), p=1) ], p=0.5) ], p=p)
def ISIC2020_get_transforms(image_size, is_training): # https://github.com/haqishen/SIIM-ISIC-Melanoma-Classification-1st-Place-Solution/blob/master/dataset.py if is_training: return 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() ]) else: return albumentations.Compose([ albumentations.Resize(image_size, image_size), albumentations.Normalize() ])
def __init__(self, data, phase_coeff): self.root = data self.folder = os.listdir(self.root) self.folder.sort() self.aug = A.Compose([ A.ShiftScaleRotate(shift_limit=0.15, scale_limit=0.15, rotate_limit=45, interpolation=1, border_mode=4, always_apply=False, p=0.3), A.RandomCrop(220, 220, always_apply=False, p=1.0), A.HorizontalFlip(always_apply=False, p=0.2), A.VerticalFlip(always_apply=False, p=0.2), A.ElasticTransform(alpha=1, sigma=50, alpha_affine=50, interpolation=1, border_mode=4, always_apply=False, p=0.5), A.RandomBrightness(limit=0.2, always_apply=False, p=0.2), A.RandomContrast(limit=0.2, always_apply=False, p=0.2), A.MedianBlur(blur_limit=5, always_apply=False, p=0.2), A.GaussNoise(var_limit=(10, 50), always_apply=False, p=0.2), A.Resize(256, 256), ]) self.phase_coeff = phase_coeff
def strong(img_size): return A.Compose([ A.Resize(img_size, img_size), A.CLAHE(p=1), A.ShiftScaleRotate(p=1), A.RandomBrightness(p=1), A.Blur(blur_limit=11, p=1), A.GaussNoise(var_limit=(100, 150), p=1), A.HorizontalFlip(p=1), A.Cutout(p=1), A.RandomRotate90(p=1), A.Normalize( mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], ), ToTensorV2() ])
def __init__(self, mode=None, resize=224): # assert type(resize) == list, f'resize type is not list ' if mode == 'train_tfms_mask': self.transform = A.Compose([ A.OneOf([ A.Perspective(p=1.0), A.Rotate(limit=20, p=1.0, border_mode=1), ], p=0.5), A.OneOf([ A.RandomBrightness(p=1.0), A.HueSaturationValue(p=1.0), A.RandomContrast(p=1.0), ], p=0.5), A.Compose([ A.Resize(resize, resize), A.Normalize(), ]) ]) elif mode == 'train_age_gender': self.transform = A.Compose([ A.Rotate(limit=20, p=0.5, border_mode=1), A.OneOf( [ A.RandomGridShuffle(grid=(2, 2), p=1.0), # not using for gender # A.RandomGridShuffle(grid=(4, 2), p=1.0), A.Perspective(p=1.0) ], p=0.5), A.GaussNoise(p=0.5), A.Compose([ A.Resize(resize, resize), A.Normalize(), ]) ]) # elif mode = elif mode == 'valid_tfms': self.transform = A.Compose([ A.Resize(resize, resize), A.Normalize(), ])
def __init__(self, cfg): self.cfg = cfg self.data = self.prepare() self.mean = self.cfg.mean self.std = self.cfg.std self.normal_transform = A.Compose([ A.Resize(384, 288, p=1.0), A.HorizontalFlip(p=0.5), A.Normalize(p=1.0, mean=self.mean, std=self.std) ]) self.augment_transform = A.Compose([ A.Resize(384, 288, p=1.0), A.HorizontalFlip(p=0.7), A.GaussNoise(p=0.5), A.ShiftScaleRotate(shift_limit=0.1, scale_limit=0.25, rotate_limit=20, p=0.6, border_mode=0), A.OneOf([ A.CLAHE(p=0.5), A.Compose([ A.RandomBrightness(limit=0.5, p=0.6), A.RandomContrast(limit=0.4, p=0.6), A.RandomGamma(p=0.6), ]) ], p=0.65), A.OneOf([ A.HueSaturationValue(10, 20, 10, p=1.0), A.RGBShift(p=1.0), A.Emboss(p=1.0), ], p=0.5), A.RandomFog(fog_coef_lower=0.3, fog_coef_upper=0.3, p=0.3), A.OneOf([ A.Perspective(p=1.0, scale=(0.05, 0.1)), A.GridDistortion(p=1.0, distort_limit=0.25, border_mode=0), A.OpticalDistortion( p=1.0, shift_limit=0.1, distort_limit=0.1, border_mode=0) ], p=0.65), A.Normalize(p=1.0, mean=self.mean, std=self.std), ])
def get_training_augmentation(min_area=0., min_visibility=0.): train_transform = [ albu.OneOf([ albu.MotionBlur(p=.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(), ], p=0.3), albu.OneOf([ albu.RandomFog(fog_coef_lower=0.1, fog_coef_upper=0.15, p=0.1), albu.RandomShadow(p=0.1), albu.RandomBrightness(limit=0.3, p=0.2), albu.RandomRain(slant_lower=0, slant_upper=8, drop_length=0, blur_value=4, brightness_coefficient=0.8, rain_type='heavy', p=0.1), albu.RandomSunFlare(p=0.2), ]), albu.OneOf([ albu.RGBShift(p=0.1), albu.HueSaturationValue(p=0.3), ]), albu.OneOf( [ albu.HorizontalFlip(p=0.5), #albu.RandomSizedCrop(min_max_height=(720, 1380), height=1380, width=720, interpolation=cv2.INTER_AREA) ], p=0.2) ] return albu.Compose(train_transform, bbox_params={ 'format': 'coco', 'min_area': min_area, 'min_visibility': min_visibility, 'label_fields': ['category_id'] })
def get_dataset(dataset, args): width = height = args.data_shape train_aug = [ A.HorizontalFlip(), A.RandomSizedBBoxSafeCrop(width, height), A.RGBShift(), A.Blur(blur_limit=11), A.RandomBrightness(), A.CLAHE(), A.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5]), ToTensor(), ] val_aug = [ A.Resize(width, height), A.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5]), ToTensor(), ] if dataset.lower() == 'voc': train_dataset = dlcv.data.VOCDetection( root='/home/vismarty/.datasets/VOCdevkit', splits=[(2007, 'trainval'), (2012, 'trainval')], transform=get_transform(train_aug)) val_dataset = dlcv.data.VOCDetection( root='/home/vismarty/.datasets/VOCdevkit', splits=[(2007, 'test')], transform=get_transform(val_aug)) # val_metric = dlcv.utils.metrics.voc_detection.VOC07MApMetric(iou_thresh=0.5, class_names=val_dataset.classes) val_metric = None # elif dataset.lower() == 'coco': # train_dataset = gdata.COCODetection(root=args.dataset_root + "/coco", splits='instances_train2017') # val_dataset = gdata.COCODetection(root=args.dataset_root + "/coco", splits='instances_val2017', skip_empty=False) # val_metric = COCODetectionMetric( # val_dataset, args.save_prefix + '_eval', cleanup=True, # data_shape=(args.data_shape, args.data_shape), post_affine=get_post_transform) # # coco validation is slow, consider increase the validation interval # if args.val_interval == 1: # args.val_interval = 10 else: raise NotImplementedError( 'Dataset: {} not implemented.'.format(dataset)) if args.num_samples < 0: args.num_samples = len(train_dataset) return train_dataset, val_dataset, val_metric
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 make_transforms(phase, mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)): list_transforms = [] if phase == "train": list_transforms.extend([ albu.HorizontalFlip(p=0.5), albu.Rotate(limit=15), albu.RandomContrast(limit=0.2), albu.RandomBrightness(limit=0.2) ]) list_transforms.extend([ albu.Resize(512, 512), Normalize(mean=mean, std=std, p=1), ToTensor(), ]) list_trfms = Compose(list_transforms) return list_trfms
def aug_train(p=1, shift_limit=0.0625, scale_limit=0.1): aug_list = [ aug.HorizontalFlip(p=0.5), aug.VerticalFlip(p=0.5), ShiftScaleRotate(shift_limit=shift_limit, scale_limit=scale_limit, rotate_limit=8, p=0.7), aug.OneOf([ aug.RandomBrightness(limit=0.1, p=1), aug.RandomContrast(limit=0.1, p=1), aug.RandomGamma(gamma_limit=(90, 110), p=1) ], p=0.5), aug.CLAHE(clip_limit=2.0, tile_grid_size=(8, 8), p=0.5) ] return aug.Compose(aug_list, p=p)
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 parse_annotation(annotation, train_input_size, annotation_type): line = annotation.split() image_path = line[0] image = np.array(cv2.imread(image_path)) image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) exist_boxes = True augmentation = al.Compose([ # al.VerticalFlip(p=0.5), # al.HorizontalFlip(p=0.5), # al.RandomRotate90(p=0.5), al.OneOf([ al.GaussNoise(0.002, p=0.5), al.IAAAffine(p=0.5), ], p=0.2), al.OneOf([ al.Blur(blur_limit=(3, 10), p=0.4), al.MedianBlur(blur_limit=3, p=0.3), al.MotionBlur(p=0.3) ], p=0.3), al.OneOf([ al.RandomBrightness(p=0.3), al.RandomContrast(p=0.4), al.RandomGamma(p=0.3) ], p=0.5), al.Cutout(num_holes=20, max_h_size=20, max_w_size=20, p=0.5), ]) bboxes = np.array([ list(map(lambda x: int(float(x)), box.split(','))) for box in line[1:] ]) if annotation_type == 'train': # image, bboxes = random_horizontal_flip(np.copy(image), np.copy(bboxes)) # image, bboxes = random_crop(np.copy(image), np.copy(bboxes)) # image, bboxes = random_translate(np.copy(image), np.copy(bboxes)) augm = augmentation(image=image) image = augm['image'].astype(np.float32) / 255. # image, bboxes = image_preprocess(np.copy(image), [train_input_size, train_input_size], np.copy(bboxes)) return image, bboxes, exist_boxes
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([ self.align_face, albumentations.Resize(self.size, self.size), albumentations.RandomBrightness(limit=0.3, p=0.7), albumentations.RandomContrast(limit=0.3, p=0.7), #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 __init__(self, split): self.split = split self.aug = albumentations.Compose([ albumentations.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)), AT.ToTensor() ]) if self.split == 'train': self.aug = albumentations.Compose([ albumentations.HorizontalFlip(), albumentations.RandomBrightness(), #albumentations.ShiftScaleRotate(rotate_limit=15, scale_limit=0.10), #albumentations.HueSaturationValue(), albumentations.Cutout(1, 4, 4, 0.5), #albumentations.GaussNoise(), #albumentations.ElasticTransform(), albumentations.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)), AT.ToTensor() ])
def __init__(self, tp, fp=None, config=None, mode='train', inv_counts=None): self.tp = tp self.fp = pd.read_csv("../input/rfcxextras/cornell-train.csv") self.fp = self.fp[self.fp.ebird_code < 'c'].reset_index(drop=True) self.fp_root = "../input/birdsong-resampled-train-audio-00/" self.inv_counts = inv_counts self.config = config self.sr = self.config.sr self.total_duration = self.config.total_duration self.duration = self.config.duration self.data_root = self.config.TRAIN_AUDIO_ROOT self.nmels = self.config.nmels self.fmin, self.fmax = 84, self.sr // 2 self.mode = mode self.num_classes = self.config.num_classes self.resampler = torchaudio.transforms.Resample(orig_freq=48_000, new_freq=self.sr) self.mel = torchaudio.transforms.MelSpectrogram(sample_rate=self.sr, n_mels=self.nmels, f_min=self.fmin, f_max=self.fmax, n_fft=2048) self.transform = Compose([ OneOf([GaussianNoiseSNR(min_snr=10), PinkNoiseSNR(min_snr=10)]), TimeShift(sr=self.sr), VolumeControl(p=0.5) ]) self.img_transform = A.Compose([ A.OneOf([ A.Cutout(max_h_size=5, max_w_size=20), A.CoarseDropout(max_holes=4), A.RandomBrightness(p=0.25), ], p=0.5) ]) self.num_splits = self.config.total_duration // self.duration assert self.config.total_duration == self.duration * self.num_splits, "not a multiple"
def get_training_augmentation(): train_transform = [ A.Resize(size[0], size[1], interpolation=1, always_apply=True), #cv2.INTER_LINEAR A.HorizontalFlip(p=0.5), A.ShiftScaleRotate(scale_limit=0.5, rotate_limit=0, shift_limit=0.1, p=1, border_mode=0), A.PadIfNeeded(min_height=size[0], min_width=size[1], always_apply=True, border_mode=0), # A.RandomCrop(height=size[0], width=size[1], always_apply=True), A.IAAAdditiveGaussianNoise(p=0.2), A.IAAPerspective(p=0.5), A.OneOf( [ A.CLAHE(p=1), A.RandomBrightness(p=1), A.RandomGamma(p=1), ], p=0.9, ), A.OneOf( [ A.IAASharpen(p=1), A.Blur(blur_limit=3, p=1), A.MotionBlur(blur_limit=3, p=1), ], p=0.9, ), A.OneOf( [ A.RandomContrast(p=1), A.HueSaturationValue(p=1), ], p=0.9, ), A.Lambda(mask=round_clip_0_1) ] return A.Compose(train_transform)
def get_preprocessing(preprocessing_fn, apply_augmentation=False): """Construct preprocessing transform Args: preprocessing_fn (callable): data normalization function (can be specific for each pretrained neural network) apply_augmentation (boolean): apply data augmentation or not Return: transform: albumentations.Compose """ _transform = [A.Resize(384, 480)] if apply_augmentation: _transform += [ A.HorizontalFlip(p=0.5), A.ShiftScaleRotate(scale_limit=0.5, rotate_limit=0, shift_limit=0.1, p=1, border_mode=0), A.IAAAdditiveGaussianNoise(p=0.2), A.IAAPerspective(p=0.5), A.OneOf( [A.CLAHE(p=1), A.RandomBrightness(p=1), A.RandomGamma(p=1)], p=0.9), A.OneOf([ A.IAASharpen(p=1), A.Blur(blur_limit=3, p=1), A.MotionBlur(blur_limit=3, p=1) ], p=0.9), A.OneOf([A.RandomContrast(p=1), A.HueSaturationValue(p=1)], p=0.9) ] _transform += [ A.Lambda(image=preprocessing_fn), A.Lambda(image=to_CHW, mask=to_CHW) ] return A.Compose(_transform)
def __init__(self, N=2, M=5): ''' Args: N: Number of augmentation transformations to apply sequentially. M: Magnitude for all the transformations. ''' self.N = N self.M = M magnitude = M / 10.0 Identity = A.NoOp(p=1.0) Brightness = A.RandomBrightness(limit=0.5 * magnitude, p=1.0) Contrast = A.RandomContrast(limit=0.5 * magnitude, p=1.0) #Solarize = albu.Solarize(threshold= int(256 * magnitude), p=1.0) #HorizontalFlip = A.HorizontalFlip(p=1.0) Translate = A.ShiftScaleRotate(shift_limit=0.45 * magnitude, scale_limit=0, rotate_limit=0, interpolation=1, border_mode=0, p=1.0) Scale = A.ShiftScaleRotate(shift_limit=0, scale_limit=0.5 * magnitude, rotate_limit=0, interpolation=1, border_mode=0, p=1.0) #Shear = albu.IAAAffine(shear=100, p=1.0) #Perspective = albu.IAAPerspective(scale=(0, 0.3), keep_size=True, p=1.0) Rotate = A.ShiftScaleRotate(shift_limit=0, scale_limit=0, rotate_limit=30 * magnitude, interpolation=1, border_mode=0, p=1.0) self.augment_list = [ Identity, Translate, Scale, Rotate, Brightness, Contrast ]
def train_dataloader(self): hparams = self.hparams augs = [] if hparams.aug_flip: augs.append(albu.HorizontalFlip(p=1.0)) if hparams.aug_brightness: augs.append(albu.RandomBrightness(limit=0.2, p=1.0)) if hparams.aug_randomcrop: aug = albu.RandomSizedBBoxSafeCrop(hparams.img_height, hparams.img_width) augs.append(aug) dataset = TransformDataset( self.train_dataset, albu.Compose( [ *augs, albu.Resize(hparams.img_height // 4, hparams.img_width // 4), albu.ToFloat(255), ToTensorV2(), ], bbox_params=AIEdgeDataset.bbox_params, ), ) if self.hparams.gpus > 1: sampler = data.distributed.DistributedSampler(dataset, shuffle=True) else: sampler = None return data.DataLoader( dataset, batch_size=hparams.batch_size, collate_fn=CollateFn(self.net.stride, hparams, "train"), num_workers=hparams.num_workers, shuffle=(sampler is None), sampler=sampler, pin_memory=(hparams.gpus > 0), drop_last=True, )
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 __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() ])
def augmentation(img_size): return albu.Compose([ #spatial wise #albu.RandomCrop(img_size[0],img_size[1]), albu.RandomResizedCrop(img_size[0],img_size[1], interpolation=cv2.INTER_NEAREST), albu.Rotate(interpolation=cv2.INTER_NEAREST), albu.HorizontalFlip(), albu.ElasticTransform(alpha_affine=10,interpolation=cv2.INTER_NEAREST), albu.OpticalDistortion(interpolation=cv2.INTER_NEAREST), #pixel transform albu.RandomGamma((100,180),p=0.8), albu.Blur(5), albu.RandomBrightness(limit=(0.05,0.20)), albu.RandomContrast(limit=(0,0.20),p=0.5), albu.MotionBlur( blur_limit =7), ])
def minty_transform(p): return albu.Compose([ # Shift, scale, rotate albu.ShiftScaleRotate(rotate_limit=15, scale_limit=(-0.15, 0.1), border_mode=cv2.BORDER_CONSTANT, value=[255, 255, 255], p=0.25), # Noise albu.IAAAdditiveGaussianNoise(p=0.25), # Contrast, brightness albu.OneOf([ albu.RandomGamma(p=1), albu.RandomContrast(p=1), albu.RandomBrightness(p=1) ], p=0.55), # Blur albu.GaussianBlur(p=0.25), ], p=p, additional_targets={'image{}'.format(_) : 'image' for _ in range(1, 101)})
def augmentation(self, images, is_train, info, aug_num): if is_train: output_path = f'{self.output_path}/train' else: output_path = f'{self.output_path}/valid' aug_num = int(aug_num * 0.2) for label in self.label_list: if not os.path.isdir(f'{output_path}/{label}'): os.makedirs(f'{output_path}/{label}') for i in tqdm(range(len(images))): image = images[i] image_name = image.split('/')[-1] label = image.split('/')[-2] cnt = int(math.ceil(aug_num / info[label])) total_images = len(os.listdir(f'{output_path}/{label}')) if total_images <= aug_num: image = cv2.imread(image) transform = A.Resize(224, 224) augmented_image = transform(image=image)['image'] cv2.imwrite(f'{output_path}/{label}/orig_{image_name}', augmented_image) for c in range(cnt): transform = A.Compose([ A.Resize(224, 224, p=1), A.HorizontalFlip(p=0.4), A.VerticalFlip(p=0.3), A.Blur(p=0.1), A.OneOf([ A.RandomContrast(p=0.5, limit=(-0.5, 0.3)), A.RandomBrightness(p=0.5, limit=(-0.2, 0.3)) ], p=0.5) ]) augmented_image = transform(image=image)['image'] cv2.imwrite(f'{output_path}/{label}/aug{c}_{image_name}', augmented_image) return output_path
def get_tr_augmentation(img_size): augmentations = [ albu.HorizontalFlip(p=0.5), albu.ShiftScaleRotate(scale_limit=0.5, rotate_limit=0, shift_limit=0.1, p=1, border_mode=0), albu.PadIfNeeded(min_height=img_size[0], min_width=img_size[1], always_apply=True, border_mode=0), albu.RandomCrop(height=img_size[0], width=img_size[1], always_apply=True), albu.IAAAdditiveGaussianNoise(p=0.2), albu.OneOf( [ albu.CLAHE(p=1), albu.RandomBrightness(p=1), albu.RandomGamma(p=1), ], p=0.9, ), albu.OneOf( [ albu.IAASharpen(p=1), albu.Blur(blur_limit=3, p=1), albu.MotionBlur(blur_limit=3, p=1), ], p=0.9, ), albu.OneOf( [ albu.RandomContrast(p=1), albu.HueSaturationValue(p=1), ], p=0.9, ) ] return augmentations