def get_transform(train: bool, im_size: int = 400): if train: transforms = A.Compose([ A.Resize( height=im_size, width=im_size, interpolation=cv2.INTER_CUBIC), A.ChannelShuffle(p=0.5), A.HorizontalFlip(p=0.5), A.ColorJitter(p=0.5), A.VerticalFlip(p=0.5), A.Blur(p=0.5), A.Normalize(), ToTensorV2(), ], bbox_params=A.BboxParams( format='pascal_voc', label_fields=['category_ids'])) else: transforms = A.Compose([ A.Resize( height=im_size, width=im_size, interpolation=cv2.INTER_CUBIC), A.Normalize(), ToTensorV2(), ], bbox_params=A.BboxParams( format='pascal_voc', label_fields=['category_ids'])) return transforms
def get_next_augmentation(): train_transform = [ albu.ChannelShuffle(p=0.1), 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 albu.Compose(train_transform)
def get_training_augmentation(): return A.Compose([ A.RandomSizedCrop(min_max_height=(300, 360), height=320, width=320, always_apply=True), A.HorizontalFlip(p=0.5), A.OneOf([ A.CLAHE(), A.RandomBrightnessContrast(), A.RandomGamma(), A.HueSaturationValue(), A.NoOp() ]), A.OneOf([ A.IAASharpen(), A.Blur(blur_limit=3), A.MotionBlur(blur_limit=3), A.NoOp() ]), A.OneOf([ A.RandomFog(), A.RandomSunFlare(src_radius=100), A.RandomRain(), A.RandomSnow(), A.NoOp() ]), A.Cutout(), A.Normalize(), ])
def gentle_transform(p): return albu.Compose( [ # p=0.5 albu.HorizontalFlip(p=0.5), albu.VerticalFlip(p=0.5), albu.OneOf( [ albu.IAASharpen(p=1), albu.Blur(blur_limit=3, p=1), albu.MotionBlur(blur_limit=3, p=1), ], p=0.5, ), albu.OneOf( [ albu.RandomBrightness(p=1), albu.RandomGamma(p=1), ], p=0.5, ), # p=0.2 albu.ShiftScaleRotate(rotate_limit=30, scale_limit=0.15, border_mode=cv2.BORDER_CONSTANT, value=[0, 0, 0], p=0.2), albu.IAAAdditiveGaussianNoise(p=0.2), albu.IAAPerspective(p=0.2), ], p=p, additional_targets={ 'image{}'.format(_): 'image' for _ in range(1, 65) })
def get_augmentations_transform(crop_size=128, p=0.5, phase="train"): imagenet_stats = {'mean':[0.485, 0.456, 0.406], 'std':[0.229, 0.224, 0.225]} if phase == "train" or "test": aug_factor_list = [ A.RandomResizedCrop(height=crop_size, width=crop_size, scale=(0.8, 1.0)), A.Cutout(num_holes=8, p=p), A.RandomRotate90(p=p), A.HorizontalFlip(p=p), A.VerticalFlip(p=p), A.HueSaturationValue(hue_shift_limit=20, sat_shift_limit=50, val_shift_limit=50), A.RandomBrightnessContrast(brightness_limit=0.2, contrast_limit=0.2), A.ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=p), A.OneOf([ A.IAAAdditiveGaussianNoise(), A.GaussNoise(), ], p=p), A.OneOf([ A.MotionBlur(p=0.2), A.MedianBlur(blur_limit=3, p=0.1), A.Blur(blur_limit=3, p=0.1), ], p=p), A.OneOf([ A.OpticalDistortion(p=0.3), A.GridDistortion(p=0.1), A.IAAPiecewiseAffine(p=0.3), ], p=p), ToTensor(normalize=imagenet_stats) ] transformed_image = A.Compose(aug_factor_list) return transformed_image elif phase == "valid": transformed_image = A.Compose([ToTensor(normalize=imagenet_stats)]) return transformed_image else: TypeError("Invalid phase type.")
def augment(image): transform = A.Compose([ A.HorizontalFlip(p=0.5), A.OneOf([ A.IAAAdditiveGaussianNoise(), A.GaussNoise(), ], p=0.2), A.OneOf([ A.MotionBlur(p=.2), A.MedianBlur(blur_limit=3, p=0.1), A.Blur(blur_limit=3, p=0.1), ], p=0.2), A.ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.2, rotate_limit=15, p=0.2), A.OneOf([ A.CLAHE(clip_limit=2), A.IAASharpen(), A.IAAEmboss(), A.RandomBrightnessContrast(), A.RandomGamma(), ], p=0.5), A.HueSaturationValue(p=0.3), ]) augmented_image = transform(image=image)['image'] return augmented_image
def transform_train(image, mask): if random.random() < 0.5: image = albumentations.RandomRotate90(p=1)(image=image)['image'] mask = albumentations.RandomRotate90(p=1)(image=mask)['image'] if random.random() < 0.5: image = albumentations.Transpose(p=1)(image=image)['image'] mask = albumentations.Transpose(p=1)(image=mask)['image'] if random.random() < 0.5: image = albumentations.VerticalFlip(p=1)(image=image)['image'] mask = albumentations.VerticalFlip(p=1)(image=mask)['image'] if random.random() < 0.5: image = albumentations.HorizontalFlip(p=1)(image=image)['image'] mask = albumentations.HorizontalFlip(p=1)(image=mask)['image'] # if random.random() < 0.5: # image = albumentations.ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.15, rotate_limit=45, p=1)(image=image)['image'] # mask = albumentations.ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.15, rotate_limit=45, p=1)(image=mask)['image'] if random.random() < 0.5: image = albumentations.RandomBrightness(0.1)(image=image)['image'] image = albumentations.RandomContrast(0.1)(image=image)['image'] image = albumentations.Blur(blur_limit=3)(image=image)['image'] # if random.random() < 0.5: # image = albumentations.Cutout(num_holes=1, max_h_size=32, max_w_size=32, p=1)(image) # mask = albumentations.Cutout(num_holes=1, max_h_size=32, max_w_size=32, p=1)(mask) return image, mask
def predefined_transform() -> None: """ Example from docs https://github.com/albumentations-team/albumentations_examples/blob/master/notebooks/example.ipynb :return: """ return A.Compose([ A.RandomRotate90(), A.Flip(), A.Transpose(), A.OneOf([ A.IAAAdditiveGaussianNoise(), A.GaussNoise(), ], p=0.2), A.OneOf([ A.MotionBlur(p=.2), A.MedianBlur(blur_limit=3, p=0.1), A.Blur(blur_limit=3, p=0.1), ], p=0.2), A.ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=0.2), A.OneOf([ A.OpticalDistortion(p=0.3), A.GridDistortion(p=.1), A.IAAPiecewiseAffine(p=0.3), ], p=0.2), A.OneOf([ A.CLAHE(clip_limit=2), A.IAASharpen(), A.IAAEmboss(), A.RandomBrightnessContrast(), ], p=0.3), A.HueSaturationValue(p=0.3), ])
def __init__(self, folds, img_height, img_width, mean, std): df = pd.read_csv("../input/train_startified_fold5.csv") df = df[df.kfold.isin(folds)] self.image_ids = df.image_id.values self.grapheme_root = df.grapheme_root.values self.vowel_diacritic = df.vowel_diacritic.values self.consonant_diacritic = df.consonant_diacritic.values self.kfold = df.kfold.values self.img_height = img_height self.img_width = img_width # Just Validate if len(folds) == 1: self.augmentations = albumentations.Compose([ albumentations.Resize(img_height, img_width, always_apply=True), albumentations.Normalize(mean, std, always_apply = True) ]) else: self.augmentations = albumentations.Compose([ albumentations.Resize(img_height, img_width, always_apply=True), albumentations.Blur(blur_limit=(7, 7), p=0.5), albumentations.ShiftScaleRotate(shift_limit = 0.7, scale_limit = 0.5, rotate_limit = 10), albumentations.ElasticTransform(), albumentations.Normalize(mean, std, always_apply = True) ])
def build_transforms(args, class_index_dict: Dict[str, int]) -> Tuple[any, any]: train_transforms = AlbumentationsDetectionWrapperTransform( [ A.HorizontalFlip(), A.RandomResizedCrop(width=args.image_size, height=args.image_size, scale=(0.8, 1.), p=1.), A.OneOf([ A.RandomGamma(), A.RandomBrightnessContrast(), A.Blur(blur_limit=5), ], p=0.5), ToTensorV2(), ], annotation_transform=VOCAnnotationTransform(class_index_dict)) test_transforms = AlbumentationsDetectionWrapperTransform( [ A.Resize(width=args.image_size, height=args.image_size), ToTensorV2(), ], annotation_transform=VOCAnnotationTransform(class_index_dict)) return train_transforms, test_transforms
def get_transform(img, boxes, labels, masks): trans = A.Compose( [ A.Blur(), A.VerticalFlip(), A.HorizontalFlip(p=0.5), # A.Rotate(limit=30, interpolation=1, border_mode=4, value=None, mask_value=None, always_apply=False, p=0.5), #A.HueSaturationValue(hue_shift_limit=20, sat_shift_limit=30, val_shift_limit=20, always_apply=False, p=0.5), #A.GaussNoise(var_limit=(10.0, 50.0), mean=0, always_apply=False, p=0.5), A.CLAHE(clip_limit=4.0, tile_grid_size=(8, 8), always_apply=False, p=0.5) ], # A.Cutout(num_holes=8, max_h_size=8, max_w_size=8, fill_value=0, always_apply=False, p=0.5)], bbox_params=A.BboxParams(format='pascal_voc', label_fields=['class_label'])) img = np.array(img) masks = np.array(masks) transformed = trans(image=img, bboxes=boxes, mask=masks, class_label=labels) transformed_img = transformed['image'] transformed_bboxes = transformed['bboxes'] transformed_masks = transformed['mask'].copy() transformed_labels = transformed['class_label'] transformed_img = np.transpose(transformed_img, (2, 0, 1)) transformed_img = torch.as_tensor(transformed_img).div(255) return transformed_img, transformed_bboxes, transformed_labels, transformed_masks
def get_transform(train: bool, im_size: int = 400): if train: aug = A.Compose([ A.OneOf([ A.RandomSizedCrop(min_max_height=(224, 720), height=im_size, width=im_size, p=0.5), A.Resize(height=im_size, width=im_size, interpolation=cv2.INTER_CUBIC, p=0.5) ], p=1), A.ChannelShuffle(p=0.5), A.HorizontalFlip(p=0.5), A.ColorJitter(p=0.5), # A.OneOf([ # A.ElasticTransform(alpha=120, sigma=120 * 0.05, alpha_affine=120 * 0.03, p=0.5), # A.GridDistortion(p=0.5), # A.OpticalDistortion(distort_limit=2, shift_limit=0.5, p=1) # ], p=0.8), A.Blur(p=0.5), A.Normalize(), ToTensorV2(), ]) else: aug = A.Compose([ A.Resize(height=im_size, width=im_size, interpolation=cv2.INTER_CUBIC), A.Normalize(), ToTensorV2(), ]) return aug
def albumtwo(image_file, path_to_train): transform2 = A.Compose([ A.RandomBrightnessContrast(p=0.6), A.OneOf([ A.IAAAdditiveGaussianNoise(), A.GaussNoise(), ], p=0.4), A.OneOf([ A.MotionBlur(p=.2), A.MedianBlur(blur_limit=3, p=0.1), A.Blur(blur_limit=3, p=0.1), ], p=0.2), A.HueSaturationValue(), A.RGBShift(), ]) image = cv2.imread(image_file) image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) transformed2 = transform2(image=image) transformed2_image = transformed2["image"] cv2.imwrite(image_file[:-4] + '_atwo.jpg', transformed2_image) base = os.path.basename(image_file) base = base[:-4] + '.txt' shutil.copy2(path_to_train + "/labels/" + base, path_to_train + "/labels/" + base[:-4] + '_atwo.txt')
def strong_aug(p=.5): return A.Compose( [ A.RandomRotate90(), A.Flip(), # Transpose(), A.OneOf([ A.IAAAdditiveGaussianNoise(), A.GaussNoise(), ], p=0.2), A.OneOf([ A.MotionBlur(p=.2), A.MedianBlur(blur_limit=3, p=0.1), A.Blur(blur_limit=3, p=0.1), ], p=0.2), A.ShiftScaleRotate( shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=0.2), A.OneOf([ A.OpticalDistortion(p=0.3), A.GridDistortion(p=.1), A.IAAPiecewiseAffine(p=0.3), ], p=0.2), A.OneOf([ A.CLAHE(clip_limit=2), A.IAASharpen(), A.IAAEmboss(), A.RandomBrightnessContrast(), ], p=0.3), A.HueSaturationValue(p=0.3), ], p=p)
def augmentations(image_size: int): channel_augs = [ A.HueSaturationValue(p=0.5), A.ChannelShuffle(p=0.5), ] result = [ # *pre_transform(image_size), A.OneOf([ A.IAAAdditiveGaussianNoise(), A.GaussNoise(), ], p=0.5), A.OneOf([ A.MotionBlur(blur_limit=3, p=0.7), A.MedianBlur(blur_limit=3, p=1.0), A.Blur(blur_limit=3, p=0.7), ], p=0.5), A.OneOf(channel_augs), A.OneOf([ A.CLAHE(clip_limit=2), A.IAASharpen(), A.IAAEmboss(), ], p=0.5), A.RandomBrightnessContrast(brightness_limit=0.5, contrast_limit=0.5, p=0.5), A.RandomGamma(p=0.5), A.OneOf([A.MedianBlur(p=0.5), A.MotionBlur(p=0.5)]), A.RandomGamma(gamma_limit=(85, 115), p=0.5), ] return A.Compose(result, bbox_params=BBOX_PARAMS)
def __init__(self, csv_path, data_path, train=True): if train: self.data = pd.read_csv(csv_path) else: self.data = pd.read_csv(csv_path) self.transforms = transforms.ToTensor() self.data_path = data_path self.train = train rotate_crop = albu.Compose([ albu.Rotate(limit=10, p=1.), albu.RandomSizedCrop((185, 202), height=224, width=224, p=1.) ], p=0.5) color = albu.OneOf([ albu.RandomBrightnessContrast(), albu.Blur(blur_limit=3), albu.GaussNoise() ], p=0.3) self.aug = albu.Compose([ albu.HorizontalFlip(), albu.RandomSizedBBoxSafeCrop( height=224, width=224, erosion_rate=0.6, p=0.45), color ], bbox_params={ 'format': 'pascal_voc', 'label_fields': ['category_id'] }, p=1.)
def get_training_augmentation(type='basic'): if type == 'basic': train_transform = [ album.RandomCrop(height=1024, width=1024, always_apply=True), album.HorizontalFlip(p=0.5), album.VerticalFlip(p=0.5), ] elif type == 'advance': train_transform = [ album.RandomCrop(height=1024, width=1024, always_apply=True), album.HorizontalFlip(p=0.5), album.VerticalFlip(p=0.5), album.RandomBrightnessContrast(brightness_limit=0.25, contrast_limit=0.25), album.HueSaturationValue(p=0.5), album.Blur(blur_limit=7, p=0.5), album.ToGray(p=0.5), album.IAASharpen(p=0.5), ] elif type == 'intermediate': train_transform = [ album.RandomCrop(height=1024, width=1024, always_apply=True), album.HorizontalFlip(p=0.5), album.VerticalFlip(p=0.5), album.Rotate(limit=90, p=0.5), album.RandomBrightnessContrast(brightness_limit=0.25, contrast_limit=0.25), album.HueSaturationValue(p=0.5), ] else: raise ValueError(f'type {type} is not supported') return album.Compose(train_transform)
def augmentations(prob=0.95): transformer = A.Compose([ A.OneOf([A.HorizontalFlip(p=prob), A.VerticalFlip(p=prob)], p=prob), A.ShiftScaleRotate(p=prob, shift_limit=0.2, scale_limit=.2, rotate_limit=45), A.RandomRotate90(p=prob), A.Transpose(p=prob), A.OneOf([A.RandomContrast(limit=0.2, p=prob), A.RandomGamma(gamma_limit=(70, 130), p=prob), A.RandomBrightness(limit=0.2, p=prob)],p=prob), A.HueSaturationValue(p=prob), A.OneOf([ A.MotionBlur(p=prob), A.MedianBlur(blur_limit=3, p=prob), A.Blur(blur_limit=3, p=prob) ], p=prob), A.OpticalDistortion(p=prob), A.GridDistortion(p=prob), A.OneOf([ A.IAAAdditiveGaussianNoise(p=prob), A.GaussNoise(p=prob), ], p=prob), ], p=prob) return transformer
def build_transforms(cfg, split='train'): if split == 'train': train_transform = [ albu.Resize(cfg.INPUT.SIZE, cfg.INPUT.SIZE), # albu.HorizontalFlip(p=0.5), albu.OneOf( [ # albu.RandomRotate90(p=1), albu.Rotate(p=1, limit=(-15, 15)), ], p=0.5), albu.GaussNoise(p=0.5), albu.OneOf( [ # albu.CLAHE(p=1), albu.RandomBrightnessContrast(p=1), ], p=0.9, ), albu.OneOf( [ albu.IAASharpen(p=1), albu.Blur(p=1), albu.MedianBlur(p=1), ], p=0.9, ), ] return albu.Compose(train_transform, p=0.6) else: test_transform = [albu.Resize(cfg.INPUT.SIZE, cfg.INPUT.SIZE)] return albu.Compose(test_transform)
def get_transforms(stage: str = None, mode: str = None): if mode == 'train': return albumentations.Compose([ # blur albumentations.OneOf([ albumentations.Blur((1, 4), p=1.0), albumentations.GaussianBlur(3, p=1.0), albumentations.MedianBlur(blur_limit=5, p=1.0), ], p=3/4), # transformations albumentations.ShiftScaleRotate(scale_limit=0.2, rotate_limit=25, border_mode=cv2.BORDER_CONSTANT, value=0, p=1.0), # cut and drop # distortion albumentations.OneOf([ albumentations.OpticalDistortion(0.6, p=1.0), albumentations.GridDistortion(8, 0.06, border_mode=cv2.BORDER_CONSTANT, value=0, p=1.0), albumentations.ElasticTransform(sigma=10, alpha=1, alpha_affine=10, border_mode=cv2.BORDER_CONSTANT, value=0, p=1.0), ], p=3/4), # add noise albumentations.OneOf([ albumentations.GaussNoise((0, 250), p=1.0), albumentations.MultiplicativeNoise(p=1.0), ], p=2/3), # common albumentations.Normalize(TRAIN_MEAN, TRAIN_STD), GridMask((3, 7), rotate=15, p=0.75), ToTensorV2(), ]) elif mode == 'valid': return albumentations.Compose([ albumentations.Normalize(TRAIN_MEAN, TRAIN_STD), ToTensorV2(), ]) else: raise ValueError('mode is %s' % mode)
def hard_transforms(): result = [ # random flip albu.RandomRotate90(), # Random shifts, stretches and turns with a 50% probability albu.ShiftScaleRotate(shift_limit=0.1, scale_limit=0.1, rotate_limit=15, border_mode=0, p=0.5), # add random brightness and contrast, 30% prob albu.RandomBrightnessContrast(brightness_limit=0.2, contrast_limit=0.2, p=0.3), # Random gamma changes with a 30% probability albu.RandomGamma(gamma_limit=(85, 115), p=0.3), # Randomly changes the hue, saturation, and color value of the input image albu.HueSaturationValue(p=0.3), albu.JpegCompression(quality_lower=80), albu.OneOf([ albu.MotionBlur(p=0.2), albu.MedianBlur(blur_limit=3, p=0.1), albu.Blur(blur_limit=3, p=0.1), ], p=0.2), albu.OneOf([ albu.OpticalDistortion(p=0.3), albu.GridDistortion(p=0.1), albu.IAAPiecewiseAffine(p=0.3), ], p=0.2), ] return result
def augment_image(image): # Works with single image transform = A.Compose([ A.HorizontalFlip(), A.OneOf([ A.IAAAdditiveGaussianNoise(), A.GaussNoise(), ], p=0.2), A.OneOf([ A.MotionBlur(), A.MedianBlur(blur_limit=3), A.Blur(blur_limit=3), ], p=0.2), A.ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=0.2), A.OneOf([ A.OpticalDistortion(p=0.3), ], p=0.2), A.OneOf([ A.IAASharpen(p=1.), A.IAAEmboss(p=1.), A.RandomBrightnessContrast(p=1.), ], p=0.3), A.HueSaturationValue(hue_shift_limit=5, sat_shift_limit=5, val_shift_limit=5, p=0.3), ]) return transform(image=image)['image']
def add_transforms(self): if self.train: self.transforms += [ A.Resize(int(self.img_size[0] * 1.1), int(self.img_size[1] * 1.1)), A.RandomCrop(self.img_size[0], self.img_size[1]), A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5), A.Rotate(p=0.5, border_mode=BORDER_REFLECT, value=0), # Pixels A.OneOf([ A.IAAEmboss(p=1.0), A.IAASharpen(p=1.0), A.Blur(p=1.0), ], p=0.5), # Affine A.OneOf([ A.ElasticTransform(p=1.0), A.IAAPiecewiseAffine(p=1.0) ], p=0.5), ] else: self.transforms += [ A.Resize(self.img_size[0], self.img_size[1]), ]
def get_strong_train_transform(): return A.Compose( [ #A.Resize(height=IMG_SIZE, width=IMG_SIZE, p=1), A.RandomSizedBBoxSafeCrop( IMG_SIZE, IMG_SIZE, interpolation=1, p=0.33), A.HorizontalFlip(), A.ShiftScaleRotate(shift_limit=0.05, scale_limit=0.1, rotate_limit=10, interpolation=1, p=0.5), A.OneOf([ A.Blur(blur_limit=(1, 3), p=0.33), A.MedianBlur(blur_limit=3, p=0.33), A.ImageCompression(quality_lower=50, p=0.33), ], p=0.5), A.OneOf([ A.RandomGamma(gamma_limit=(85, 115), p=0.33), A.RandomBrightnessContrast(brightness_limit=0.2, p=0.33), A.HueSaturationValue(hue_shift_limit=25, sat_shift_limit=25, val_shift_limit=30, p=0.5) ], p=0.34), A.CLAHE(clip_limit=2.5, p=0.5), A.Normalize(always_apply=True, p=1.0), ToTensorV2(p=1.0) ], bbox_params=A.BboxParams(format='pascal_voc', min_area=5, min_visibility=0.1, label_fields=['labels']))
def __init__(self): self.transform = None try: import albumentations as A check_version(A.__version__, '1.0.3', hard=True) # version requirement self.transform = A.Compose([ A.Blur(p=0.01), A.MedianBlur(p=0.01), A.ToGray(p=0.01), A.CLAHE(p=0.01), A.RandomBrightnessContrast(p=0.0), A.RandomGamma(p=0.0), A.ImageCompression(quality_lower=75, p=0.0) ], bbox_params=A.BboxParams( format='yolo', label_fields=['class_labels'])) LOGGER.info( colorstr('albumentations: ') + ', '.join(f'{x}' for x in self.transform.transforms if x.p)) except ImportError: # package not installed, skip pass except Exception as e: LOGGER.info(colorstr('albumentations: ') + f'{e}')
def __getitem__(self, idx): aug = albu.Compose([ albu.Flip(p=0.3), albu.Rotate(p=0.9), albu.Blur(p=0.4), albu.ToFloat(p=1.) ]) # image = self.crop_im[idx] # segment = self.crop_mask[idx] image = self.images[idx] # mask = self.masks[idx] segment = self.labels_dict[self.files_names[idx]]['segment'] segment = preprocessing.rleToMask(segment).reshape((4, 256, 1600)) # mask = np.transpose(mask, (2, 1, 0)) # if image.shape != (200, 256, 4): # image = cv2.resize(image, dsize=(200, 256)) # mask = cv2.resize(mask, dsize=(200, 256)) # image = preprocessing.one_augment(aug, image) segment = np.transpose(segment, (1, 2, 0)) image = ToTensor()(image).float() segment = ToTensor()(segment).float() # mask = ToTensor()(mask).float() return (image, segment)
def tr_da_fn(height, width): train_transform = [ A.HorizontalFlip(p=0.5), A.ShiftScaleRotate(scale_limit=0.10, rotate_limit=7, shift_limit=0.10, border_mode=cv2.BORDER_CONSTANT, p=1.0), A.Perspective(scale=(0.025, 0.04), p=0.3), A.RandomResizedCrop(height=height, width=width, scale=(0.9, 1.0), p=0.3), A.OneOf( [ A.CLAHE(p=1), A.RandomBrightness(p=1), A.RandomGamma(p=1), A.RandomContrast(limit=0.2, p=1.0), ], p=0.5, ), A.OneOf( [ A.Sharpen(alpha=(0.2, 0.5), lightness=(0.5, 1.0), p=1.0), A.Blur(blur_limit=[2, 3], p=1.0), A.GaussNoise(var_limit=(5, 25), p=1.0), # A.MotionBlur(blur_limit=3, p=1.0), ], p=0.5, ), A.Lambda(image=_da_negative, p=0.2), A.LongestMaxSize(max_size=max(height, width), always_apply=True), A.PadIfNeeded(min_height=height, min_width=width, border_mode=cv2.BORDER_CONSTANT, always_apply=True), ] return A.Compose(train_transform)
def weak_aug(self, p=0.5): '''Create a weakly augmented image framework''' return A.Compose([ A.HorizontalFlip(), A.OneOf([ A.IAAAdditiveGaussianNoise(), A.GaussNoise(), ], p=0.2), A.OneOf([ A.MotionBlur(p=0.2), A.MedianBlur(blur_limit=3, p=0.1), A.Blur(blur_limit=3, p=0.1), ], p=0.2), A.ShiftScaleRotate( shift_limit=0.0625, scale_limit=0.2, rotate_limit=10, p=0.2), A.OpticalDistortion(p=0.2), A.OneOf([ A.CLAHE(clip_limit=2), A.IAASharpen(), A.IAAEmboss(), ], p=0.3), ], p=p)
def get_pseudo_transforms(): return A.Compose([ A.RandomSizedCrop( min_max_height=(800, 1024), height=1024, width=1024, p=0.5), A.OneOf([ A.HueSaturationValue(hue_shift_limit=0.2, sat_shift_limit=0.2, val_shift_limit=0.2, p=0.9), A.RandomBrightnessContrast( brightness_limit=0.2, contrast_limit=0.2, p=0.9), ], p=0.9), A.ToGray(p=0.01), A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5), A.RandomRotate90(p=0.5), A.Transpose(p=0.5), A.JpegCompression(quality_lower=85, quality_upper=95, p=0.2), A.OneOf( [A.Blur(blur_limit=3, p=1.0), A.MedianBlur(blur_limit=3, p=1.0)], p=0.1), A.Resize(height=SIZE, width=SIZE, p=1), A.Cutout( num_holes=8, max_h_size=64, max_w_size=64, fill_value=0, p=0.5), ToTensorV2(p=1.0), ], p=1.0, bbox_params=A.BboxParams(format='pascal_voc', min_area=0, min_visibility=0, label_fields=['labels']))
def get_training_augmentation(): """Builds random transformations we want to apply to our dataset. Arguments: Returns: A albumentation functions to pass our images to. Raises: """ train_transform = [ 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)