def light_aug(p=1): return Compose( [ # albumentations supports uint8 and float32 inputs. For the latter, all # values must lie in the range [0.0, 1.0]. To apply augmentations, we # first use a `ToFloat()` transformation, which will inspect the data # type of the input image and convert the image to a float32 ndarray where # all values lie in the required range [0.0, 1.0]. ToFloat(), RandomBrightness(limit=(0, 0.2), p=0.2), # Alternatively, you can specify the maximum possible value for your input # and all values will be divided by it instead of using a predefined value # for a specific data type. # ToFloat(max_value=65535.0), # Then we will apply augmentations HorizontalFlip(p=0.1), ShiftScaleRotate( shift_limit=1 / 14, scale_limit=0.1, rotate_limit=15, p=0.9), OpticalDistortion(distort_limit=0.1, shift_limit=0.05, p=0.5), # You can convert the augmented image back to its original # data type by using `FromFloat`. # FromFloat(dtype='uint16'), # As in `ToFloat` you can specify a `max_value` argument and all input values # will be multiplied by it. FromFloat(dtype='uint16', max_value=65535.0), ], p=p, additional_targets={"image1": "image"})
def strong_aug(p=0.5): return Compose([ OneOf([ CoarseDropout(p=0.5), Cutout(p=0.5), ], p=0.3), OneOf([ IAAAdditiveGaussianNoise(), GaussNoise(), ], p=0.2), ShiftScaleRotate( shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, 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), OneOf([ OpticalDistortion(p=0.3), GridDistortion(p=0.1), IAAPiecewiseAffine(p=0.3), ], p=0.2), OneOf([ IAASharpen(), IAAEmboss(), RandomBrightnessContrast(), ], p=0.2) ], p=p)
def get_augmentations(p=1.0): return Compose([ RandomSizedCrop((250, 600), 224, 224), OneOf([ IAAAdditiveGaussianNoise(), GaussNoise(), ], p=1), OneOf([ MotionBlur(p=.6), MedianBlur(blur_limit=3, p=0.6), Blur(blur_limit=3, p=0.6), ], p=1), ShiftScaleRotate(shift_limit=0.0825, scale_limit=0.3, rotate_limit=30, p=1), OneOf([ OpticalDistortion(p=0.5), GridDistortion(p=.4), IAAPiecewiseAffine(p=0.5), ], p=0.8), OneOf([ CLAHE(clip_limit=2), IAASharpen(), IAAEmboss(), RandomBrightnessContrast(), ], p=0.9), HueSaturationValue(p=0.3), ], p=p)
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 get_transforms(): Compose([ RandomRotate90(), Flip(), Transpose(), OneOf([ IAAAdditiveGaussianNoise(), GaussNoise(), ], p=0.2), OneOf([ MotionBlur(p=.2), MedianBlur(blur_limit=3, p=0.1), Blur(blur_limit=3, p=0.1), ], p=0.2), ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.2, rotate_limit=90, p=0.5), OneOf([ OpticalDistortion(p=0.3), GridDistortion(p=.1), IAAPiecewiseAffine(p=0.3), ], p=0.2), OneOf([ CLAHE(clip_limit=2), IAASharpen(), IAAEmboss(), RandomBrightnessContrast(), ], p=0.3), HueSaturationValue(p=0.3), ], p=0.8)
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 flow(data_dir, Timage, Tmask, batch, size1, size2, augument=False): images_ = os.listdir(data_dir + Timage) shuffle(images_) ids_int = list(range(len(images_))) NORMALIZE = 127.5 while True: try: for start in range(0, len(ids_int), batch): x_batch = [] y_batch = [] end = min(start + batch, len(images_)) batch_create = ids_int[start:end] jbs = dict() for loads in batch_create: try: img = cv2.imread( os.path.join(data_dir, Timage, images_[loads])) img = image_resize(img, width=param_maps["scale"]) height_o_image, width_o_image = img.shape[ 0], img.shape[1] if height_o_image % 2 != 0: height_o_image = height_o_image - 1 if width_o_image % 2 != 0: width_o_image = width_o_image - 1 jbs["width"] = width_o_image * 2 jbs["height"] = height_o_image * 2 img = cv2.resize(img, (width_o_image, height_o_image)) img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) masks = cv2.imread( os.path.join(data_dir, Tmask, images_[loads])) masks = cv2.resize(masks, (jbs["width"], jbs["height"])) except: continue if augument: aug = Compose([ VerticalFlip(p=0.1), Transpose(p=0.01), RandomGamma(p=0.06), OpticalDistortion(p=0.00, distort_limit=0.7, shift_limit=0.3) ]) augmented = aug(image=img, mask=masks) img = augmented['image'] masks = augmented['mask'] x_batch.append(img) y_batch.append(masks) else: x_batch.append(img) y_batch.append(masks) x_batch = np.array(x_batch) / NORMALIZE x_batch = x_batch - 1 y_batch = np.array(y_batch) / NORMALIZE y_batch = y_batch - 1 yield x_batch, y_batch except: continue
def strong_aug(p=0.7): from albumentations import ( HorizontalFlip, IAAPerspective, ShiftScaleRotate, CLAHE, RandomRotate90, Transpose, ShiftScaleRotate, Blur, OpticalDistortion, GridDistortion, HueSaturationValue, IAAAdditiveGaussianNoise, GaussNoise, MotionBlur, MedianBlur, IAAPiecewiseAffine, IAASharpen, IAAEmboss, RandomBrightnessContrast, Flip, OneOf, Compose) augs = [ OneOf( [ MotionBlur(p=0.3), #MedianBlur(blur_limit=3, p=0.1), Blur(blur_limit=10, p=0.3), ], p=0.3), ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=0.2), OneOf( [ OpticalDistortion(p=0.3), #GridDistortion(p=0.1), # causes segmentation fault, due to version mismatch with open cv... IAAPiecewiseAffine(p=0.2), ], p=0.3), ] return Compose(augs, p=p)
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 strong_aug(p=1): return Compose([ ToFloat(), RandomRotate90(), Flip(), Transpose(), 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), ShiftScaleRotate( shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=0.2), OneOf([ OpticalDistortion(p=0.3), GridDistortion(p=0.1), IAAPiecewiseAffine(p=0.3), ], p=0.2), FromFloat(dtype='uint16', max_value=65535.0) ], p=p)
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 strong_aug(p=0.5): return Compose( [ #RandomRotate90(), #Flip(), #Transpose(), 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), ShiftScaleRotate( shift_limit=0.0625, scale_limit=0.2, rotate_limit=3, p=0.2), OneOf([ OpticalDistortion(p=0.3), GridDistortion(p=0.1), IAAPiecewiseAffine(p=0.3), ], p=0.2), OneOf([ CLAHE(clip_limit=2), IAASharpen(), IAAEmboss(), RandomContrast(), RandomBrightness(), ], p=0.3), HueSaturationValue(p=0.3), ], p=p)
def augment(self): #p=.5): return Compose([ RandomRotate90(), Flip(), Transpose(), ShiftScaleRotate( shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=.2), OneOf([ OpticalDistortion(p=0.3), GridDistortion(p=.1), IAAPiecewiseAffine(p=0.3), ], p=0.2), OneOf([ IAAAdditiveGaussianNoise(), GaussNoise(), ], p=0.2), RandomCrop(256, 256, p=1), OneOf([ MedianBlur(blur_limit=3, p=.1), Blur(blur_limit=3, p=.1), ], p=0.2), OneOf([ CLAHE(clip_limit=2), IAASharpen(), IAAEmboss(), RandomContrast(), RandomBrightness(), ], p=0.3), HueSaturationValue(p=0.7), ], p=1)
def test_optical_distortion_interpolation(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) aug = OpticalDistortion(distort_limit=(0.05, 0.05), shift_limit=(0, 0), interpolation=interpolation, p=1) data = aug(image=image, mask=mask) expected_image = F.optical_distortion(image, k=0.05, dx=0, dy=0, interpolation=interpolation, border_mode=cv2.BORDER_REFLECT_101) expected_mask = F.optical_distortion(mask, k=0.05, dx=0, dy=0, interpolation=cv2.INTER_NEAREST, border_mode=cv2.BORDER_REFLECT_101) assert np.array_equal(data['image'], expected_image) assert np.array_equal(data['mask'], expected_mask)
def aug_train(resolution, p=1): return Compose([Resize(resolution, resolution), OneOf([ HorizontalFlip(), VerticalFlip(), RandomRotate90(), Transpose()], p=0.5), OneOf([ IAAAdditiveGaussianNoise(), GaussNoise(), ], p=0.5), OneOf([ MotionBlur(p=.2), MedianBlur(blur_limit=3, p=0.1), Blur(blur_limit=3, p=0.1), ], p=0.5), ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=0.2), OneOf([ OpticalDistortion(p=0.3), GridDistortion(p=.1), IAAPiecewiseAffine(p=0.3), ], p=0.5), OneOf([ CLAHE(clip_limit=2), IAASharpen(), IAAEmboss(), RandomBrightnessContrast(), ], p=0.5), HueSaturationValue(p=0.3), Normalize() ], p=p)
def gettraintransforms(self, mean, std, p=1): # Train Phase transformations albumentations_transform = Compose([ RandomRotate90(), Flip(), GaussNoise(p=0.6, mean=mean), OneOf([ MotionBlur(p=0.2), MedianBlur(blur_limit=3, p=0.1), Blur(blur_limit=3, p=0.1), ], p=0.2), ShiftScaleRotate( shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=0.3), OneOf([ OpticalDistortion(p=0.4), GridDistortion(p=0.2), ], p=0.3), HueSaturationValue(hue_shift_limit=20, sat_shift_limit=0.1, val_shift_limit=0.1, p=0.3), Cutout(always_apply=True, num_holes=2, max_h_size=10, max_w_size=10, fill_value=(255 * .6)), Normalize(mean=mean, std=std, always_apply=True), pytorch.ToTensorV2(always_apply=True), ], p=p) return albumentations_transform
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 strong_aug(p=.5): return Compose([ HorizontalFlip(), OneOf([ IAAAdditiveGaussianNoise(), GaussNoise(), ], p=0.4), OneOf([ MotionBlur(p=.2), MedianBlur(blur_limit=3, p=.1), Blur(blur_limit=3, p=.1), ], p=0.3), OneOf([ OpticalDistortion(p=0.3), GridDistortion(p=.1), IAAPiecewiseAffine(p=0.3), ], p=0.2), OneOf([ CLAHE(clip_limit=2), IAASharpen(), RandomContrast(), RandomBrightness(), ], p=0.3), HueSaturationValue(p=0.3), ChannelShuffle(), Cutout(num_holes=20, max_h_size=16, max_w_size=16) ], p=p)
def medium_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=1, shift_limit=0.5) ], p=0.8) ]) return aug
def get_train_transforms(): augmentations = Compose([ Resize(236,236), Flip(), OneOf([ IAAAdditiveGaussianNoise(p=.5), GaussNoise(p=.4), ], p=0.4), OneOf([ MotionBlur(p=0.6), Blur(blur_limit=3, p=0.2), ], p=0.4), ShiftScaleRotate(shift_limit=0.0725, scale_limit=0.2, rotate_limit=45, p=0.6), OneOf([ OpticalDistortion(p=0.3), GridDistortion(p=0.4), IAAPiecewiseAffine(p=0.2), ], p=0.3), OneOf([ CLAHE(clip_limit=2), IAASharpen(), IAAEmboss(), RandomBrightnessContrast(), ], p=0.25), HueSaturationValue(p=0.3), CenterCrop(224,224), Normalize( mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225] ), ToTensor() ]) return lambda img:augmentations(image=np.array(img))
def get_corrupter(self): distortion_augs = OneOf([OpticalDistortion(p=1), GridDistortion(p=1)], p=1) effects_augs = OneOf([ IAASharpen(p=1), IAAEmboss(p=1), IAAPiecewiseAffine(p=1), IAAPerspective(p=1), CLAHE(p=1) ], p=1) misc_augs = OneOf([ ShiftScaleRotate(p=1), HueSaturationValue(p=1), RandomBrightnessContrast(p=1) ], p=1) blur_augs = OneOf( [Blur(p=1), MotionBlur(p=1), MedianBlur(p=1), GaussNoise(p=1)], p=1) aug = Compose([distortion_augs, effects_augs, misc_augs, blur_augs]) return aug
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 opticalDistortion(image, mask): aug = OpticalDistortion(p=1, distort_limit=2, shift_limit=0.5) augmented = aug(image=image, mask=mask) image_optical = augmented['image'] mask_optical = augmented['mask'] return image_optical, mask_optical
def transform(p=1): aug = Compose([ RandomRotate90(0.5), HueSaturationValue(hue_shift_limit=(-25, 0), sat_shift_limit=0, val_shift_limit=0, p=0), OneOf([ IAAAdditiveGaussianNoise(), GaussNoise(), ], p=0.1), OneOf([ MedianBlur(blur_limit=3, p=0), Blur(blur_limit=3, p=0.1), ], p=0.1), ShiftScaleRotate( shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=0.2), OneOf([ OpticalDistortion(p=0.3), GridDistortion(p=0.1), IAAPiecewiseAffine(p=0.3), ], p=0.2), OneOf([ CLAHE(clip_limit=2), IAASharpen(), IAAEmboss(), RandomBrightnessContrast(brightness_limit=(-0.2, 0.2), contrast_limit=(-0.2, 0.2), p=0.3), ], p=0.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=1, shift_limit=0.5) ], p=0.2), Resize(512, 512) ], p=p) return aug
def _transform_generic_np(self, npimages, prob): """So, we assume these images are batched numpy values, scaled from 0..255""" batchsz, height, width, channels = npimages.shape assert height == width, "We assume squares as inputs." assert channels == 3, "We assume RGB images." assert npimages.dtype == np.uint8 assert 0 <= npimages.min() and npimages.max() <= 255 # make these the images that albumentation requires. outputs = np.zeros((batchsz, self.outsz, self.outsz, channels), dtype=np.uint8) ops = Compose( \ [ \ Compose( \ [ \ OneOf([ \ IAAAdditiveGaussianNoise(p=1.0), \ GaussNoise(p=1.0), \ ], p=0.5), \ OneOf([ \ MotionBlur(p=1.0), \ MedianBlur(blur_limit=3, p=1.0), \ Blur(blur_limit=3, p=1.0), \ ], p=0.5), \ RandomGamma(p=0.5), \ Rotate(limit=45, interpolation=cv2.INTER_CUBIC, p=0.5), \ ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, interpolation=cv2.INTER_CUBIC, p=0.5), \ OneOf([ \ OpticalDistortion(interpolation=cv2.INTER_CUBIC, p=1.0), \ GridDistortion(interpolation=cv2.INTER_CUBIC, p=1.0), \ IAAPiecewiseAffine(p=1.0), \ ], p=0.5), \ OneOf([ \ CLAHE(clip_limit=2, p=1.0), \ IAASharpen(p=1.0), \ IAAEmboss(p=1.0), \ RandomContrast(p=1.0), \ RandomBrightness(p=1.0), \ ], p=0.5), \ HueSaturationValue(p=0.5), \ ], \ p=prob \ ), \ Resize(self.outsz, self.outsz, interpolation=cv2.INTER_CUBIC), \ ], \ p=1.0 \ ) # So, the output of ops, should be a dictionary containing an image for idx in range(0, batchsz): vvv = ops(image=npimages[idx])["image"] outputs[idx] = vvv return outputs
def augmentTest(self): return Compose([ OpticalDistortion(distort_limit=0.02, shift_limit=0.02, border_mode=0, value=0, p=0.1), GridDistortion(num_steps=9, distort_limit=0.1, border_mode=0, value=0, p=0.1), ShiftScaleRotate(shift_limit=0.03125, scale_limit=0.05, rotate_limit=4, p=.15), OneOf([ IAASharpen(), IAAEmboss(), ], p=0.05), HorizontalFlip(p=0.6), ToTensor() ], p=0.9)
def empty_aug3(): return [ # HorizontalFlip(p=0.001), # IAAPiecewiseAffine(p=1.0), OneOf([ OpticalDistortion(p=0.1), GridDistortion(p=0.1), # IAAPerspective(p=1.0), # IAAAffine(p=1.0), # IAAPiecewiseAffine(p=1.0), ], p=0.0) ]
def get_transforms(stage: str = None, mode: str = None, input_size: int = 224): train_image_transforms = [ OpticalDistortion(distort_limit=0.3, p=0.3), JpegCompression(quality_lower=50, p=0.8), HorizontalFlip(p=0.5), MotionBlur(p=0.5), ShiftScaleRotate(shift_limit=0.1, scale_limit=0.2, rotate_limit=20, p=0.5), RandomBrightnessContrast(brightness_limit=0.3, contrast_limit=0.2, p=0.4), HueSaturationValue(hue_shift_limit=3, sat_shift_limit=20, val_shift_limit=30, p=0.4), CLAHE(clip_limit=2, p=0.3) ] infer_image_transforms = [ Resize(input_size, input_size), Normalize(), ToTorchTensor(p=1.0) ] stack = TorchStack() train_images_fn = GroupTransform(transforms=train_image_transforms + infer_image_transforms) valid_images_fn = GroupTransform(transforms=infer_image_transforms) def train_aug_fn(images): images = train_images_fn(images) images = stack(images) return images def valid_aug_fn(images): images = valid_images_fn(images) images = stack(images) return images train_transforms = Augmentor(dict_key="features", augment_fn=lambda x: train_aug_fn(x)) valid_transforms = Augmentor(dict_key="features", augment_fn=lambda x: valid_aug_fn(x)) if mode == "train": return train_transforms else: return valid_transforms
def TTA(img, model, model_name, seed=88, niter=4): input_size = int(model.get_input_at(0).get_shape()[1]) AUGMENTATIONS = Compose([ HorizontalFlip(p=0.25), RandomSizedCrop(min_max_height=(int(input_size * 0.75), input_size), height=input_size, width=input_size, p=0.5), OneOf([ ShiftScaleRotate(rotate_limit=25), ElasticTransform( alpha=120, sigma=120 * 0.05, alpha_affine=120 * 0.03), GridDistortion(), OpticalDistortion(distort_limit=2, shift_limit=0.5), ], p=0.5), OneOf([RandomContrast(), RandomGamma(), RandomBrightness()], p=0.5), OneOf( [Blur(), MedianBlur(), GaussNoise(), GaussianBlur()], p=0.5) ], p=0.5) np.random.seed(seed) original_img = img.copy() inverted_img = np.invert(img.copy()) hflipped_img = np.fliplr(img.copy()) original_img_array = np.empty( (niter + 1, img.shape[0], img.shape[1], img.shape[2])) inverted_img_array = original_img_array.copy() hflipped_img_array = original_img_array.copy() original_img_array[0] = original_img inverted_img_array[0] = inverted_img hflipped_img_array[0] = hflipped_img for each_iter in range(niter): original_img_array[each_iter + 1] = AUGMENTATIONS(image=original_img)['image'] inverted_img_array[each_iter + 1] = AUGMENTATIONS(image=inverted_img)['image'] hflipped_img_array[each_iter + 1] = AUGMENTATIONS(image=hflipped_img)['image'] tmp_array = np.vstack( (original_img_array, inverted_img_array, hflipped_img_array)) tmp_array = preprocess_input(tmp_array, model_name) prediction = np.mean(model.predict(tmp_array), axis=0) return prediction