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)
