def augment(self, x): x = x.transpose(1, 2, 0) # cutout x = CoarseDropout(max_holes=1, max_height=16, max_width=16, min_holes=1, min_height=1, min_width=1, fill_value=0, p=0.5)(image=x)["image"] # width height shift and rotate x = ShiftScaleRotate( shift_limit=0.25, scale_limit=0, rotate_limit=0, interpolation=cv2.INTER_LINEAR, border_mode=cv2.BORDER_REFLECT_101, value=0, mask_value=0, p=0.5, )(image=x)["image"] # flip x = HorizontalFlip(p=0.5)(image=x)["image"] x = x.transpose(2, 0, 1) return (x - self.mean) / self.std
def __init__(self, settype): self.settype = settype self.stddev, self.means = self.dataset_calculate_mean_std() if self.settype == 'train': print("Train set") self.albumentation_transform = Compose([ RandomBrightnessContrast(always_apply=False, p=0.5, brightness_limit=(-0.40, 0.82), contrast_limit=(-0.40, 0.82), brightness_by_max=True), HorizontalFlip(always_apply=False, p=0.5), # Cutout(always_apply=False, p=1.0, num_holes=2, max_h_size=6, max_w_size=6, fill_value=[127.5,127.5,127.5]), GaussNoise(always_apply=False, p=1.0, var_limit=(60, 100)), CoarseDropout(max_holes=2, max_height=16, max_width=16, min_holes=1, min_height=8, min_width=8, fill_value=list(255 * self.means), always_apply=False, p=1.0), Normalize( mean = list(self.means), std = list(self.stddev), ), ToTensor() ]) elif self.settype == 'test': print("Test set") self.albumentation_transform = Compose([ Normalize( mean = list(self.means), std = list(self.stddev), ), ToTensor() ])
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 test_aug(): img = Image.open( '/media/wenyan/data_nataliya/camera21062019/depth_camera1246.svo/depth000005.png' ) # img = img.resize((640, 480), Image.ANTIALIAS) a = np.array(img).astype('uint16') a = cv2.resize(a, dsize=(640, 480), interpolation=cv2.INTER_CUBIC) print(a.shape) b = a / 65525. * 255 show(b) im_w = b.shape[1] im_h = b.shape[0] aug = HorizontalFlip(p=1) aug = CoarseDropout(max_holes=8, max_height=50, max_width=45, min_holes=1, min_height=30, min_width=30, fill_value=0, always_apply=False, p=0.85) for i in range(10): # Rotate(limit=20, p=1) # RandomCrop(height=640, width=1000, p=1) # Blur(blur_limit=(50, 50), p=1) # ElasticTransform() aug = strong_aug(im_height=im_h, im_width=im_w) augment_and_show(aug, b) """
def albumentations_transforms(p=1.0, is_train=False): # Mean and standard deviation of train dataset mean = np.array([0.4914, 0.4822, 0.4465]) std = np.array([0.2023, 0.1994, 0.2010]) transforms_list = [] # Use data aug only for train data if is_train: transforms_list.extend([ PadIfNeeded(min_height=72, min_width=72, p=1.0), RandomCrop(height=64, width=64, p=1.0), HorizontalFlip(p=0.25), Rotate(limit=15, p=0.25), RGBShift(r_shift_limit=20, g_shift_limit=20, b_shift_limit=20, p=0.25), CoarseDropout(max_holes=1, max_height=32, max_width=32, min_height=8, min_width=8, fill_value=mean * 255.0, p=0.5), ]) transforms_list.extend([ Normalize(mean=mean, std=std, max_pixel_value=255.0, p=1.0), ToTensor() ]) data_transforms = Compose(transforms_list, p=p) return lambda img: data_transforms(image=np.array(img))["image"]
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 albumentations_transforms(p=1.0, is_train=False): # Mean and standard deviation of train dataset mean = np.array([0.4914, 0.4822, 0.4465]) std = np.array([0.2023, 0.1994, 0.2010]) transforms_list = [] # Use data aug only for train data if is_train: transforms_list.extend([ HueSaturationValue(p=0.25), HorizontalFlip(p=0.5), Rotate(limit=15), CoarseDropout(max_holes=1, max_height=16, max_width=16, min_height=4, min_width=4, fill_value=mean*255.0, p=0.75), ]) transforms_list.extend([ Normalize( mean=mean, std=std, max_pixel_value=255.0, p=1.0 ), ToTensor() ]) transforms = Compose(transforms_list, p=p) return lambda img:transforms(image=np.array(img))["image"
def albumentations_transforms(p=1.0, is_train=False): # Mean and standard deviation of train dataset mean = np.array([0.4914, 0.4822, 0.4465]) std = np.array([0.2023, 0.1994, 0.2010]) transforms_list = [] # Use data aug only for train data if is_train: transforms_list.extend([ PadIfNeeded(min_height=40, min_width=40, border_mode=BORDER_CONSTANT, value=mean*255.0, p=1.0), OneOf([ RandomCrop(height=32, width=32, p=0.8), CenterCrop(height=32, width=32, p=0.2), ], p=1.0), HorizontalFlip(p=0.5), CoarseDropout(max_holes=1, max_height=8, max_width=8, min_height=8, min_width=8, fill_value=mean*255.0, p=0.75), ]) transforms_list.extend([ Normalize( mean=mean, std=std, max_pixel_value=255.0, p=1.0 ), ToTensor() ]) transforms = Compose(transforms_list, p=p) return lambda img:transforms(image=np.array(img))["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 __init__(self, means, stddev, settype): self.settype = settype self.means = np.array(means) self.stddev = np.array(stddev) if self.settype == 'train': print("Train set") self.albumentation_transform = Compose([ PadIfNeeded(min_height=72, min_width=72, border_mode=1, value=list(255 * self.means), p=1.0), # RandomBrightnessContrast(always_apply=False, p=0.5, brightness_limit=(-0.40, 0.82), contrast_limit=(-0.40, 0.82), brightness_by_max=True), RandomCrop(height=64, width=64, always_apply=True, p=1.0), HorizontalFlip(always_apply=False, p=0.5), Rotate(limit=15, interpolation=1, border_mode=4, value=None, mask_value=None, always_apply=False, p=0.5), # Cutout(always_apply=True, p=1.0, num_holes=1, max_h_size=8, max_w_size=8, fill_value=list(255 * self.means)), GaussNoise(always_apply=False, p=1.0, var_limit=(60, 100)), CoarseDropout(max_holes=1, max_height=16, max_width=16, min_holes=1, min_height=8, min_width=8, fill_value=list(255 * self.means), always_apply=False, p=1.0), Normalize( mean = list(self.means), std = list(self.stddev), ), ToTensor() ]) elif self.settype == 'test': print("Test set") self.albumentation_transform = Compose([ Normalize( mean = list(self.means), std = list(self.stddev), ), ToTensor() ])
def get_transforms(*, data): if data == 'train': return Compose([ RandomResizedCrop(CFG.size, CFG.size), Transpose(p=0.5), HorizontalFlip(p=0.5), VerticalFlip(p=0.5), ShiftScaleRotate(p=0.5), HueSaturationValue(hue_shift_limit=0.2, sat_shift_limit=0.2, val_shift_limit=0.2, p=0.5), RandomBrightnessContrast(brightness_limit=(-0.1,0.1), contrast_limit=(-0.1, 0.1), p=0.5), CoarseDropout(p=0.5), Cutout(p=0.5), Normalize( mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], ), ToTensorV2(), ]) elif data == 'valid': return Compose([ Resize(CFG.size, CFG.size), Normalize( mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], ), ToTensorV2(), ])
def get_transforms(*, data): if data == 'train': return Compose([ #Resize(CFG.size, CFG.size), RandomResizedCrop(CFG.size, CFG.size, scale=(0.85, 1.0)), HorizontalFlip(p=0.5), RandomBrightnessContrast(p=0.2, brightness_limit=(-0.2, 0.2), contrast_limit=(-0.2, 0.2)), HueSaturationValue(p=0.2, hue_shift_limit=0.2, sat_shift_limit=0.2, val_shift_limit=0.2), ShiftScaleRotate(p=0.2, shift_limit=0.0625, scale_limit=0.2, rotate_limit=20), CoarseDropout(p=0.2), Cutout(p=0.2, max_h_size=16, max_w_size=16, fill_value=(0., 0., 0.), num_holes=16), Normalize( mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], ), ToTensorV2(), ]) elif data == 'valid': return Compose([ Resize(CFG.size, CFG.size), Normalize( mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], ), ToTensorV2(), ])
def get_train_transforms(): return Compose( [ #Resize(args.img_size, args.img_size), RandomResizedCrop(args.img_size, args.img_size), Transpose(p=0.5), HorizontalFlip(p=0.5), VerticalFlip(p=0.25), ShiftScaleRotate(p=0.25), HueSaturationValue(hue_shift_limit=0.2, sat_shift_limit=0.2, val_shift_limit=0.2, p=0.25), RandomBrightnessContrast(brightness_limit=(-0.1, 0.1), contrast_limit=(-0.1, 0.1), p=0.5), Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], max_pixel_value=255.0, p=1.0), CoarseDropout(p=0.5), # Cutout(p=0.5), ToTensorV2(p=1.0), ], p=1.)
def gettraintransforms(self, mean, std, p=1): # Train Phase transformations albumentations_transform = Compose([ # RandomRotate90(), PadIfNeeded(72, 72, border_mode=cv2.BORDER_REFLECT, always_apply=True), RandomCrop(64, 64, True), Flip(), GaussNoise(p=0.8, mean=mean), OneOf([ MotionBlur(p=0.4), MedianBlur(blur_limit=3, p=0.2), Blur(blur_limit=3, p=0.2), ], p=0.4), ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=0.6), OneOf([ OpticalDistortion(p=0.8), GridDistortion(p=0.4), ], p=0.6), HueSaturationValue(hue_shift_limit=20, sat_shift_limit=0.1, val_shift_limit=0.1, p=0.6), CoarseDropout(always_apply=True, max_holes=1, min_holes=1, max_height=16, max_width=16, fill_value=(255 * .6), min_height=16, min_width=16), Normalize(mean=mean, std=std, always_apply=True), pytorch.ToTensorV2(always_apply=True), ], p=p) return albumentations_transform;
def _prepare_data(self): # Augumentation used only while training train_transforms_album = Compose([ HueSaturationValue(p=0.25), HorizontalFlip(p=0.5), Rotate(limit=15), CoarseDropout( max_holes=1, max_height=16, max_width=16, min_height=4, min_width=4, fill_value=np.array(self._train_mean()) * 255.0, p=0.75, ), Normalize(mean=self._train_mean(), std=self._train_std()), ToTensor(), ]) def train_transforms(img): return train_transforms_album(image=np.array(img))["image"] # train_transforms = transforms.Compose( # [ # transforms.RandomCrop(32, padding=4), # transforms.RandomHorizontalFlip(), # transforms.ToTensor(), # transforms.Normalize(self._train_mean(), self._train_std()), # ] # ) train_dataset = datasets.CIFAR10(root="./data", train=True, download=True, transform=train_transforms) # No Augumentation while testing test_transforms_album = Compose([ Normalize(mean=self._test_mean(), std=self._test_std()), ToTensor() # transforms.ToTensor(), # transforms.Normalize(self._test_mean(), self._test_std()), ]) def test_transforms(img): return test_transforms_album(image=np.array(img))["image"] # Pytorch default approach # test_transforms = transforms.Compose( # [ # transforms.ToTensor(), # transforms.Normalize(self._test_mean(), self._test_std()), # ] # ) test_dataset = datasets.CIFAR10(root="./data", train=False, transform=test_transforms) return train_dataset, test_dataset
def cutout_aug_3(): augs_list = [ OneOf([ CoarseDropout(min_holes=2, max_holes=10, max_height=12, max_width=12, fill_value=0, p=0.3), CoarseDropout(max_holes=1, max_height=64, max_width=64, fill_value=0, p=0.3) ]), Normalize(), ToTensorV2() ] return Compose(augs_list, p=1)
def __init__(self): self.albumentation_transforms = Compose([ # Resize(256, 256), Rotate((-7.0, 7.0)), #Cutout(), CoarseDropout(), # RandomCrop(224,224), HorizontalFlip(), Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]), ToTensor() ])
def __init__(self): self.albumentation_transforms = Compose([ Rotate((-7.0, 7.0)), Cutout(), CoarseDropout(), # RandomSizedCrop':{'height':32,'width':32,'min_max_height':[28,28]}, # RandomCrop(10,10), HorizontalFlip(), Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]), ToTensor() ])
def cutout_aug_2(): augs_list = [ CoarseDropout(max_holes=1, max_height=64, max_width=64, fill_value=0, p=0.3), Normalize(), ToTensorV2() ] return Compose(augs_list, p=1)
def generate_cutout_augmentation(aug_cfg): cutout_aug_list = [] if aug_cfg.COARSE_DROPOUT_PROB > 0: cutout_aug_list.append(CoarseDropout(max_holes=5, max_height=7, max_width=7, p=aug_cfg.COARSE_DROPOUT_PROB)) if len(cutout_aug_list) > 0: cutout_aug = Compose(cutout_aug_list, p=1) return cutout_aug else: return None
def augument(): augm = Compose([ RGBShift(), RandomBrightness(), RandomContrast(), HueSaturationValue(p=0.2), ChannelShuffle(), CLAHE(), Blur(), ToGray(), CoarseDropout() ], p=0.5) return augm
def transforms(size, p=0.5): area = size**2 transform = [ CoarseDropout(max_holes=256, max_height=8, max_width=8, min_holes=16, min_height=1, min_width=1, p=p), HorizontalFlip(p=p), VerticalFlip(p=p), RandomRotate90(p=p), Resize(size, size), ] return Compose(transform)
def __init__(self, annotations, root_dir, augmented): """ Args: annotations [[string, int]] root_dir (string): Directory with all the images. augmented (bool): True if we want to augment the dataset with flips, rotate, etc """ self.annotations = annotations self.root_dir = root_dir self.augmented = augmented if (augmented): self.augmentations = Compose([HorizontalFlip(), VerticalFlip(), RandomRotate90(), CoarseDropout(max_holes=12, max_height=24, max_width=24)]) else: self.augmentations = Compose([])
def __init__(self, image_filenames, labels, root_directory='', batch_size=128, mix=False, shuffle=True, augment=True): self.image_filenames = image_filenames self.labels = labels self.root_directory = root_directory self.batch_size = batch_size self.is_mix = mix self.is_augment = augment self.shuffle = shuffle if self.shuffle: self.on_epoch_end() if self.is_augment: self.generator = Compose([Blur(), Flip(), Transpose(), ShiftScaleRotate(), RandomBrightnessContrast(), HueSaturationValue(), CLAHE(), GridDistortion(), ElasticTransform(), CoarseDropout(), ToFloat(max_value=255.0, p=1.0)], p=1.0) else: self.generator = Compose([ToFloat(max_value=255.0, p=1.0)], p=1.0)
def gridmask_aug(): augs_list = [ OneOf([ OneOf([ GridMask(num_grid=(10, 15), rotate=10, mode=0, fill_value=0), GridMask(num_grid=(10, 15), rotate=10, mode=2, fill_value=0), GridMask(num_grid=(10, 15), rotate=0, mode=0, fill_value=0), GridMask(num_grid=(10, 15), rotate=0, mode=2, fill_value=0) ], p=0.7), CoarseDropout(min_holes=2, max_holes=10, max_height=15, max_width=15, fill_value=0, p=0.7) ]), Normalize(), ToTensorV2() ] return Compose(augs_list)
def __init__(self): transformation = [] transformation += [ RandomResizedCrop(512, 512, scale=(0.8, 1.0)), ShiftScaleRotate(), OneOf([ GridDistortion(), OpticalDistortion(), ElasticTransform(approximate=True) ], p=0.8), OneOf([ IAAAdditiveGaussianNoise(), GaussNoise(), MedianBlur(blur_limit=3), Blur(blur_limit=3) ], p=0.8), CoarseDropout(max_holes=2, max_height=32, max_width=32) ] self.transform = Compose(transformation)
def get_train_transforms(size=300): return Compose([ ImageCompression(quality_lower=60, quality_upper=100, p=0.5), GaussNoise(p=0.1), GaussianBlur(blur_limit=3, p=0.05), HorizontalFlip(), Resize(height=size, width=size), PadIfNeeded(min_height=size, min_width=size, border_mode=cv2.BORDER_CONSTANT), OneOf([RandomBrightnessContrast(), HueSaturationValue()], p=0.5), # FancyPCA(), OneOf([CoarseDropout(), GridDropout()], p=0.2), ToGray(p=0.2), ShiftScaleRotate(shift_limit=0.1, scale_limit=0.2, rotate_limit=10, border_mode=cv2.BORDER_CONSTANT, p=0.5), Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)), ToTensorV2() ])
def build_aun_fn(image_size): transforms = Compose([ RandomResizedCrop(image_size, image_size), Transpose(p=0.5), HorizontalFlip(p=0.5), VerticalFlip(p=0.5), ShiftScaleRotate(p=0.5), HueSaturationValue(hue_shift_limit=0.2, sat_shift_limit=0.2, val_shift_limit=0.2, p=0.5), RandomBrightnessContrast( brightness_limit=(-0.1, 0.1), contrast_limit=(-0.1, 0.1), p=0.5), Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], max_pixel_value=255.0, p=1.0), CoarseDropout(p=0.5), Cutout(p=0.5) ], p=1.) def aug_fn(image): data = {"image": image} aug_data = transforms(**data) aug_img = aug_data["image"] aug_img = tf.cast(aug_img / 255.0, tf.float32) aug_img = tf.image.resize(aug_img, size=[image_size, image_size]) return aug_img def augment(image, label): aug_img = tf.numpy_function(func=aug_fn, inp=[image], Tout=tf.float32) return aug_img, label return augment
def build_train(self): train_transform = Compose([ RandomResizedCrop(width=512, height=512, scale=(0.08, 1.0), ratio=(0.75, 1.3333333333333333)), Transpose(p=0.5), HorizontalFlip(p=0.5), VerticalFlip(p=0.5), ShiftScaleRotate(p=0.5), HueSaturationValue(p=0.5), RandomBrightnessContrast(brightness_limit=(-0.1, 0.1), contrast_limit=(-0.1, 0.1), p=0.5), Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], max_pixel_value=255.0, p=1.0), CoarseDropout(p=0.5), ToTensorV2(p=1.0) ], p=1) return train_transform
def strong_aug(img_shape, p=0.5): return [ RandomRotate90(), Flip(), CoarseDropout(2, int(img_shape[0] * 0.1), int(img_shape[1] * 0.1), 1, int(img_shape[0] * 0.05), int(img_shape[1] * 0.05), p=1.), # mudar para 5 a 10 % do tamanho da imagem OneOf( [ IAAAdditiveGaussianNoise( scale=(0.05 * 255, 0.1 * 255)), # default: (0.01 * 255, 0.05 * 255) GaussNoise(), ], p=1.), OneOf([ MotionBlur(p=0.2), MedianBlur(blur_limit=3, p=0.1), Blur(blur_limit=3, p=0.1), ], p=1.), ShiftScaleRotate(shift_limit=0.0625, scale_limit=(0.0, 0.3), rotate_limit=25, p=0.35), OneOf( [ CLAHE(clip_limit=2), IAASharpen(), RandomBrightnessContrast(brightness_limit=0.3), #default: 0.2 ], p=1.), ]