def test_augment_images__list_as_value(self):
base_img = np.zeros((2, 2, 3), dtype=np.uint8)
base_img[..., 0] += 20
base_img[..., 1] += 40
base_img[..., 2] += 60
aug = iaa.AddToHueAndSaturation([0, 10, 20])
base_img = base_img[0:1, 0:1, :]
expected_imgs = [
iaa.AddToHueAndSaturation(0).augment_image(base_img),
iaa.AddToHueAndSaturation(10).augment_image(base_img),
iaa.AddToHueAndSaturation(20).augment_image(base_img)
]
assert not np.array_equal(expected_imgs[0], expected_imgs[1])
assert not np.array_equal(expected_imgs[1], expected_imgs[2])
assert not np.array_equal(expected_imgs[0], expected_imgs[2])
nb_iterations = 300
seen = dict([(i, 0) for i, _ in enumerate(expected_imgs)])
for _ in sm.xrange(nb_iterations):
observed = aug.augment_image(base_img)
for i, expected_img in enumerate(expected_imgs):
if np.allclose(observed, expected_img):
seen[i] += 1
assert np.sum(list(seen.values())) == nb_iterations
n_exp = nb_iterations / 3
n_exp_tol = nb_iterations * 0.1
assert all(
[n_exp - n_exp_tol < v < n_exp + n_exp_tol for v in seen.values()])
def main():
image = data.astronaut()
cv2.namedWindow("aug", cv2.WINDOW_NORMAL)
cv2.imshow("aug", image)
cv2.waitKey(TIME_PER_STEP)
# for value in cycle(np.arange(-255, 255, VAL_PER_STEP)):
for value in np.arange(-255, 255, VAL_PER_STEP):
aug = iaa.AddToHueAndSaturation(value=value)
img_aug = aug.augment_image(image)
img_aug = iaa.pad(img_aug, bottom=40)
img_aug = ia.draw_text(img_aug,
x=0,
y=img_aug.shape[0] - 38,
text="value=%d" % (value, ),
size=30)
cv2.imshow("aug", img_aug)
cv2.waitKey(TIME_PER_STEP)
images_aug = iaa.AddToHueAndSaturation(
value=(-255, 255), per_channel=True).augment_images([image] * 64)
ia.imshow(ia.draw_grid(images_aug))
image = ia.quokka_square((128, 128))
images_aug = []
images_aug.extend(iaa.AddToHue().augment_images([image] * 10))
images_aug.extend(iaa.AddToSaturation().augment_images([image] * 10))
ia.imshow(ia.draw_grid(images_aug, rows=2))
def test_augment_images(self):
base_img = np.zeros((2, 2, 3), dtype=np.uint8)
base_img[..., 0] += 20
base_img[..., 1] += 40
base_img[..., 2] += 60
gen = itertools.product([False, True], ["cv2", "numpy"])
for per_channel, backend in gen:
with self.subTest(per_channel=per_channel, backend=backend):
aug = iaa.AddToHueAndSaturation(0, per_channel=per_channel)
aug.backend = backend
observed = aug.augment_image(base_img)
expected = base_img
assert np.allclose(observed, expected)
aug = iaa.AddToHueAndSaturation(30, per_channel=per_channel)
aug.backend = backend
observed = aug.augment_image(base_img)
expected = self._add_hue_saturation(base_img, 30)
diff = np.abs(observed.astype(np.float32) - expected)
assert np.all(diff <= 1)
aug = iaa.AddToHueAndSaturation(255, per_channel=per_channel)
aug.backend = backend
observed = aug.augment_image(base_img)
expected = self._add_hue_saturation(base_img, 255)
diff = np.abs(observed.astype(np.float32) - expected)
assert np.all(diff <= 1)
aug = iaa.AddToHueAndSaturation(-255, per_channel=per_channel)
aug.backend = backend
observed = aug.augment_image(base_img)
expected = self._add_hue_saturation(base_img, -255)
diff = np.abs(observed.astype(np.float32) - expected)
assert np.all(diff <= 1)
def chapter_alpha_masks_introduction():
# -----------------------------------------
# example introduction
# -----------------------------------------
import imgaug as ia
from imgaug import augmenters as iaa
ia.seed(2)
# Example batch of images.
# The array has shape (8, 128, 128, 3) and dtype uint8.
images = np.array([ia.quokka(size=(128, 128)) for _ in range(8)],
dtype=np.uint8)
seqs = [
iaa.BlendAlpha((0.0, 1.0),
foreground=iaa.MedianBlur(11),
per_channel=True),
iaa.BlendAlphaSimplexNoise(foreground=iaa.EdgeDetect(1.0),
per_channel=False),
iaa.BlendAlphaSimplexNoise(foreground=iaa.EdgeDetect(1.0),
background=iaa.LinearContrast((0.5, 2.0)),
per_channel=0.5),
iaa.BlendAlphaFrequencyNoise(foreground=iaa.Affine(rotate=(-10, 10),
translate_px={
"x": (-4, 4),
"y": (-4, 4)
}),
background=iaa.AddToHueAndSaturation(
(-40, 40)),
per_channel=0.5),
iaa.BlendAlphaSimplexNoise(foreground=iaa.BlendAlphaSimplexNoise(
foreground=iaa.EdgeDetect(1.0),
background=iaa.LinearContrast((0.5, 2.0)),
per_channel=True),
background=iaa.BlendAlphaFrequencyNoise(
exponent=(-2.5, -1.0),
foreground=iaa.Affine(rotate=(-10, 10),
translate_px={
"x": (-4, 4),
"y": (-4, 4)
}),
background=iaa.AddToHueAndSaturation(
(-40, 40)),
per_channel=True),
per_channel=True,
aggregation_method="max",
sigmoid=False)
]
cells = []
for seq in seqs:
images_aug = seq(images=images)
cells.extend(images_aug)
# ------------
save("alpha", "introduction.jpg", grid(cells, cols=8, rows=5))
def imag_aug_iaa_fun(imgn, idx=0):
img_aug_list = []
img_aug_list.append(imgn.copy())
if idx == 0: #单一方式增强
seq = iaa.Sequential(
[iaa.Sharpen(alpha=(0.0, 0.45), lightness=(0.65, 1.35))])
# print('-------------------->>> imgaug 0 : Sharpen')
elif idx == 1:
seq = iaa.Sequential([
iaa.AverageBlur(k=(2))
]) # blur image using local means with kernel sizes between 2 and 4
# print('-------------------->>> imgaug 1 : AverageBlur')
elif idx == 2:
seq = iaa.Sequential([
iaa.MedianBlur(k=(3))
]) # blur image using local means with kernel sizes between 3 and 5
# print('-------------------->>> imgaug 2 : MedianBlur')
elif idx == 3:
seq = iaa.Sequential([iaa.GaussianBlur((0.0, 0.55))])
# print('-------------------->>> imgaug 3 : GaussianBlur')
elif idx == 4:
seq = iaa.Sequential([iaa.ContrastNormalization((0.90, 1.10))])
# print('-------------------->>> imgaug 4 : ContrastNormalization') # 对比度
elif idx == 5:
seq = iaa.Sequential([iaa.Add((-55, 55))])
# print('-------------------->>> imgaug 5 : Add')
elif idx == 6:
seq = iaa.Sequential(
[iaa.AddToHueAndSaturation((-10, 10), per_channel=True)])
# print('-------------------->>> imgaug 6 : AddToHueAndSaturation')
elif idx == 7:
# seq = iaa.Sequential([iaa.AdditiveGaussianNoise(loc=0, scale=(0.0, 0.02*255), per_channel=False, name=None, deterministic=False, random_state=None)])
seq = iaa.Sequential([
iaa.AdditiveGaussianNoise(loc=0,
scale=(0.0, 0.1 * 255),
per_channel=False,
name=None,
deterministic=False,
random_state=None)
])
# print('-------------------->>> imgaug 7 : AdditiveGaussianNoise')
elif idx == 8: #复合增强方式
# print(' *** 复合增强方式')
# print('-------------------->>> 符合增强')
seq = iaa.Sequential([
iaa.Sharpen(alpha=(0.0, 0.05), lightness=(0.9, 1.1)),
iaa.GaussianBlur((0, 0.8)),
iaa.ContrastNormalization((0.9, 1.1)),
iaa.Add((-5, 5)),
iaa.AddToHueAndSaturation((-5, 5)),
])
images_aug = seq.augment_images(img_aug_list)
return images_aug[0].copy()
def aug_image(image, is_infer=False, augment = 1):
if is_infer:
flip_code = augment
if flip_code == 1:
seq = iaa.Sequential([iaa.Fliplr(1.0)])
elif flip_code == 2:
seq = iaa.Sequential([iaa.Flipud(1.0)])
elif flip_code == 3:
seq = iaa.Sequential([iaa.Flipud(1.0),
iaa.Fliplr(1.0)])
elif flip_code ==0:
return image
else:
seq = iaa.Sequential([
iaa.Affine(rotate= (-15, 15),
shear = (-15, 15),
mode='edge'),
iaa.SomeOf((0, 2),
[
iaa.GaussianBlur((0, 1.5)),
iaa.AdditiveGaussianNoise(loc=0, scale=(0.0, 0.01 * 255), per_channel=0.5),
iaa.AddToHueAndSaturation((-5, 5)),
iaa.EdgeDetect(alpha=(0, 0.5)),
iaa.CoarseSaltAndPepper(0.2, size_percent=(0.05, 0.1)),
],
random_order=True
)
])
image = seq.augment_image(image)
return image
def __init__(self,
blur=True,
flip=False,
rotate=10,
shear=10,
**kwargs):
from imgaug import augmenters as iaa
sequence = []
sequence += [
iaa.Scale((INPUT_SIZE, INPUT_SIZE)),
iaa.ContrastNormalization((0.75, 1.25)),
iaa.AddElementwise((-10, 10), per_channel=0.5),
iaa.AddToHueAndSaturation(value=(-20, 20),
per_channel=True),
iaa.Multiply((0.75, 1.25)),
]
sequence += [
iaa.PiecewiseAffine(scale=(0.0005, 0.005)),
iaa.Affine(rotate=(-rotate, rotate),
shear=(-shear, shear),
mode='symmetric'),
iaa.Grayscale(alpha=(0.0, 0.5)),
]
if flip:
sequence += [
iaa.Fliplr(0.5),
]
if blur:
sequence += [
iaa.Sometimes(0.01, iaa.GaussianBlur(sigma=(0, 1.0))),
]
self.aug = iaa.Sequential(sequence)
def __getitem__(self, idx):
pair = self.pair_list[idx]
input_img = cv2.imread(pair[0])
input_img = cv2.cvtColor(input_img, cv2.COLOR_BGR2RGB)
img_label = pair[1] # normal is 0
# shape must be deterministic so it can be reused
if self.shape_augs is not None:
shape_augs = self.shape_augs.to_deterministic()
input_img = shape_augs.augment_image(input_img)
if self.input_augs is not None:
input_img = iaa.Sequential(
[
iaa.OneOf([
iaa.GaussianBlur(
(0, 3.0)), # gaussian blur with random sigma
iaa.MedianBlur(
k=(3, 5)), # median with random kernel sizes
iaa.AdditiveGaussianNoise(
loc=0, scale=(0.0, 0.05 * 255), per_channel=0.5),
]),
iaa.Add((-26, 26)),
iaa.AddToHueAndSaturation((-10, 10)),
iaa.LinearContrast((0.8, 1.2), per_channel=1.0),
],
random_order=True).augment_image(input_img)
return input_img, img_label
def image_aug(image):
"""
@param image:
@return:
"""
seq = iaa.SomeOf(
(1, 3),
[
iaa.Crop(px=(0, 16)), # 裁剪
iaa.Multiply((0.7, 1.3)), # 改变色调
iaa.Affine(scale=(0.5, 0.7)), # 放射变换
iaa.GaussianBlur(sigma=(0, 1.5)), # 高斯模糊
iaa.AddToHueAndSaturation(value=(25, -25)),
iaa.ChannelShuffle(1), # RGB三通道随机交换
iaa.ElasticTransformation(alpha=0.1),
iaa.Grayscale(alpha=(0.2, 0.5)),
iaa.Pepper(p=0.03),
iaa.AdditiveGaussianNoise(scale=(0.03 * 255, 0.05 * 255)),
iaa.Dropout(p=(0.03, 0.05)),
iaa.Salt(p=(0.03, 0.05)),
iaa.AverageBlur(k=(1, 3)),
iaa.Add((-10, 10)),
iaa.CoarseSalt(size_percent=0.01)
])
seq_det = seq.to_deterministic()
image_aug = seq_det.augment_images([image])[0]
return image_aug
def test_augment_images__different_hue_and_saturation__mixed_perchan(self):
base_img = np.zeros((2, 2, 3), dtype=np.uint8)
base_img[..., 0] += 20
base_img[..., 1] += 40
base_img[..., 2] += 60
class _DummyParamValue(iap.StochasticParameter):
def _draw_samples(self, size, random_state):
arr = np.float32([10, 20])
return np.tile(arr[np.newaxis, :], (size[0], 1))
class _DummyParamPerChannel(iap.StochasticParameter):
def _draw_samples(self, size, random_state):
assert size == (3, )
return np.float32([1.0, 0.0, 1.0])
aug = iaa.AddToHueAndSaturation(value=_DummyParamValue(),
per_channel=_DummyParamPerChannel())
img_expected1 = self._add_hue_saturation(base_img,
value_hue=10,
value_saturation=20)
img_expected2 = self._add_hue_saturation(base_img,
value_hue=10,
value_saturation=10)
img_expected3 = self._add_hue_saturation(base_img,
value_hue=10,
value_saturation=20)
img_observed1, img_observed2, img_observed3, = \
aug.augment_images([base_img] * 3)
assert np.array_equal(img_observed1, img_expected1)
assert np.array_equal(img_observed2, img_expected2)
assert np.array_equal(img_observed3, img_expected3)
def __init__(self):
sometimes = lambda aug: iaa.Sometimes(0.5, aug)
self.seq = iaa.Sequential(
[
iaa.GaussianBlur(
(0, 1.0)), # blur images with a sigma between 0 and 1.0
sometimes(
iaa.AdditiveGaussianNoise(
loc=0, scale=(0.0, 0.01 * 255), per_channel=0.5)),
sometimes(iaa.Sharpen(
alpha=(0, 1.0), lightness=(0.75, 1.5))), # sharpen images
sometimes(iaa.Emboss(alpha=(0, 1.0),
strength=(0, 1.0))), # emboss images
sometimes(
iaa.ContrastNormalization(
(0.5, 2.0),
per_channel=0.5)), # improve or worsen the contrast
sometimes(iaa.Grayscale(alpha=(0.0, 1.0))),
sometimes(
# change brightness of images (by -10 to 10 of original value)
iaa.Add((-10, 10), per_channel=0.5)),
sometimes(
# change hue and saturation
iaa.AddToHueAndSaturation((-20, 20))),
sometimes(
# randomly remove up to 10% of the pixels
iaa.Dropout((0.01, 0.1), per_channel=0.5)),
],
random_order=True)
def imgAug(inputImage, crop=True, flip=True, gaussianBlur=True, channelInvert=True, brightness=True, hueSat=True):
augList = []
if crop:
augList += [iaa.Crop(px=(0, 16))] # crop images from each side by 0 to 16px (randomly chosen)
if flip:
augList += [iaa.Fliplr(0.5)] # horizontally flip 50% of the images
if gaussianBlur:
augList += [iaa.GaussianBlur(sigma=(0, 3.0))] # blur images with a sigma of 0 to 3.0
if channelInvert:
augList += [iaa.Invert(0.05, per_channel=True)] # invert color channels
if brightness:
augList += [iaa.Add((-10, 10), per_channel=0.5)] # change brightness of images (by -10 to 10 of original value)
if hueSat:
augList += [iaa.AddToHueAndSaturation((-20, 20))] # change hue and saturation
seq = iaa.Sequential(augList)
# seq = iaa.Sequential([
# iaa.Crop(px=(0, 16)), # crop images from each side by 0 to 16px (randomly chosen)
# # iaa.Fliplr(0.5), # horizontally flip 50% of the images
# iaa.GaussianBlur(sigma=(0, 3.0)), # blur images with a sigma of 0 to 3.0
# iaa.Invert(0.05, per_channel=True), # invert color channels
# iaa.Add((-10, 10), per_channel=0.5), # change brightness of images (by -10 to 10 of original value)
# iaa.AddToHueAndSaturation((-20, 20)), # change hue and saturation
# ])
image_aug = seq.augment_image(inputImage)
return image_aug
def train_augmentors(self):
shape_augs = [
iaa.Resize((512, 512), interpolation='nearest'),
# iaa.CropToFixedSize(width=800, height=800),
]
#
sometimes = lambda aug: iaa.Sometimes(0.2, aug)
input_augs = [
iaa.OneOf([
iaa.GaussianBlur((0, 3.0)), # gaussian blur with random sigma
iaa.MedianBlur(k=(3, 5)), # median with random kernel sizes
iaa.AdditiveGaussianNoise(loc=0,
scale=(0.0, 0.05 * 255),
per_channel=0.5),
]),
sometimes(iaa.ElasticTransformation(alpha=(0.5, 3.5), sigma=0.25)),
# move pixels locally around (with random strengths)
sometimes(iaa.PiecewiseAffine(scale=(0.01, 0.05))
), # sometimes move parts of the image around
sometimes(iaa.PerspectiveTransform(scale=(0.01, 0.1))),
iaa.Sequential([
iaa.Add((-26, 26)),
iaa.AddToHueAndSaturation((-20, 20)),
iaa.LinearContrast((0.75, 1.25), per_channel=1.0),
],
random_order=True),
sometimes([
iaa.CropAndPad(percent=(-0.05, 0.1),
pad_mode="reflect",
pad_cval=(0, 255)),
]),
]
return shape_augs, input_augs
def __init__(self):
sometimes = lambda aug: iaa.Sometimes(0.3, aug)
self.aug = iaa.Sequential(iaa.SomeOf((1, 5),
[
# blur
sometimes(iaa.OneOf([iaa.GaussianBlur(sigma=(0, 1.0)),
iaa.MotionBlur(k=3)])),
# color
sometimes(iaa.AddToHueAndSaturation(value=(-10, 10), per_channel=True)),
sometimes(iaa.SigmoidContrast(gain=(3, 10), cutoff=(0.4, 0.6), per_channel=True)),
sometimes(iaa.Invert(0.25, per_channel=0.5)),
sometimes(iaa.Solarize(0.5, threshold=(32, 128))),
sometimes(iaa.Dropout2d(p=0.5)),
sometimes(iaa.Multiply((0.5, 1.5), per_channel=0.5)),
sometimes(iaa.Add((-40, 40), per_channel=0.5)),
sometimes(iaa.JpegCompression(compression=(5, 80))),
# distort
sometimes(iaa.Crop(percent=(0.01, 0.05), sample_independently=True)),
sometimes(iaa.PerspectiveTransform(scale=(0.01, 0.01))),
sometimes(iaa.Affine(scale=(0.7, 1.3), translate_percent=(-0.1, 0.1),
# rotate=(-5, 5), shear=(-5, 5),
order=[0, 1], cval=(0, 255),
mode=ia.ALL)),
sometimes(iaa.PiecewiseAffine(scale=(0.01, 0.01))),
sometimes(iaa.OneOf([iaa.Dropout(p=(0, 0.1)),
iaa.CoarseDropout(p=(0, 0.1), size_percent=(0.02, 0.25))])),
],
random_order=True),
random_order=True)
def aug_image(image, is_infer=False, augment=None):
if is_infer:
flip_code = augment[0]
if flip_code == 1:
seq = iaa.Sequential([iaa.Fliplr(1.0)])
elif flip_code == 2:
seq = iaa.Sequential([iaa.Flipud(1.0)])
elif flip_code == 3:
seq = iaa.Sequential([iaa.Flipud(1.0), iaa.Fliplr(1.0)])
elif flip_code == 0:
return image
else:
seq = iaa.Sequential([
iaa.Affine(rotate=(-15, 15), shear=(-15, 15), mode='edge'),
iaa.SomeOf(
(0, 2),
[
iaa.GaussianBlur((0, 1.5)),
iaa.AdditiveGaussianNoise(
loc=0, scale=(0.0, 0.01 * 255), per_channel=0.5),
iaa.AddToHueAndSaturation(
(-5, 5)), # change hue and saturation
iaa.PiecewiseAffine(scale=(0.01, 0.03)),
iaa.PerspectiveTransform(scale=(0.01, 0.1))
],
random_order=True)
])
image = seq.augment_image(image)
return image
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 __init__(self, settings, show_image=False, jitter=0, input_size=(416,416), instances_path="", labels_path="", augmentate=True):
self.settings = settings
self.show_image = show_image
self.jitter = jitter
self.input_size = input_size
self.instances_path = instances_path
self.labels_path = labels_path
self.classes = self.settings["CLASSES_LABEL"]
self.augmentate_flag = augmentate
self.augmentate = iaa.Sequential(
[
iaa.Add((-20, 20)),
iaa.ContrastNormalization((0.8, 1.6)),
iaa.AddToHueAndSaturation((-21, 21)),
],
random_order=False
)
self.augmentate_off = iaa.Sequential(
[
#iaa.Sharpen(alpha=(0.4, 0.4)),
#iaa.ContrastNormalization((0.8, 0.8), per_channel=1.0),
# iaa.Add((-50, 50)),
#iaa.Multiply((0.8, 0.8))
],
random_order=False
)
def test___init___per_channel(self):
aug = iaa.AddToHueAndSaturation(per_channel=0.5)
assert aug.value is None
assert aug.value_hue is None
assert aug.value_saturation is None
assert isinstance(aug.per_channel, iap.Binomial)
assert np.isclose(aug.per_channel.p.value, 0.5)
def test_augment_images__value_hue_and_value_saturation(self):
base_img = np.zeros((2, 2, 3), dtype=np.uint8)
base_img[..., 0] += 20
base_img[..., 1] += 40
base_img[..., 2] += 60
class _DummyParam(iap.StochasticParameter):
def _draw_samples(self, size, random_state):
return np.float32([10, 20, 30])
aug = iaa.AddToHueAndSaturation(value_hue=_DummyParam(),
value_saturation=_DummyParam() + 40)
img_expected1 = self._add_hue_saturation(base_img,
value_hue=10,
value_saturation=40 + 10)
img_expected2 = self._add_hue_saturation(base_img,
value_hue=20,
value_saturation=40 + 20)
img_expected3 = self._add_hue_saturation(base_img,
value_hue=30,
value_saturation=40 + 30)
img_observed1, img_observed2, img_observed3 = \
aug.augment_images([base_img] * 3)
assert np.array_equal(img_observed1, img_expected1)
assert np.array_equal(img_observed2, img_expected2)
assert np.array_equal(img_observed3, img_expected3)
def MarkerAug():
"""
Marker arugmentatio that does not include noise as that augmentation is applied much later.
:return:
"""
sometimes = lambda aug: iaa.Sometimes(0.8, aug)
aug_seq = iaa.Sequential(
[
iaa.Fliplr(0.5), # horizontally flip 50% of the images
iaa.Flipud(0.5), # horizontally flip 50% of the images
iaa.PerspectiveTransform(scale=(0.01, 0.1)),
iaa.Multiply((0.25, 1.75), per_channel=True),
iaa.AddToHueAndSaturation((-25, 25)),
iaa.Affine(
scale={"x": (0.8, 1.2), "y": (0.8, 1.2)},
# scale images to 80-120% of their size, individually per axis
# translate_percent={"x": (-0.2, 0.2), "y": (-0.2, 0.2)}, # translate by -20 to +20 percent (per axis)
rotate=(-180, 180), # rotate by -45 to +45 degrees
shear=(-16, 16), # shear by -16 to +16 degrees
)
]
)
return aug_seq
def train(model, args, config):
"""Train the model."""
# Training dataset.
dataset_train = LegoDataset()
dataset_train.load_lego(args.dataset, "train")
dataset_train.prepare()
# Validation dataset
dataset_val = LegoDataset()
dataset_val.load_lego(args.dataset, "val")
dataset_val.prepare()
# MW add augmentation like I did in Reginanet
if args.enable_augmentation:
print('Augmentation Enabled.')
# Little augmentation (3)
augmentation = iaa.Sometimes(0.8, [
iaa.AdditiveGaussianNoise(loc=0, scale=(0.0, 0.015 * 255)),
iaa.Add((-10, 10)), # change brightness of images (by -10 to 10 RGB value of original value)
iaa.AddToHueAndSaturation((-10, 10)) # change hue and saturation
])
# Normal augmentation (1) -> soweit schlechtere Resultate als mit "Little"
# augmentation = iaa.Sometimes(0.8, [
# iaa.AdditiveGaussianNoise(loc=0, scale=(0.0, 0.03 * 255)),
# iaa.Add((-40, 40)), # change brightness of images (by -40 to 40 RGB value of original value)
# iaa.AddToHueAndSaturation((-50, 50)) # change hue and saturation
# ])
else:
augmentation = None
# *** This training schedule is an example. Update to your needs ***
# 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.
# Train all
if config.USE_STAGE_TWO and config.USE_RPN_ROIS:
layers = 'all'
# Train MRCNN only
elif config.USE_STAGE_TWO and not config.USE_RPN_ROIS:
layers = 'mrcnn_only'
# Train RPN only
elif not config.USE_STAGE_TWO and config.USE_RPN_ROIS:
layers = 'rpn_only'
else:
assert('No valid layer training configuration.')
print("Training '{}' network".format(layers))
model.train(dataset_train, dataset_val,
learning_rate=config.LEARNING_RATE,
epochs=config.NB_OF_EPOCHS,
layers=layers,
augmentation=augmentation)
def aug_iamges_backgroud(images,backgrouds):
# images and heatmaps, just arrays filled with value 30
#images = np.ones((16, 128, 128, 3), dtype=np.uint8) * 30
#heatmaps = np.ones((16, 128, 128, 21), dtype=np.uint8) * 30
# add vertical lines to see the effect of flip
#images[:, 16:128-16, 120:124, :] = 120
#heatmaps[:, 16:128-16, 120:124, :] = 120
sometimes = lambda aug: iaa.Sometimes(0.5, aug)
seq = iaa.Sequential([
iaa.Fliplr(0.5, name="Flipper"),
sometimes(iaa.GaussianBlur((0, 3.0), name="GaussianBlur")),
sometimes(iaa.Add((-10, 10), per_channel=0.5, name='add')), # change brightness of images (by -10 to 10 of original value)
sometimes(iaa.AddToHueAndSaturation((-20, 20), name='addhue')), # change hue and saturation
sometimes(iaa.ContrastNormalization((0.5, 2.0), per_channel=0.5, name='contrast')), # improve or worsen the contrast
])
# change the activated augmenters for heatmaps,
# we only want to execute horizontal flip, affine transformation and one of
# the gaussian noises
def activator_heatmaps(images, augmenter, parents, default):
if augmenter.name in ["GaussianBlur", "add", "contrast", "addhue"]:
return False
else:
# default value for all other augmenters
return default
hooks_heatmaps = ia.HooksImages(activator=activator_heatmaps)
seq_det = seq.to_deterministic() # call this for each batch again, NOT only once at the start
images_aug = seq_det.augment_images(images)
backgrouds_aug = seq_det.augment_images(backgrouds, hooks=hooks_heatmaps)
return images_aug, backgrouds_aug
def __init__(self):
"""
init Constructor
@param self Object.
"""
self.aug = iaa.Sequential([
# Blur or Sharpness
iaa.Sometimes(
0.25,
iaa.OneOf([
iaa.GaussianBlur(sigma=(0, 1.0)),
iaa.pillike.EnhanceSharpness(factor=(0.8, 1.5))
])),
# Flip horizontally
iaa.Fliplr(0.5),
# Rotation
iaa.Rotate((-20, 20)),
# Pixel Dropout
iaa.Sometimes(
0.25,
iaa.OneOf([
iaa.Dropout(p=(0, 0.1)),
iaa.CoarseDropout(0.1, size_percent=0.5)
])),
# Color
iaa.AddToHueAndSaturation(value=(-10, 10), per_channel=True),
])
def customizedImgAug(input_img):
rarely = lambda aug: iaa.Sometimes(0.1, aug)
sometimes = lambda aug: iaa.Sometimes(0.25, aug)
often = lambda aug: iaa.Sometimes(0.5, aug)
seq = iaa.Sequential([
iaa.Fliplr(0.5),
often(
iaa.Affine(
scale={
"x": (0.9, 1.1),
"y": (0.9, 1.1)
},
translate_percent={
"x": (-0.1, 0.1),
"y": (-0.12, 0)
},
rotate=(-10, 10),
shear=(-8, 8),
order=[0, 1],
cval=(0, 255),
)),
iaa.SomeOf((0, 4), [
rarely(iaa.Superpixels(p_replace=(0, 0.3), n_segments=(20, 200))),
iaa.OneOf([
iaa.GaussianBlur((0, 2.0)),
iaa.AverageBlur(k=(2, 4)),
iaa.MedianBlur(k=(3, 5)),
]),
iaa.Sharpen(alpha=(0, 0.3), lightness=(0.75, 1.5)),
iaa.Emboss(alpha=(0, 1.0), strength=(0, 0.5)),
rarely(
iaa.OneOf([
iaa.EdgeDetect(alpha=(0, 0.3)),
iaa.DirectedEdgeDetect(alpha=(0, 0.7),
direction=(0.0, 1.0)),
])),
iaa.AdditiveGaussianNoise(
loc=0, scale=(0.0, 0.05 * 255), per_channel=0.5),
iaa.OneOf([
iaa.Dropout((0.0, 0.05), per_channel=0.5),
iaa.CoarseDropout(
(0.03, 0.05), size_percent=(0.01, 0.05), per_channel=0.2),
]),
rarely(iaa.Invert(0.05, per_channel=True)),
often(iaa.Add((-40, 40), per_channel=0.5)),
iaa.Multiply((0.7, 1.3), per_channel=0.5),
iaa.ContrastNormalization((0.5, 2.0), per_channel=0.5),
iaa.Grayscale(alpha=(0.0, 1.0)),
sometimes(iaa.PiecewiseAffine(scale=(0.01, 0.03))),
sometimes(iaa.ElasticTransformation(alpha=(0.5, 1.5), sigma=0.25)),
],
random_order=True),
iaa.Fliplr(0.5),
iaa.AddToHueAndSaturation(value=(-10, 10), per_channel=True)
],
random_order=True) # apply augmenters in random order
output_img = seq.augment_image(input_img)
return output_img
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 get_augmentation_sequence():
"""
Define the augmentation for training
"""
# Macro to apply something with 50% chance
sometimes = lambda aug: iaa.Sometimes(0.5, aug) # 50%
rarely = lambda aug: iaa.Sometimes(0.1, aug) # 10%
# Augmentation applied to every image
# Augmentors sampled one value per channel
aug_sequence = iaa.Sequential(
[
# apply the following augmenters to most images
iaa.Fliplr(0.5), # horizontally flip 50% of all images
iaa.Flipud(0.5), # vertically flip 50% of all images
# crop images by -0.25% to 0.25% of their height/width
# positive values crop the image, negative pad
sometimes(
iaa.CropAndPad(
percent=(-0.25, 0.25),
pad_mode=['constant', 'edge'
], # pad with constant value of the edge value
pad_cval=(
0, 0
) # if mode is constant, use a cval between 0 and 0 to ensure mask background is preserved
)),
sometimes(
iaa.Affine(
scale={
"x": (0.8, 1.2),
"y": (0.8, 1.2)
}, # scale images to 80-120% of their size, individually per axis
translate_percent={
"x": (-0.2, 0.2),
"y": (-0.2, 0.2)
}, # translate by -20 to +20 percent (per axis)
rotate=(-45, 45), # rotate by -45 to +45 degrees
shear=(-16, 16), # shear by -16 to +16 degrees
order=[
0,
1
], # use nearest neighbour or bilinear interpolation (fast)
cval=(
0, 0
), # if mode is constant, use a cval between 0 and 0 to ensure mask background is preserved
mode=
'constant' # ia.ALL # use any of scikit-image's warping modes (see 2nd image from the top for examples)
)),
# rarely(iaa.Superpixels(p_replace=(0, 1.0), n_segments=(20, 200))),
iaa.GaussianBlur((0, 3.0)),
iaa.Add(
(-10, 10), per_channel=0.7
), # change brightness of images (by -10 to 10 of original value)
iaa.AddToHueAndSaturation((-20, 20)),
# sometimes(iaa.PerspectiveTransform(scale=(0.01, 0.1)))
],
random_order=True)
return aug_sequence
def train(model):
"""Train the model."""
# Training dataset.
dataset_train = CustomDataset()
dataset_train.load_custom(args.dataset, "train")
dataset_train.prepare()
# Validation dataset
dataset_val = CustomDataset()
dataset_val.load_custom(args.dataset, "val")
dataset_val.prepare()
# *** This training schedule is an example. Update to your needs ***
# 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")
augmentation = iaa.Sequential([
iaa.AddToHueAndSaturation(value=(-20, 20), per_channel=True),
iaa.Fliplr(0.5),
iaa.Affine(rotate=(-20, 20), mode='constant'),
])
model.train(dataset_train,
dataset_val,
learning_rate=config.LEARNING_RATE,
epochs=40,
layers='heads',
augmentation=augmentation)
def augmentation(self):
aug = iaa.Sequential(
[
# iaa.Scale((224, 224)),
iaa.Sometimes(0.25, iaa.GaussianBlur(sigma=(0, 1.5))),
# iaa.Fliplr(0.5),
# iaa.Sometimes(0.5, iaa.Affine(
# # translate by -20 to +20 percent (per axis)
# translate_percent={"x": (-0.2, 0.2), "y": (-0.2, 0.2)},
# rotate=(-45, 45), # rotate by -45 to +45 degrees
# shear=(-16, 16), # shear by -16 to +16 degrees
# )),
iaa.Sometimes(
0.401,
iaa.OneOf([
iaa.Dropout(p=(0, 0.0071)),
iaa.CoarseDropout(0.041, size_percent=0.5)
])),
iaa.Sometimes(
0.3,
iaa.AddToHueAndSaturation(value=(-40, 40),
per_channel=True)),
# iaa.Sometimes(0.3, iaa.PerspectiveTransform(
# scale=(0.061, 0.071))),
iaa.Sometimes(0.3, iaa.Add((-10, 10), per_channel=0.5)),
iaa.Sometimes(
0.1,
iaa.AdditiveGaussianNoise(
loc=0, scale=(0.0, 0.007 * 255), per_channel=0.5)),
],
random_order=True)
return aug
def img_aug(img_name, base_dir):
image = mpimg.imread(Path(base_dir, 'datasets', 'images', img_name))
ran = random.randint(1, 5)
if ran == 1:
aug = iaa.Sequential([
iaa.CropAndPad(percent=(-0.2, 0.2), pad_mode="edge"),
iaa.AddToHueAndSaturation((-60, 60)),
iaa.ElasticTransformation(alpha=90, sigma=9),
iaa.Cutout()
],
random_order=True)
image = aug(image=image)
elif ran == 2:
aug = iaa.BlendAlphaRegularGrid(nb_rows=2,
nb_cols=2,
foreground=iaa.Multiply(0.0),
background=iaa.AveragePooling(8),
alpha=[0.0, 0.0, 1.0])
image = aug(image=image)
elif ran == 3:
image = tf.image.adjust_brightness(image, 0.4)
elif ran == 4:
image = tf.image.random_flip_left_right(image)
image = tf.image.rot90(image)
image = tf.image.random_flip_up_down(image)
elif ran == 5:
image = tf.image.central_crop(image, central_fraction=0.5)
return image
def data_aug_v2(image, label, prob=0.5):
image = image.numpy()
aug = iaa.Sequential([
iaa.Sometimes(
prob,
iaa.OneOf(
[iaa.Multiply((0.4, 1.5)),
iaa.GammaContrast((0.3, 2.0))])),
iaa.Sometimes(
prob,
iaa.OneOf([
iaa.Grayscale((0, 0.3)),
iaa.ContrastNormalization((0.3, 2.5)),
iaa.AddToHueAndSaturation((-50, 50))
])),
iaa.Sometimes(
prob,
iaa.OneOf([
iaa.AverageBlur(k=((1, 4), (1, 4))),
iaa.GaussianBlur(sigma=(0.0, 1.5)),
iaa.MedianBlur(k=(1, 5)),
iaa.MotionBlur(k=[5, 19], angle=(0, 360))
])),
iaa.Sometimes(
prob, iaa.AdditiveGaussianNoise(scale=(0, 10), per_channel=0.5))
])
image = aug.augment_image(image)
image = (image / 255).astype(dtype=np.float32)
return image, label
