def get_augmenters(): return [ iaa.Scale((224, 224)), iaa.Sometimes(0.25, iaa.GaussianBlur(sigma=(0, 3.0))), iaa.Fliplr(0.5), iaa.Affine(rotate=(-20, 20), mode='symmetric'), iaa.Sometimes( 0.25, iaa.OneOf([ iaa.Dropout(p=(0, 0.1)), iaa.CoarseDropout(0.1, size_percent=0.5) ])), iaa.AddToHueAndSaturation(value=(-10, 10), per_channel=True), iaa.Sometimes(0.3, iaa.OneOf([iaa.Add(-10), iaa.Add(45), iaa.Add(80)])), iaa.Sometimes(0.3, iaa.OneOf([iaa.Dropout(0.03), iaa.Dropout(0.05)])), iaa.Sometimes( 0.3, iaa.OneOf([ iaa.ContrastNormalization(0.5), iaa.ContrastNormalization(1.2), iaa.PerspectiveTransform(0.075), iaa.PerspectiveTransform(0.100), iaa.PerspectiveTransform(0.125) ])), iaa.Sometimes( 0.3, iaa.OneOf([ iaa.Grayscale(alpha=1.0), iaa.Grayscale(alpha=0.5), iaa.Grayscale(alpha=0.2) ])), iaa.Sometimes( 0.3, iaa.OneOf([ iaa.CoarsePepper(size_percent=0.30), iaa.CoarsePepper(size_percent=0.02), iaa.CoarsePepper(size_percent=0.1) ])), iaa.Sometimes( 0.3, iaa.OneOf( [iaa.SaltAndPepper(p=0.05), iaa.SaltAndPepper(p=0.03)])), ]
def chapter_augmenters_saltandpepper(): fn_start = "arithmetic/saltandpepper" aug = iaa.SaltAndPepper(0.1) run_and_save_augseq(fn_start + ".jpg", aug, [ia.quokka(size=(128, 128)) for _ in range(8)], cols=4, rows=2, quality=95) aug = iaa.SaltAndPepper(0.1, per_channel=True) run_and_save_augseq(fn_start + "_per_channel.jpg", aug, [ia.quokka(size=(128, 128)) for _ in range(8)], cols=4, rows=2, quality=95)
def logic(self, image): for param in self.augmentation_params: self.augmentation_data.append([ str(param.augmentation_value), iaa.SaltAndPepper(p=param.augmentation_value).to_deterministic( ).augment_image(image), param.detection_tag ])
def augmentator(images): """Apply data augmentation""" augmenter = iaa.Sequential([ # Invert pixel values on 25% images iaa.Invert(0.25, per_channel=0.5), # Blur 30% of images iaa.Sometimes( .3, iaa.OneOf([ iaa.GaussianBlur(sigma=(0.0, 3.0)), iaa.AverageBlur(k=(2, 2)), iaa.MedianBlur(k=(1, 3)), ]), ), # Do embossing or sharpening iaa.OneOf([ iaa.Sometimes(.2, iaa.Emboss(alpha=(0.0, .3), strength=(.2, .8))), iaa.Sometimes( .2, iaa.Sharpen(alpha=(0.0, 1.0), lightness=(0.75, 2.0))), ]), # Add one noise (or none) iaa.OneOf([ iaa.Dropout((0, 0.01)), iaa.AdditiveGaussianNoise(scale=0.01 * 255), iaa.SaltAndPepper(0.01), iaa.Noop(), ]), # Convert to grayscale iaa.Sometimes(.2, iaa.Grayscale(alpha=(0.0, 1.0))), iaa.Sometimes(.4, iaa.LinearContrast((0.5, 1.5), per_channel=0.5)), # iaa.PiecewiseAffine(scale=(0.005, 0.05)), ]) images = augmenter(images=images) return images
def __init__(self, mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], input_scale_size=224, data_dir='/data/synthesized/model', model_save_name='model.ckpt', batch_size=64): self.DATA_DIR = data_dir self.MODEL_SAVE_NAME = model_save_name self.BATCH_SIZE = batch_size self.IMAGE_SCALE_SIZE = input_scale_size self.MEAN = mean self.STD = std self.data_transforms = { 'train': transforms.Compose([ transforms.RandomCrop(32, padding=4), transforms.ImageAugmentaion(), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize(self.MEAN, self.STD) ]), 'test': transforms.Compose([ transforms.ToTensor(), transforms.Normalize(self.MEAN, self.STD) ]) } self.image_datasets = { x: torchvision.datasets.CIFAR10(root='./data', train=(x == 'train'), download=True, transform=self.data_transforms[x]) for x in ['train', 'test'] } self.dataloaders = { x: torch.utils.data.DataLoader(self.image_datasets[x], batch_size=self.BATCH_SIZE, shuffle=True, num_workers=6) for x in ['train', 'test'] } self.dataset_sizes = { x: len(self.image_datasets[x]) for x in ['train', 'test'] } self.class_names = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck') self.iaa_seq = iaa.Sequential([ iaa.PerspectiveTransform(scale=0.075), iaa.Multiply((0.5, 1.5)), iaa.Affine(scale={ "x": (1, 1.1), "y": (1, 1.1) }), iaa.SaltAndPepper((0.05)), iaa.Add((-20, 20)), iaa.GaussianBlur((0, 0.50)), iaa.Scale((1.0, 1.3)), ])
def get_aug(): sometimes = lambda aug: iaa.Sometimes(0.5, aug) augmenter = iaa.Sequential([ sometimes( iaa.OneOf([ iaa.AdditiveGaussianNoise( loc=0, scale=(0.0, 0.05 * 255), per_channel=0.5), iaa.Affine(scale={ "x": (0.8, 1), "y": (0.8, 1) }, translate_percent={ "x": (-0.1, 0.1), "y": (-0.1, 0.1) }, rotate=(-10, 10), shear=(-5, 5), order=[0, 1], cval=(0, 255), mode='constant'), iaa.PerspectiveTransform(scale=(0.01, 0.03)), iaa.Crop(px=(4, 6)), iaa.SaltAndPepper(p=(0.01, 0.02)), iaa.Fliplr(1.0) ])), ], random_order=True) return augmenter
def preprocess(self, ims, augment): def normalize(batch): return batch.astype(np.float32) / float(255) if augment: augmentations = iaa.Sequential([ iaa.Resize(int(1.1 * hp.img_size)), iaa.Fliplr(0.5), iaa.Sometimes(0.4, iaa.Rotate((-30, 30))), iaa.Sometimes(0.4, iaa.Affine(scale=(0.9, 1.2))), iaa.Sometimes(0.5, iaa.PerspectiveTransform(scale=(0.01, 0.20))), # Crop/resize image to proper dimension iaa.CropToFixedSize(hp.img_size, hp.img_size), iaa.Resize(hp.img_size), iaa.Sometimes(0.3, iaa.SaltAndPepper(0.01)), iaa.CLAHE(to_colorspace='HSV') ]) else: augmentations = ia.Sequential([iaa.CLAHE(to_colorspace='HSV')]) augmented = augmentations.augment_images(ims) for i in augmented: if i.shape != (hp.img_size, hp.img_size, 3): print(i.shape) augmented = np.stack(augmented, axis=0) return normalize(augmented)
def get(): def sometimes(aug): return iaa.Sometimes(0.5, aug) return iaa.SomeOf( 3, [ # iaa.PiecewiseAffine(scale=(0.01, 0.025)), iaa.AverageBlur((1, 3)), iaa.Grayscale((0.6, 1.0)), # iaa.PerspectiveTransform(scale=(0.01, 0.05), keep_size=True), # iaa.Flipud(1.0), # iaa.Fliplr(1.0), iaa.OneOf([ iaa.Rot90(0, keep_size=True), iaa.Rot90(1, keep_size=True), iaa.Rot90(2, keep_size=True), iaa.Rot90(3, keep_size=True) ]), iaa.OneOf([ iaa.AdditiveGaussianNoise(scale=(0, 0.1 * 255)), iaa.AdditiveGaussianNoise(scale=(0, 0.1 * 255), per_channel=True) ]), iaa.Multiply((0.8, 1.2)), iaa.SaltAndPepper(0.03), iaa.OneOf([ iaa.GaussianBlur(sigma=(0.25, 0.7)), iaa.MotionBlur(k=(3, 7), angle=[-45, 45]) ]) ], random_order=False)
def apply_augmentation(images): seq = iaa.Sequential([ # Blur iaa.SomeOf((0, 1), [ iaa.GaussianBlur(sigma=(1., 2.5)), iaa.AverageBlur(k=(2, 5)) ]), # Rotation and padding iaa.SomeOf((0,1), [ iaa.Affine(translate_percent={"x": (-0.1, 0.1), "y": (-0.1, 0.1)}), ]), # Light iaa.SomeOf((0,2), [ iaa.GammaContrast((0.5, 2.0)), iaa.SigmoidContrast(gain=(3, 10), cutoff=(0.4, 0.6)), iaa.Multiply((0.5, 1.5)), iaa.ContrastNormalization((0.5, 1.5)) ]), # Noise iaa.SomeOf((0, 1), [ iaa.AdditiveGaussianNoise(scale=(0, 0.1*255)), iaa.AdditiveLaplaceNoise(scale=(0, 0.1*255)), iaa.SaltAndPepper(0.02), ]) ]) image = seq(images=images) return image
def augment(): return iaa.SomeOf( (0, 4), [ # iaa.Add((-50, 50)), iaa.CropAndPad(percent=(-0.4, 0.4)), iaa.Fliplr(0.5), iaa.Flipud(0.5), iaa.Affine(scale={ "x": (0.85, 1.15), "y": (0.85, 1.15) }, translate_percent={ "x": (-0.15, 0.15), "y": (-0.15, 0.15) }, rotate=(-90, 90)), iaa.SomeOf( (1, 3), [ iaa.Dropout(p=(0.01, 0.2)), iaa.GaussianBlur(sigma=(0.0, 1.5)), iaa.AverageBlur(k=(3, 7)), # iaa.MedianBlur(k=(3, 7)), iaa.MotionBlur(k=(3, 7)), iaa.AdditiveGaussianNoise(scale=(0, 0.1 * 255)), iaa.SaltAndPepper(p=0.2), iaa.GammaContrast((0.5, 2.0)) ]) ], random_order=True)
def __init__(self, scale_size, crop_size): self.aug = iaa.Sequential([ iaa.Scale((scale_size, scale_size)), iaa.Sometimes( 0.25, iaa.OneOf([ iaa.GaussianBlur(sigma=(0, 3.0)), iaa.AverageBlur(k=(1, 5)), iaa.MedianBlur(k=(1, 5)) ])), iaa.Fliplr(p=0.5), iaa.Affine(rotate=(-20, 20), mode='symmetric'), iaa.Sometimes( 0.25, iaa.OneOf([ iaa.Dropout(p=(0, 0.1)), iaa.Add((-20, 20)), iaa.SaltAndPepper(p=0.01), ])), iaa.Sometimes( 0.25, iaa.OneOf([ iaa.AddToHueAndSaturation(value=(-10, 10), per_channel=True), iaa.Grayscale(alpha=(0, 1.0)) ])), iaa.GammaContrast(gamma=(0.5, 1.5)) ]) self.crop_size = crop_size
def my_aug(pics): # at labels generating step, we will not useaugmentation that would influence 0 value of background '''input : [img]''' '''output : [aug_img]''' aug = iaa.Sequential( [ iaa.SomeOf(1, [ iaa.Noop(), iaa.Grayscale(alpha=(0.0, 1.0)), # iaa.Invert(0.5, per_channel=True), iaa.Add((-10, 10), per_channel=0.5), iaa.AddToHueAndSaturation((-20, 20)), iaa.GaussianBlur(sigma=(0, 3.0)), iaa.Dropout((0.01, 0.1), per_channel=0.5), iaa.SaltAndPepper(0.05), iaa.AverageBlur(k=(2, 7)), iaa.Sharpen(alpha=(0, 1.0), lightness=(0.75, 1.5)), iaa.Emboss(alpha=(0, 1.0), strength=(0, 2.0)) ]) ]) # let every round use a same augmentation aug_pics = aug.augment_images(pics) return aug_pics
def augment_dataset(dataset): # generate augmented samples of dataset ia.seed(0) # flip from left to right aug = iaa.SaltAndPepper(0.1) augmented_samples = [] for sample in dataset: img = sample['image'].numpy() img = np.moveaxis(img, 0, -1) seg = SegmentationMapsOnImage(sample['mask'].numpy().astype(bool), shape=img.shape) i, s = seq(image=img, segmentation_maps=seg) s = torch.FloatTensor(s.get_arr().copy()) i = torch.FloatTensor(np.moveaxis(i, -1, 0).copy()) augmented_samples.append((i, sample['mask'])) # do the same thing but flip images upside down seq = iaa.Sequential([iaa.Flipud()]) for sample in dataset: img = sample['image'].numpy() img = np.moveaxis(img, 0, -1) seg = SegmentationMapsOnImage(sample['mask'].numpy().astype(bool), shape=img.shape) i, s = seq(image=img, segmentation_maps=seg) s = torch.FloatTensor(s.get_arr().copy()) i = torch.FloatTensor(np.moveaxis(i, -1, 0).copy()) augmented_samples.append((i, s)) return augmented_samples
def imgaugRGB(img): print(img.shape) seq = iaa.Sequential( [ # blur iaa.SomeOf((0, 2), [ iaa.GaussianBlur((0.0, 2.0)), iaa.AverageBlur(k=(3, 7)), iaa.MedianBlur(k=(3, 7)), iaa.BilateralBlur(d=(1, 7)), iaa.MotionBlur(k=(3, 7)) ]), #color iaa.SomeOf( (0, 2), [ #iaa.WithColorspace(), iaa.AddToHueAndSaturation((-20, 20)), #iaa.ChangeColorspace(to_colorspace[], alpha=0.5), iaa.Grayscale(alpha=(0.0, 0.2)) ]), #brightness iaa.OneOf([ iaa.Sequential([ iaa.Add((-10, 10), per_channel=0.5), iaa.Multiply((0.5, 1.5), per_channel=0.5) ]), iaa.Add((-10, 10), per_channel=0.5), iaa.Multiply((0.5, 1.5), per_channel=0.5), iaa.FrequencyNoiseAlpha(exponent=(-4, 0), first=iaa.Multiply( (0.5, 1.5), per_channel=0.5), second=iaa.ContrastNormalization( (0.5, 2.0), per_channel=0.5)) ]), #contrast iaa.SomeOf((0, 2), [ iaa.GammaContrast((0.5, 1.5), per_channel=0.5), iaa.SigmoidContrast( gain=(0, 10), cutoff=(0.25, 0.75), per_channel=0.5), iaa.LogContrast(gain=(0.75, 1), per_channel=0.5), iaa.LinearContrast(alpha=(0.7, 1.3), per_channel=0.5) ]), #arithmetic iaa.SomeOf((0, 3), [ iaa.AdditiveGaussianNoise(scale=(0, 0.05), per_channel=0.5), iaa.AdditiveLaplaceNoise(scale=(0, 0.05), per_channel=0.5), iaa.AdditivePoissonNoise(lam=(0, 8), per_channel=0.5), iaa.Dropout(p=(0, 0.05), per_channel=0.5), iaa.ImpulseNoise(p=(0, 0.05)), iaa.SaltAndPepper(p=(0, 0.05)), iaa.Salt(p=(0, 0.05)), iaa.Pepper(p=(0, 0.05)) ]), #iaa.Sometimes(p=0.5, iaa.JpegCompression((0, 30)), None), ], random_order=True) return seq.augment_image(img)
def transform_op(transform): if transform == 'flip_h': seq = iaa.Sequential([ iaa.Fliplr(1), ]) elif transform == 'invert': seq = iaa.Sequential([ iaa.Invert(1, True), ]) elif transform == 'brigth': seq = iaa.Sequential([ iaa.Multiply(1.5, True), ]) elif transform == 'dark': seq = iaa.Sequential([ iaa.Multiply(0.5, True), ]) elif transform == 'blur': seq = iaa.Sequential([ iaa.GaussianBlur(0.5), ]) elif transform == 'sharp': seq = iaa.Sequential([ iaa.Sharpen(1, 1.25), ]) elif transform == 'dark_sharp': seq = iaa.Sequential([ iaa.Sharpen(1, 0.25), ]) elif transform == 'gauss_noise': seq = iaa.Sequential([ iaa.AdditiveGaussianNoise(0.03, 10, True), ]) elif transform == 'dropout': seq = iaa.Sequential([ iaa.Dropout(0.08, True), ]) elif transform == 'salt': seq = iaa.Sequential([ iaa.Salt(0.08, True), ]) elif transform == 'salt_pepper': seq = iaa.Sequential([ iaa.SaltAndPepper(0.08, True), ]) elif transform == 'contrast': seq = iaa.Sequential([ iaa.ContrastNormalization(1.5, True), ]) else: # So far it's only implemented horizontal flips print("Sorry, only those operations listed in help are implemented. \ Check data_augmentation.py -help for further instructions") return None return seq
def light_augmentation(): augmenter = iaa.Sequential([ iaa.Sometimes(0.5, iaa.GaussianBlur( sigma=(0, 3.0))), # blur images with a sigma of 0 to 3.0 iaa.OneOf([ iaa.Sometimes(0.5, iaa.SaltAndPepper(p=(0, 0.05))), iaa.Sometimes(0.5, iaa.SaltAndPepper(p=(0, 0.05), per_channel=True)) ]), iaa.Sometimes( 0.5, iaa.OneOf([ iaa.Multiply((0.8, 1.2), per_channel=0.5), iaa.LinearContrast((0.8, 1.2)) ])) ]) return augmenter
def get_preview(images, augmentationList): """ Accepts a list of images and augmentationList as input. Provides a list of augmented images in that order as ouptut. """ augmented = [] for image in images: for augmentation in augmentationList: aug_id = augmentation['id'] params = augmentation['params'] if (aug_id == 1): image = iaa.SaltAndPepper(p=params[0], per_channel=params[1])(image=image) elif (aug_id == 2): image = iaa.imgcorruptlike.GaussianNoise( severity=(params[0], params[1]))(image=image) elif (aug_id == 3): image = iaa.Rain(speed=(params[0], params[1]), drop_size=(params[2], params[3]))(image=image) elif (aug_id == 4): image = iaa.imgcorruptlike.Fog( severity=(params[0], params[1]))(image=image) elif (aug_id == 5): image = iaa.imgcorruptlike.Snow( severity=(params[0], params[1]))(image=image) elif (aug_id == 6): image = iaa.imgcorruptlike.Spatter( severity=(params[0], params[1]))(image=image) elif (aug_id == 7): image = iaa.BlendAlphaSimplexNoise( iaa.EdgeDetect(1))(image=image) elif (aug_id == 8): image = iaa.Rotate(rotate=(params[0], params[1]))(image=image) elif (aug_id == 9): image = iaa.Affine()(image=image) #to be implemented elif (aug_id == 10): image = iaa.MotionBlur(k=params[0], angle=(params[1], params[2]))(image=image) elif (aug_id == 11): image = iaa.imgcorruptlike.ZoomBlur( severity=(params[0], params[1]))(image=image) elif (aug_id == 12): image = iaa.AddToBrightness()(image=image) #to be implemented elif (aug_id == 13): image = iaa.ChangeColorTemperature( kelvin=(params[0], params[1]))(image=image) elif (aug_id == 14): image = iaa.SigmoidContrast()(image=image) #to be implemented elif (aug_id == 15): image = iaa.Cutout(nb_iterations=(params[0], params[1]), size=params[2], squared=params[3])(image=image) else: print("Not implemented") augmented.append(image) return augmented
def heavy_augmentation(): augmenter = iaa.Sequential( [ iaa.Sometimes( 0.1, iaa.OneOf([ iaa.CoarseSaltAndPepper(0.02, size_percent=(0.001, 0.02)), iaa.CoarseSaltAndPepper( 0.02, size_percent=(0.001, 0.02), per_channel=True) ])), iaa.Sometimes(0.5, iaa.GaussianBlur( sigma=(0, 3.0))), # blur images with a sigma of 0 to 3.0 iaa.OneOf([ iaa.Sometimes(0.33, iaa.SaltAndPepper(p=(0, 0.05))), iaa.Sometimes(0.33, iaa.SaltAndPepper(p=(0, 0.05), per_channel=True)) ]), iaa.Sometimes( 0.6, iaa.OneOf([ iaa.Multiply((0.6, 1.4), per_channel=0.5), iaa.Multiply((0.8, 1.2), per_channel=0.5), ])), iaa.Sometimes(0.6, iaa.LinearContrast((0.6, 1.4))), # Too slow to do all the time iaa.Sometimes( 0.2, iaa.CropAndPad( percent=(-0.2, 0.2), pad_mode="constant", pad_cval=0)), iaa.Sometimes(0.1, iaa.imgcorruptlike.ShotNoise(severity=1)), iaa.Sometimes( 0.2, iaa.OneOf([ iaa.imgcorruptlike.Pixelate(severity=1), iaa.imgcorruptlike.GlassBlur(severity=1), iaa.imgcorruptlike.ZoomBlur(severity=1), iaa.imgcorruptlike.Fog(severity=1), iaa.imgcorruptlike.Frost(severity=1), iaa.imgcorruptlike.Spatter(severity=1) ])), ], random_order=True) return augmenter
def __call__(self, image): im = image.copy() pix = np.array(im, dtype='float32') pix = iaa.Fliplr(0.5).augment_image(pix) aug_ratate = iaa.OneOf([ iaa.PerspectiveTransform(scale=(0, 0.015)), iaa.Rotate((-10, 10)) ]) pix = aug_ratate.augment_image(pix) if self.istest: return pix pix = self.rand_brightness(pix) if random.randint(2): self.aumentone(pix) #distort = SSD_Compose(self.pd[:-1]) else: self.aumenttwo(pix) #distort = SSD_Compose(self.pd[1:]) #pix = distort(pix) #pix = pix.astype('uint8') pix = np.where(pix > 255, 255, pix) pix = np.where(pix < 0, 0, pix) #im = Image.fromarray(pix, 'RGB') #self.rand_light_noise(pix) # aug = iaa.Sequential(iaa.SomeOf(2, [ # iaa.AdditiveGaussianNoise(scale=(0, 0.1*255)), # iaa.Dropout(p=(0, 0.1), per_channel=0.5), # iaa.SaltAndPepper(p=(0, 0.1), per_channel=True), # iaa.GaussianBlur(sigma=(0.0, 3.0)), # iaa.MotionBlur(k=15, angle=[-45, 45]), # iaa.AverageBlur(k=((0, 5), (0, 5))) # ], random_order=True)) aug_noise = iaa.OneOf([ iaa.AdditiveGaussianNoise(scale=(0, 0.1 * 255)), iaa.Dropout(p=(0, 0.1), per_channel=0.5), iaa.SaltAndPepper(p=(0, 0.1), per_channel=True), ]) aug_blur = iaa.OneOf([ iaa.GaussianBlur(sigma=(0.0, 1.5)), iaa.MotionBlur(k=7, angle=[-20, 20]), iaa.AverageBlur(k=((0, 2.5), (0, 2.5))) ]) pix = aug_noise.augment_image(pix) pix = aug_blur.augment_image(pix) return pix / 255.0
def get_ill_seq(self): light_change = 50 seq = iaa.Sequential([ # 全局调整,含有颜色空间调整 iaa.Sometimes( 0.5, iaa.OneOf([ iaa.WithColorspace( to_colorspace="HSV", from_colorspace="RGB", children=iaa.OneOf([ iaa.WithChannels(0, iaa.Add((-5, 5))), iaa.WithChannels(1, iaa.Add((-20, 20))), iaa.WithChannels( 2, iaa.Add((-light_change, light_change))), ])), iaa.Grayscale((0.2, 0.6)), iaa.ChannelShuffle(1), iaa.Add((-light_change, light_change)), iaa.Multiply((0.5, 1.5)), ])), # # dropout阴影模仿,暂时不使用,转而使用了自定义的阴影模仿 # iaa.Sometimes(0.5, iaa.OneOf([ # iaa.Alpha((0.2, 0.7), iaa.CoarseDropout(p=0.2, size_percent=(0.02, 0.005))) # ])), # 椒盐噪声 iaa.Sometimes( 0.5, iaa.OneOf( [iaa.Alpha((0.2, 0.6), iaa.SaltAndPepper((0.01, 0.03)))])), # 图像反转 iaa.Sometimes(0.5, iaa.OneOf([ iaa.Invert(1), ])), # 对比度调整 iaa.Sometimes(0.5, iaa.OneOf([ iaa.ContrastNormalization((0.5, 1.5)), ])), iaa.Sometimes( 0.5, iaa.OneOf([ iaa.AdditiveGaussianNoise(0, (3, 6)), iaa.AdditivePoissonNoise((3, 6)), iaa.JpegCompression((30, 60)), iaa.GaussianBlur(sigma=1), iaa.AverageBlur((1, 3)), iaa.MedianBlur((1, 3)), ])), ]) return seq
def _main_(args) : number_of_data_augmentation = int(args.number_of_dataset_augmentation) last_gen = int(args.number_of_the_last_dataset_augmentation) aug = iaa.SomeOf(3, [ #FIRST GEN OF DATA AUGMENTATION iaa.Affine(scale=(0.8, 1.2)), iaa.Affine(rotate=(-30, 30)), iaa.Affine(translate_percent={"x":(-0.2, 0.2),"y":(-0.2, 0.2)}), iaa.Fliplr(1), #SECOND GEN OF DATA AUGMENTATION iaa.SaltAndPepper(0.1, per_channel=True), iaa.Add((-40, 40), per_channel=0.5), iaa.AdditiveGaussianNoise(scale=(0, 0.2*255)), iaa.Multiply((0.5, 1.5), per_channel=0.5), iaa.AverageBlur(k=((5, 11), (1, 3))), iaa.WithColorspace(to_colorspace="HSV",from_colorspace="RGB",children=iaa.WithChannels(0,iaa.Add((0, 50)))), iaa.AddToHueAndSaturation((-50, 50), per_channel=True), #iaa.RandAugment(n=(0, 3)), # ==> DON'T WORK WITH BOUNDING BOX #iaa.BlendAlphaCheckerboard(nb_rows=2, nb_cols=(1, 4),foreground=iaa.AddToHue((-100, 100))), #iaa.BlendAlphaHorizontalLinearGradient(iaa.TotalDropout(1.0),min_value=0.2, max_value=0.8), #iaa.BlendAlphaSimplexNoise(iaa.EdgeDetect(1.0)), iaa.Solarize(0.5, threshold=(32, 128)), iaa.WithHueAndSaturation(iaa.WithChannels(0, iaa.Add((0, 50)))) ]) labels_df = xml_to_csv('vanilla_dataset_annot/') labels_df.to_csv(('labels.csv'), index=None) for i in range(number_of_data_augmentation): prefix = "aug{}_".format(i+last_gen+1) augmented_images_df = image_aug(labels_df, 'vanilla_dataset_img/', 'aug_images/', prefix, aug) csv_to_xml(augmented_images_df, 'aug_images/') # Concat resized_images_df and augmented_images_df together and save in a new all_labels.csv file if(i==0): all_labels_df = pd.concat([labels_df, augmented_images_df]) else: all_labels_df = pd.concat([all_labels_df, augmented_images_df]) all_labels_df.to_csv('all_labels.csv', index=False) del_unique_file() # Lastly we can copy all our augmented images in the same folder as original resized images for file in os.listdir('aug_images/'): shutil.copy('aug_images/'+file, 'train_image_folder/'+file) for file in os.listdir("aug_annot/"): shutil.copy('aug_annot/'+file, 'train_annot_folder/'+file)
def img_aug_seq(): # first we need switch height and width def sometimes(aug): return iaa.Sometimes(0.5, aug) seq = iaa.Sequential([ iaa.AdditiveGaussianNoise(scale=(0, 20)), iaa.SaltAndPepper(p=0.05), sometimes(iaa.Invert(p=1)), ]) return seq
def main(): aug_seq = iaa.Sequential( [ iaa.Add((-20, 20)), iaa.ContrastNormalization((0.8, 1.6)), iaa.AddToHueAndSaturation((-21, 21)), iaa.SaltAndPepper(p=0.1), iaa.Scale({"width":224, "height":"keep-aspect-ratio"}, 1), iaa.CropAndPad( percent=(-0.05, 0.1), pad_mode=ia.ALL, pad_cval=(0, 255) ) ], random_order=True) ensure_folder('data/train') dst_folder = 'data/train' base_path = 'data/pre_train' paths = find_paths(base_path) pb = ProgressBar(total=100, prefix='Realizando 'augmentate'...', suffix='', decimals=3, length=50, fill='=') i = 0 for im_path in paths: # print 'im_path', im_path im_data = cv2.imread(im_path) # im_data = load_image_data(im_path) fname = im_path[20:] # print 'fname: ', fname paste = im_path[15:19] # print 'paste: ', paste ensure_folder('data/train/'+str(paste)) #print paste #Salva a imagem 'original' sem augmentate no diretorio 'dst_folder' dst_path = os.path.join(dst_folder, paste, fname) cv2.imwrite(dst_path, im_data) pb.print_progress_bar((i + 1) * 100 / len(paths)) #Faz o augmentate da imagem original e salva no diretorio 'dst_folder' for i in range(10): im_data_aug = aug_seq.augment_image(im_data) fname = im_path[20:-4] + str(i) + '.jpg' #print('Fname Aug: ' + fname) # cv2.imshow("frame", im_data_aug) dst_path = os.path.join(dst_folder, paste, fname) #print dst_path cv2.imwrite(dst_path, im_data_aug)
def _get_augmentor(self): return iaa.Sequential( [ iaa.OneOf([ iaa.OneOf([ iaa.AdditiveGaussianNoise(scale=(0.04, 0.3)), iaa.SaltAndPepper(0.01) ]), iaa.CoarseDropout(p=(0.02, 0.1)), iaa.GaussianBlur(sigma=(0.1, 2.0)) ]) ], random_order=False )
def __init__(self): self.aug = iaa.Sequential([ # iaa.Sometimes(0.1, iaa.GaussianBlur(sigma=(0, 1.5))), iaa.Sometimes(0.25, iaa.Fliplr(0.5)), iaa.Sometimes(0.25, iaa.Flipud(0.5)), iaa.Sometimes(0.1, iaa.Affine(rotate=(-15, 15), mode='symmetric')), iaa.Sometimes( 0.1, iaa.OneOf([ iaa.Dropout(p=(0, 0.1)), iaa.CoarseDropout((0.0, 0.05), size_percent=(0.01, 0.1)) ])), iaa.Sometimes(0.1, iaa.SaltAndPepper(0.1)) ])
def get_transforms(): sometimes = lambda aug: iaa.Sometimes(0.2, aug) seq1 = iaa.Sequential([ iaa.Fliplr(0.5), iaa.Flipud(0.5), sometimes( iaa.Affine( scale={ "x": (0.8, 1.2), "y": (0.8, 1.2) }, translate_percent={ "x": (-0.2, 0.2), "y": (-0.2, 0.2) }, rotate=(-30, 30), shear=(-10, 10), mode='constant', cval=(0, 255), )), sometimes( iaa.PiecewiseAffine( scale=(0.01, 0.05), nb_cols=8, nb_rows=8, mode='constant', cval=(0, 255), )), ], ) seq2 = iaa.Sequential([ iaa.SomeOf((0, 1), [ sometimes(iaa.MultiplyElementwise((0.8, 1.2))), sometimes(iaa.AddElementwise((-20, 20))), sometimes(iaa.ContrastNormalization((0.8, 1.2))), ]), iaa.SomeOf((0, 1), [ iaa.OneOf([ iaa.GaussianBlur((0, 2.0)), iaa.AverageBlur(k=2), iaa.MedianBlur(k=3), ]), iaa.AdditiveGaussianNoise(0, 10), iaa.SaltAndPepper(0.01), iaa.ReplaceElementwise(0.05, (0, 255)) ]), ], ) return seq1, seq2
def __init__(self): self.aug = iaa.Sequential([ iaa.OneOf([iaa.GaussianBlur(sigma=(0, 0.4))]), iaa.Fliplr(0.5), iaa.Affine(rotate=(-20, 20), mode='symmetric'), iaa.Sometimes(0.3, iaa.OneOf([iaa.AdditivePoissonNoise((4, 16)), iaa.AdditiveGaussianNoise(scale=(0, 0.03 * 255), per_channel=True)])), iaa.Sometimes(0.3, iaa.OneOf([iaa.SaltAndPepper((0.05, 0.1)), iaa.Dropout((0.05, 0.1))])), iaa.OneOf([iaa.AddToHueAndSaturation(value=(-10, 10), per_channel=True), iaa.ContrastNormalization((0.75, 1.5)), iaa.GammaContrast((0.5, 1.75), per_channel=True)]), iaa.OneOf([iaa.Add((-40, 40), per_channel=True), iaa.Add((-40, 40), per_channel=False)]), #iaa.Sharpen(alpha=(0, 0.5)) ])
def data_aug_pipeline(img): from matplotlib import pyplot seq = iaa.Sequential([ iaa.SaltAndPepper(0.05), iaa.Affine(scale=(1, 1.1)), ]) images_aug = [] for i in range(9): image_aug = seq.augment_image(img) images_aug.append(image_aug) pyplot.subplot(3, 3, i + 1) pyplot.imshow(images_aug[i]) pyplot.show()
def augment(img, label): aug_seq = iaa.Sequential([ iaa.Add((-20, 20)), iaa.ContrastNormalization((0.8, 1.6)), iaa.AddToHueAndSaturation((-21, 21)), iaa.SaltAndPepper(p=0.1), ], random_order=True) images = [] labels = [] for i in range(10): images += [aug_seq.augment_image(img)] labels += [label] return images, labels
def train(model): """Train the model.""" # Training dataset. dataset_train = PlateDataset() dataset_train.load_plates("train") dataset_train.prepare() # Validation dataset dataset_val = PlateDataset() dataset_val.load_plates("val") dataset_val.prepare() #Augmentation aug = iaa.OneOf([ iaa.GaussianBlur(sigma=(0, 1.0)), iaa.MotionBlur(), iaa.RemoveSaturation((0.0, 0.5)), iaa.GammaContrast(), iaa.Rotate(rotate=(-45, 45)), iaa.PerspectiveTransform(scale=(0.01, 0.15)), iaa.SaltAndPepper(), iaa.JpegCompression(compression=(0, 75)), iaa.imgcorruptlike.Spatter(severity=(1, 4)), iaa.imgcorruptlike.DefocusBlur(severity=1) ]) custom_callbacks = [ ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=5, verbose=1), EarlyStopping(monitor='val_loss', min_delta=0, patience=10, verbose=1) ] # Since we're using a very small dataset, and starting from # COCO trained weights, we don't need to train too long. Also, # no need to train all layers, just the heads should do it. print("Training network heads") model.train(dataset_train, dataset_val, learning_rate=config.LEARNING_RATE, epochs=100, layers='all', augmentation=aug, custom_callbacks=custom_callbacks)