def __init__(self, data_root='data', split_file='', size=(256, 256), fold=0, resize=False): self.data_root = data_root pkl_data = pickle.load(open(split_file, 'rb')) if fold == -1: self.path_list = pkl_data[0]['train'] self.path_list.extend(pkl_data[0]['val']) else: self.path_list = pkl_data[fold]['train'] self.len = len(self.path_list) if resize: self.transforms = Compose([Resize(height=size[0], width=size[1], interpolation=cv2.INTER_NEAREST), ShiftScaleRotate(shift_limit=0.1, scale_limit=0.2, rotate_limit=20, p=0.7, border_mode=cv2.BORDER_CONSTANT, value=0), HorizontalFlip(p=0.5), OneOf([ElasticTransform(p=1, alpha=50, sigma=30, alpha_affine=30, border_mode=cv2.BORDER_CONSTANT, value=0), OpticalDistortion(p=1, distort_limit=0.5, shift_limit=0.1, border_mode=cv2.BORDER_CONSTANT, value=0)], p=0.5), RandomGamma(gamma_limit=(80, 120), p=0.5), GaussNoise(var_limit=(0.02, 0.1), mean=0, p=0.5) ]) else: self.transforms = Compose([LongestMaxSize(max_size=max(size)), PadIfNeeded(min_height=size[0], min_width=size[1], value=0, border_mode=cv2.BORDER_CONSTANT), ShiftScaleRotate(shift_limit=0.1, scale_limit=0.2, rotate_limit=20, p=0.7, border_mode=cv2.BORDER_CONSTANT, value=0), HorizontalFlip(p=0.5), OneOf([ElasticTransform(p=1, alpha=50, sigma=30, alpha_affine=30, border_mode=cv2.BORDER_CONSTANT, value=0), OpticalDistortion(p=1, distort_limit=0.5, shift_limit=0.1, border_mode=cv2.BORDER_CONSTANT, value=0)], p=0.5), RandomGamma(gamma_limit=(80, 120), p=0.5), GaussNoise(var_limit=(0.02, 0.1), mean=0, p=0.5) ])
def get_augmentations(): crop_p = 0.4 blur_p = 0.4 distort1_p = 0.2 distort2_p = 0.4 flip_p = 0.4 crop = RandomSizedCropAlbuAug(crop_p) gauss_blur = GaussianBlurAug(p=blur_p, kernel_sizes=range(7, 16, 2)) motion_blur = MotionBlurAug(p=blur_p, kernel_sizes=(3, 5)) optical_distort = AlbuAug( OpticalDistortion(p=distort1_p, distort_limit=1, shift_limit=0.5)) grid_distort = AlbuAug(GridDistortion(p=distort1_p)) elastic1 = AlbuAug( ElasticTransform(p=distort2_p, alpha=40, sigma=90 * 0.05, alpha_affine=90 * 0.05)) elastic2 = AlbuAug(ElasticTransform(p=distort1_p)) blur_aug = PickOne([gauss_blur, motion_blur]) distort_aug = PickOne([optical_distort, grid_distort, elastic1, elastic2]) flip_aug = FlipAug(p=flip_p) return ApplyAll([crop, blur_aug, distort_aug, flip_aug])
def augment(patch_size=patch_size): return Compose([ VerticalFlip(p=.5), HorizontalFlip(p=.5), HueSaturationValue(hue_shift_limit=(-15, 15), sat_shift_limit=0, val_shift_limit=0, p=.5), HueSaturationValue(hue_shift_limit=(-10, 10), sat_shift_limit=(-20, 20), val_shift_limit=0, p=.5), Rotate(limit=(0, 359), p=.5, border_mode=cv2.BORDER_CONSTANT), RandomBrightnessContrast(brightness_limit=0.15, contrast_limit=0.1, always_apply=False, p=0.5), ElasticTransform(always_apply=True, approximate=True, alpha=20, sigma=10, alpha_affine=0, border_mode=cv2.BORDER_CONSTANT), GridDistortion(num_steps=16, distort_limit=0.5, border_mode=cv2.BORDER_CONSTANT, always_apply=False, p=0.5), ])
def augmentation(image, mask, noise=False, transform=False, clahe=True, r_bright=True, r_gamma=True): aug_list = [ VerticalFlip(p=0.5), HorizontalFlip(p=0.5), RandomRotate90(p=0.5), ] if r_bright: aug_list += [RandomBrightnessContrast(p=.5)] if r_gamma: aug_list += [RandomGamma(p=.5)] if clahe: aug_list += [CLAHE(p=1., always_apply=True)] if noise: aug_list += [GaussNoise(p=.5, var_limit=1.)] if transform: aug_list += [ ElasticTransform(p=.5, sigma=1., alpha_affine=20, border_mode=0) ] aug = Compose(aug_list) augmented = aug(image=image, mask=mask) image_heavy = augmented['image'] mask_heavy = augmented['mask'] return image_heavy, mask_heavy
def aug_with_crop(width=640, height=480, crop_prob=1): return Compose( [ # RandomCrop(width=480, height=640, p=crop_prob), HorizontalFlip(p=0.5), VerticalFlip(p=0.5), RandomRotate90(p=0.5), Transpose(p=0.5), ShiftScaleRotate( shift_limit=0.01, scale_limit=0.04, rotate_limit=0, p=0.25), RandomBrightnessContrast(p=0.5), RandomGamma(p=0.25), IAAEmboss(p=0.25), Blur(p=0.01, blur_limit=3), OneOf([ ElasticTransform(p=0.5, alpha=120, sigma=120 * 0.05, alpha_affine=120 * 0.03), GridDistortion(p=0.5), OpticalDistortion(p=1, distort_limit=2, shift_limit=0.5) ], p=0.8) ], p=1)
def __init__(self, df, image_idx, mode='train'): self.imglist = df['image_path'].values self.labellist = df['label'].values self.index = image_idx self.mode = mode self.train_transformation = Compose([ # RandomRotate90(), GridDistortion(p=0.6), HorizontalFlip(p=0.6), ElasticTransform(alpha=1, sigma=25, alpha_affine=50, p=0.75), OneOf([ IAAAdditiveGaussianNoise(), GaussNoise(), ], p=0.5), Cutout(num_holes=30, max_h_size=9, max_w_size=11, fill_value=128, p=0.75), ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.15, rotate_limit=15, p=0.75), # Normalize(), # ToTensor(), ]) self.valid_transformation = Compose([ # Normalize(), # ToTensor(), ])
def train_transform(upside_down=False): return Compose( [ Resize(202, 202, interpolation=cv2.INTER_NEAREST), PadIfNeeded(min_height=SIZE, min_width=SIZE, border_mode=cv2.BORDER_REPLICATE), VerticalFlip(p=int(upside_down)), HorizontalFlip(p=0.5), Cutout(p=0.5, num_holes=5, max_h_size=5, max_w_size=5), OneOf([ Blur(), IAAAdditiveGaussianNoise(), ], p=0.1), ElasticTransform( p=0.25, alpha=1, sigma=30, # TODO alpha_affine=30), # TODO ShiftScaleRotate( p=0.25, rotate_limit=.15, # TODO shift_limit=.15, # TODO scale_limit=.15, # TODO interpolation=cv2.INTER_CUBIC, #border_mode=cv2.BORDER_REFLECT_101), border_mode=cv2.BORDER_REPLICATE), Normalize(), ], p=1)
def get_augmenter(p=1.0): return Compose([ ElasticTransform( p=0.8, alpha_affine=10, border_mode=cv2.BORDER_REPLICATE), RandomGamma(p=0.8, gamma_limit=(50, 150)), ], p=p)
def mask_transformation(mask): """ To simulate the deformation noise. affine transform + non-rigid deformations(TPS) + dilation This is from paper: `during offline training we generate input masks by deforming the annotated masks via affine transformation as well as non-rigid deformations via thin-plate splines [4], followed by a coarsening step (dilation morphological operation) to remove details of the object contour. ` :param mask: np.array of shape (h, w) :return: np.array of shape (h, w) after deformation noise. """ aug = Compose([ # add another mask transformation ? IAAPiecewiseAffine(p=0.4), # affine + non-rigid deformation ElasticTransform(p=0.6, alpha=50, sigma=50, alpha_affine=20, border_mode=cv2.BORDER_CONSTANT, always_apply=True), ]) augmented = aug(image=mask) mask = augmented['image'] kernel = np.ones((5, 5), np.uint8) mask = cv2.dilate(mask, kernel, iterations=random.randrange(1, 10)) return mask
def box_segmentation_aug(): return Compose([ OneOf([ RandomBrightnessContrast(brightness_limit=0.2, p=0.5), RandomGamma(gamma_limit=50, p=0.5), ChannelShuffle(p=0.5) ]), OneOf([ ImageCompression(quality_lower=0, quality_upper=20, p=0.5), MultiplicativeNoise(multiplier=(0.3, 0.8), elementwise=True, per_channel=True, p=0.5), Blur(blur_limit=(15, 15), p=0.5) ]), OneOf([ CenterCrop(height=1000, width=1000, p=0.1), RandomGridShuffle(grid=(3, 3), p=0.2), CoarseDropout(max_holes=20, max_height=100, max_width=100, fill_value=53, p=0.2) ]), OneOf([ GridDistortion(p=0.5, num_steps=2, distort_limit=0.2), ElasticTransform(alpha=157, sigma=80, alpha_affine=196, p=0.5), OpticalDistortion(distort_limit=0.5, shift_limit=0.5, p=0.5) ]), OneOf([ VerticalFlip(p=0.5), HorizontalFlip(p=0.5), Rotate(limit=44, p=0.5) ]) ])
def __init__(self, root_dir= r"C:\Users\Indy-Windows\Desktop\carvana\carvana\data\train", transform=None, image_size=(512, 512)): #Initialize Directory Tree from current working directory if no directory is provided self.root_dir = root_dir self.img_dir = os.path.join(self.root_dir, 'images') self.mask_dir = os.path.join(self.root_dir, 'masks') self.img_transform = transform self.num_img = len(os.listdir(self.img_dir)) self.num_mask = len(os.listdir(self.mask_dir)) self.img_list = os.listdir(self.img_dir) self.mask_list = os.listdir(self.mask_dir) self.image_height = image_size[1] self.image_width = image_size[0] self.transform = transform self.album_transform = Compose([ HorizontalFlip(), ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=0.2), OneOf([ ElasticTransform(p=.2), IAAPerspective(p=.35), ], p=.35) ]) if self.transform == None: self.transform = self.album_transform
def initialize_elements(self): self.using_roi = hasattr(self.params, "roi_crop") self.resizer = self.plain_resize if hasattr(self.params, "random_crop_scale"): self.resizer = RandomResizedCrop( height=self.params.default_height, width=self.params.default_width, scale=self.params.random_crop_scale, ratio=self.params.random_crop_ratio) if self.using_roi: self.roi_resize = Resize(height=self.params.roi_height, width=self.params.roi_width) starting_aug = [Rotate(limit=15), HorizontalFlip(p=0.5)] heavy_aug = [ # RandomGamma(p=0.1), ElasticTransform(p=0.1, alpha=120, sigma=120 * 0.05, alpha_affine=120 * 0.03), GaussNoise(p=0.05), GaussianBlur(p=0.05) ] if self.params.data_augmentation == constants.heavy_augmentation: starting_aug.extend(heavy_aug) self.aug = Compose(starting_aug)
def test_elastic_transform_interpolation(monkeypatch, interpolation): image = np.random.randint(low=0, high=256, size=(100, 100, 3), dtype=np.uint8) mask = np.random.randint(low=0, high=2, size=(100, 100), dtype=np.uint8) monkeypatch.setattr( 'albumentations.augmentations.transforms.ElasticTransform.get_params', lambda *_: {'random_state': 1111}) aug = ElasticTransform(alpha=1, sigma=50, alpha_affine=50, interpolation=interpolation, p=1) data = aug(image=image, mask=mask) expected_image = F.elastic_transform_fast( image, alpha=1, sigma=50, alpha_affine=50, interpolation=interpolation, border_mode=cv2.BORDER_REFLECT_101, random_state=np.random.RandomState(1111)) expected_mask = F.elastic_transform_fast( mask, alpha=1, sigma=50, alpha_affine=50, interpolation=cv2.INTER_NEAREST, border_mode=cv2.BORDER_REFLECT_101, random_state=np.random.RandomState(1111)) assert np.array_equal(data['image'], expected_image) assert np.array_equal(data['mask'], expected_mask)
def medium_aug(p=1.0): return Compose( [ HorizontalFlip(p=0.5), ShiftScaleRotate(p=0.75, shift_limit=0.1, scale_limit=0.2, rotate_limit=45, border_mode=cv2.BORDER_CONSTANT), RandomBrightnessContrast( brightness_limit=0.6, contrast_limit=0.6, p=0.5), OneOf([ HueSaturationValue(p=1.0), RGBShift(p=1.0), ChannelShuffle(p=1.0) ], p=0.5), OneOf([ Blur(p=1.0), MedianBlur(p=1.0), MotionBlur(p=1.0), ], p=0.3), OneOf([GridDistortion(p=1.0), ElasticTransform(p=1.0)], p=0.3), OneOf([ CLAHE(p=1.0), IAASharpen(p=1.0), ], p=0.3), IAAAdditiveGaussianNoise(p=0.5) # ToGray(p=1.0), ], p=p)
def __init__(self, root_dir, annotation_lines, class_number, transform=None, loader=default_loader): self.annotation_lines = annotation_lines self.class_number = class_number self.transform = transform self.loader = loader self.root_dir = root_dir curr_size = 512 min_max_height = (curr_size - curr_size // 2, curr_size - 1) self.transform_strong = Compose([ RandomSizedCrop(min_max_height=min_max_height, height=curr_size, width=curr_size, p=1.0), OneOf([ Transpose(p=0.5), HorizontalFlip(p=0.5), VerticalFlip(p=0.5), Rotate(p=0.5), ], p=1.0), ElasticTransform(alpha=curr_size, sigma=curr_size * 0.05, alpha_affine=10, p=1.0) ])
def train_pipeline(cache, mask_db, path): image, mask = read_image_and_mask_cached(cache, mask_db, (101, 101), path) args = Compose([ LabelMaskBorder(), HorizontalFlip(p=0.5), OneOf([ ShiftScaleRotate(rotate_limit=15, border_mode=cv2.BORDER_REPLICATE), RandomSizedCrop(min_max_height=(70, 100), height=101, width=101) ], p=0.2), GaussNoise(p=0.2), OneOf([ RandomBrightness(limit=0.4), RandomGamma(), ], p=0.5), OneOf([Blur(), MedianBlur(), MotionBlur()], p=0.2), OneOf([ ElasticTransform(alpha=10, sigma=10, alpha_affine=10), GridDistortion() ], p=0.2), Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]), PadIfNeeded(128, 128, cv2.BORDER_REPLICATE), ChannelsFirst() ])(image=image, mask=mask) return args['image'], args.get('mask')
def strong_aug(p=1): return Compose( [ HorizontalFlip(p=0.5), OneOf([ RandomCrop(94, 94, p=0.6), ShiftScaleRotate(shift_limit=(0.1, 0.1), scale_limit=(0.05, 0.05), rotate_limit=10, p=0.4), ], p=0.6), OneOf([ ElasticTransform(p=0.2, alpha=120, sigma=120 * 0.05, alpha_affine=120 * 0.03), IAAPiecewiseAffine(p=.4), GridDistortion(p=0.4), ], p=.4), OneOf( [ # CLAHE(clip_limit=2), RandomGamma((90, 110)), IAAEmboss((0.1, 0.4), (0.1, 0.6)), RandomContrast(0.1), RandomBrightness(0.1), ], p=0.5), ], p=p)
def train_transform(p=1): return Compose([ HorizontalFlip(p=0.5), OneOf([ RandomSizedCrop((92, 98), 101, 101, p=0.6), ShiftScaleRotate(shift_limit=(0, 0.1), scale_limit=(0, 0.05), rotate_limit=10, p=0.4), ], p=0.6), #OneOf([ # IAAAdditiveGaussianNoise(), #may by # GaussNoise(),#may by #], p=0.2), #OneOf([ # MotionBlur(p=0.2), # MedianBlur(blur_limit=3, p=0.3), # Blur(blur_limit=3, p=0.5), #], p=0.4), OneOf([ ElasticTransform(p=0.2, alpha=120, sigma=120 * 0.05, alpha_affine=120 * 0.03), IAAPiecewiseAffine(p=.4), GridDistortion(p=0.4), ], p=.4), OneOf([ #CLAHE(clip_limit=2), RandomGamma((90,110)), ShiftBrightness((5, 20)), IAAEmboss((0.1, 0.4), (0.1, 0.6)), RandomContrast(0.08), RandomBrightness(0.08), ], p=0.5), ], p=p)
def __init__(self, root_dir, partition, augment=True): self.root_dir = root_dir self.list_IDs = os.listdir( os.path.join(self.root_dir, 'x_{}'.format(partition))) self.partition = partition self.augment = augment self.augmentator = Compose([ # Non destructive transformations VerticalFlip(p=0.6), HorizontalFlip(p=0.6), RandomRotate90(), Transpose(p=0.6), ShiftScaleRotate(p=0.45, scale_limit=(0.1, 0.3)), # # Non-rigid transformations ElasticTransform(p=0.25, alpha=160, sigma=180 * 0.05, alpha_affine=120 * 0.03), Blur(blur_limit=3, p=0.2), # Color augmentation RandomBrightness(p=0.5), RandomContrast(p=0.5), RandomGamma(p=0.5), CLAHE(p=0.5) ])
def strong_aug(p=0.6, im_height=700, im_width=1200): dropout_w = int(im_width / 82) dropout_h = int(im_height / 9.) return Compose([ Rotate(limit=2, p=0.5), RandomCrop( height=int(im_height * 0.95), width=int(im_width * 0.9), p=0.3), ElasticTransform(p=0.8), HorizontalFlip(p=0.5), CoarseDropout(max_holes=8, max_height=dropout_w, max_width=dropout_h, min_holes=1, min_height=5, min_width=5, fill_value=0, always_apply=False, p=0.85), OneOf([ MotionBlur(p=0.8), Blur(blur_limit=20, p=0.8), ], p=0.35), Resize(height=256, width=256, p=1) ], p=p)
def __init__(self): self.transformer = Compose([ HorizontalFlip(p=0.5), OneOf([ GridDistortion( num_steps=5, distort_limit=(-0.46, 0.40), value=(0, 0, 0)), ElasticTransform(alpha=1.68, sigma=48.32, alpha_affine=44.97, value=(0, 0, 0)), RandomResizedCrop(height=512, width=512, scale=(0.08, 1.0), ratio=(0.75, 1.33)) ], p=.3), ShiftScaleRotate(shift_limit=(-0.06, 0.06), scale_limit=(-0.1, 0.1), rotate_limit=(-90, 90), p=0.3), Normalize(mean=[0.46009655, 0.43957878, 0.41827092], std=[0.2108204, 0.20766491, 0.21656131], max_pixel_value=255.0, p=1.0), ToTensorV2(), ])
def augment(self, image, mask): aug = Compose([ OneOf([ RandomSizedCrop(min_max_height=(50, 101), height=self.out_size, width=self.out_size, p=0.5), PadIfNeeded( min_height=self.out_size, min_width=self.out_size, p=0.5) ], p=1), VerticalFlip(p=0.5), RandomRotate90(p=0.5), OneOf([ ElasticTransform(p=0.5, alpha=120, sigma=120 * 0.05, alpha_affine=120 * 0.03), GridDistortion(p=0.5), OpticalDistortion(p=1, distort_limit=2, shift_limit=0.5) ], p=0.8), CLAHE(p=0.8), RandomBrightnessContrast(p=0.8), RandomGamma(p=0.8) ]) augmented = aug(image=image, mask=mask) image_heavy = augmented['image'] mask_heavy = augmented['mask'] return image_heavy, mask_heavy
def train_aug(self, image, label): aug = Compose( [ OneOf( [CLAHE(), IAASharpen(), IAAEmboss()], p=0.5), # OneOf([IAAAdditiveGaussianNoise(), GaussNoise()], p=0.2), # OneOf([MotionBlur(p=0.2), MedianBlur(blur_limit=3, p=0.1), Blur(blur_limit=3, p=0.1)], p=0.2), RandomContrast(), RandomBrightness(), # ChannelShuffle(), RandomRotate90(), Flip(), # RandomScale(scale_limit=(0.0, 0.1)), OneOf([ ElasticTransform(), OpticalDistortion(), GridDistortion(), IAAPiecewiseAffine() ], p=0.5), # HueSaturationValue(p=0.3), ], p=0.9) augmented = aug(image=image, mask=label) augmented = ToGray(p=1)(image=augmented['image'], mask=augmented['mask']) augmented = RandomCrop(256, 256)(image=augmented['image'], mask=augmented['mask']) image, label = augmented['image'], augmented['mask'] return image, label
def augmentation(img, n): """ Make random augmentations with image n times. :rtype: ndarray :param img: image in matrix form :param n: how many augmentations need to apply :return: list of augmented versions of image """ methods = [ElasticTransform(**elastic_params), RandomGamma(**gamma_params), GridDistortion(**all_other), RGBShift(**r_shift_params), Rotate(**rotate_params), RandomBrightness(**brightness_params) ] for i in range(len(methods)): methods[i] = Compose([methods[i], ], p=1) chosen = np.random.choice(methods, replace=False, size=n) augmented = np.empty((n,), dtype=np.object) for i, method in enumerate(chosen): transformed = transform_image(method(image=img)["image"]) if to_normalize: transformed = normalize(transformed) augmented[i] = transformed return augmented
def get_transforms(phase): list_transforms = [] if phase == "train": list_transforms.extend( [ OneOf([ RandomSizedCrop(min_max_height=(50, 101), height=original_height, width=original_width, p=0.5), PadIfNeeded(min_height=original_height, min_width=original_width, p=0.5)], p=1), VerticalFlip(p=0.5), # RandomRotate90(p=0.5), OneOf([ ElasticTransform(p=0.5, alpha=120, sigma=120 * 0.05, alpha_affine=120 * 0.03), GridDistortion(p=0.5), OpticalDistortion(p=1, distort_limit=2, shift_limit=0.5) ], p=0.8), CLAHE(p=0.8), RandomBrightnessContrast(p=0.8), RandomGamma(p=0.8), ] ) list_transforms.extend( [ Resize(height=int(original_height/4), width=int(original_width/4), interpolation=cv2.INTER_NEAREST), Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), p=1), ToTensor(), ] ) list_trfms = Compose(list_transforms) return list_trfms
def hard_aug(original_height=128, original_width=128, k=4): aug = Compose([ OneOf([ RandomSizedCrop( min_max_height=(original_height // k, original_height), height=original_height, width=original_width, p=0.5), PadIfNeeded( min_height=original_height, min_width=original_width, p=0.5) ], p=1), VerticalFlip(p=0.5), HorizontalFlip(p=0.5), RandomRotate90(p=0.5), Transpose(p=0.5), OneOf([ ElasticTransform( p=0.5, alpha=120, sigma=120 * 0.05, alpha_affine=120 * 0.03), GridDistortion(p=0.5), OpticalDistortion(p=1, distort_limit=2, shift_limit=0.5) ], p=0.8), CLAHE(p=0.8), RandomBrightnessContrast(p=0.8), RandomGamma(p=0.8) ]) return aug
def random_elastic_transform(image, label): size = random.randrange(100, 500) aug = ElasticTransform(p=1, alpha=size, sigma=size * 0.05, alpha_affine=size * 0.03) augmented = aug(image=image, mask=label) image = augmented['image'] label = augmented['mask'] return image, label
def strong_aug(p=0.5, crop_size=(512, 512)): return Compose([ RandomResizedCrop(crop_size[0], crop_size[1], scale=(0.3, 1.0), ratio=(0.75, 1.3), interpolation=4, p=1.0), RandomRotate90(), Flip(), Transpose(), OneOf([ IAAAdditiveGaussianNoise(), GaussNoise(), ], p=0.8), OneOf([ MotionBlur(p=0.5), MedianBlur(blur_limit=3, p=0.5), Blur(blur_limit=3, p=0.5), ], p=0.3), ShiftScaleRotate( shift_limit=0.2, scale_limit=0.5, rotate_limit=180, p=0.8), OneOf([ OpticalDistortion(p=0.5), GridDistortion(p=0.5), IAAPiecewiseAffine(p=0.5), ElasticTransform(p=0.5), ], p=0.3), OneOf([ CLAHE(clip_limit=2), IAASharpen(), IAAEmboss(), RandomBrightnessContrast(), ], p=0.3), OneOf([ GaussNoise(), RandomRain( p=0.2, brightness_coefficient=0.9, drop_width=1, blur_value=5), RandomSnow(p=0.4, brightness_coeff=0.5, snow_point_lower=0.1, snow_point_upper=0.3), RandomShadow(p=0.2, num_shadows_lower=1, num_shadows_upper=1, shadow_dimension=5, shadow_roi=(0, 0.5, 1, 1)), RandomFog( p=0.5, fog_coef_lower=0.3, fog_coef_upper=0.5, alpha_coef=0.1) ], p=0.3), RGBShift(), HueSaturationValue(p=0.9), ], p=p)
def augment_data(save_dir): """ A special that implemnets the data augmentation pipeline. :param save_dir: Where to save the augmented data? :return: """ seed = 1337 random.seed(seed) start_time = time.time() print(f"====== Augmenting data. Seed set at {seed} ======") data_file = h5py.File(os.path.join(save_dir, 'data_file.h5'), 'r') data_shape = data_file['data/data'].shape data_aug = np.zeros(shape=data_shape, dtype=np.float32) n_samples = data_shape[0] img_channels, img_height, img_width, img_depth = data_shape[1:5] try: aug = alb.load(os.path.join(save_dir, 'aug_pipeline_1.json')) except FileNotFoundError: print("Pipeline not found. Generating One ...") aug = Compose([ OneOf([VerticalFlip(p=1), HorizontalFlip(p=1)], p=1), OneOf([ ElasticTransform(p=1, sigma=6, alpha_affine=4, alpha=75), GridDistortion(p=1), OpticalDistortion(p=1, distort_limit=2, shift_limit=0.5) ], p=0.8) ]) alb.save(aug, os.path.join(save_dir, 'aug_pipeline_1.json')) for data_idx in np.arange(n_samples): img = data_file['data/data'][data_idx, ...] img = img.reshape(img_channels, img_height, img_width, -1) img_aug = aug(image=img[0, ...])['image'].reshape(img_channels, img_height, img_width, img_depth, -1) data_aug[data_idx, ...] = img_aug del img_aug del img data_file.close() with h5py.File(os.path.join(save_dir, 'data_aug.h5'), 'w') as file: file.create_dataset('data/data', data=data_aug, dtype=np.float32) print( f"====== Finished augmentation. Time taken: {time.time() - start_time}s ======" )
def warp(image, mask): alpha = randrange(30, 45) sigma = randrange(5, 7) aug = ElasticTransform(alpha=alpha, sigma=sigma, p=1., border_mode=cv2.BORDER_CONSTANT) augmented = aug(image=image, mask=mask) return augmented['image'], augmented['mask']