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), albu.Transpose(always_apply=True), albu.OpticalDistortion(always_apply=True), albu.ElasticTransform(always_apply=True), ]) } crop_fn = { 'random': albu.RandomCrop(size, size, always_apply=True), 'center': albu.CenterCrop(size, size, always_apply=True) }[crop] pad = albu.PadIfNeeded(size, size) if scope == "nothing": pipeline = albu.Compose([crop_fn, pad], additional_targets={'target': 'image'}) else: aug_fn = augs[scope] pipeline = albu.Compose([aug_fn, crop_fn, pad], additional_targets={'target': 'image'}) def process(a, b): r = pipeline(image=a, target=b) return r['image'], r['target'] return process
def get_augmentations(): return A.OneOf([ A.RandomContrast(limit=(0.8,1.2),p=0.2), A.MotionBlur(blur_limit=15,p=0.2), A.Cutout(num_holes=8, max_h_size=8, max_w_size=8, fill_value=0,p=0.8), A.Cutout(num_holes=16, max_h_size=4, max_w_size=4, fill_value=255,p=0.8), A.Cutout(num_holes=3, max_h_size=20, max_w_size=20, fill_value=0,p=0.8), A.Cutout(num_holes=10, max_h_size=20, max_w_size=20, fill_value=255,p=0.8), A.ShiftScaleRotate(shift_limit=0.06,scale_limit=0.1,rotate_limit=15,border_mode=cv2.BORDER_CONSTANT,value=255,p=0.8), A.ElasticTransform(alpha=30,sigma=5,alpha_affine=10,border_mode=cv2.BORDER_CONSTANT,value=255,p=1.0), A.ElasticTransform(alpha=60,sigma=15,alpha_affine=20,border_mode=cv2.BORDER_CONSTANT,value=255,p=1.0), ],p=AUGM_PROB)
def get_transform(name='default', resize=512): if name == 'default': transform = A.Compose([ A.Resize(resize, resize), A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5), A.OneOf([ A.RandomContrast(), A.RandomGamma(), A.RandomBrightness(), A.ColorJitter(brightness=0.07, contrast=0.07, saturation=0.1, hue=0.1, always_apply=False, p=0.3), ], p=0.3), A.OneOf([ A.ElasticTransform( alpha=120, sigma=120 * 0.05, alpha_affine=120 * 0.03), A.GridDistortion(), A.OpticalDistortion(distort_limit=2, shift_limit=0.5), ], p=0.0), A.ShiftScaleRotate(), ]) elif name == 'train1': transform = A.Compose([ A.RandomCrop(resize, resize, True), A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5), A.ColorJitter(brightness=0.07, contrast=0.07, saturation=0.1, hue=0.1, always_apply=False, p=0.3), A.ElasticTransform(alpha=120, sigma=120 * 0.05, alpha_affine=120 * 0.03), A.ChannelShuffle(p=0.6) ]) elif name == 'val' or name == 'test': transform = A.Compose([A.Resize(resize, resize)]) else: return None return transform
def hard_spatial_augmentations(image_size: Tuple[int, int], rot_angle=45): return A.Compose([ A.OneOf([ A.NoOp(), A.RandomGridShuffle(grid=(4, 4)), A.RandomGridShuffle(grid=(3, 3)), A.RandomGridShuffle(grid=(2, 2)), ]), A.MaskDropout(max_objects=10), A.OneOf([ A.ShiftScaleRotate(scale_limit=0.1, rotate_limit=rot_angle, border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0), A.NoOp(), ]), A.OneOf([ A.ElasticTransform(border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0), A.GridDistortion(border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0), A.NoOp(), ]), # D4 A.Compose([A.Transpose(), A.RandomRotate90()]), ])
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 = A.ElasticTransform(alpha=1, sigma=50, alpha_affine=50, interpolation=interpolation, p=1) data = aug(image=image, mask=mask) expected_image = F.elastic_transform( 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( 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 get_train_transform(): crop_height = 256 crop_width = 256 return albu.Compose([ albu.PadIfNeeded(min_height=crop_height, min_width=crop_width, p=1), albu.RandomSizedCrop((int(0.3 * crop_height), 288), crop_height, crop_width, p=1), albu.HorizontalFlip(p=0.5), albu.OneOf([ albu.IAAAdditiveGaussianNoise(p=0.5), albu.GaussNoise(p=0.5), ], p=0.2), 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.ShiftScaleRotate(shift_limit=0.0625, scale_limit=0, rotate_limit=20, p=0.1), albu.OneOf([ albu.OpticalDistortion(p=0.3), albu.GridDistortion(p=0.1), albu.IAAPiecewiseAffine(p=0.3), ], p=0.2), albu.OneOf([ albu.CLAHE(clip_limit=2, p=0.5), albu.IAASharpen(p=0.5), albu.IAAEmboss(p=0.5), albu.RandomBrightnessContrast(p=0.5), ], p=0.3), albu.HueSaturationValue(p=0.3), albu.JpegCompression(p=0.2, quality_lower=20, quality_upper=99), albu.ElasticTransform(p=0.1), albu.Normalize(p=1) ], p=1)
def get_transforms(image_size): transforms_train = albumentations.Compose([ albumentations.Transpose(p=0.5), albumentations.VerticalFlip(p=0.5), albumentations.HorizontalFlip(p=0.5), albumentations.RandomBrightness(limit=0.2, p=0.75), albumentations.RandomContrast(limit=0.2, p=0.75), albumentations.OneOf([ albumentations.MotionBlur(blur_limit=5), albumentations.MedianBlur(blur_limit=5), albumentations.GaussianBlur(blur_limit=5), albumentations.GaussNoise(var_limit=(5.0, 30.0)), ], p=0.7), albumentations.OneOf([ albumentations.OpticalDistortion(distort_limit=1.0), albumentations.GridDistortion(num_steps=5, distort_limit=1.), albumentations.ElasticTransform(alpha=3), ], p=0.7), albumentations.CLAHE(clip_limit=4.0, p=0.7), albumentations.HueSaturationValue(hue_shift_limit=10, sat_shift_limit=20, val_shift_limit=10, p=0.5), albumentations.ShiftScaleRotate(shift_limit=0.1, scale_limit=0.1, rotate_limit=15, border_mode=0, p=0.85), albumentations.Resize(image_size, image_size), albumentations.Cutout(max_h_size=int(image_size * 0.375), max_w_size=int(image_size * 0.375), num_holes=1, p=0.7), albumentations.Normalize() ]) transforms_val = albumentations.Compose([ albumentations.Resize(image_size, image_size), albumentations.Normalize() ]) return transforms_train, transforms_val
def da_policy_combination_old(img_size): print("Using Data Augmentation Combinations Old") train_aug = [ albumentations.ElasticTransform(p=0.72, alpha=177, sigma=177 * 0.05, alpha_affine=176 * 0.03), albumentations.GridDistortion(p=0.675, distort_limit=0.3), albumentations.OpticalDistortion(p=0.2, distort_limit=0.2, shift_limit=0.2), albumentations.ShiftScaleRotate(p=0.56, shift_limit=0.2, scale_limit=0.0, rotate_limit=0), # shift albumentations.ShiftScaleRotate(p=0.25, shift_limit=0.0, scale_limit=0.2, rotate_limit=0), # scale albumentations.VerticalFlip(p=0.325), albumentations.HorizontalFlip(p=0.3), albumentations.Rotate(p=0.625, limit=45, interpolation=1, border_mode=0), ] train_aug = common_test_augmentation(img_size) + train_aug train_aug_img = [] val_aug = common_test_augmentation(img_size) return train_aug, train_aug_img, val_aug
def get_transforms(*, data_type): if data_type == "light_train": return Compose([ Resize(CFG.size, CFG.size), Transpose(p=0.5), HorizontalFlip(p=0.5), VerticalFlip(p=0.5), ShiftScaleRotate(scale_limit=(0, 0), p=0.5), ToTensorV2(), ]) if data_type == "train": return Compose([ Resize(CFG.size, CFG.size), Transpose(p=0.5), HorizontalFlip(p=0.5), VerticalFlip(p=0.5), albumentations.OneOf([ albumentations.ElasticTransform( alpha=1, sigma=20, alpha_affine=10), albumentations.GridDistortion(num_steps=6, distort_limit=0.1), albumentations.OpticalDistortion(distort_limit=0.05, shift_limit=0.05), ], p=0.2), albumentations.core.composition.PerChannel(albumentations.OneOf([ albumentations.MotionBlur(p=.05), albumentations.MedianBlur(blur_limit=3, p=.05), albumentations.Blur(blur_limit=3, p=.05), ]), p=1.0), albumentations.OneOf([ albumentations.CoarseDropout(max_holes=16, max_height=CFG.size // 16, max_width=CFG.size // 16, fill_value=0, p=0.5), albumentations.GridDropout(ratio=0.09, p=0.5), albumentations.Cutout(num_holes=8, max_h_size=CFG.size // 16, max_w_size=CFG.size // 16, p=0.2), ], p=0.5), albumentations.ShiftScaleRotate( shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=0.5), ToTensorV2(), ], additional_targets={ 'r': 'image', 'g': 'image', 'b': 'image', 'y': 'image', }) elif data_type == 'valid': return Compose([ Resize(CFG.size, CFG.size), ToTensorV2(), ])
def get_train_transform(self): # fill values for cutout or cropping portion fill_value = [255. * mean for mean in self.means] rc_padding = 32 rc_pval = 0.2 randomCrop = [albumentations.PadIfNeeded(min_height=self.size+rc_padding, min_width=self.size+rc_padding, border_mode=cv2.BORDER_REPLICATE, value=fill_value, p=1.0), albumentations.OneOf([ albumentations.RandomCrop(height=self.size, width=self.size, p=rc_pval), albumentations.CenterCrop(height=self.size, width=self.size, p=1-rc_pval), ], p=1.0) ] train_tf = albumentations.Compose([ albumentations.Resize(self.size,self.size), albumentations.RandomBrightness(limit=0.2, p=0.5), albumentations.RandomContrast(limit=0.2, p=0.5), albumentations.Rotate(limit=(-10,10), p=0.70), randomCrop[0], randomCrop[1], albumentations.HorizontalFlip(p=0.7), albumentations.ElasticTransform(sigma=50, alpha=1, alpha_affine=10,p=0.10), albumentations.CoarseDropout(max_holes=1, max_height=64, max_width=64, min_height=16, min_width=16, fill_value=fill_value, p=0.70), albumentations.Normalize(mean=self.means, std=self.stds), ToTensor() ]) train_tf = AlbumCompose(train_tf) return train_tf
def get_aug(mode="train"): if mode == "Nor": aug = A.Compose([ ToTensor(), ]) elif mode == "train": aug = A.Compose([ A.Flip(), A.ShiftScaleRotate(rotate_limit=1.0, p=0.8), # 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), A.Normalize(p=1.0), ToTensor(), ]) else: aug = A.Compose([ A.Normalize(p=1.0), ToTensor(), ]) return aug
def album(self): #이미지 변환 transform = A.Compose([ #A.RandomRotate90(), A.Flip(p=0.2), #A.Transpose(), A.ChannelShuffle(p=0.3), A.ElasticTransform(p=0.3,border_mode=cv2.BORDER_REFLECT_101,alpha_affine=40), 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), ]) image = cv2.cvtColor(self.srcResize, cv2.COLOR_BGR2RGB) transformed = transform(image=image)['image'] self.update(transformed)
def __init__(self, data_dir, train=True, **kwargs): if train: transform_shape = A.Compose([ A.ElasticTransform(alpha=2, sigma=5, alpha_affine=5), A.RandomScale((-.15, .1)), A.PadIfNeeded(160, 160, value=0, border_mode=1), A.CenterCrop(160, 160), A.HorizontalFlip(), A.Rotate(limit=5), ]) transform_color = A.Compose([ A.RandomBrightnessContrast(brightness_limit=.15, contrast_limit=.15), A.GaussianBlur(blur_limit=7), A.GaussNoise(var_limit=.001, ) ]) else: transform_shape = transform_color = None super(brain_dataset, self).__init__(data_dir, sample=True, transform_shape=transform_shape, transform_color=transform_color, **kwargs)
def __init__(self, dataset, file, factor=1): super(TrainDataset, self).__init__() import h5py DATA = h5py.File(file, 'r') self.data = DATA.get(f'{dataset}/data') self.av = DATA.get(f'{dataset}/av') self.field = DATA.get(f'{dataset}/radial-field') self.mask = DATA.get(f'{dataset}/mask') self.geo_aug = A.Compose([ #A.PadIfNeeded(800, 800, value=0, border_mode=cv2.BORDER_CONSTANT), #A.RandomCrop(da_config['crop-size'], da_config['crop-size']), A.HorizontalFlip(p=0.5), A.Rotate(limit=(-180, 180)), A.ElasticTransform( alpha=da_config['elastic-transform']['alpha'], sigma=da_config['elastic-transform']['sigma'], alpha_affine=da_config['elastic-transform'] ['alpha-affine'], border_mode=cv2.BORDER_CONSTANT, p=.9), A.VerticalFlip(p=0.5), ToTensorV2() ]) self.factor = factor self._data_length = len(self.data)
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 __init__(self, image_size): self.data_transform = { 'train_transform':A.Compose([ A.Transpose(p=0.5), A.VerticalFlip(p=0.5), A.HorizontalFlip(p=0.5), A.RandomBrightness(limit=0.2, p=0.75), A.RandomContrast(limit=0.2, p=0.75), A.OneOf([ A.MotionBlur(blur_limit=5), A.MedianBlur(blur_limit=5), A.GaussianBlur(blur_limit=5), A.GaussNoise(var_limit=(5.0, 30.0)),], p=0.7), A.OneOf([ A.OpticalDistortion(distort_limit=1.0), A.GridDistortion(num_steps=5, distort_limit=1.), A.ElasticTransform(alpha=3),], p=0.7), A.CLAHE(clip_limit=4.0, p=0.7), A.HueSaturationValue(hue_shift_limit=10, sat_shift_limit=20, val_shift_limit=10, p=0.5), A.ShiftScaleRotate(shift_limit=0.1, scale_limit=0.1, rotate_limit=15, border_mode=0, p=0.85), A.Resize(image_size, image_size), A.Cutout(max_h_size=int(image_size * 0.375), max_w_size=int(image_size * 0.375), num_holes=1, p=0.7), A.Normalize() ]), 'test_transform': A.Compose([ A.Resize(image_size, image_size), A.Normalize(), A.Resize(image_size, image_size) ])}
def _strong_aug(p=0.5): import albumentations return albumentations.Compose([ albumentations.HorizontalFlip(p=0.5), albumentations.ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.2, rotate_limit=0, p=0.5, border_mode=cv2.BORDER_CONSTANT), albumentations.OneOf([ albumentations.OpticalDistortion(p=0.5, border_mode=cv2.BORDER_CONSTANT), albumentations.GridDistortion(p=0.5, border_mode=cv2.BORDER_CONSTANT), albumentations.IAAPiecewiseAffine(p=0.5), albumentations.ElasticTransform(p=0.5, border_mode=cv2.BORDER_CONSTANT), ], p=0.5), albumentations.OneOf([ albumentations.CLAHE(clip_limit=2), albumentations.IAASharpen(), albumentations.IAAEmboss(), ], p=0.5), albumentations.OneOf([ albumentations.RandomBrightnessContrast(p=0.5), ], p=0.4), albumentations.HueSaturationValue(p=0.5), ], p=p)
def get_aug(mode="train"): if mode=="Nor": aug=A.Compose([ ToTensor(), ]) elif mode =="train": print("train aug") mean = (0.485,0.456,0.406) std = (0.229,0.224,0.225) aug=A.Compose([ A.Flip(), A.ShiftScaleRotate(rotate_limit=1.0, p=0.8), # 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), A.Normalize(mean=mean,std=std,max_pixel_value=255.0,always_apply=True), ]) else: print("valid/test aug") mean = (0.485,0.456,0.406) std = (0.229,0.224,0.225) aug=A.Compose([ A.Normalize(mean=mean,std=std,max_pixel_value=255.0,always_apply=True), ]) return aug
def get_transforms(size: int, scope: str = 'geometric', crop='random'): augs = { 'weak': albu.Compose([ albu.HorizontalFlip(), ]), 'geometric': albu.OneOf([ albu.HorizontalFlip(always_apply=True), albu.ShiftScaleRotate(always_apply=True), albu.Transpose(always_apply=True), albu.OpticalDistortion(always_apply=True), albu.ElasticTransform(always_apply=True), ]) } 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, pad, crop_fn], additional_targets={'target': 'image'}) def process(a, b): r = pipeline(image=a, target=b) return r['image'], r['target'] return process
def get_transforms(type="albumentations"): if type == "albumentations": train_transforms = albumentations.Compose([ albumentations.Transpose(p=0.5), albumentations.OneOf([ albumentations.VerticalFlip(p=0.5), albumentations.HorizontalFlip(p=0.5), ]), albumentations.OneOf([ albumentations.RandomBrightness(limit=0.2, p=0.75), albumentations.RandomContrast(limit=0.2, p=0.75), ]), albumentations.OneOf([ albumentations.MotionBlur(blur_limit=5), albumentations.MedianBlur(blur_limit=5), albumentations.GaussianBlur(blur_limit=5), albumentations.GaussNoise(var_limit=(5.0, 30.0)), ], p=0.7), albumentations.OneOf([ albumentations.OpticalDistortion(distort_limit=1.0), albumentations.GridDistortion(num_steps=5, distort_limit=1.), albumentations.ElasticTransform(alpha=3), ], p=0.7), # albumentations.OneOf([ # albumentations.CLAHE(clip_limit=4.0, p=0.7), # albumentations.HueSaturationValue(hue_shift_limit=10, sat_shift_limit=20, val_shift_limit=10, p=0.5), # albumentations.ShiftScaleRotate(shift_limit=0.1, scale_limit=0.1, rotate_limit=15, border_mode=0, # p=0.85), # ]), albumentations.Resize(256, 256), # albumentations.Cutout(max_h_size=int(256 * 0.375), max_w_size=int(256 * 0.375), num_holes=1, p=0.7), # albumentations.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) test_transforms = albumentations.Compose([ albumentations.Resize(256, 256), # albumentations.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) else: train_transforms = transforms.Compose([ # AdvancedHairAugmentation(hairs_folder='/kaggle/input/melanoma-hairs'), transforms.RandomResizedCrop(size=256, scale=(0.9, 1.0)), transforms.RandomHorizontalFlip(), transforms.RandomVerticalFlip(), Microscope(p=0.5), transforms.Resize((256, 256)), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) test_transforms = transforms.Compose([ transforms.Resize((256, 256)), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) return train_transforms, test_transforms
def elastic_tranform_r_brightness(p=1.0): return albumentations.Compose([ albumentations.ElasticTransform(p=p), albumentations.RandomBrightnessContrast(p=p), albumentations.RandomRain(p=p) ], p=p)
def get_transforms(phase, size, mean, std): list_transforms = [] if phase == "train": list_transforms.extend( [ albu.HorizontalFlip(), albu.OneOf([ albu.RandomContrast(), albu.RandomGamma(), albu.RandomBrightness(), ], p=0.3), albu.OneOf([ albu.ElasticTransform(alpha=120, sigma=120 * 0.05, alpha_affine=120 * 0.03), albu.GridDistortion(), albu.OpticalDistortion(distort_limit=2, shift_limit=0.5), ], p=0.3), albu.ShiftScaleRotate(), ] ) list_transforms.extend( [ albu.Normalize(mean=mean, std=std, p=1), albu.Resize(size, size), ToTensorV2(), ] ) list_trfms = albu.Compose(list_transforms) return list_trfms
def get_transforms(phase, width=1600, height=256): list_transforms = [] if phase == "train": list_transforms.extend([ albu.HorizontalFlip(), albu.OneOf([ albu.RandomContrast(), albu.RandomGamma(), albu.RandomBrightness(), ], p=0.3), albu.OneOf([ albu.ElasticTransform( alpha=120, sigma=120 * 0.05, alpha_affine=120 * 0.03), albu.GridDistortion(), albu.OpticalDistortion(distort_limit=2, shift_limit=0.5), ], p=0.3), albu.ShiftScaleRotate(), ]) list_transforms.extend([ albu.Resize(width, height, always_apply=True), albu.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), p=1), ToTensor(), ]) list_trfms = albu.Compose(list_transforms) return list_trfms
def cifar_alb_trainData(): '''Apply Albumentations data transforms to the dataset and returns iterable''' train_transform = [ A.HorizontalFlip(p=0.15), A.ShiftScaleRotate(shift_limit=0.05, scale_limit=0.05, rotate_limit=15, p=0.25), A.RGBShift(r_shift_limit=15, g_shift_limit=15, b_shift_limit=15, p=0.5), A.RandomBrightnessContrast(p=0.25), A.RandomGamma(p=0.25), A.CLAHE(p=0.25), A.ChannelShuffle(p=0.1), A.ElasticTransform(p=0.1), A.MotionBlur(blur_limit=17, p=0.1), A.Cutout(num_holes=1, max_h_size=16, max_w_size=16, fill_value=mean, always_apply=False, p=0.5), A.Normalize(mean=mean, std=std), ToTensor() ] transforms_result = A.Compose(train_transform) return lambda img: transforms_result(image=np.array(img))["image"]
def cifar_alb_trainData(): '''Apply Albumentations data transforms to the dataset and returns iterable''' mean = (0.491, 0.482, 0.446) std = (0.247, 0.243, 0.261) train_transform = [ A.ShiftScaleRotate(shift_limit=0.05, scale_limit=0.05, rotate_limit=15, p=0.5), A.RandomCrop(height=32, width=32), A.RGBShift(r_shift_limit=15, g_shift_limit=15, b_shift_limit=15, p=0.5), A.RandomBrightnessContrast(p=0.5), A.GaussNoise(), A.ElasticTransform(), # A.MaskDropout((10,15), p=1), A.Cutout(num_holes=1, max_h_size=16, max_w_size=16, fill_value=mean, always_apply=False, p=0.5), A.Normalize(mean=mean, std=std), ToTensorV2() ] transforms_result = A.Compose(train_transform) return lambda img: transforms_result(image=np.array(img))["image"]
def __init__(self, imgs_dir, masks_dir, labels_dir=None): self.imgs_dir = imgs_dir self.masks_dir = masks_dir self.images_filesnames = sorted(os.listdir(imgs_dir)) self.labels_dir = labels_dir self.labels, self.negative_samples_idx = None, [] if labels_dir is not None: self.labels = pd.read_csv(labels_dir)['labels'].to_numpy() # For now: use 1 for benign/malignant, 0 for normal self.labels[self.labels != 2] = 1 self.labels[self.labels == 2] = 0 self.negative_samples_idx = (self.labels == 0) # Specify data augmentations here self.transformations = A.Compose([ A.Resize(256, 256), A.OneOf([ A.RandomRotate90(p=0.5), A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5), A.ShiftScaleRotate(scale_limit=0.5, rotate_limit=0, shift_limit=0.1, p=0.5, border_mode=0), A.RandomBrightnessContrast(p=0.2), A.GridDistortion(p=0.2), A.ElasticTransform(p=0.2) ]), ])
def get_individual_transforms(): transforms = A.Compose([ A.OneOf( [ A.Transpose(p=1.0), A.VerticalFlip(p=1.0), A.HorizontalFlip(p=1.0), A.RandomRotate90(p=1.0), A.NoOp(), ], p=1.0, ), A.OneOf( [ A.ElasticTransform(p=1.0), A.GridDistortion(p=1.0), A.OpticalDistortion(p=1.0), A.NoOp(), ], p=1.0, ), A.OneOf( [ A.GaussNoise(p=1.0), A.GaussianBlur(p=1.0), A.ISONoise(p=1.0), A.CoarseDropout( p=1.0, max_holes=16, max_height=16, max_width=16), A.NoOp(), ], p=1.0, ), ]) return transforms
def aug_medium(prob=1): return aug.Compose([ aug.Flip(), aug.OneOf([ aug.CLAHE(clip_limit=2, p=.5), aug.IAASharpen(p=.25), ], p=0.35), aug.OneOf([ aug.RandomContrast(), aug.RandomGamma(), aug.RandomBrightness(), ], p=0.3), aug.OneOf([ aug.ElasticTransform( alpha=120, sigma=120 * 0.05, alpha_affine=120 * 0.03), aug.GridDistortion(), aug.OpticalDistortion(distort_limit=2, shift_limit=0.5), ], p=0.3), aug.ShiftScaleRotate(rotate_limit=12), aug.OneOf([ aug.GaussNoise(p=.35), SaltPepperNoise(level_limit=0.0002, p=.7), aug.ISONoise(p=.7), ], p=.5), aug.Cutout(num_holes=3, p=.25), ], p=prob)
def get_augmentation( aug_prob: float = 1.0, rotate_limit: int = 45, scale_limit: float = 0.1, shift_limit: float = 0.3, ): """Returns image augmentor.""" aug = alb.Compose( [ # Flips, shifts, scales, rotations. alb.ShiftScaleRotate( shift_limit=shift_limit, scale_limit=scale_limit, rotate_limit=rotate_limit, p=aug_prob, ), # Transforms. alb.ElasticTransform(), ], p=aug_prob, ) def augment(image): augmented = aug(image=image.numpy()) return augmented["image"] def _mapper(image): image_aug = tf.py_function(augment, [image], image.dtype) image_aug.set_shape(image.shape) return image_aug return _mapper
def composeAugmentation(self): if self.source == 'train': self.total = 10 self.augment = albumentations.Compose([ albumentations.Rotate(3, always_apply=True), albumentations.RandomSizedCrop((self.sizeY // 2, 700), self.sizeY, self.sizeX, 1, always_apply=True), albumentations.HorizontalFlip(), #albumentations.GridDistortion(always_apply=False), #albumentations.IAAAffine(rotate=2, shear=5, always_apply=False), #albumentations.OpticalDistortion(), albumentations.ElasticTransform(alpha=64, sigma=24, always_apply=False, alpha_affine=0), albumentations.RandomBrightnessContrast(0.1, 0.1, always_apply=False), #albumentations.Blur(always_apply=False) ]) else: self.total = 4 self.augment = albumentations.Compose([ albumentations.RandomSizedCrop((self.sizeY, self.sizeY), self.sizeY, self.sizeX, 1, always_apply=True), ])