def light_aug(): return Compose([ RandomBrightness(limit=0.1, p=0.2), RandomContrast(limit=0.1, p=0.2), Blur(blur_limit=3, p=0.2), HorizontalFlip(p=0.7), ])
def get_train_transform(smallest_max_size: int, size: int): return Compose([ SmallestMaxSize(smallest_max_size), RandomScale(scale_limit=0.125), # PadIfNeeded(256, 256, border_mode=cv2.BORDER_CONSTANT., value=0, p=1.), # ShiftScaleRotate( # shift_limit=0.0625, scale_limit=0.1, rotate_limit=30, # border_mode=cv2.BORDER_REFLECT_101, p=1.), Rotate(limit=20, border_mode=cv2.BORDER_REFLECT_101, p=1.), OneOf([ RandomCrop(size, size, p=0.9), CenterCrop(size, size, p=0.1), ], p=1.), HorizontalFlip(p=0.5), RandomContrast(limit=0.2, p=0.5), RandomGamma(gamma_limit=(80, 120), p=0.5), RandomBrightness(limit=0.2, p=0.5), # HueSaturationValue(hue_shift_limit=5, sat_shift_limit=20, # val_shift_limit=10, p=1.), # OneOf([ # OpticalDistortion(p=0.3), # GridDistortion(p=0.1), # IAAPiecewiseAffine(p=0.3), # ], p=0.2), # OneOf([ # IAAAdditiveGaussianNoise( # loc=0, scale=(1., 6.75), per_channel=False, p=0.3), # GaussNoise(var_limit=(5.0, 20.0), p=0.6), # ], p=0.5), # Cutout(num_holes=4, max_h_size=30, max_w_size=50, p=0.75), # JpegCompression(quality_lower=50, quality_upper=100, p=0.5) ])
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 transforms_train(aug_proba=1.): return Compose(transforms=[ HorizontalFlip(p=0.5), Rotate(limit=25, p=0.5, border_mode=cv2.BORDER_CONSTANT, value=0, interpolation=cv2.INTER_CUBIC), OneOf([ IAAAdditiveGaussianNoise(p=1), GaussNoise(p=1), ], p=0.2), OneOf([ HueSaturationValue(hue_shift_limit=10, sat_shift_limit=15, val_shift_limit=10, p=1), RGBShift(r_shift_limit=10, g_shift_limit=10, b_shift_limit=10, p=1) ]), OneOf([RandomContrast(p=1), RandomBrightness(p=1)], p=0.3), OpticalDistortion(p=0.1), Resize(*SIZE), Normalize() ], p=aug_proba, additional_targets={'trimap': 'mask'})
def strong_aug(p=1.0): return Compose( [ Cutout(num_holes=1, max_h_size=16, max_w_size=16, fill_value=[0.4914 * 255, 0.4822 * 255, 0.4465 * 255], p=1.), HorizontalFlip(p=0.5), # RandomGamma(p=0.5), # ElasticTransform(value=10), ShiftScaleRotate( shift_limit=0.0625, scale_limit=0.2, rotate_limit=20, p=1.), # Below are Required OneOf([ CLAHE(clip_limit=2), IAASharpen(), IAAEmboss(), RandomContrast(), RandomBrightness(), ], p=0.3), # HueSaturationValue(p=0.3), ToTensor(normalize={ 'mean': (0.4914, 0.4822, 0.4465), 'std': (0.2023, 0.1994, 0.2010) }) ], 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 aug_image(image): from albumentations import ( HorizontalFlip, IAAPerspective, ShiftScaleRotate, CLAHE, RandomRotate90, RandomGamma, VerticalFlip, Transpose, ShiftScaleRotate, Blur, OpticalDistortion, GridDistortion, HueSaturationValue, IAAAdditiveGaussianNoise, GaussNoise, MotionBlur, MedianBlur, RandomBrightnessContrast, IAAPiecewiseAffine, IAASharpen, IAAEmboss, Flip, OneOf, Compose, Rotate, RandomContrast, RandomBrightness, RandomCrop, Resize, OpticalDistortion) transforms = Compose( [ OneOf( [ RandomContrast( p=1, limit=(-0.5, 1.5) ), # -0.5 ~ 2 까지가 현장과 가장 비슷함 -- RandomBrightnessContrast RandomBrightness(p=1, limit=(-0.2, 0.2)), RandomGamma(p=1, gamma_limit=(80, 150)), ], p=1), MotionBlur(p=0.2), # 움직일때 흔들리는 것 같은 이미지 ], p=1) return transforms(image=image)['image']
def hard_augmentations2(use_d4=False): d4 = Compose([RandomRotate90(p=1), HorizontalFlip(p=1), VerticalFlip(p=1)]) fliplr = HorizontalFlip() aug = Compose( [ RandomBrightness(p=1), # OneOf([IAAAdditiveGaussianNoise(), , ], p=0.2), # GaussNoise(p=1), IAAAdditiveGaussianNoise(p=1), OneOf([ MotionBlur(p=1), MedianBlur(blur_limit=3, p=1), Blur(blur_limit=3, p=1) ], p=0.5), ShiftScaleRotate( shift_limit=0.0625, scale_limit=0.1, rotate_limit=5, p=1), # OneOf([GridDistortion(p=0.1), IAAPiecewiseAffine(p=0.3)], p=0.2), # GridDistortion(p=1), # IAAPiecewiseAffine(p=1) ], p=1) default = default_transforms() return Compose([d4 if use_d4 else fliplr, aug, default])
def __init__(self, root_path, file_list, is_test=False, is_val=False, augment=False): self.is_test = is_test self.augment = augment self.root_path = root_path self.file_list = file_list self.pad = Compose([ PadIfNeeded(p=1, min_height=PAD_SIZE, min_width=PAD_SIZE), ToTensor(), ]) original_height, original_width = 101, 101 self.augmentation = Compose([ RandomSizedCrop(min_max_height=(50, 101), height=original_height, width=original_width, p=0.9), HorizontalFlip(p=0.5), GridDistortion(p=0.8), RandomContrast(p=0.8), RandomBrightness(p=0.8), RandomGamma(p=0.8) ])
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 augment_3d(img, input_channel=3): """ input_channel==1 : img: slice_num x W x H input_channel==3 : img: 3 x slice_num x W x H """ transform = Compose( [ HorizontalFlip(p=0.1), ShiftScaleRotate( shift_limit=0.1, scale_limit=0.1, rotate_limit=15, border_mode=cv2.BORDER_REPLICATE, p=0.5, ), # RandomSizedCrop(min_max_height=(h-int(h*0.1), h), height=h, width=w, p=p), RandomBrightness(limit=0.2, p=0.5), GaussNoise(var_limit=0.001, mean=0.0, p=0.5), ], p=1, additional_targets={ "image1": "image", "image2": "image" }, ) if input_channel == 1: img = img.transpose((1, 2, 0)) augment = transform(image=img) img = augment["image"] img = img.transpose((2, 0, 1)) elif input_channel == 3: # t0 = time.time() img0 = img[0].transpose((1, 2, 0)) img1 = img[1].transpose((1, 2, 0)) img2 = img[2].transpose((1, 2, 0)) # print("transpose: ", time.time() - t0) # t0 = time.time() augment = transform(image=img0, image1=img1, image2=img2) # print("augment: ", time.time() - t0) # t0 = time.time() img0, img1, img2 = augment["image"], augment["image1"], augment[ "image2"] img = np.concatenate( ( img0.transpose((2, 0, 1))[np.newaxis], img1.transpose((2, 0, 1))[np.newaxis], img2.transpose((2, 0, 1))[np.newaxis], ), axis=0, ) # print("transpose2: ", time.time() - t0) return img
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 get_photometric(self): coeff = int(3 * self.strength) k = max(1, coeff if coeff % 2 else coeff - 1) return Compose([ OneOf( [ # CLAHE(clip_limit=2, p=.4), IAASharpen(p=.5), IAAEmboss(p=.5), ], p=0.2), OneOf([ IAAAdditiveGaussianNoise(p=.3), GaussNoise(p=.7), ], p=.2), OneOf([ MotionBlur(p=.2), MedianBlur(blur_limit=k, p=.3), Blur(blur_limit=k, p=.5), ], p=.2), OneOf([ RandomContrast(), RandomBrightness(), ], p=.2) ])
def train_transform(p=1): return Compose( [ # Rescale(SIZE), RandomCrop(SIZE), RandomBrightness(0.2), OneOf([ IAAAdditiveGaussianNoise(), GaussNoise(), ], p=0.15), # OneOf([ # OpticalDistortion(p=0.3), # GridDistortion(p=.1), # IAAPiecewiseAffine(p=0.3), # ], p=0.1), # OneOf([ # IAASharpen(), # IAAEmboss(), # RandomContrast(), # RandomBrightness(), # ], p=0.15), HueSaturationValue(p=0.15), HorizontalFlip(p=0.5), Normalize(p=1), ], p=p)
def aug_daniel(prob=0.8): return Compose( [ RandomRotate90(p=0.5), Transpose(p=0.5), Flip(p=0.5), OneOf( [ IAAAdditiveGaussianNoise(), GaussNoise(), #Blur(), ], p=0.3), OneOf( [ CLAHE(clip_limit=2), IAASharpen(), IAAEmboss(), OneOf([ RandomContrast(), RandomBrightness(), ]), #Blur(), #GaussNoise() ], p=0.5), HueSaturationValue(p=0.5) ], p=prob)
def strong_aug(config, aug_prob): return Compose( [ # Resize(config.image_height, config.image_width, always_apply=True), RandomSizedCrop( p=config.random_sized_crop_prob, min_max_height=(int( config.image_height * config.min_max_height), config.image_height), height=config.image_height, width=config.image_width, w2h_ratio=config.image_width / config.image_height), HorizontalFlip(p=config.horizontal_flip_prob), RandomGamma(p=config.random_gamma_prob), RandomContrast(p=config.random_contrast_prob, limit=config.random_contrast_limit), RandomBrightness(p=config.random_brightness_prob, limit=config.random_brightness_limit), OneOf([ MotionBlur(p=config.motion_blur_prob), MedianBlur(blur_limit=config.median_blur_limit, p=config.median_blur_prob), Blur(blur_limit=config.blur_limit, p=config.blur_prob), ], p=config.one_of_blur_prob), CLAHE(clip_limit=config.clahe_limit, p=config.clahe_prob), IAAEmboss(p=config.iaaemboss_prob), HueSaturationValue(p=config.hue_saturation_value_prob, hue_shift_limit=config.hue_shift_limit, sat_shift_limit=config.sat_shift_limit, val_shift_limit=config.val_shift_limit) ], p=aug_prob)
def albumentations_transform(self, img): # 训练集的增强 trans_train = Compose([ # 随机更改输入图像的色相,饱和度和值 # HueSaturationValue(hue_shift_limit=20, sat_shift_limit=30, val_shift_limit=20, always_apply=False, p=0.5), # 通过用255减去像素值来反转输入图像。 # InvertImg(always_apply=False, p=1), # 随机改变RGB三个通道的顺序 # ChannelShuffle(always_apply=False, p=0.5), # 随机出现小黑点 # Cutout(num_holes=8, max_h_size=8, max_w_size=8, fill_value=0, always_apply=False, p=0.5), # RandomCrop(224, 224), OneOf([ RandomBrightness(limit=0.1, p=1), RandomContrast(limit=0.1, p=1) ]), # OneOf([MotionBlur(blur_limit=3),MedianBlur(blur_limit=3), GaussianBlur(blur_limit=3),], p=0.5,), VerticalFlip(p=0.5), HorizontalFlip(p=0.5), # ShiftScaleRotate( # shift_limit=0.2, # scale_limit=0.2, # rotate_limit=20, # interpolation=cv2.INTER_LINEAR, # border_mode=cv2.BORDER_REFLECT_101, # p=1, # ), ]) augmented = trans_train(image=img) return augmented['image']
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 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 get_transforms(phase, size, mean, std): list_transforms = [] if phase == "train": list_transforms.extend( [ HorizontalFlip(p=0.5), # OneOf([ # RandomBrightnessContrast(), # RandomGamma(), # RandomBrightness(), # ], p=0.5), RandomBrightness(p=0.2, limit=0.2), RandomContrast(p=0.1, limit=0.2), ShiftScaleRotate( shift_limit=0, # no resizing scale_limit=0.1, rotate_limit=10, # rotate p=0.5, border_mode=cv2.BORDER_CONSTANT ), ] ) list_transforms.extend( [ Normalize(mean=mean, std=std, p=1), Resize(size, size), ToTensor(), ] ) list_trfms = Compose(list_transforms) return list_trfms
def strong_aug(p=.5): return Compose([ JpegCompression(p=0.9), HorizontalFlip(p=0.5), OneOf([ IAAAdditiveGaussianNoise(), GaussNoise(), ], p=0.5), OneOf([ MotionBlur(p=.2), MedianBlur(blur_limit=3, p=.1), Blur(blur_limit=3, p=.1), ], p=0.5), ShiftScaleRotate( shift_limit=0.0625, scale_limit=0.2, rotate_limit=15, p=.5), OneOf([ CLAHE(clip_limit=2), IAASharpen(), IAAEmboss(), RandomContrast(), RandomBrightness(), ], p=0.5), HueSaturationValue(p=0.5), ], p=p)
def __init__(self, to_tensor=True): augs = [ RandomSizedBBoxSafeCrop(height=512, width=512), RandomBrightness(p=0.5), RandomContrast(p=0.5), #RandomSunFlare(p=0.5, flare_roi=(0, 0, 1, 0.5), angle_lower=0.5,src_radius= 150), RandomShadow(p=0.5, num_shadows_lower=1, num_shadows_upper=1, shadow_dimension=5, shadow_roi=(0, 0.5, 1, 1)), HorizontalFlip(p=0.5), GaussianBlur(p=0.5), ] if to_tensor: augs.append( ToTensor(normalize={ "mean": [0.485, 0.456, 0.406], "std": [0.229, 0.224, 0.225] })) self.transform = Compose(augs, bbox_params={ "format": "albumentations", "min_area": 0, "min_visibility": 0.2, 'label_fields': ['category_id'] })
def get_transforms(config, mode): if (mode == "val") or (mode =="test"): transform = [ Resize(config["model"]["image_size"], config["model"]["image_size"]), # Normalize(mean=phase_config.mean, std=phase_config.std, p=1), ToTensor(), ] return transform elif mode == "train": list_transforms = [] config_tarnsform = config[mode]["transform"] if config_tarnsform["HorizontalFlip"]: list_transforms.append(HorizontalFlip()) if config_tarnsform["VerticalFlip"]: list_transforms.append(VerticalFlip()) if config_tarnsform["Contrast"]: list_transforms.append( OneOf([ RandomContrast(0.5), RandomBrightness(), ], p=0.5), ) if config_tarnsform["ShiftScaleRotate"]: list_transforms.append(ShiftScaleRotate(shift_limit=(-0.05, 0.05), scale_limit=(-0.05, 0.05), rotate_limit=(-30,30), p=0.5)) list_transforms.extend( [ Resize(config["model"]["image_size"], config["model"]["image_size"]), # Normalize(mean=phase_config.mean, std=phase_config.std, p=1), ToTensor(), ] ) return list_transforms
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=0.5): return Compose([ RandomRotate90(), Flip(), Transpose(), OneOf([ IAAAdditiveGaussianNoise(), GaussNoise(), ], p=p), OneOf([ MotionBlur(p=p), ], p=p), ShiftScaleRotate( shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=p), OneOf([ OpticalDistortion(p=p), GridDistortion(p=p), IAAPiecewiseAffine(p=p), ], p=p), OneOf([ IAASharpen(), IAAEmboss(), RandomContrast(), RandomBrightness(), ], p=p), HueSaturationValue(p=p), ], p=p)
def __init__(self, data, img_size=384, aug=True, mode='train'): self.data = data self.mode = mode if mode is 'train': self.images = data.ImageId.unique() self._aug = Compose([ HorizontalFlip(), VerticalFlip(), OneOf([ RandomRotate90(), ShiftScaleRotate(shift_limit=0.2, scale_limit=0.2, rotate_limit=0), ], p=1), OneOf([ CLAHE(), RandomBrightness(), RandomContrast(), RandomGamma() ], p=1), Normalize(), RandomCrop(img_size, img_size) # Resize(256, 256), # Resize(img_size, img_size), ]) elif mode is 'test' or mode is 'val': self.images = data.ImageId.unique() self._aug = Compose([ Normalize(), # Resize(256, 256), # Resize(img_size, img_size), # RandomCrop(img_size, img_size) # PadIfNeeded(768, 768) ]) else: raise RuntimeError()
def alb_transform_train(imsize = 256, p=1): albumentations_transform = Compose([ # RandomCrop(imsize), # RandomRotate90(), Flip(), # Transpose(), OneOf([ IAAAdditiveGaussianNoise(), GaussNoise(), ], p=0.2), OneOf([ MotionBlur(p=.2), MedianBlur(blur_limit=3, p=.1), Blur(blur_limit=3, p=.1), ], p=0.2), 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([ # CLAHE(clip_limit=2), IAASharpen(), IAAEmboss(), RandomContrast(), RandomBrightness(), ], p=0.3), Normalize( mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225] ) ], p=p) return albumentations_transform
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 strong_aug(p=.5): return Compose([ HorizontalFlip(p=0.5), ToGray(p=0.1), OneOf([ IAAAdditiveGaussianNoise(), GaussNoise(), ], p=0.4), OneOf([ MotionBlur(p=.2), MedianBlur(blur_limit=3, p=.1), Blur(blur_limit=3, p=.1), ], p=0.2), 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), ], p=p)
def img_augment(p=1.): return Compose( [ #RandomSizedCrop((300, 300), img_sz, img_sz, p=1.), Resize(img_sz, img_sz), HorizontalFlip(p=0.8), #RandomRotate90(p=0.25), OneOf([ CLAHE(clip_limit=2), IAASharpen(), IAAEmboss(), RandomContrast(), RandomBrightness(), ], p=0.3), # ShiftScaleRotate( shift_limit=0.0625, scale_limit=0.1, rotate_limit=10, p=.75), RandomBrightnessContrast(p=0.2), #GaussNoise(), #Blur(blur_limit=3, p=.33), #OpticalDistortion(p=.33), #GridDistortion(p=.33), #HueSaturationValue(p=.33) ], p=p)