def test_transform_pipeline_serialization_with_keypoints( seed, image, keypoints, keypoint_format, labels): aug = A.Compose( [ A.OneOrOther( A.Compose([ A.RandomRotate90(), A.OneOf([A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5)]) ]), A.Compose([ A.Rotate(p=0.5), A.OneOf([A.HueSaturationValue(p=0.5), A.RGBShift(p=0.7)], p=1) ]), ), A.SomeOf( n=2, transforms=[ A.HorizontalFlip(p=1), A.Transpose(p=1), A.HueSaturationValue(p=0.5), A.RandomBrightnessContrast(p=0.5), ], replace=False, ), ], keypoint_params={ "format": keypoint_format, "label_fields": ["labels"] }, ) serialized_aug = A.to_dict(aug) deserialized_aug = A.from_dict(serialized_aug) set_seed(seed) aug_data = aug(image=image, keypoints=keypoints, labels=labels) set_seed(seed) deserialized_aug_data = deserialized_aug(image=image, keypoints=keypoints, labels=labels) assert np.array_equal(aug_data["image"], deserialized_aug_data["image"]) assert np.array_equal(aug_data["keypoints"], deserialized_aug_data["keypoints"])
def get_augumentation(phase, width=1024, height=1024, min_area=0., min_visibility=0.): list_transforms = [] if phase == 'train': list_transforms.extend([ albu.augmentations.transforms.LongestMaxSize( max_size=width, always_apply=True), albu.PadIfNeeded(min_height=height, min_width=width, always_apply=True, border_mode=0, value=[0, 0, 0]), albu.augmentations.transforms.RandomResizedCrop( height=height, width=width, p=0.3), albu.augmentations.transforms.Flip(), albu.augmentations.transforms.Transpose(), albu.OneOf([ albu.RandomBrightnessContrast(brightness_limit=0.5, contrast_limit=0.4), albu.RandomGamma(gamma_limit=(50, 150)), albu.NoOp() ]), albu.OneOf([ albu.RGBShift(r_shift_limit=20, b_shift_limit=15, g_shift_limit=15), albu.HueSaturationValue(hue_shift_limit=5, sat_shift_limit=5), albu.NoOp() ]), albu.CLAHE(p=0.8), albu.HorizontalFlip(p=0.5), albu.VerticalFlip(p=0.5), ]) if(phase == 'test' or phase == 'valid'): list_transforms.extend([ albu.Resize(height=height, width=width) ]) list_transforms.extend([ albu.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), p=1), ToTensor() ]) if(phase == 'test'): return albu.Compose(list_transforms) return albu.Compose(list_transforms, bbox_params=albu.BboxParams(format='pascal_voc', min_area=min_area, min_visibility=min_visibility, label_fields=['category_id']))
def train_dataloader(self): aug_pipeline_train = A.Compose([ A.Resize(self.hparams.image_size, self.hparams.image_size, always_apply=True, p=1.0), A.RandomCrop(self.hparams.crop_size, self.hparams.crop_size, always_apply=True, p=1.0), A.HorizontalFlip(p=0.5), A.CoarseDropout(min_holes=1, max_holes=4, max_width=100, max_height=100, min_width=25, min_height=25, p=0.5), A.ShiftScaleRotate(shift_limit=0.1, scale_limit=0.1, rotate_limit=15, border_mode=cv2.BORDER_REFLECT, p=0.5), A.OneOf([A.HueSaturationValue(p=0.5), A.ToGray(p=0.5), A.RGBShift(p=0.5), A.RandomGamma(p=0.5)], p=0.5), A.RandomBrightnessContrast(brightness_limit=0.2, contrast_limit=0.2, p=0.5), A.Normalize(always_apply=True, p=1.0), ToTensorV2(always_apply=True, p=1.0) ], p=1.0) train_dataset = RetinaDataset(os.path.join(self.hparams.path, f'retina_labels_train.csv'), os.path.join(self.hparams.path, f'retina_data_train'), augmentations=aug_pipeline_train, file_type='.jpg', balance_ratio=0.25) sample_weights = [train_dataset.get_weight(i) for i in range(len(train_dataset))] sampler = data.sampler.WeightedRandomSampler(sample_weights, len(train_dataset), replacement=True) train_loader = data.DataLoader(train_dataset, batch_size=self.hparams.batch_size, shuffle=False, sampler=sampler, num_workers=16) return train_loader
def get_data_transforms(self) -> Tuple[A.BasicTransform, A.BasicTransform]: """Get albumentations transform objects for data augmentation. Returns: 1st tuple arg: a transform that doesn't do any data augmentation 2nd tuple arg: a transform with data augmentation """ cfg = self.cfg bbox_params = self.get_bbox_params() base_tfs = [A.Resize(cfg.data.img_sz, cfg.data.img_sz)] if cfg.data.base_transform is not None: base_tfs.append(A.from_dict(cfg.data.base_transform)) base_transform = A.Compose(base_tfs, bbox_params=bbox_params) if cfg.data.aug_transform is not None: aug_transform = A.from_dict(cfg.data.aug_transform) aug_transform = A.Compose([aug_transform, base_transform], bbox_params=bbox_params) return base_transform, aug_transform augmentors_dict = { 'Blur': A.Blur(), 'RandomRotate90': A.RandomRotate90(), 'HorizontalFlip': A.HorizontalFlip(), 'VerticalFlip': A.VerticalFlip(), 'GaussianBlur': A.GaussianBlur(), 'GaussNoise': A.GaussNoise(), 'RGBShift': A.RGBShift(), 'ToGray': A.ToGray() } aug_transforms = [] for augmentor in cfg.data.augmentors: try: aug_transforms.append(augmentors_dict[augmentor]) except KeyError as e: log.warning( '{0} is an unknown augmentor. Continuing without {0}. \ Known augmentors are: {1}'.format( e, list(augmentors_dict.keys()))) aug_transforms.append(base_transform) aug_transform = A.Compose(aug_transforms, bbox_params=bbox_params) return base_transform, aug_transform
def color_transforms(p=0.5): """ Applies RandomGamma or RandomBrightnessContrast random with a probability p. Args: p (float, optional): probability. Defaults to 0.5. Returns: albumentation transforms: transforms. """ return albu.OneOf( [ albu.Compose([ albu.RandomGamma(gamma_limit=(80, 120), p=1), albu.RandomBrightnessContrast( brightness_limit=0.1, # 0.3 contrast_limit=0.1, # 0.3 p=1, ), ]), albu.RGBShift( r_shift_limit=30, g_shift_limit=0, b_shift_limit=30, p=1, ), albu.HueSaturationValue( hue_shift_limit=30, sat_shift_limit=30, val_shift_limit=30, p=1, ), albu.ColorJitter( brightness=0.3, # 0.3 contrast=0.3, # 0.3 saturation=0.3, hue=0.05, p=1, ), ], p=p, )
def test_transform_pipeline_serialization_with_bboxes(seed, image, bboxes, bbox_format, labels): aug = A.Compose( [ A.OneOrOther( A.Compose([A.RandomRotate90(), A.OneOf([A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5)]),]), A.Compose([A.Rotate(p=0.5), A.OneOf([A.HueSaturationValue(p=0.5), A.RGBShift(p=0.7)], p=1),]), ), A.HorizontalFlip(p=1), A.RandomBrightnessContrast(p=0.5), ], bbox_params={"format": bbox_format, "label_fields": ["labels"]}, ) serialized_aug = A.to_dict(aug) deserialized_aug = A.from_dict(serialized_aug) set_seed(seed) aug_data = aug(image=image, bboxes=bboxes, labels=labels) set_seed(seed) deserialized_aug_data = deserialized_aug(image=image, bboxes=bboxes, labels=labels) assert np.array_equal(aug_data["image"], deserialized_aug_data["image"]) assert np.array_equal(aug_data["bboxes"], deserialized_aug_data["bboxes"])
def __init__(self, Normalize_mean_std=None, Rotate=None, HorizontalFlip=False, RGBshift=None, cutout=None): self.transforms = [] if Rotate is not None: self.transforms.append(A.Rotate(Rotate)) if HorizontalFlip: self.transforms.append(A.HorizontalFlip()) if RGBshift is not None: self.transforms.append(A.RGBShift(*RGBshift)) if Normalize_mean_std is not None: self.transforms.append( A.Normalize(Normalize_mean_std[0], Normalize_mean_std[1])) if cutout is not None: self.transforms.append(A.Cutout(*cutout)) self.transforms.append(ToTensor()) self.Transforms = A.Compose(self.transforms)
def test_transform_pipeline_serialization(seed, image, mask): aug = A.Compose([ A.OneOrOther( A.Compose([ A.Resize(1024, 1024), A.RandomSizedCrop(min_max_height=(256, 1024), height=512, width=512, p=1), A.OneOf([ A.RandomSizedCrop(min_max_height=(256, 512), height=384, width=384, p=0.5), A.RandomSizedCrop(min_max_height=(256, 512), height=512, width=512, p=0.5), ]), ]), A.Compose([ A.Resize(1024, 1024), A.RandomSizedCrop(min_max_height=(256, 1025), height=256, width=256, p=1), A.OneOf([A.HueSaturationValue(p=0.5), A.RGBShift(p=0.7)], p=1), ]), ), A.HorizontalFlip(p=1), A.RandomBrightnessContrast(p=0.5), ]) serialized_aug = A.to_dict(aug) deserialized_aug = A.from_dict(serialized_aug) set_seed(seed) aug_data = aug(image=image, mask=mask) set_seed(seed) deserialized_aug_data = deserialized_aug(image=image, mask=mask) assert np.array_equal(aug_data["image"], deserialized_aug_data["image"]) assert np.array_equal(aug_data["mask"], deserialized_aug_data["mask"])
def hard_augmentations(): return A.Compose([ A.RandomRotate90(), A.Transpose(), A.RandomGridShuffle(), A.ShiftScaleRotate(scale_limit=0.1, rotate_limit=45, border_mode=cv2.BORDER_CONSTANT, mask_value=0, value=0), A.ElasticTransform(border_mode=cv2.BORDER_CONSTANT, alpha_affine=5, mask_value=0, value=0), # Add occasion blur A.OneOf([ A.GaussianBlur(), A.GaussNoise(), A.IAAAdditiveGaussianNoise(), A.NoOp() ]), # D4 Augmentations A.OneOf([A.CoarseDropout(), A.MaskDropout(max_objects=10), A.NoOp()]), # Spatial-preserving augmentations: A.OneOf([ A.RandomBrightnessContrast(brightness_by_max=True), A.CLAHE(), A.HueSaturationValue(), A.RGBShift(), A.RandomGamma(), A.NoOp(), ]), # Weather effects A.OneOf([ A.RandomFog(fog_coef_lower=0.01, fog_coef_upper=0.3, p=0.1), A.NoOp() ]), A.Normalize(), ])
def __init__(self, img, data, img_size): """ arguments --------- img : list list of images, in the original size (height, width, 3) data : list of dict Each dict has : 'image' : index of the image. The index should match with img 'mask' : [xx, yy] IMPORTANT : (WIDTH, HEIGHT) 'box' : [[xmin, ymin], [xmax,ymax]] 'size' : the size of the image that the data was created with IMPORTANT : (WIDTH, HEIGHT) img_size : tuple Desired output image size The axes will be swapped to match pygame. IMPORTANT : (WIDTH, HEIGHT) """ self.image = img self.data = data self.n = len(data) self.output_size = img_size self.aug = A.Compose([ A.OneOf([ A.RandomGamma((40, 200), p=1), A.RandomBrightness(limit=0.5, p=1), A.RandomContrast(limit=0.5, p=1), A.RGBShift(40, 40, 40, p=1), A.Downscale(scale_min=0.25, scale_max=0.5, p=1), A.ChannelShuffle(p=1), ], p=0.8), A.InvertImg(p=0.5), A.VerticalFlip(p=0.5), A.RandomRotate90(p=1), A.Resize(img_size[0], img_size[1]), ], ) for datum in data: datum['mask_min'] = np.min(datum['mask'], axis=1) datum['mask_max'] = np.max(datum['mask'], axis=1) + 1
def _random_crop_and_enhance(self, sample): offset = int(self.crop_size / 10) compose = A.Compose([ A.PadIfNeeded(self.crop_size + offset, self.crop_size + offset), A.RandomSizedCrop( (self.crop_size - offset + 10, self.crop_size + offset - 10), self.crop_size, self.crop_size, p=1), A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5), A.RGBShift(), A.Blur(), A.GaussNoise(), A.Normalize(mean=self.mean, std=self.std, p=1) ], additional_targets={ 'image': 'image', 'label': 'mask' }) return compose(**sample)
def setup(self, stage: str): img_files = get_img_files() folds = KFold( n_splits=self.hp.n_splits, random_state=self.hp.seed, shuffle=True, ) train_idx, val_idx = list(folds.split(img_files))[self.hp.fold] self.train_dataset = MaskDataset( img_files[train_idx], transform=A.Compose([ A.RandomResizedCrop( self.hp.img_size, self.hp.img_size, ), A.Rotate(13), A.HorizontalFlip(), A.RandomBrightnessContrast(), A.HueSaturationValue(), A.RGBShift(), A.RandomGamma(), MyCoarseDropout( min_holes=1, max_holes=8, max_height=32, max_width=32, ), ]), ) self.val_dataset = MaskDataset( img_files[val_idx], transform=A.Compose([ A.Resize( self.hp.img_size, self.hp.img_size, ), ]), )
def albumentations_list(MAGN: int = 4): """ Returns standard list of albumentations transforms, each of mangitude `MAGN`. Args: MAGN (int): Magnitude of each transform in the returned list. """ M = MAGN transform_list = [ # PIXEL-LEVEL A.RandomContrast(limit=M * .1, always_apply=True), A.RandomBrightness(limit=M * .1, always_apply=True), A.Equalize(always_apply=True), A.OpticalDistortion(distort_limit=M * .2, shift_limit=M * .1, always_apply=True), A.RGBShift(r_shift_limit=M * 10, g_shift_limit=M * 10, b_shift_limit=M * 10, always_apply=True), A.ISONoise(color_shift=(M * .01, M * .1), intensity=(M * .02, M * .2), always_apply=True), A.RandomFog(fog_coef_lower=M * .01, fog_coef_upper=M * .1, always_apply=True), A.CoarseDropout(max_holes=M * 10, always_apply=True), A.GaussNoise(var_limit=(M, M * 50), always_apply=True), # SPATIAL A.Rotate(always_apply=True), A.Transpose(always_apply=True), A.NoOp(always_apply=True), A.ElasticTransform(alpha=M * .25, sigma=M * 3, alpha_affine=M * 3, always_apply=True), A.GridDistortion(distort_limit=M * .075, always_apply=True) ] return transform_list
def _aug_image(self, instance): image_name = instance['filename'] image = cv2.imread(image_name) # RGB image if image is None: print('Cannot find ', image_name) image = image[:, :, ::-1] # RGB image image_h, image_w, _ = image.shape image, new_w, new_h = minmaxresize(image, self.min_net_size, self.max_net_size) # determine the amount of scaling and cropping dw = image_w - (self.jitter * image_w) dh = image_h - (self.jitter * image_h) all_objs = correct_bounding_boxes(instance['object'], new_w, new_h, new_w, new_h, 0, 0, 0, image_w, image_h) # alabumentation setup annotations = {'image': image, 'bboxes': [], 'category_id': []} for ann in all_objs: annotations['category_id'].append( self.names_to_labels[ann['name']]) annotations['bboxes'].append( [ann['xmin'], ann['ymin'], ann['xmax'], ann['ymax']]) aug = albumentations.Compose( [ albumentations.RGBShift(), albumentations.HorizontalFlip(), # albumentations.ShiftScaleRotate(scale_limit=1.), albumentations.CLAHE(), albumentations.RandomGamma(), ], bbox_params={ 'format': 'pascal_voc', 'label_fields': ['category_id'] }) augmented = aug(**annotations) return augmented
def get_medium_augmentations(image_size): return A.Compose([ A.OneOf([ A.ShiftScaleRotate(shift_limit=0.05, scale_limit=0.1, rotate_limit=15, border_mode=cv2.BORDER_CONSTANT, value=0), A.OpticalDistortion(distort_limit=0.11, shift_limit=0.15, border_mode=cv2.BORDER_CONSTANT, value=0), A.NoOp() ]), ZeroTopAndBottom(p=0.3), A.RandomSizedCrop(min_max_height=(int(image_size[0] * 0.75), image_size[0]), height=image_size[0], width=image_size[1], p=0.3), A.OneOf([ A.RandomBrightnessContrast(brightness_limit=0.5, contrast_limit=0.4), IndependentRandomBrightnessContrast(brightness_limit=0.25, contrast_limit=0.24), A.RandomGamma(gamma_limit=(50, 150)), A.NoOp() ]), A.OneOf([ FancyPCA(alpha_std=4), A.RGBShift(r_shift_limit=20, b_shift_limit=15, g_shift_limit=15), A.HueSaturationValue(hue_shift_limit=5, sat_shift_limit=5), A.NoOp() ]), A.OneOf([ChannelIndependentCLAHE(p=0.5), A.CLAHE(), A.NoOp()]), A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5) ])
def get_transforms(size: int, scope: str = 'geometric', crop='random'): augs = {'strong': albu.Compose([albu.HorizontalFlip(), albu.ShiftScaleRotate(shift_limit=0.0, scale_limit=0.2, rotate_limit=20, p=.4), albu.ElasticTransform(), albu.OpticalDistortion(), albu.OneOf([ albu.CLAHE(clip_limit=2), albu.IAASharpen(), albu.IAAEmboss(), albu.RandomBrightnessContrast(), albu.RandomGamma() ], p=0.5), albu.OneOf([ albu.RGBShift(), albu.HueSaturationValue(), ], p=0.5), ]), 'weak': albu.Compose([albu.HorizontalFlip(), ]), 'geometric': albu.OneOf([albu.HorizontalFlip(always_apply=True), albu.ShiftScaleRotate(always_apply=True, scale_limit=.5, rotate_limit=30), albu.Transpose(always_apply=True), albu.OpticalDistortion(always_apply=True, distort_limit=0.1, shift_limit=0.1), albu.ElasticTransform(always_apply=True), ]), 'empty': NoOp(), } aug_fn = augs[scope] crop_fn = {'random': albu.RandomCrop(size, size, always_apply=True), 'center': albu.CenterCrop(size, size, always_apply=True)}[crop] pad = albu.PadIfNeeded(size, size) pipeline = albu.Compose([aug_fn, crop_fn, pad]) def process(a): r = pipeline(image=a) return r['image'] return process
def __init__(self, img, data, img_size): """ arguments --------- img : list list of images, in the original size (height, width, 3) data : list of dict Each dict has : 'image' : index of the image. The index should match with img 'mask' : [rr, cc] 'box' : [[xmin, ymin], [xmax,ymax]] 'size' : the size of the image that the data was created with IMPORTANT : (WIDTH, HEIGHT) img_size : tuple Desired output image size The axes will be swapped to match pygame. IMPORTANT : (WIDTH, HEIGHT) """ self.img = img self.data = data self.n = len(data) self.output_size = img_size self.aug = A.Compose( [ A.OneOf([ A.RandomGamma((40, 200), p=1), A.RandomBrightness(limit=0.5, p=1), A.RandomContrast(limit=0.5, p=1), A.RGBShift(p=1), ], p=0.8), A.VerticalFlip(p=0.5), A.RandomRotate90(p=1), A.Resize(img_size[1], img_size[0]), ], bbox_params=A.BboxParams(format='albumentations', label_fields=['bbox_classes']), keypoint_params=A.KeypointParams(format='xy'), )
def __init__(self, opt): super(Dataset3D, self).__init__() self.opt = opt self.augs = A.Compose([ A.LongestMaxSize(max(self.opt.input_h, self.opt.input_w), always_apply=True), A.PadIfNeeded(self.opt.input_h, self.opt.input_w, border_mode=cv2.BORDER_CONSTANT, value=[0, 0, 0]), A.Blur(blur_limit=(4, 8), p=0.1), # A.ShiftScaleRotate(shift_limit=0.2, scale_limit=(-0.4, 0.2), rotate_limit=0, # border_mode=cv2.BORDER_CONSTANT, value=(0, 0, 0), p=0.8), A.OneOf([ A.RandomBrightnessContrast(always_apply=True), A.RandomGamma(gamma_limit=(60, 140), always_apply=True), # A.CLAHE(always_apply=True) ], p=0.5), A.OneOf([ A.RGBShift(), A.HueSaturationValue(), A.ToGray() ], p=0.1) ], keypoint_params=A.KeypointParams(format='xy', remove_invisible=False) )
def blur_and_distortion(self, kernel_size=(3, 3)): # Blur & Distortion return A.Compose( [ A.OneOf( [ # Blur the input image using a random-sized kernel. A.Blur(blur_limit=kernel_size, p=self.p), # Apply motion blur to the input image using a random-sized kernel. A.MotionBlur(blur_limit=kernel_size, p=self.p), # Blur the input image using using a median filter with a random aperture linear size. A.MedianBlur(blur_limit=kernel_size, p=self.p), # Blur the input image using using a Gaussian filter with a random kernel size. A.GaussianBlur(blur_limit=kernel_size, p=self.p) ], p=1), A.OneOf( [ A.RandomGamma(gamma_limit=(80, 120), p=self.p), A.OpticalDistortion( distort_limit=0.05, shift_limit=0.05, p=self.p), A.ElasticTransform(p=self.p), # Randomly change hue, saturation and value of the input image. A.HueSaturationValue(p=self.p), # Randomly shift values for each channel of the input RGB image. A.RGBShift(p=self.p), # Randomly rearrange channels of the input RGB image. # A.ChannelShuffle(p=self.p), # Apply Contrast Limited Adaptive Histogram Equalization to the input image. A.CLAHE(p=self.p), # Invert the input image by subtracting pixel values from 255. A.InvertImg(p=self.p), ], p=1), # Apply gaussian noise to the input image. A.GaussNoise(var_limit=(10.0, 50.0), mean=0, p=self.p), # Simulates shadows for the image A.RandomShadow(p=self.p), ], p=1)
def augment_image(self, image, annotations): annotation = { 'image': image, 'bboxes': annotations[:, :4], 'category_id': annotations[:, 4] } aug = self.get_aug([ A.VerticalFlip(), A.HorizontalFlip(), A.RGBShift(), A.Blur(), A.GaussNoise(), ]) augmented = aug(**annotation) image = augmented['image'] annotations[:, :4] = augmented['bboxes'] annotations[:, 4] = augmented['category_id'] return image, annotations
def _aug(config): global _augmentor if _augmentor is None: _augmentor = A.Compose( [ A.VerticalFlip(p=0.4), A.RandomSizedBBoxSafeCrop(width=config.IMAGE_WIDTH, height=config.IMAGE_HEIGHT, erosion_rate=0.0, p=0.4), A.RGBShift(p=0.4), A.Blur(blur_limit=7, p=0.4), A.RandomBrightness(p=0.4), ], bbox_params={ 'format': 'coco', 'min_area': 0, 'min_visibility': 0, 'label_fields': ['labels'] }, p=0.4) return _augmentor
def main(): image = cv2.imread("cuiyan.png") image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) def visualize(image): plt.figure(figsize=(6, 6)) plt.axis("off") plt.imshow(image) # plt.show() transform = A.Compose([ A.RandomCrop(111, 222), A.OneOf([A.RGBShift(), A.HueSaturationValue()]), ]) random.seed(42) transformed = transform(image=image) visualize(transformed["image"]) A.save(transform, "./transform.json") A.save(transform, "./transform.yml", data_format="yaml") pprint.pprint(A.to_dict(transform))
def get_data(data_dir, voc_type, max_len, num_samples, height, width, batch_size, workers, is_train, keep_ratio, augment=False): transform = albu.Compose([ albu.RGBShift(p=0.5), albu.RandomBrightnessContrast(p=0.5), albu.OpticalDistortion(distort_limit=0.1, shift_limit=0.1, p=0.5) ]) if augment else None if isinstance(data_dir, list): dataset = ConcatDataset([ LmdbDataset(data_dir_, voc_type, max_len, num_samples, transform) for data_dir_ in data_dir ]) else: dataset = LmdbDataset(data_dir, voc_type, max_len, num_samples, transform) print('total image: ', len(dataset)) data_loader = DataLoader(dataset, batch_size=batch_size, num_workers=workers, shuffle=is_train, pin_memory=True, drop_last=is_train, collate_fn=AlignCollate(imgH=height, imgW=width, keep_ratio=keep_ratio)) return dataset, data_loader
def __init__(self): self.img_transforms = A.Compose( [ A.Resize(224, 224), A.RGBShift(), A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.2), A.ChannelShuffle(0.2), A.ColorJitter(p=0.5), A.Cutout(num_holes=3, max_h_size=24, max_w_size=24, fill_value=0, always_apply=False, 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=224, min_width=224, always_apply=True, border_mode=0), A.IAAAdditiveGaussianNoise(p=0.2), A.IAAPerspective(p=0.5), A.RandomBrightnessContrast(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.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)), ToTensorV2(), ])
def test_force_apply(): """ Unit test for https://github.com/albu/albumentations/issues/189 """ aug = A.Compose([ A.OneOrOther( A.Compose([ A.RandomSizedCrop(min_max_height=(256, 1025), height=512, width=512, p=1), A.OneOf([ A.RandomSizedCrop(min_max_height=(256, 512), height=384, width=384, p=0.5), A.RandomSizedCrop(min_max_height=(256, 512), height=512, width=512, p=0.5), ]), ]), A.Compose([ A.RandomSizedCrop(min_max_height=(256, 1025), height=256, width=256, p=1), A.OneOf([A.HueSaturationValue(p=0.5), A.RGBShift(p=0.7)], p=1), ]), ), A.HorizontalFlip(p=1), A.RandomBrightnessContrast(p=0.5), ]) res = aug(image=np.zeros((1248, 1248, 3), dtype=np.uint8)) assert res["image"].shape[0] in (256, 384, 512) assert res["image"].shape[1] in (256, 384, 512)
def get_training_pipeline(image_size, crop_size, strength=0): if strength == 0: return A.Compose([ A.Resize(image_size, image_size, always_apply=True, p=1.0), A.RandomCrop(crop_size, crop_size, always_apply=True, p=1.0), A.HorizontalFlip(p=0.5), A.CoarseDropout(min_holes=1, max_holes=3, max_width=75, max_height=75, min_width=25, min_height=25, p=0.3), A.ShiftScaleRotate(shift_limit=0.1, scale_limit=0.3, rotate_limit=45, border_mode=cv2.BORDER_CONSTANT, value=0, p=0.5), A.OneOf([ A.HueSaturationValue(p=0.5), A.ToGray(p=0.5), A.RGBShift(p=0.5) ], p=0.3), A.OneOf([ A.RandomBrightnessContrast(brightness_limit=0.1, contrast_limit=0.2), A.RandomGamma() ], p=0.5), A.Normalize(always_apply=True, p=1.0), ToTensorV2(always_apply=True, p=1.0) ], p=1.0) else: return None
def get_albumentations_train_transforms(): return A.Compose( [ A.RandomSizedCrop( min_max_height=(600, 800), height=1024, width=1024, p=0.5), A.OneOf([ A.HueSaturationValue(hue_shift_limit=20, sat_shift_limit=30, val_shift_limit=20, p=1.0), A.RandomBrightnessContrast( brightness_limit=0.2, contrast_limit=0.2, p=1.0), ], p=0.8), A.OneOf( [ A.RGBShift(p=1.0), A.CLAHE(p=1.0), # internal logic is rgb order A.RandomGamma(p=1.0), ], p=0.4), # A.CLAHE(p=0.3), A.ToGray(p=0.01), A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5), A.RandomRotate90(p=0.5), A.Cutout(num_holes=8, max_h_size=64, max_w_size=64, fill_value=(124, 117, 104), p=0.5), # rgb order ], p=1.0, bbox_params=A.BboxParams(format='coco', min_area=4, min_visibility=0.01, label_fields=['category_id']))
def make_augmentation(output_size, is_validation): aug = None if is_validation: aug = get_aug([ A.Resize(width=output_size[0], height=output_size[1], always_apply=True), A.Normalize(), ], min_visibility=0.1) else: aug = get_aug([ A.RGBShift(p=0.1), A.OneOf([ A.RandomBrightnessContrast(p=0.5), A.HueSaturationValue(), A.RandomGamma(p=0.25), A.RandomBrightness(p=0.25), A.Blur(blur_limit=2, p=0.25), ], p=0.01), A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.05), A.ShiftScaleRotate(shift_limit=0.1, scale_limit=0.05, rotate_limit=15, border_mode=0, p=0.2, value=(144.75479165, 137.70713403, 129.666091), mask_value=0.0), A.Resize(width=output_size[0], height=output_size[1], always_apply=True), A.Normalize(), ], min_visibility=0.1) return aug
def augment(img_size, mean=[0.5]*3, std=[0.5]*3): aug_seq1 = A.OneOf([ A.HorizontalFlip(p=1.0), A.VerticalFlip(p=1.0), A.Transpose(p=1.0), ], p=1.0) aug_seq2 = A.OneOf([ # A.RandomGamma(always_apply=False, p=1.0, gamma_limit=(80, 120), eps=1e-07), A.RandomBrightnessContrast(always_apply=False, p=1.0, brightness_limit=(-0.2, 0.2), contrast_limit=(-0.2, 0.2), brightness_by_max=True), ], p=1.0) aug_seq3 = A.OneOf([ A.RGBShift(always_apply=False, p=1.0, r_shift_limit=(-10, 10), g_shift_limit=(-10, 10), b_shift_limit=(-10, 10)), A.HueSaturationValue(always_apply=False, p=1.0, hue_shift_limit=(-4, 4), sat_shift_limit=(-30, 30), val_shift_limit=(-20, 20)), ], p=1.0) aug_seq4 = A.OneOf([ A.MultiplicativeNoise(always_apply=False, p=1.0, multiplier=( 0.8999999761581421, 1.100000023841858), per_channel=True, elementwise=True), A.MotionBlur(always_apply=False, p=1.0, blur_limit=(3, 7)), A.GaussNoise(always_apply=False, p=1.0, var_limit=(10.0, 50.0)), A.Blur(always_apply=False, p=1.0, blur_limit=(3, 7)), ], p=1.0) aug_seq = A.Compose([ A.Resize(img_size, img_size), aug_seq1, aug_seq2, aug_seq3, aug_seq4, A.Normalize(mean=mean, std=std), # A.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]), ]) return aug_seq
def hard_augmentations(mask_dropout=True) -> List[A.DualTransform]: return [ # D4 Augmentations A.RandomRotate90(p=1), A.Transpose(p=0.5), # Spatial augmentations A.OneOf( [ A.ShiftScaleRotate(scale_limit=0.2, rotate_limit=45, border_mode=cv2.BORDER_REFLECT101), A.ElasticTransform(border_mode=cv2.BORDER_REFLECT101, alpha_affine=5), ] ), # Color augmentations A.OneOf( [ A.RandomBrightnessContrast(brightness_by_max=True), A.CLAHE(), A.FancyPCA(), A.HueSaturationValue(), A.RGBShift(), A.RandomGamma(), ] ), # Dropout & Shuffle A.OneOf( [ A.RandomGridShuffle(), A.CoarseDropout(), A.MaskDropout(max_objects=2, mask_fill_value=0) if mask_dropout else A.NoOp(), ] ), # Add occasion blur A.OneOf([A.GaussianBlur(), A.GaussNoise(), A.IAAAdditiveGaussianNoise()]), # Weather effects A.RandomFog(fog_coef_lower=0.01, fog_coef_upper=0.3, p=0.1), ]