def chapter_augmenters_multiplyelementwise():
aug = iaa.MultiplyElementwise((0.5, 1.5))
run_and_save_augseq("multiplyelementwise.jpg",
aug, [ia.quokka(size=(512, 512)) for _ in range(1)],
cols=1,
rows=1,
quality=90)
aug = iaa.MultiplyElementwise((0.5, 1.5), per_channel=True)
run_and_save_augseq("multiplyelementwise_per_channel.jpg",
aug, [ia.quokka(size=(512, 512)) for _ in range(1)],
cols=1,
rows=1,
quality=90)
def get_seq(params):
"""
Main filters and augmentations for pilotnet data augmentation.
"""
filters = iaa.SomeOf(params.filters_repeat, [
iaa.ChangeColorspace("BGR"),
iaa.ChangeColorspace("GRAY"),
iaa.GaussianBlur(sigma=(0.0, 3.0)),
iaa.AverageBlur(k=(2, 9)),
iaa.MedianBlur(k=(3, 9)),
iaa.Add((-40, 40), per_channel=0.5),
iaa.Add((-40, 40)),
iaa.AdditiveGaussianNoise(scale=0.05 * 255, per_channel=0.5),
iaa.AdditiveGaussianNoise(scale=0.05 * 255),
iaa.Multiply((0.5, 1.5), per_channel=0.5),
iaa.Multiply((0.5, 1.5)),
iaa.MultiplyElementwise((0.5, 1.5)),
iaa.ContrastNormalization((0.5, 1.5)),
iaa.ContrastNormalization((0.5, 1.5), per_channel=0.5),
iaa.ElasticTransformation(alpha=(0, 2.5), sigma=0.25),
iaa.Sharpen(alpha=(0.6, 1.0)),
iaa.Emboss(alpha=(0.0, 0.5)),
iaa.CoarseDropout(0.2, size_percent=0.00001, per_channel=1.0),
])
affine = iaa.Affine(
rotate=(-7, 7),
scale=(0.9, 1.1),
translate_percent=dict(x=(-0.05, 0.05)),
mode="symmetric",
)
return iaa.Sequential([
filters,
affine,
])
def augmentation_sequence(params):
if params is None:
params = dicto.load_("params.yml")
n_augmenters = params.data_augmentation.n_augmenters
return iaa.SomeOf(n_augmenters, [
iaa.Grayscale(alpha=(0.0, 1.0)),
iaa.GaussianBlur(sigma=(0.0, 3.0)),
iaa.AverageBlur(k=(2, 9)),
iaa.MedianBlur(k=(3, 9)),
iaa.Sharpen(alpha=(0.0, 1.0), lightness=(0.75, 2.0)),
iaa.Emboss(alpha=(0.0, 1.0), strength=(0.5, 1.5)),
iaa.Add((-40, 40), per_channel=0.5),
iaa.AddElementwise((-40, 40), per_channel=0.5),
iaa.AdditiveGaussianNoise(scale=0.05 * 255, per_channel=0.5),
iaa.Multiply((0.5, 1.5), per_channel=0.5),
iaa.MultiplyElementwise((0.5, 1.5), per_channel=0.5),
iaa.Dropout(p=(0, 0.2), per_channel=0.5),
iaa.CoarseDropout(0.05, size_percent=0.1),
iaa.Invert(1.0, per_channel=0.5),
iaa.ContrastNormalization((0.5, 1.5), per_channel=0.5),
iaa.ElasticTransformation(alpha=(0, 5.0), sigma=0.25),
iaa.PiecewiseAffine(scale=(0.01, 0.05)),
])
def __init__(self):
self.aug = A.MultiplicativeNoise((0, 1),
per_channel=True,
elementwise=True,
p=1)
self.imgaug_transform = iaa.MultiplyElementwise(mul=(0, 1),
per_channel=True)
def __init__(self):
self._add_augmentation_list = [
iaa.Add((-30, 30), per_channel=True),
iaa.Add((-30, 30), per_channel=False),
iaa.AddElementwise((-30, 30), per_channel=False),
iaa.AddElementwise((-30, 30), per_channel=True),
iaa.Invert(p=0.2, per_channel=True),
iaa.Invert(p=0.2, per_channel=False),
iaa.AddToHueAndSaturation((0, 80), True),
iaa.Multiply((0.8, 1.2), per_channel=True),
iaa.Multiply((0.8, 1.2), per_channel=False),
iaa.MultiplyElementwise((0.8, 1.2), per_channel=True),
iaa.MultiplyElementwise((0.8, 1.2), per_channel=False)
]
self._blur_augmentation_list = [
iaa.GaussianBlur((2, 3)),
iaa.AverageBlur((2, 3)),
iaa.MedianBlur((3, 5)),
iaa.BilateralBlur((2, 3))
]
self._noise_augmentation_list = [
iaa.AdditiveGaussianNoise(0, (5, 20), per_channel=True),
iaa.AdditiveGaussianNoise(0, (5, 20), per_channel=False),
iaa.Dropout((0.05, 0.15), per_channel=False),
iaa.Dropout((0.05, 0.15), per_channel=True),
iaa.CoarseDropout((0.05, 0.15), size_percent=(0.65, 0.85))
]
self._other_augmentation_list = [
iaa.Sharpen((0.9, 0.11), (0.8, 1.2)),
iaa.Emboss((0.9, 0.11), (0.3, 1.6)),
iaa.EdgeDetect((0, 0.4)),
iaa.Grayscale((0, 1))
]
self.noise_list = self._add_augmentation_list +\
self._blur_augmentation_list +\
self._noise_augmentation_list +\
self._other_augmentation_list
def sub_policy_4():
seq = Sequential_add_bbs_only([
# Rotate 0.6 10, range[-30, 30]
iaa.Sometimes(0.6, iaa.Affine(
rotate=20,
)),
# Color 1.0, 6, range[0.1, 1.9], 1.3
# if the factor inside
# iaa.Sometimes(1, iaa.Alpha(1.3, iaa.Grayscale(1.0)))
iaa.Sometimes(1, iaa.MultiplyElementwise(1.3))
], bbox_only=[0, 0])
return seq
def create_image_only_augmenter():
aug = iaa.SomeOf((0, None), [
iaa.Noop(),
iaa.GaussianBlur(sigma=(0.0, 1.0)),
iaa.AdditiveGaussianNoise(scale=(0, 0.02 * 255)),
iaa.AdditiveGaussianNoise(scale=0.02 * 255, per_channel=0.5),
iaa.MultiplyElementwise((0.75, 1.25)),
iaa.Dropout(p=(0, 0.1)),
iaa.Add((-20, 20)),
iaa.AddElementwise((-20, 20)),
iaa.ContrastNormalization((0.75, 1.25))
])
return aug
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 cpu_augment(self, imgs, boxes):
# for bx in boxes:
# self.assert_bboxes(bx)
ia_bb = []
for n in range(len(imgs)):
c_boxes = []
for i in boxes[n]:
try:
c_boxes.append(
ia.BoundingBox(x1=i[0], y1=i[1], x2=i[2], y2=i[3]))
except AssertionError:
print('Assertion Error: ', i)
ia_bb.append(ia.BoundingBoxesOnImage(c_boxes, shape=imgs[n].shape))
seq = iaa.Sequential([
iaa.Sometimes(0.5, iaa.AddElementwise((-20, 20), per_channel=1)),
iaa.Sometimes(0.5,
iaa.AdditiveGaussianNoise(scale=(0, 0.10 * 255))),
iaa.Sometimes(0.5, iaa.Multiply((0.75, 1.25), per_channel=1)),
iaa.Sometimes(0.5, iaa.MultiplyElementwise((0.75, 1.25))),
iaa.Sometimes(0.5, iaa.GaussianBlur(sigma=(0.0, 1.0))),
iaa.Fliplr(0.5),
iaa.Sometimes(
0.95,
iaa.SomeOf(1, [
iaa.CoarseDropout(p=(0.10, 0.25),
size_percent=(0.25, 0.5)),
iaa.CoarseDropout(p=(0.0, 0.15), size_percent=(0.1, 0.25)),
iaa.Dropout(p=(0, 0.25)),
iaa.CoarseSaltAndPepper(p=(0, 0.25),
size_percent=(0.1, 0.2))
])),
iaa.Affine(scale=iap.Choice(
[iap.Uniform(0.4, 1), iap.Uniform(1, 3)]),
rotate=(-180, 180))
])
seq_det = seq.to_deterministic()
image_b_aug = seq_det.augment_images(imgs)
bbs_b_aug = seq_det.augment_bounding_boxes(ia_bb)
bbs_b_aug = [
b.remove_out_of_image().cut_out_of_image() for b in bbs_b_aug
]
return image_b_aug, [
np.array([self.bbox_r(j) for j in i.bounding_boxes])
for i in bbs_b_aug
]
def DA_MultiplyElementwise(inputimg):
'''
change brightness in a stotic value or a fixed value randomly
:param inputimg: src img need to be augmented
:return:(Name, VALUE, aug_img) List augmented img tuples.
'''
assert inputimg.ndim in [2, 3], "input invalid! Please check input"
mul_values = np.arange(0.2, 2.0, 0.2)
p_channels = np.arange(0.2, 1.01, 0.2)
ret = []
for i in np.arange(len(mul_values)):
for j in np.arange(len(p_channels)):
Name = "DA_MultiplyElementwise_" + str(mul_values[i]) + "_p_channels_" + str(p_channels[j])
VALUE = str(mul_values[i]) + "_" + str(p_channels[j])
aug_img = iaa.MultiplyElementwise(mul=mul_values[i], per_channel=p_channels[j]).augment_image(inputimg)
ret.append((Name, VALUE, aug_img))
assert len(ret) == 45, "DA_MultiplyElementwise output size not match!"
return ret
def __init__(self,
data_path,
transform=None,
use_bgr=True,
use_bgr2gray=True,
depth_range=[0.2, 0.7],
test=False,
object_list=None,
data_augmentation=True):
self.test = test
self.data_path = data_path
self.transform = transform
if self.test:
self.file_paths = list(
sorted(Path(self.data_path).glob("depth/*.npy")))
else:
# data_path/class/fancy/depth/*.npy
self.file_paths = list(
sorted(Path(self.data_path).glob("*/*/depth/*.npy")))
if object_list is not None:
print('len(object_list)', len(object_list))
self.file_paths = list(
filter(
lambda path: any(target_object in str(path)
for target_object in object_list),
self.file_paths))
print('Select {} data in object_list'.format(
len(self.file_paths)))
self.use_bgr = use_bgr
if use_bgr2gray:
self.use_bgr = True
self.use_bgr2gray = use_bgr2gray
self.depth_range = depth_range
self.data_shape = (256, 256)
self.data_augmentation = data_augmentation
self.aug_seq = iaa.Sequential(
[
iaa.Dropout([0, 0.8]),
iaa.MultiplyElementwise((0.99, 1.01)),
# iaa.GaussianBlur((0, 1.0)),
],
random_order=True)
def augment_depth(depth, random_value=False):
"""data augmentation for depth image
Parameters
----------
depth : numpy.ndarray
random_value : bool, optional
if true, erase with pixel level random value,
by default False
Returns
-------
depth : numpy.ndarray
"""
aug_seq = iaa.Sequential([
iaa.Dropout([0, 0.8]),
iaa.MultiplyElementwise((0.99, 1.01)),
],
random_order=True)
depth = depth_edges_erase(depth)
depth = aug_seq.augment_image(depth)
nonzero_depth = depth.copy()
nonzero_depth[nonzero_depth == 0] = depth.max()
if random_value:
depth_eraser = get_random_eraser(p=0.9,
s_l=0.1,
s_h=0.5,
v_l=nonzero_depth.min(),
v_h=depth.max(),
pixel_level=False)
else:
depth_eraser = get_random_eraser(p=0.9,
s_l=0.1,
s_h=0.5,
v_l=0,
v_h=0,
pixel_level=False)
depth = depth_eraser(depth)
return depth
def __init__(self):
self.transform = iaa.Sequential(
[
iaa.Sometimes(
0.5,
iaa.SomeOf((1, 2), [
iaa.Fliplr(1.0),
iaa.Flipud(1.0),
])),
iaa.OneOf([
iaa.Sometimes(
0.3,
[
iaa.OneOf([
iaa.Multiply((0.7, 1.2)),
iaa.MultiplyElementwise((0.7, 1.2)),
]),
iaa.OneOf([
iaa.MultiplySaturation((5.0, 10.0)), # good
iaa.MultiplyHue((1.5, 3.0)),
iaa.LinearContrast((0.8, 2.0)),
iaa.AllChannelsHistogramEqualization(),
]),
]),
iaa.Sometimes(0.3, [
iaa.SomeOf((1, 2), [
iaa.pillike.EnhanceColor((1.1, 1.6)),
iaa.pillike.EnhanceSharpness((0.7, 1.6)),
iaa.pillike.Autocontrast(cutoff=(4, 8)),
iaa.MultiplySaturation((1.2, 5.1)),
])
])
]),
iaa.Sometimes(0.3, [
iaa.Dropout(p=(0.01, 0.09)),
iaa.GaussianBlur((0.4, 1.5)),
]),
],
random_order=True # apply the augmentations in random order
)
def randomIntensityAugmentation(image):
intensity_seq = iaa.Sequential(
[
# iaa.Invert(0.3),
iaa.Sometimes(0.3, iaa.ContrastNormalization((0.5, 1.5))),
iaa.OneOf([
iaa.Noop(),
iaa.Sequential([
iaa.OneOf([
iaa.Add((-10, 10)),
iaa.AddElementwise((-10, 10)),
iaa.Multiply((0.95, 1.05)),
iaa.MultiplyElementwise((0.95, 1.05)),
]),
]),
iaa.OneOf([
iaa.GaussianBlur(sigma=(0.0, 1.0)),
iaa.AverageBlur(k=(2, 5)),
iaa.MedianBlur(k=(3, 5))
])
])
],
random_order=False)
return intensity_seq.augment_images(image)
augment_bg = iaa.Sequential([
iaa.SomeOf((0, 1), [
iaa.GammaContrast(per_channel=True, gamma=(0.5, 1.75)),
iaa.SigmoidContrast(per_channel=True, gain=(5, 15), cutoff=(0.0, 1.0))
]),
iaa.SaltAndPepper(p=(0, 0.05)),
iaa.Dropout(p=(0, 0.1)),
iaa.SomeOf((1, 3), [
iaa.GaussianBlur(sigma=(1.2, 5)),
iaa.AverageBlur(k=(2, 7)),
iaa.MotionBlur(angle=(72, 288), k=(3, 13))
]),
iaa.AdditiveGaussianNoise(scale=0.01 * 255),
iaa.Add((-30, 30)),
iaa.AddElementwise((-20, 20)),
iaa.MultiplyElementwise((0.9, 1.2), per_channel=True),
iaa.ContrastNormalization((0.5, 1.5))
])
def get_valid_coord(x, size):
if x < 0:
return 0
if x > size:
return size
return x
def get_image(bg, fontpath, text):
img = bg.copy()
img = np.asarray(img)[:, :, 1:]
random_order=True)
color_seq_grey = iaa.Sequential(
[
# Color
iaa.Invert(0.3),
iaa.Sometimes(0.3, iaa.ContrastNormalization((0.5, 1.5))),
iaa.Sometimes(0.3, iaa.ElasticTransformation(alpha=(1, 5), sigma=0.1)),
iaa.OneOf([
iaa.Noop(),
iaa.Sequential([
iaa.OneOf([
iaa.Add((0, 100)),
iaa.AddElementwise((0, 100)),
iaa.Multiply((0, 100)),
iaa.MultiplyElementwise((0, 100)),
]),
]),
iaa.OneOf([
iaa.GaussianBlur(sigma=(0.0, 8.0)),
iaa.AverageBlur(k=(2, 21)),
iaa.MedianBlur(k=(3, 15))
])
])
],
random_order=False)
def crop_seq(crop_size):
seq = iaa.Sequential(
[affine_seq, RandomCropFixedSize(px=crop_size)], random_order=False)
def __init__(self,
base_data_path,
train,
transform,
id_name_path,
device,
little_train=False,
read_mode='jpeg4py',
input_size=224,
C=2048,
test_mode=False):
print('data init')
self.train = train
self.base_data_path = base_data_path
self.transform = transform
self.fnames = []
self.resize = input_size
self.little_train = little_train
self.id_name_path = id_name_path
self.C = C
self.read_mode = read_mode
self.device = device
self._test = test_mode
self.fnames = self.get_data_list(base_data_path)
self.num_samples = len(self.fnames)
self.get_id_map()
self.cls_path_map = self.get_cls_pathlist_map()
self.img_augsometimes = lambda aug: iaa.Sometimes(0.5, aug)
self.augmentation = iaa.Sequential(
[
# augment without change bboxes
self.img_augsometimes(
iaa.SomeOf(
(1, 4),
[
iaa.Dropout([0.05, 0.2
]), # drop 5% or 20% of all pixels
iaa.Sharpen((0.1, .8)), # sharpen the image
# iaa.GaussianBlur(sigma=(2., 3.5)),
iaa.OneOf([
iaa.GaussianBlur(sigma=(2., 3.5)),
iaa.AverageBlur(k=(2, 5)),
iaa.BilateralBlur(d=(7, 12),
sigma_color=(10, 250),
sigma_space=(10, 250)),
iaa.MedianBlur(k=(3, 7)),
]),
iaa.AddElementwise((-50, 50)),
iaa.AdditiveGaussianNoise(scale=(0, 0.1 * 255)),
iaa.JpegCompression(compression=(80, 95)),
iaa.Multiply((0.5, 1.5)),
iaa.MultiplyElementwise((0.5, 1.5)),
iaa.ReplaceElementwise(0.05, [0, 255]),
# iaa.WithColorspace(to_colorspace="HSV", from_colorspace="RGB",
# children=iaa.WithChannels(2, iaa.Add((-10, 50)))),
iaa.OneOf([
iaa.WithColorspace(to_colorspace="HSV",
from_colorspace="RGB",
children=iaa.WithChannels(
1, iaa.Add((-10, 50)))),
iaa.WithColorspace(to_colorspace="HSV",
from_colorspace="RGB",
children=iaa.WithChannels(
2, iaa.Add((-10, 50)))),
]),
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=(-25, 25),
shear=(-8, 8))
],
random_order=True)),
iaa.Fliplr(.5),
iaa.Flipud(.25),
],
random_order=True)
# Add gaussian noise (aka white noise) to an image, sampled once per pixel from a normal
# distribution N(0, s), where s is sampled per image and varies between lo and hi*255 for percent of all
# images (sampled once for all channels) and sampled three (RGB) times (channel-wise)
# for the rest from the same normal distribution:
"Additive_Gaussian_Noise": lambda lo, hi, percent:
iaa.AdditiveGaussianNoise(scale=(lo, hi), per_channel=percent),
# Multiply in percent of all images each pixel with random values between lo and hi and multiply
# the pixels in the rest of the images channel-wise,
# i.e. sample one multiplier independently per channel and pixel:
"Multiply": lambda lo, hi, percent: iaa.Multiply((lo, hi), per_channel=percent),
# Multiply values of pixels with possibly different values for neighbouring pixels,
# making each pixel darker or brighter. Multiply each pixel with a random value between lo and hi:
"Multiply_Element_Wise": lambda lo, hi, percent: iaa.MultiplyElementwise((0.5, 1.5), per_channel=0.5),
# Augmenter that sets a certain fraction of pixels in images to zero.
# Sample per image a value p from the range lo<=p<=hi and then drop p percent of all pixels in the image
# (i.e. convert them to black pixels), but do this independently per channel in percent of all images
"Dropout": lambda lo, hi, percent: iaa.Dropout(p=(lo, hi), per_channel=percent),
# Augmenter that sets rectangular areas within images to zero.
# Drop d_lo to d_hi percent of all pixels by converting them to black pixels,
# but do that on a lower-resolution version of the image that has s_lo to s_hi percent of the original size,
# Also do this in percent of all images channel-wise, so that only the information of some
# channels is set to 0 while others remain untouched:
"Coarse_Dropout": lambda d_lo, d_hi, s_lo, s_hi, percent:
iaa.CoarseDropout((d_lo, d_hi), size_percent=(s_hi, s_hi), per_channel=percent),
# Augmenter that inverts all values in images, i.e. sets a pixel from value v to 255-v.
import cv2
import pandas as pd
transforms = iaa.Sequential(
[
iaa.Sometimes(0.5,
iaa.SomeOf((1, 2), [
iaa.Fliplr(1.0),
iaa.Flipud(1.0),
])),
iaa.OneOf([
iaa.Sometimes(0.4, [
iaa.OneOf([
iaa.Multiply((0.7, 1.1)),
iaa.MultiplyElementwise((0.7, 1.1)),
]),
iaa.OneOf([
iaa.MultiplySaturation((0.6, 1.5)),
iaa.MultiplyHue((0.6, 1.1)),
iaa.LinearContrast((0.8, 1.6)),
iaa.SigmoidContrast(gain=(3, 10), cutoff=(0.4, 0.6)),
]),
]),
iaa.Sometimes(0.5, [
iaa.SomeOf((1, 2), [
iaa.pillike.EnhanceColor((0.8, 1.2)),
iaa.pillike.EnhanceSharpness((0.7, 1.6)),
iaa.pillike.Autocontrast(cutoff=(2, 5)),
])
])
def main():
parser = argparse.ArgumentParser(description="Check augmenters visually.")
parser.add_argument(
"--only",
default=None,
help=
"If this is set, then only the results of an augmenter with this name will be shown. "
"Optionally, comma-separated list.",
required=False)
args = parser.parse_args()
images = [
ia.quokka_square(size=(128, 128)),
ia.imresize_single_image(data.astronaut(), (128, 128))
]
keypoints = [
ia.KeypointsOnImage([
ia.Keypoint(x=50, y=40),
ia.Keypoint(x=70, y=38),
ia.Keypoint(x=62, y=52)
],
shape=images[0].shape),
ia.KeypointsOnImage([
ia.Keypoint(x=55, y=32),
ia.Keypoint(x=42, y=95),
ia.Keypoint(x=75, y=89)
],
shape=images[1].shape)
]
bounding_boxes = [
ia.BoundingBoxesOnImage([
ia.BoundingBox(x1=10, y1=10, x2=20, y2=20),
ia.BoundingBox(x1=40, y1=50, x2=70, y2=60)
],
shape=images[0].shape),
ia.BoundingBoxesOnImage([
ia.BoundingBox(x1=10, y1=10, x2=20, y2=20),
ia.BoundingBox(x1=40, y1=50, x2=70, y2=60)
],
shape=images[1].shape)
]
augmenters = [
iaa.Sequential([
iaa.CoarseDropout(p=0.5, size_percent=0.05),
iaa.AdditiveGaussianNoise(scale=0.1 * 255),
iaa.Crop(percent=0.1)
],
name="Sequential"),
iaa.SomeOf(2,
children=[
iaa.CoarseDropout(p=0.5, size_percent=0.05),
iaa.AdditiveGaussianNoise(scale=0.1 * 255),
iaa.Crop(percent=0.1)
],
name="SomeOf"),
iaa.OneOf(children=[
iaa.CoarseDropout(p=0.5, size_percent=0.05),
iaa.AdditiveGaussianNoise(scale=0.1 * 255),
iaa.Crop(percent=0.1)
],
name="OneOf"),
iaa.Sometimes(0.5,
iaa.AdditiveGaussianNoise(scale=0.1 * 255),
name="Sometimes"),
iaa.WithColorspace("HSV",
children=[iaa.Add(20)],
name="WithColorspace"),
iaa.WithChannels([0], children=[iaa.Add(20)], name="WithChannels"),
iaa.AddToHueAndSaturation((-20, 20),
per_channel=True,
name="AddToHueAndSaturation"),
iaa.Noop(name="Noop"),
iaa.Resize({
"width": 64,
"height": 64
}, name="Resize"),
iaa.CropAndPad(px=(-8, 8), name="CropAndPad-px"),
iaa.Pad(px=(0, 8), name="Pad-px"),
iaa.Crop(px=(0, 8), name="Crop-px"),
iaa.Crop(percent=(0, 0.1), name="Crop-percent"),
iaa.Fliplr(0.5, name="Fliplr"),
iaa.Flipud(0.5, name="Flipud"),
iaa.Superpixels(p_replace=0.75, n_segments=50, name="Superpixels"),
iaa.Grayscale(0.5, name="Grayscale0.5"),
iaa.Grayscale(1.0, name="Grayscale1.0"),
iaa.GaussianBlur((0, 3.0), name="GaussianBlur"),
iaa.AverageBlur(k=(3, 11), name="AverageBlur"),
iaa.MedianBlur(k=(3, 11), name="MedianBlur"),
iaa.BilateralBlur(d=10, name="BilateralBlur"),
iaa.Sharpen(alpha=(0.1, 1.0), lightness=(0, 2.0), name="Sharpen"),
iaa.Emboss(alpha=(0.1, 1.0), strength=(0, 2.0), name="Emboss"),
iaa.EdgeDetect(alpha=(0.1, 1.0), name="EdgeDetect"),
iaa.DirectedEdgeDetect(alpha=(0.1, 1.0),
direction=(0, 1.0),
name="DirectedEdgeDetect"),
iaa.Add((-50, 50), name="Add"),
iaa.Add((-50, 50), per_channel=True, name="AddPerChannel"),
iaa.AddElementwise((-50, 50), name="AddElementwise"),
iaa.AdditiveGaussianNoise(loc=0,
scale=(0.0, 0.1 * 255),
name="AdditiveGaussianNoise"),
iaa.Multiply((0.5, 1.5), name="Multiply"),
iaa.Multiply((0.5, 1.5), per_channel=True, name="MultiplyPerChannel"),
iaa.MultiplyElementwise((0.5, 1.5), name="MultiplyElementwise"),
iaa.Dropout((0.0, 0.1), name="Dropout"),
iaa.CoarseDropout(p=0.05,
size_percent=(0.05, 0.5),
name="CoarseDropout"),
iaa.Invert(p=0.5, name="Invert"),
iaa.Invert(p=0.5, per_channel=True, name="InvertPerChannel"),
iaa.ContrastNormalization(alpha=(0.5, 2.0),
name="ContrastNormalization"),
iaa.SaltAndPepper(p=0.05, name="SaltAndPepper"),
iaa.Salt(p=0.05, name="Salt"),
iaa.Pepper(p=0.05, name="Pepper"),
iaa.CoarseSaltAndPepper(p=0.05,
size_percent=(0.01, 0.1),
name="CoarseSaltAndPepper"),
iaa.CoarseSalt(p=0.05, size_percent=(0.01, 0.1), name="CoarseSalt"),
iaa.CoarsePepper(p=0.05, size_percent=(0.01, 0.1),
name="CoarsePepper"),
iaa.Affine(scale={
"x": (0.8, 1.2),
"y": (0.8, 1.2)
},
translate_px={
"x": (-16, 16),
"y": (-16, 16)
},
rotate=(-45, 45),
shear=(-16, 16),
order=ia.ALL,
cval=(0, 255),
mode=ia.ALL,
name="Affine"),
iaa.PiecewiseAffine(scale=0.03,
nb_rows=(2, 6),
nb_cols=(2, 6),
name="PiecewiseAffine"),
iaa.PerspectiveTransform(scale=0.1, name="PerspectiveTransform"),
iaa.ElasticTransformation(alpha=(0.5, 8.0),
sigma=1.0,
name="ElasticTransformation"),
iaa.Alpha(factor=(0.0, 1.0),
first=iaa.Add(100),
second=iaa.Dropout(0.5),
per_channel=False,
name="Alpha"),
iaa.Alpha(factor=(0.0, 1.0),
first=iaa.Add(100),
second=iaa.Dropout(0.5),
per_channel=True,
name="AlphaPerChannel"),
iaa.Alpha(factor=(0.0, 1.0),
first=iaa.Affine(rotate=(-45, 45)),
per_channel=True,
name="AlphaAffine"),
iaa.AlphaElementwise(factor=(0.0, 1.0),
first=iaa.Add(50),
second=iaa.ContrastNormalization(2.0),
per_channel=False,
name="AlphaElementwise"),
iaa.AlphaElementwise(factor=(0.0, 1.0),
first=iaa.Add(50),
second=iaa.ContrastNormalization(2.0),
per_channel=True,
name="AlphaElementwisePerChannel"),
iaa.AlphaElementwise(factor=(0.0, 1.0),
first=iaa.Affine(rotate=(-45, 45)),
per_channel=True,
name="AlphaElementwiseAffine"),
iaa.SimplexNoiseAlpha(first=iaa.EdgeDetect(1.0),
per_channel=False,
name="SimplexNoiseAlpha"),
iaa.FrequencyNoiseAlpha(first=iaa.EdgeDetect(1.0),
per_channel=False,
name="FrequencyNoiseAlpha")
]
augmenters.append(
iaa.Sequential([iaa.Sometimes(0.2, aug.copy()) for aug in augmenters],
name="Sequential"))
augmenters.append(
iaa.Sometimes(0.5, [aug.copy() for aug in augmenters],
name="Sometimes"))
for augmenter in augmenters:
if args.only is None or augmenter.name in [
v.strip() for v in args.only.split(",")
]:
print("Augmenter: %s" % (augmenter.name, ))
grid = []
for image, kps, bbs in zip(images, keypoints, bounding_boxes):
aug_det = augmenter.to_deterministic()
imgs_aug = aug_det.augment_images(
np.tile(image[np.newaxis, ...], (16, 1, 1, 1)))
kps_aug = aug_det.augment_keypoints([kps] * 16)
bbs_aug = aug_det.augment_bounding_boxes([bbs] * 16)
imgs_aug_drawn = [
kps_aug_one.draw_on_image(img_aug)
for img_aug, kps_aug_one in zip(imgs_aug, kps_aug)
]
imgs_aug_drawn = [
bbs_aug_one.draw_on_image(img_aug)
for img_aug, bbs_aug_one in zip(imgs_aug_drawn, bbs_aug)
]
grid.append(np.hstack(imgs_aug_drawn))
ia.imshow(np.vstack(grid))
def test_determinism():
reseed()
images = [
ia.quokka(size=(128, 128)),
ia.quokka(size=(64, 64)),
ia.imresize_single_image(skimage.data.astronaut(), (128, 256))
]
images.extend([ia.quokka(size=(16, 16))] * 20)
keypoints = [
ia.KeypointsOnImage([
ia.Keypoint(x=20, y=10, vis=None, label=None), ia.Keypoint(x=5, y=5, vis=None, label=None),
ia.Keypoint(x=10, y=43, vis=None, label=None)], shape=(50, 60, 3))
] * 20
augs = [
iaa.Sequential([iaa.Fliplr(0.5), iaa.Flipud(0.5)]),
iaa.SomeOf(1, [iaa.Fliplr(0.5), iaa.Flipud(0.5)]),
iaa.OneOf([iaa.Fliplr(0.5), iaa.Flipud(0.5)]),
iaa.Sometimes(0.5, iaa.Fliplr(1.0)),
iaa.WithColorspace("HSV", children=iaa.Add((-50, 50))),
# iaa.WithChannels([0], iaa.Add((-50, 50))),
# iaa.Noop(name="Noop-nochange"),
# iaa.Lambda(
# func_images=lambda images, random_state, parents, hooks: images,
# func_keypoints=lambda keypoints_on_images, random_state, parents, hooks: keypoints_on_images,
# name="Lambda-nochange"
# ),
# iaa.AssertLambda(
# func_images=lambda images, random_state, parents, hooks: True,
# func_keypoints=lambda keypoints_on_images, random_state, parents, hooks: True,
# name="AssertLambda-nochange"
# ),
# iaa.AssertShape(
# (None, None, None, 3),
# check_keypoints=False,
# name="AssertShape-nochange"
# ),
iaa.Resize((0.5, 0.9)),
iaa.CropAndPad(px=(-50, 50)),
iaa.Pad(px=(1, 50)),
iaa.Crop(px=(1, 50)),
iaa.Fliplr(0.5),
iaa.Flipud(0.5),
iaa.Superpixels(p_replace=(0.25, 1.0), n_segments=(16, 128)),
# iaa.ChangeColorspace(to_colorspace="GRAY"),
iaa.Grayscale(alpha=(0.1, 1.0)),
iaa.GaussianBlur((0.1, 3.0)),
iaa.AverageBlur((3, 11)),
iaa.MedianBlur((3, 11)),
# iaa.Convolve(np.array([[0, 1, 0],
# [1, -4, 1],
# [0, 1, 0]])),
iaa.Sharpen(alpha=(0.1, 1.0), lightness=(0.8, 1.2)),
iaa.Emboss(alpha=(0.1, 1.0), strength=(0.8, 1.2)),
iaa.EdgeDetect(alpha=(0.1, 1.0)),
iaa.DirectedEdgeDetect(alpha=(0.1, 1.0), direction=(0.0, 1.0)),
iaa.Add((-50, 50)),
iaa.AddElementwise((-50, 50)),
iaa.AdditiveGaussianNoise(scale=(0.1, 1.0)),
iaa.Multiply((0.6, 1.4)),
iaa.MultiplyElementwise((0.6, 1.4)),
iaa.Dropout((0.3, 0.5)),
iaa.CoarseDropout((0.3, 0.5), size_percent=(0.05, 0.2)),
iaa.Invert(0.5),
iaa.ContrastNormalization((0.6, 1.4)),
iaa.Affine(scale=(0.7, 1.3), translate_percent=(-0.1, 0.1),
rotate=(-20, 20), shear=(-20, 20), order=ia.ALL,
mode=ia.ALL, cval=(0, 255)),
iaa.PiecewiseAffine(scale=(0.1, 0.3)),
iaa.ElasticTransformation(alpha=0.5)
]
augs_affect_geometry = [
iaa.Sequential([iaa.Fliplr(0.5), iaa.Flipud(0.5)]),
iaa.SomeOf(1, [iaa.Fliplr(0.5), iaa.Flipud(0.5)]),
iaa.OneOf([iaa.Fliplr(0.5), iaa.Flipud(0.5)]),
iaa.Sometimes(0.5, iaa.Fliplr(1.0)),
iaa.Resize((0.5, 0.9)),
iaa.CropAndPad(px=(-50, 50)),
iaa.Pad(px=(1, 50)),
iaa.Crop(px=(1, 50)),
iaa.Fliplr(0.5),
iaa.Flipud(0.5),
iaa.Affine(scale=(0.7, 1.3), translate_percent=(-0.1, 0.1),
rotate=(-20, 20), shear=(-20, 20), order=ia.ALL,
mode=ia.ALL, cval=(0, 255)),
iaa.PiecewiseAffine(scale=(0.1, 0.3)),
iaa.ElasticTransformation(alpha=(5, 100), sigma=(3, 5))
]
for aug in augs:
aug_det = aug.to_deterministic()
images_aug1 = aug_det.augment_images(images)
images_aug2 = aug_det.augment_images(images)
aug_det = aug.to_deterministic()
images_aug3 = aug_det.augment_images(images)
images_aug4 = aug_det.augment_images(images)
assert array_equal_lists(images_aug1, images_aug2), \
"Images (1, 2) expected to be identical for %s" % (aug.name,)
assert array_equal_lists(images_aug3, images_aug4), \
"Images (3, 4) expected to be identical for %s" % (aug.name,)
assert not array_equal_lists(images_aug1, images_aug3), \
"Images (1, 3) expected to be different for %s" % (aug.name,)
for aug in augs_affect_geometry:
aug_det = aug.to_deterministic()
kps_aug1 = aug_det.augment_keypoints(keypoints)
kps_aug2 = aug_det.augment_keypoints(keypoints)
aug_det = aug.to_deterministic()
kps_aug3 = aug_det.augment_keypoints(keypoints)
kps_aug4 = aug_det.augment_keypoints(keypoints)
assert keypoints_equal(kps_aug1, kps_aug2), \
"Keypoints (1, 2) expected to be identical for %s" % (aug.name,)
assert keypoints_equal(kps_aug3, kps_aug4), \
"Keypoints (3, 4) expected to be identical for %s" % (aug.name,)
assert not keypoints_equal(kps_aug1, kps_aug3), \
"Keypoints (1, 3) expected to be different for %s" % (aug.name,)
def __init__(self,
list_file,
train,
transform,
device,
little_train=False,
S=7):
print('data init')
self.train = train
self.transform = transform
self.fnames = []
self.boxes = []
self.labels = []
self.S = S
self.B = 2
self.C = 20
self.device = device
self.augmentation = iaa.Sometimes(
0.5,
iaa.SomeOf(
(1, 6),
[
iaa.Dropout([0.05, 0.2]), # drop 5% or 20% of all pixels
iaa.Sharpen((0.1, 1.0)), # sharpen the image
iaa.GaussianBlur(sigma=(2., 3.5)),
iaa.OneOf([
iaa.GaussianBlur(sigma=(2., 3.5)),
iaa.AverageBlur(k=(2, 5)),
iaa.BilateralBlur(d=(7, 12),
sigma_color=(10, 250),
sigma_space=(10, 250)),
iaa.MedianBlur(k=(3, 7)),
]),
# iaa.Fliplr(1.0),
# iaa.Flipud(1.0),
iaa.AddElementwise((-50, 50)),
iaa.AdditiveGaussianNoise(scale=(0, 0.1 * 255)),
iaa.JpegCompression(compression=(80, 95)),
iaa.Multiply((0.5, 1.5)),
iaa.MultiplyElementwise((0.5, 1.5)),
iaa.ReplaceElementwise(0.05, [0, 255]),
iaa.WithColorspace(to_colorspace="HSV",
from_colorspace="RGB",
children=iaa.WithChannels(
2, iaa.Add((-10, 50)))),
iaa.OneOf([
iaa.WithColorspace(to_colorspace="HSV",
from_colorspace="RGB",
children=iaa.WithChannels(
1, iaa.Add((-10, 50)))),
iaa.WithColorspace(to_colorspace="HSV",
from_colorspace="RGB",
children=iaa.WithChannels(
2, iaa.Add((-10, 50)))),
]),
],
random_order=True))
torch.manual_seed(23)
with open(list_file) as f:
lines = f.readlines()
if little_train:
lines = lines[:64]
for line in lines:
splited = line.strip().split()
self.fnames.append(splited[0])
self.num_samples = len(self.fnames)
#iaa.Sometimes(0.3, iaa.PiecewiseAffine(scale=(0.04, 0.08))),
#iaa.Sometimes(0.3, iaa.PerspectiveTransform(scale=(0.05, 0.1))),
],
random_order=True)
intensity_seq = iaa.Sequential([
iaa.Invert(0.3),
iaa.Sometimes(0.3, iaa.ContrastNormalization((0.5, 1.5))),
iaa.OneOf([
iaa.Noop(),
iaa.Sequential([
iaa.OneOf([
iaa.Add((-10, 10)),
iaa.AddElementwise((-10, 10)),
iaa.Multiply((0.95, 1.05)),
iaa.MultiplyElementwise((0.95, 1.05)),
]),
]),
iaa.OneOf([
iaa.GaussianBlur(sigma=(0.0, 1.0)),
iaa.AverageBlur(k=(2, 5)),
iaa.MedianBlur(k=(3, 5))
])
])
],
random_order=False)
brightness_seq = iaa.Sequential([
iaa.Multiply((0.9, 1.1)),
iaa.Sometimes(0.3, iaa.GaussianBlur(sigma=(0, 0.5)))
],
def build_augmentators(self):
"""Build the augmentator"""
self.augment_character = iaa.Sequential([
iaa.Sometimes(
0.5,
iaa.OneOf([
iaa.PiecewiseAffine(scale=0.01,
nb_cols=15,
nb_rows=10,
cval=self.cval),
iaa.PiecewiseAffine(scale=0.01,
nb_cols=7,
nb_rows=5,
cval=self.cval)
])),
iaa.Sometimes(0.3, ItalicizeLine(shear=(-20, 21), cval=self.cval)),
iaa.Sometimes(
0.3,
ItalicizeLine(shear=(-20, 21), vertical=True, cval=self.cval)),
iaa.Sometimes(0.3, RotateLine(angle=(-5, 5), cval=self.cval)),
iaa.Sometimes(
0.3,
PerspectiveTransform((0.05, 0.15),
cval=self.cval,
keep_size=False)),
iaa.Sometimes(
0.3,
iaa.ElasticTransformation(alpha=(0, 1.0),
sigma=(0.4, 0.6),
cval=self.cval)),
iaa.Sometimes(0.02, Skeletonize(self.is_binary)),
iaa.Sometimes(0.1 * self.grayscale_only,
iaa.ContrastNormalization((0.5, 1.5))),
iaa.Sometimes(0.3 * self.grayscale_only, PencilStroke()),
iaa.Sometimes(
0.3 * self.grayscale_only * self.background_images_value,
BackgroundImageNoises(self.background_images_path)),
iaa.Sometimes(
self.grayscale_only,
iaa.OneOf([
iaa.Sometimes(
0.5,
iaa.OneOf([
iaa.GaussianBlur((0.2, 1.0)),
iaa.AverageBlur(k=(1, 5)),
iaa.MedianBlur(k=(1, 3))
])),
iaa.OneOf([
iaa.Add((-50, 30)),
iaa.Multiply((0.9, 1.1)),
iaa.OneOf([
iaa.Dropout(p=(0.01, 0.05)),
iaa.CoarseDropout((0.01, 0.02),
size_percent=(0.1, 0.25))
]),
iaa.Sometimes(
0.7,
iaa.OneOf([
iaa.AddElementwise((-10 * n, 5 * n))
for n in range(1, 5)
] + [
iaa.AdditiveGaussianNoise(scale=(0.05 * 255,
0.1 * 255)),
iaa.MultiplyElementwise((0.95, 1.05))
]))
])
]))
])
def main():
images = [
misc.imresize(
ndimage.imread("../quokka.jpg")[0:643, 0:643], (128, 128)),
misc.imresize(data.astronaut(), (128, 128))
]
augmenters = [
iaa.Noop(name="Noop"),
iaa.Crop(px=(0, 8), name="Crop-px"),
iaa.Crop(percent=(0, 0.1), name="Crop-percent"),
iaa.Fliplr(0.5, name="Fliplr"),
iaa.Flipud(0.5, name="Flipud"),
iaa.Superpixels(p_replace=0.75, n_segments=50, name="Superpixels"),
iaa.Grayscale(0.5, name="Grayscale0.5"),
iaa.Grayscale(1.0, name="Grayscale1.0"),
iaa.GaussianBlur((0, 3.0), name="GaussianBlur"),
iaa.Sharpen(alpha=(0.1, 1.0), lightness=(0, 2.0), name="Sharpen"),
iaa.Emboss(alpha=(0.1, 1.0), strength=(0, 2.0), name="Emboss"),
iaa.EdgeDetect(alpha=(0.1, 1.0), name="EdgeDetect"),
iaa.DirectedEdgeDetect(alpha=(0.1, 1.0),
direction=(0, 1.0),
name="DirectedEdgeDetect"),
iaa.AdditiveGaussianNoise(loc=0,
scale=(0.0, 0.1 * 255),
name="AdditiveGaussianNoise"),
iaa.Dropout((0.0, 0.1), name="Dropout"),
iaa.Invert(p=0.5, name="Invert"),
iaa.Invert(p=0.5, per_channel=True, name="InvertPerChannel"),
iaa.Add((-50, 50), name="Add"),
iaa.Add((-50, 50), per_channel=True, name="AddPerChannel"),
iaa.AddElementwise((-50, 50), name="AddElementwise"),
iaa.Multiply((0.5, 1.5), name="Multiply"),
iaa.Multiply((0.5, 1.5), per_channel=True, name="MultiplyPerChannel"),
iaa.MultiplyElementwise((0.5, 1.5), name="MultiplyElementwise"),
iaa.ContrastNormalization(alpha=(0.5, 2.0),
name="ContrastNormalization"),
iaa.Affine(scale={
"x": (0.8, 1.2),
"y": (0.8, 1.2)
},
translate_px={
"x": (-16, 16),
"y": (-16, 16)
},
rotate=(-45, 45),
shear=(-16, 16),
order=ia.ALL,
cval=(0, 255),
mode=ia.ALL,
name="Affine"),
iaa.ElasticTransformation(alpha=(0.5, 8.0),
sigma=1.0,
name="ElasticTransformation")
]
#for i, aug in enumerate(augmenters):
#print(i)
#aug.deepcopy()
#import copy
#copy.deepcopy(aug)
augmenters.append(
iaa.Sequential([iaa.Sometimes(0.2, aug.copy()) for aug in augmenters],
name="Sequential"))
augmenters.append(
iaa.Sometimes(0.5, [aug.copy() for aug in augmenters],
name="Sometimes"))
for augmenter in augmenters:
print("Augmenter: %s" % (augmenter.name, ))
grid = augmenter.draw_grid(images, rows=1, cols=16)
misc.imshow(grid)
name="norm"),
iaa.Grayscale(alpha=(0.0, 1.0), name="gray"),
])),
# Blur and Noise
iaa.Sometimes(
0.2,
iaa.SomeOf((1, None), [
iaa.OneOf([
iaa.MotionBlur(k=3, name="motion-blur"),
iaa.GaussianBlur(sigma=(0.5, 1.0), name="gaus-blur")
]),
iaa.OneOf([
iaa.AddElementwise(
(-5, 5), per_channel=0.5, name="add-element"),
iaa.MultiplyElementwise(
(0.95, 1.05), per_channel=0.5, name="mul-element"),
iaa.AdditiveGaussianNoise(
scale=0.01 * 255, per_channel=0.5, name="guas-noise"),
iaa.AdditiveLaplaceNoise(
scale=(0, 0.01 * 255), per_channel=True, name="lap-noise"),
iaa.Sometimes(
1.0,
iaa.Dropout(
p=(0.003, 0.01), per_channel=0.5, name="dropout")),
]),
],
random_order=True)),
# Colored Blocks
iaa.Sometimes(
0.2,
def build_augmentators(self):
""" Build the augmentators from the information """
print(self.grayscale_only, self.background_images_value)
self.augment_lines_general = iaa.Sequential([
iaa.Sometimes(0.3, ItalicizeLine(shear=(-30, 31), cval=self.cval)),
iaa.Sometimes(0.3, RotateLine(angle=(-5, 5), cval=self.cval)),
iaa.OneOf([
iaa.Pad(percent=((0.02, 0.1), (0.01, 0.1), (0.02, 0.1), (0.02,
0.1)),
pad_mode='constant',
pad_cval=self.cval),
iaa.Pad(px=((2, 20), (2, 60), (2, 20), (2, 60)),
pad_mode='constant',
pad_cval=self.cval),
]),
iaa.Sometimes(
0.3,
PerspectiveTransform((0.05, 0.15),
cval=self.cval,
keep_size=False)),
iaa.Sometimes(
0.3,
iaa.ElasticTransformation(alpha=(0, 1.0),
sigma=(0.4, 0.6),
cval=self.cval)),
iaa.Sometimes(0.02, Skeletonize(self.is_binary)),
iaa.Sometimes(0.1 * self.grayscale_only,
iaa.ContrastNormalization((0.5, 1.5))),
iaa.Sometimes(0.3 * self.grayscale_only, PencilStroke()),
iaa.Sometimes(
self.grayscale_only,
iaa.OneOf([
iaa.Sometimes(
0.5,
iaa.OneOf([
iaa.GaussianBlur((0.2, 1.0)),
iaa.AverageBlur(k=(1, 5)),
iaa.MedianBlur(k=(1, 3))
])),
iaa.OneOf([
iaa.Add((-50, 30)),
iaa.Multiply((0.9, 1.1)),
iaa.OneOf([
iaa.Dropout(p=(0.01, 0.05)),
iaa.CoarseDropout((0.01, 0.02),
size_percent=(0.1, 0.25))
]),
iaa.Sometimes(
0.7,
iaa.OneOf([
iaa.AddElementwise((-10 * n, 5 * n))
for n in range(1, 5)
] + [
iaa.AdditiveGaussianNoise(scale=(0.05 * 255,
0.1 * 255)),
iaa.MultiplyElementwise((0.95, 1.05))
]))
]),
iaa.Sometimes(
self.grayscale_only * self.background_images_value,
BackgroundImageNoises(self.background_images_path)),
]))
])
# reduce absolute padding size, perspective transform value, gaussblur
self.augment_lines_short_image = iaa.Sequential([
iaa.Sometimes(0.4, ItalicizeLine(shear=(-25, 25), cval=self.cval)),
iaa.Sometimes(0.4, RotateLine(angle=(-5, 5), cval=self.cval)),
iaa.OneOf([
iaa.Pad(percent=((0.01, 0.05), (0.01, 0.05), (0.01, 0.05),
(0.01, 0.05)),
pad_mode='constant',
pad_cval=self.cval),
iaa.Pad(px=((3, 10), (3, 30), (3, 10), (3, 30)),
pad_mode='constant',
pad_cval=self.cval),
]),
iaa.Sometimes(
0.3,
PerspectiveTransform((0.02, 0.05),
cval=self.cval,
keep_size=False)),
iaa.Sometimes(
0.3,
iaa.ElasticTransformation(alpha=(0, 1.0),
sigma=(0.4, 0.6),
cval=self.cval)),
iaa.Sometimes(0.02, Skeletonize(self.is_binary)),
iaa.Sometimes(0.1 * self.grayscale_only,
iaa.ContrastNormalization((0.5, 1.5))),
iaa.Sometimes(0.3 * self.grayscale_only, PencilStroke()),
iaa.Sometimes(
self.grayscale_only,
iaa.Sequential([
iaa.Sometimes(
0.5,
iaa.OneOf([
iaa.GaussianBlur((0.2, 0.5)),
iaa.AverageBlur(k=(1, 5)),
iaa.MedianBlur(k=(1, 3))
])),
iaa.Sequential([
iaa.Sometimes(
0.7,
iaa.OneOf([
iaa.Add((-60, 0)),
iaa.Multiply((0.6, 0.9)),
])),
iaa.Sometimes(
0.7,
iaa.OneOf([
iaa.Dropout(p=(0.01, 0.05)),
iaa.CoarseDropout((0.01, 0.02),
size_percent=(0.1, 0.25))
])),
iaa.Sometimes(
0.7,
iaa.OneOf([
iaa.AddElementwise((-10 * n, 5 * n))
for n in range(1, 5)
] + [
iaa.AdditiveGaussianNoise(scale=(0.05 * 255,
0.1 * 255)),
iaa.MultiplyElementwise((0.95, 1.05))
]))
]),
# iaa.Sometimes(
# self.grayscale_only * self.background_images_value,
# BackgroundImageNoises(self.background_images_path)),
]))
])
def create_augmenters(height, width, height_augmentable, width_augmentable,
only_augmenters):
def lambda_func_images(images, random_state, parents, hooks):
return images
def lambda_func_heatmaps(heatmaps, random_state, parents, hooks):
return heatmaps
def lambda_func_keypoints(keypoints, random_state, parents, hooks):
return keypoints
def assertlambda_func_images(images, random_state, parents, hooks):
return True
def assertlambda_func_heatmaps(heatmaps, random_state, parents, hooks):
return True
def assertlambda_func_keypoints(keypoints, random_state, parents, hooks):
return True
augmenters_meta = [
iaa.Sequential([iaa.Noop(), iaa.Noop()],
random_order=False,
name="Sequential_2xNoop"),
iaa.Sequential([iaa.Noop(), iaa.Noop()],
random_order=True,
name="Sequential_2xNoop_random_order"),
iaa.SomeOf((1, 3),
[iaa.Noop(), iaa.Noop(), iaa.Noop()],
random_order=False,
name="SomeOf_3xNoop"),
iaa.SomeOf((1, 3),
[iaa.Noop(), iaa.Noop(), iaa.Noop()],
random_order=True,
name="SomeOf_3xNoop_random_order"),
iaa.OneOf([iaa.Noop(), iaa.Noop(), iaa.Noop()], name="OneOf_3xNoop"),
iaa.Sometimes(0.5, iaa.Noop(), name="Sometimes_Noop"),
iaa.WithChannels([1, 2], iaa.Noop(), name="WithChannels_1_and_2_Noop"),
iaa.Noop(name="Noop"),
iaa.Lambda(func_images=lambda_func_images,
func_heatmaps=lambda_func_heatmaps,
func_keypoints=lambda_func_keypoints,
name="Lambda"),
iaa.AssertLambda(func_images=assertlambda_func_images,
func_heatmaps=assertlambda_func_heatmaps,
func_keypoints=assertlambda_func_keypoints,
name="AssertLambda"),
iaa.AssertShape((None, height_augmentable, width_augmentable, None),
name="AssertShape"),
iaa.ChannelShuffle(0.5, name="ChannelShuffle")
]
augmenters_arithmetic = [
iaa.Add((-10, 10), name="Add"),
iaa.AddElementwise((-10, 10), name="AddElementwise"),
#iaa.AddElementwise((-500, 500), name="AddElementwise"),
iaa.AdditiveGaussianNoise(scale=(5, 10), name="AdditiveGaussianNoise"),
iaa.AdditiveLaplaceNoise(scale=(5, 10), name="AdditiveLaplaceNoise"),
iaa.AdditivePoissonNoise(lam=(1, 5), name="AdditivePoissonNoise"),
iaa.Multiply((0.5, 1.5), name="Multiply"),
iaa.MultiplyElementwise((0.5, 1.5), name="MultiplyElementwise"),
iaa.Dropout((0.01, 0.05), name="Dropout"),
iaa.CoarseDropout((0.01, 0.05),
size_percent=(0.01, 0.1),
name="CoarseDropout"),
iaa.ReplaceElementwise((0.01, 0.05), (0, 255),
name="ReplaceElementwise"),
#iaa.ReplaceElementwise((0.95, 0.99), (0, 255), name="ReplaceElementwise"),
iaa.SaltAndPepper((0.01, 0.05), name="SaltAndPepper"),
iaa.ImpulseNoise((0.01, 0.05), name="ImpulseNoise"),
iaa.CoarseSaltAndPepper((0.01, 0.05),
size_percent=(0.01, 0.1),
name="CoarseSaltAndPepper"),
iaa.Salt((0.01, 0.05), name="Salt"),
iaa.CoarseSalt((0.01, 0.05),
size_percent=(0.01, 0.1),
name="CoarseSalt"),
iaa.Pepper((0.01, 0.05), name="Pepper"),
iaa.CoarsePepper((0.01, 0.05),
size_percent=(0.01, 0.1),
name="CoarsePepper"),
iaa.Invert(0.1, name="Invert"),
# ContrastNormalization
iaa.JpegCompression((50, 99), name="JpegCompression")
]
augmenters_blend = [
iaa.Alpha((0.01, 0.99), iaa.Noop(), name="Alpha"),
iaa.AlphaElementwise((0.01, 0.99), iaa.Noop(),
name="AlphaElementwise"),
iaa.SimplexNoiseAlpha(iaa.Noop(), name="SimplexNoiseAlpha"),
iaa.FrequencyNoiseAlpha((-2.0, 2.0),
iaa.Noop(),
name="FrequencyNoiseAlpha")
]
augmenters_blur = [
iaa.GaussianBlur(sigma=(1.0, 5.0), name="GaussianBlur"),
iaa.AverageBlur(k=(3, 11), name="AverageBlur"),
iaa.MedianBlur(k=(3, 11), name="MedianBlur"),
iaa.BilateralBlur(d=(3, 11), name="BilateralBlur"),
iaa.MotionBlur(k=(3, 11), name="MotionBlur")
]
augmenters_color = [
# InColorspace (deprecated)
iaa.WithColorspace(to_colorspace="HSV",
children=iaa.Noop(),
name="WithColorspace"),
iaa.WithHueAndSaturation(children=iaa.Noop(),
name="WithHueAndSaturation"),
iaa.MultiplyHueAndSaturation((0.8, 1.2),
name="MultiplyHueAndSaturation"),
iaa.MultiplyHue((-1.0, 1.0), name="MultiplyHue"),
iaa.MultiplySaturation((0.8, 1.2), name="MultiplySaturation"),
iaa.AddToHueAndSaturation((-10, 10), name="AddToHueAndSaturation"),
iaa.AddToHue((-10, 10), name="AddToHue"),
iaa.AddToSaturation((-10, 10), name="AddToSaturation"),
iaa.ChangeColorspace(to_colorspace="HSV", name="ChangeColorspace"),
iaa.Grayscale((0.01, 0.99), name="Grayscale"),
iaa.KMeansColorQuantization((2, 16), name="KMeansColorQuantization"),
iaa.UniformColorQuantization((2, 16), name="UniformColorQuantization")
]
augmenters_contrast = [
iaa.GammaContrast(gamma=(0.5, 2.0), name="GammaContrast"),
iaa.SigmoidContrast(gain=(5, 20),
cutoff=(0.25, 0.75),
name="SigmoidContrast"),
iaa.LogContrast(gain=(0.7, 1.0), name="LogContrast"),
iaa.LinearContrast((0.5, 1.5), name="LinearContrast"),
iaa.AllChannelsCLAHE(clip_limit=(2, 10),
tile_grid_size_px=(3, 11),
name="AllChannelsCLAHE"),
iaa.CLAHE(clip_limit=(2, 10),
tile_grid_size_px=(3, 11),
to_colorspace="HSV",
name="CLAHE"),
iaa.AllChannelsHistogramEqualization(
name="AllChannelsHistogramEqualization"),
iaa.HistogramEqualization(to_colorspace="HSV",
name="HistogramEqualization"),
]
augmenters_convolutional = [
iaa.Convolve(np.float32([[0, 0, 0], [0, 1, 0], [0, 0, 0]]),
name="Convolve_3x3"),
iaa.Sharpen(alpha=(0.01, 0.99), lightness=(0.5, 2), name="Sharpen"),
iaa.Emboss(alpha=(0.01, 0.99), strength=(0, 2), name="Emboss"),
iaa.EdgeDetect(alpha=(0.01, 0.99), name="EdgeDetect"),
iaa.DirectedEdgeDetect(alpha=(0.01, 0.99), name="DirectedEdgeDetect")
]
augmenters_edges = [iaa.Canny(alpha=(0.01, 0.99), name="Canny")]
augmenters_flip = [
iaa.Fliplr(1.0, name="Fliplr"),
iaa.Flipud(1.0, name="Flipud")
]
augmenters_geometric = [
iaa.Affine(scale=(0.9, 1.1),
translate_percent={
"x": (-0.05, 0.05),
"y": (-0.05, 0.05)
},
rotate=(-10, 10),
shear=(-10, 10),
order=0,
mode="constant",
cval=(0, 255),
name="Affine_order_0_constant"),
iaa.Affine(scale=(0.9, 1.1),
translate_percent={
"x": (-0.05, 0.05),
"y": (-0.05, 0.05)
},
rotate=(-10, 10),
shear=(-10, 10),
order=1,
mode="constant",
cval=(0, 255),
name="Affine_order_1_constant"),
iaa.Affine(scale=(0.9, 1.1),
translate_percent={
"x": (-0.05, 0.05),
"y": (-0.05, 0.05)
},
rotate=(-10, 10),
shear=(-10, 10),
order=3,
mode="constant",
cval=(0, 255),
name="Affine_order_3_constant"),
iaa.Affine(scale=(0.9, 1.1),
translate_percent={
"x": (-0.05, 0.05),
"y": (-0.05, 0.05)
},
rotate=(-10, 10),
shear=(-10, 10),
order=1,
mode="edge",
cval=(0, 255),
name="Affine_order_1_edge"),
iaa.Affine(scale=(0.9, 1.1),
translate_percent={
"x": (-0.05, 0.05),
"y": (-0.05, 0.05)
},
rotate=(-10, 10),
shear=(-10, 10),
order=1,
mode="constant",
cval=(0, 255),
backend="skimage",
name="Affine_order_1_constant_skimage"),
# TODO AffineCv2
iaa.PiecewiseAffine(scale=(0.01, 0.05),
nb_rows=4,
nb_cols=4,
order=1,
mode="constant",
name="PiecewiseAffine_4x4_order_1_constant"),
iaa.PiecewiseAffine(scale=(0.01, 0.05),
nb_rows=4,
nb_cols=4,
order=0,
mode="constant",
name="PiecewiseAffine_4x4_order_0_constant"),
iaa.PiecewiseAffine(scale=(0.01, 0.05),
nb_rows=4,
nb_cols=4,
order=1,
mode="edge",
name="PiecewiseAffine_4x4_order_1_edge"),
iaa.PiecewiseAffine(scale=(0.01, 0.05),
nb_rows=8,
nb_cols=8,
order=1,
mode="constant",
name="PiecewiseAffine_8x8_order_1_constant"),
iaa.PerspectiveTransform(scale=(0.01, 0.05),
keep_size=False,
name="PerspectiveTransform"),
iaa.PerspectiveTransform(scale=(0.01, 0.05),
keep_size=True,
name="PerspectiveTransform_keep_size"),
iaa.ElasticTransformation(
alpha=(1, 10),
sigma=(0.5, 1.5),
order=0,
mode="constant",
cval=0,
name="ElasticTransformation_order_0_constant"),
iaa.ElasticTransformation(
alpha=(1, 10),
sigma=(0.5, 1.5),
order=1,
mode="constant",
cval=0,
name="ElasticTransformation_order_1_constant"),
iaa.ElasticTransformation(
alpha=(1, 10),
sigma=(0.5, 1.5),
order=1,
mode="nearest",
cval=0,
name="ElasticTransformation_order_1_nearest"),
iaa.ElasticTransformation(
alpha=(1, 10),
sigma=(0.5, 1.5),
order=1,
mode="reflect",
cval=0,
name="ElasticTransformation_order_1_reflect"),
iaa.Rot90((1, 3), keep_size=False, name="Rot90"),
iaa.Rot90((1, 3), keep_size=True, name="Rot90_keep_size")
]
augmenters_pooling = [
iaa.AveragePooling(kernel_size=(1, 16),
keep_size=False,
name="AveragePooling"),
iaa.AveragePooling(kernel_size=(1, 16),
keep_size=True,
name="AveragePooling_keep_size"),
iaa.MaxPooling(kernel_size=(1, 16), keep_size=False,
name="MaxPooling"),
iaa.MaxPooling(kernel_size=(1, 16),
keep_size=True,
name="MaxPooling_keep_size"),
iaa.MinPooling(kernel_size=(1, 16), keep_size=False,
name="MinPooling"),
iaa.MinPooling(kernel_size=(1, 16),
keep_size=True,
name="MinPooling_keep_size"),
iaa.MedianPooling(kernel_size=(1, 16),
keep_size=False,
name="MedianPooling"),
iaa.MedianPooling(kernel_size=(1, 16),
keep_size=True,
name="MedianPooling_keep_size")
]
augmenters_segmentation = [
iaa.Superpixels(p_replace=(0.05, 1.0),
n_segments=(10, 100),
max_size=64,
interpolation="cubic",
name="Superpixels_max_size_64_cubic"),
iaa.Superpixels(p_replace=(0.05, 1.0),
n_segments=(10, 100),
max_size=64,
interpolation="linear",
name="Superpixels_max_size_64_linear"),
iaa.Superpixels(p_replace=(0.05, 1.0),
n_segments=(10, 100),
max_size=128,
interpolation="linear",
name="Superpixels_max_size_128_linear"),
iaa.Superpixels(p_replace=(0.05, 1.0),
n_segments=(10, 100),
max_size=224,
interpolation="linear",
name="Superpixels_max_size_224_linear"),
iaa.UniformVoronoi(n_points=(250, 1000), name="UniformVoronoi"),
iaa.RegularGridVoronoi(n_rows=(16, 31),
n_cols=(16, 31),
name="RegularGridVoronoi"),
iaa.RelativeRegularGridVoronoi(n_rows_frac=(0.07, 0.14),
n_cols_frac=(0.07, 0.14),
name="RelativeRegularGridVoronoi"),
]
augmenters_size = [
iaa.Resize((0.8, 1.2), interpolation="nearest", name="Resize_nearest"),
iaa.Resize((0.8, 1.2), interpolation="linear", name="Resize_linear"),
iaa.Resize((0.8, 1.2), interpolation="cubic", name="Resize_cubic"),
iaa.CropAndPad(percent=(-0.2, 0.2),
pad_mode="constant",
pad_cval=(0, 255),
keep_size=False,
name="CropAndPad"),
iaa.CropAndPad(percent=(-0.2, 0.2),
pad_mode="edge",
pad_cval=(0, 255),
keep_size=False,
name="CropAndPad_edge"),
iaa.CropAndPad(percent=(-0.2, 0.2),
pad_mode="constant",
pad_cval=(0, 255),
name="CropAndPad_keep_size"),
iaa.Pad(percent=(0.05, 0.2),
pad_mode="constant",
pad_cval=(0, 255),
keep_size=False,
name="Pad"),
iaa.Pad(percent=(0.05, 0.2),
pad_mode="edge",
pad_cval=(0, 255),
keep_size=False,
name="Pad_edge"),
iaa.Pad(percent=(0.05, 0.2),
pad_mode="constant",
pad_cval=(0, 255),
name="Pad_keep_size"),
iaa.Crop(percent=(0.05, 0.2), keep_size=False, name="Crop"),
iaa.Crop(percent=(0.05, 0.2), name="Crop_keep_size"),
iaa.PadToFixedSize(width=width + 10,
height=height + 10,
pad_mode="constant",
pad_cval=(0, 255),
name="PadToFixedSize"),
iaa.CropToFixedSize(width=width - 10,
height=height - 10,
name="CropToFixedSize"),
iaa.KeepSizeByResize(iaa.CropToFixedSize(height=height - 10,
width=width - 10),
interpolation="nearest",
name="KeepSizeByResize_CropToFixedSize_nearest"),
iaa.KeepSizeByResize(iaa.CropToFixedSize(height=height - 10,
width=width - 10),
interpolation="linear",
name="KeepSizeByResize_CropToFixedSize_linear"),
iaa.KeepSizeByResize(iaa.CropToFixedSize(height=height - 10,
width=width - 10),
interpolation="cubic",
name="KeepSizeByResize_CropToFixedSize_cubic"),
]
augmenters_weather = [
iaa.FastSnowyLandscape(lightness_threshold=(100, 255),
lightness_multiplier=(1.0, 4.0),
name="FastSnowyLandscape"),
iaa.Clouds(name="Clouds"),
iaa.Fog(name="Fog"),
iaa.CloudLayer(intensity_mean=(196, 255),
intensity_freq_exponent=(-2.5, -2.0),
intensity_coarse_scale=10,
alpha_min=0,
alpha_multiplier=(0.25, 0.75),
alpha_size_px_max=(2, 8),
alpha_freq_exponent=(-2.5, -2.0),
sparsity=(0.8, 1.0),
density_multiplier=(0.5, 1.0),
name="CloudLayer"),
iaa.Snowflakes(name="Snowflakes"),
iaa.SnowflakesLayer(density=(0.005, 0.075),
density_uniformity=(0.3, 0.9),
flake_size=(0.2, 0.7),
flake_size_uniformity=(0.4, 0.8),
angle=(-30, 30),
speed=(0.007, 0.03),
blur_sigma_fraction=(0.0001, 0.001),
name="SnowflakesLayer")
]
augmenters = (augmenters_meta + augmenters_arithmetic + augmenters_blend +
augmenters_blur + augmenters_color + augmenters_contrast +
augmenters_convolutional + augmenters_edges +
augmenters_flip + augmenters_geometric + augmenters_pooling +
augmenters_segmentation + augmenters_size +
augmenters_weather)
if only_augmenters is not None:
augmenters_reduced = []
for augmenter in augmenters:
if any([
re.search(pattern, augmenter.name)
for pattern in only_augmenters
]):
augmenters_reduced.append(augmenter)
augmenters = augmenters_reduced
return augmenters
def test_determinism():
reseed()
images = [
ia.quokka(size=(128, 128)),
ia.quokka(size=(64, 64)),
ia.quokka((128, 256))
]
images.extend([ia.quokka(size=(16, 16))] * 20)
keypoints = [
ia.KeypointsOnImage([
ia.Keypoint(x=20, y=10), ia.Keypoint(x=5, y=5),
ia.Keypoint(x=10, y=43)], shape=(50, 60, 3))
] * 20
augs = [
iaa.Sequential([iaa.Fliplr(0.5), iaa.Flipud(0.5)]),
iaa.SomeOf(1, [iaa.Fliplr(0.5), iaa.Flipud(0.5)]),
iaa.OneOf([iaa.Fliplr(0.5), iaa.Flipud(0.5)]),
iaa.Sometimes(0.5, iaa.Fliplr(1.0)),
iaa.WithColorspace("HSV", children=iaa.Add((-50, 50))),
iaa.Resize((0.5, 0.9)),
iaa.CropAndPad(px=(-50, 50)),
iaa.Pad(px=(1, 50)),
iaa.Crop(px=(1, 50)),
iaa.Fliplr(0.5),
iaa.Flipud(0.5),
iaa.Superpixels(p_replace=(0.25, 1.0), n_segments=(16, 128)),
iaa.Grayscale(alpha=(0.1, 1.0)),
iaa.GaussianBlur((0.1, 3.0)),
iaa.AverageBlur((3, 11)),
iaa.MedianBlur((3, 11)),
iaa.Sharpen(alpha=(0.1, 1.0), lightness=(0.8, 1.2)),
iaa.Emboss(alpha=(0.1, 1.0), strength=(0.8, 1.2)),
iaa.EdgeDetect(alpha=(0.1, 1.0)),
iaa.DirectedEdgeDetect(alpha=(0.1, 1.0), direction=(0.0, 1.0)),
iaa.Add((-50, 50)),
iaa.AddElementwise((-50, 50)),
iaa.AdditiveGaussianNoise(scale=(0.1, 1.0)),
iaa.Multiply((0.6, 1.4)),
iaa.MultiplyElementwise((0.6, 1.4)),
iaa.Dropout((0.3, 0.5)),
iaa.CoarseDropout((0.3, 0.5), size_percent=(0.05, 0.2)),
iaa.Invert(0.5),
iaa.Affine(scale=(0.7, 1.3), translate_percent=(-0.1, 0.1),
rotate=(-20, 20), shear=(-20, 20), order=ia.ALL,
mode=ia.ALL, cval=(0, 255)),
iaa.PiecewiseAffine(scale=(0.1, 0.3)),
iaa.ElasticTransformation(alpha=10.0)
]
augs_affect_geometry = [
iaa.Sequential([iaa.Fliplr(0.5), iaa.Flipud(0.5)]),
iaa.SomeOf(1, [iaa.Fliplr(0.5), iaa.Flipud(0.5)]),
iaa.OneOf([iaa.Fliplr(0.5), iaa.Flipud(0.5)]),
iaa.Sometimes(0.5, iaa.Fliplr(1.0)),
iaa.Resize((0.5, 0.9)),
iaa.CropAndPad(px=(-50, 50)),
iaa.Pad(px=(1, 50)),
iaa.Crop(px=(1, 50)),
iaa.Fliplr(0.5),
iaa.Flipud(0.5),
iaa.Affine(scale=(0.7, 1.3), translate_percent=(-0.1, 0.1),
rotate=(-20, 20), shear=(-20, 20), order=ia.ALL,
mode=ia.ALL, cval=(0, 255)),
iaa.PiecewiseAffine(scale=(0.1, 0.3)),
iaa.ElasticTransformation(alpha=(5, 100), sigma=(3, 5))
]
for aug in augs:
aug_det = aug.to_deterministic()
images_aug1 = aug_det.augment_images(images)
images_aug2 = aug_det.augment_images(images)
aug_det = aug.to_deterministic()
images_aug3 = aug_det.augment_images(images)
images_aug4 = aug_det.augment_images(images)
assert array_equal_lists(images_aug1, images_aug2), \
"Images (1, 2) expected to be identical for %s" % (aug.name,)
assert array_equal_lists(images_aug3, images_aug4), \
"Images (3, 4) expected to be identical for %s" % (aug.name,)
assert not array_equal_lists(images_aug1, images_aug3), \
"Images (1, 3) expected to be different for %s" % (aug.name,)
for aug in augs_affect_geometry:
aug_det = aug.to_deterministic()
kps_aug1 = aug_det.augment_keypoints(keypoints)
kps_aug2 = aug_det.augment_keypoints(keypoints)
aug_det = aug.to_deterministic()
kps_aug3 = aug_det.augment_keypoints(keypoints)
kps_aug4 = aug_det.augment_keypoints(keypoints)
assert keypoints_equal(kps_aug1, kps_aug2), \
"Keypoints (1, 2) expected to be identical for %s" % (aug.name,)
assert keypoints_equal(kps_aug3, kps_aug4), \
"Keypoints (3, 4) expected to be identical for %s" % (aug.name,)
assert not keypoints_equal(kps_aug1, kps_aug3), \
"Keypoints (1, 3) expected to be different for %s" % (aug.name,)
def __init__(self):
self.fast_aug = albu.Compose(
[
albu.OneOf([
albu.RandomBrightnessContrast(0.2, 0.2, p=0.5),
albu.RandomGamma((78, 130), p=0.5),
albu.CLAHE(4.0, (32, 32), p=0.1) # we have big images
]),
albu.JpegCompression(80, 100, p=0.1),
albu.OneOf([
albu.Blur(5, p=1),
albu.MedianBlur(5, p=1),
albu.GaussianBlur(5, p=1)
],
p=0.2),
albu.GaussNoise((5, 10), p=0.2),
albu.OneOf([
albu.HueSaturationValue(hue_shift_limit=10,
sat_shift_limit=10,
val_shift_limit=30,
p=1),
albu.RGBShift(20, 10, 20, p=1),
],
p=0.5),
albu.ElasticTransform(
alpha=5, sigma=50, alpha_affine=0, approximate=True, p=0.2)
],
p=0.5)
'''
Bounding Box index: pixel based
'''
self.spaaug = albu.Compose([
albu.Rotate(15, interpolation=cv2.INTER_LINEAR,\
border_mode=cv2.BORDER_CONSTANT, p=1.0,\
always_apply=True)],\
bbox_params={'format': 'pascal_voc', 'min_area': 2, 'label_fields': ['category_id']}, p=0.5)
# Sometimes(0.5, ...) applies the given augmenter in 50% of all cases,
# e.g. Sometimes(0.5, GaussianBlur(0.3)) would blur roughly every second image.
sometimes = lambda aug: iaa.Sometimes(0.2, aug)
self.seq = iaa.Sequential(
[
sometimes(iaa.MultiplyElementwise(
(0.5, 1.5), per_channel=0.5)),
# execute 0 to 2 of the following (less important) augmenters per image
# don't execute all of them, as that would often be way too strong
iaa.SomeOf(
(0, 2),
[
sometimes(
iaa.Superpixels(p_replace=(0, 0.1),
n_segments=(2048, 4096))
), # convert images into their superpixel representation
iaa.Sharpen(alpha=(0, 0.3),
lightness=(0.75, 1.5)), # sharpen images
iaa.Emboss(alpha=(0, 0.3),
strength=(0, 2.0)), # emboss images
# search either for all edges or for directed edges,
# blend the result with the original image using a blobby mask
sometimes(
iaa.SimplexNoiseAlpha(
iaa.OneOf([
iaa.EdgeDetect(alpha=(0.5, 1.0)),
iaa.DirectedEdgeDetect(
alpha=(0.5, 1.0),
direction=(0.0, 1.0)),
]))),
iaa.OneOf([
iaa.Dropout(
(0.01, 0.1), per_channel=0.5
), # randomly remove up to 10% of the pixels
iaa.CoarseDropout((0.03, 0.15),
size_percent=(0.02, 0.05),
per_channel=0.2),
]),
iaa.Grayscale(alpha=(0.0, 0.3)),
],
random_order=True)
],
random_order=True)
