def main():
image = data.astronaut()
image = ia.imresize_single_image(image, (HEIGHT, WIDTH))
kps = []
for y in range(NB_ROWS):
ycoord = BB_Y1 + int(y * (BB_Y2 - BB_Y1) / (NB_COLS - 1))
for x in range(NB_COLS):
xcoord = BB_X1 + int(x * (BB_X2 - BB_X1) / (NB_ROWS - 1))
kp = (xcoord, ycoord)
kps.append(kp)
kps = set(kps)
kps = [ia.Keypoint(x=xcoord, y=ycoord) for (xcoord, ycoord) in kps]
kps = ia.KeypointsOnImage(kps, shape=image.shape)
bb = ia.BoundingBox(x1=BB_X1, x2=BB_X2, y1=BB_Y1, y2=BB_Y2)
bbs = ia.BoundingBoxesOnImage([bb], shape=image.shape)
seq = iaa.Affine(rotate=45)
seq_det = seq.to_deterministic()
image_aug = seq_det.augment_image(image)
kps_aug = seq_det.augment_keypoints([kps])[0]
bbs_aug = seq_det.augment_bounding_boxes([bbs])[0]
image_before = np.copy(image)
image_before = kps.draw_on_image(image_before)
image_before = bbs.draw_on_image(image_before)
image_after = np.copy(image_aug)
image_after = kps_aug.draw_on_image(image_after)
image_after = bbs_aug.draw_on_image(image_after)
ia.imshow(np.hstack([image_before, image_after]))
imageio.imwrite("bb_aug.jpg", np.hstack([image_before, image_after]))
def main():
nb_rows = 8
nb_cols = 8
h, w = (128, 128)
sample_size = 128
noise_gens = [
iap.SimplexNoise(),
iap.FrequencyNoise(exponent=-4, size_px_max=sample_size, upscale_method="cubic"),
iap.FrequencyNoise(exponent=-2, size_px_max=sample_size, upscale_method="cubic"),
iap.FrequencyNoise(exponent=0, size_px_max=sample_size, upscale_method="cubic"),
iap.FrequencyNoise(exponent=2, size_px_max=sample_size, upscale_method="cubic"),
iap.FrequencyNoise(exponent=4, size_px_max=sample_size, upscale_method="cubic"),
iap.FrequencyNoise(exponent=(-4, 4), size_px_max=(4, sample_size),
upscale_method=["nearest", "linear", "cubic"]),
iap.IterativeNoiseAggregator(
other_param=iap.FrequencyNoise(exponent=(-4, 4), size_px_max=(4, sample_size),
upscale_method=["nearest", "linear", "cubic"]),
iterations=(1, 3),
aggregation_method=["max", "avg"]
),
iap.IterativeNoiseAggregator(
other_param=iap.Sigmoid(
iap.FrequencyNoise(exponent=(-4, 4), size_px_max=(4, sample_size),
upscale_method=["nearest", "linear", "cubic"]),
threshold=(-10, 10),
activated=0.33,
mul=20,
add=-10
),
iterations=(1, 3),
aggregation_method=["max", "avg"]
)
]
samples = [[] for _ in range(len(noise_gens))]
for _ in range(nb_rows * nb_cols):
for i, noise_gen in enumerate(noise_gens):
samples[i].append(noise_gen.draw_samples((h, w)))
rows = [np.hstack(row) for row in samples]
grid = np.vstack(rows)
ia.imshow((grid*255).astype(np.uint8))
images = [ia.quokka_square(size=(128, 128)) for _ in range(16)]
seqs = [
iaa.SimplexNoiseAlpha(first=iaa.EdgeDetect(1.0)),
iaa.SimplexNoiseAlpha(first=iaa.EdgeDetect(1.0), per_channel=True),
iaa.FrequencyNoiseAlpha(first=iaa.EdgeDetect(1.0)),
iaa.FrequencyNoiseAlpha(first=iaa.EdgeDetect(1.0), per_channel=True)
]
images_aug = []
for seq in seqs:
images_aug.append(np.hstack(seq.augment_images(images)))
images_aug = np.vstack(images_aug)
ia.imshow(images_aug)
def main():
image = imageio.imread("https://upload.wikimedia.org/wikipedia/commons/8/89/Kukle%2CCzech_Republic..jpg",
format="jpg")
augs = [
("iaa.SnowflakesLayer()", iaa.SnowflakesLayer(
density=0.05, density_uniformity=0.5, flake_size=0.9, flake_size_uniformity=0.5,
angle=(-45, 45), speed=(0.001, 0.04), blur_sigma_fraction=(0.75*0.0001, 0.75*0.001))
)
]
for descr, aug in augs:
print(descr)
images_aug = aug.augment_images([image] * 64)
ia.imshow(ia.draw_grid(images_aug))
def main():
for size in [0.1, 0.2, 1.0]:
image = imageio.imread("https://upload.wikimedia.org/wikipedia/commons/8/89/Kukle%2CCzech_Republic..jpg",
format="jpg")
image = ia.imresize_single_image(image, size, "cubic")
print(image.shape)
augs = [
("iaa.Fog()", iaa.Fog())
]
for descr, aug in augs:
print(descr)
images_aug = aug.augment_images([image] * 64)
ia.imshow(ia.draw_grid(images_aug))
def main():
augs = [
("iaa.Rot90(-1, keep_size=False)", iaa.Rot90(-1, keep_size=False)),
("iaa.Rot90(0, keep_size=False)", iaa.Rot90(0, keep_size=False)),
("iaa.Rot90(1, keep_size=False)", iaa.Rot90(1, keep_size=False)),
("iaa.Rot90(2, keep_size=False)", iaa.Rot90(2, keep_size=False)),
("iaa.Rot90(3, keep_size=False)", iaa.Rot90(3, keep_size=False)),
("iaa.Rot90(4, keep_size=False)", iaa.Rot90(4, keep_size=False)),
("iaa.Rot90(-1, keep_size=True)", iaa.Rot90(-1, keep_size=True)),
("iaa.Rot90(0, keep_size=True)", iaa.Rot90(0, keep_size=True)),
("iaa.Rot90(1, keep_size=True)", iaa.Rot90(1, keep_size=True)),
("iaa.Rot90(2, keep_size=True)", iaa.Rot90(2, keep_size=True)),
("iaa.Rot90(3, keep_size=True)", iaa.Rot90(3, keep_size=True)),
("iaa.Rot90(4, keep_size=True)", iaa.Rot90(4, keep_size=True)),
("iaa.Rot90([0, 1, 2, 3, 4], keep_size=False)", iaa.Rot90([0, 1, 2, 3, 4], keep_size=False)),
("iaa.Rot90([0, 1, 2, 3, 4], keep_size=True)", iaa.Rot90([0, 1, 2, 3, 4], keep_size=True)),
("iaa.Rot90((0, 4), keep_size=False)", iaa.Rot90((0, 4), keep_size=False)),
("iaa.Rot90((0, 4), keep_size=True)", iaa.Rot90((0, 4), keep_size=True)),
("iaa.Rot90((1, 3), keep_size=False)", iaa.Rot90((1, 3), keep_size=False)),
("iaa.Rot90((1, 3), keep_size=True)", iaa.Rot90((1, 3), keep_size=True))
]
image = ia.quokka(0.25)
print("--------")
print("Image + Keypoints")
print("--------")
kps = ia.quokka_keypoints(0.25)
for name, aug in augs:
print(name, "...")
aug_det = aug.to_deterministic()
images_aug = aug_det.augment_images([image] * 16)
kps_aug = aug_det.augment_keypoints([kps] * 16)
images_aug = [kps_aug_i.draw_on_image(image_aug_i, size=5)
for image_aug_i, kps_aug_i in zip(images_aug, kps_aug)]
ia.imshow(ia.draw_grid(images_aug))
print("--------")
print("Image + Heatmaps (low res)")
print("--------")
hms = ia.quokka_heatmap(0.10)
for name, aug in augs:
print(name, "...")
aug_det = aug.to_deterministic()
images_aug = aug_det.augment_images([image] * 16)
hms_aug = aug_det.augment_heatmaps([hms] * 16)
images_aug = [hms_aug_i.draw_on_image(image_aug_i)[0]
for image_aug_i, hms_aug_i in zip(images_aug, hms_aug)]
ia.imshow(ia.draw_grid(images_aug))
def main():
img = ia.quokka(0.5)
mul = 0.01
augs = [
("iaa.ImpulseNoise(p=0*mul)", iaa.ImpulseNoise(p=0*mul)),
("iaa.ImpulseNoise(p=1*mul)", iaa.ImpulseNoise(p=1*mul)),
("iaa.ImpulseNoise(p=2*mul)", iaa.ImpulseNoise(p=2*mul)),
("iaa.ImpulseNoise(p=3*mul)", iaa.ImpulseNoise(p=3*mul)),
("iaa.ImpulseNoise(p=(0*mul, 1*mul))", iaa.ImpulseNoise(p=(0*mul, 1*mul))),
("iaa.ImpulseNoise(p=[0*mul, 1*mul, 2*mul])", iaa.ImpulseNoise(p=[0*mul, 1*mul, 2*mul]))
]
for descr, aug in augs:
print(descr)
imgs_aug = aug.augment_images([img] * 16)
ia.imshow(ia.draw_grid(imgs_aug))
def main():
img = ia.quokka(0.5)
augs = [
("iaa.AdditivePoissonNoise(0)", iaa.AdditivePoissonNoise(0)),
("iaa.AdditivePoissonNoise(10.0)", iaa.AdditivePoissonNoise(10.0)),
("iaa.AdditivePoissonNoise(20.0)", iaa.AdditivePoissonNoise(20.0)),
("iaa.AdditivePoissonNoise(50.0)", iaa.AdditivePoissonNoise(50.0)),
("iaa.AdditivePoissonNoise((10.0, 20))", iaa.AdditivePoissonNoise((10.0, 20))),
("iaa.AdditivePoissonNoise([10.0, 20.0, 50])", iaa.AdditivePoissonNoise([10.0, 20.0, 50])),
("iaa.AdditivePoissonNoise(20, per_channel=True)", iaa.AdditivePoissonNoise(50, per_channel=True)),
]
for descr, aug in augs:
print(descr)
imgs_aug = aug.augment_images([img] * 16)
ia.imshow(ia.draw_grid(imgs_aug))
def main():
image = ia.quokka()
image_gray = np.average(image, axis=2).astype(np.uint8)
image_gray_3d = image_gray[:, :, np.newaxis]
ia.imshow(image)
ia.imshow(image / 255.0)
ia.imshow(image_gray)
ia.imshow(image_gray_3d)
def main():
image = ia.quokka()
image_gray = np.average(image, axis=2).astype(np.uint8)
image_gray_3d = image_gray[:, :, np.newaxis]
ia.imshow(image)
ia.imshow(image / 255.0)
ia.imshow(image_gray)
ia.imshow(image_gray_3d)
def example_keypoints():
print("Example: Keypoints")
import imgaug as ia
from imgaug import augmenters as iaa
import random
images = np.random.randint(0, 50, (4, 128, 128, 3), dtype=np.uint8)
# Generate random keypoints.
# The augmenters expect a list of imgaug.KeypointsOnImage.
keypoints_on_images = []
for image in images:
height, width = image.shape[0:2]
keypoints = []
for _ in range(4):
x = random.randint(0, width - 1)
y = random.randint(0, height - 1)
keypoints.append(ia.Keypoint(x=x, y=y))
keypoints_on_images.append(
ia.KeypointsOnImage(keypoints, shape=image.shape))
seq = iaa.Sequential(
[iaa.GaussianBlur((0, 3.0)),
iaa.Affine(scale=(0.5, 0.7))])
seq_det = seq.to_deterministic(
) # call this for each batch again, NOT only once at the start
# augment keypoints and images
images_aug = seq_det.augment_images(images)
keypoints_aug = seq_det.augment_keypoints(keypoints_on_images)
# Example code to show each image and print the new keypoints coordinates
for img_idx, (image_before, image_after, keypoints_before,
keypoints_after) in enumerate(
zip(images, images_aug, keypoints_on_images,
keypoints_aug)):
image_before = keypoints_before.draw_on_image(image_before)
image_after = keypoints_after.draw_on_image(image_after)
ia.imshow(np.concatenate((image_before, image_after),
axis=1)) # before and after
for kp_idx, keypoint in enumerate(keypoints_after.keypoints):
keypoint_old = keypoints_on_images[img_idx].keypoints[kp_idx]
x_old, y_old = keypoint_old.x, keypoint_old.y
x_new, y_new = keypoint.x, keypoint.y
print(
"[Keypoints for image #%d] before aug: x=%d y=%d | after aug: x=%d y=%d"
% (img_idx, x_old, y_old, x_new, y_new))
def example_background_pool():
print("Example: Background Augmentation via pool()")
import numpy as np
import imgaug as ia
from imgaug import augmenters as iaa
# Basic augmentation sequence. PiecewiseAffine is slow and therefore well suited
# for augmentation on multiple CPU cores.
aug = iaa.Sequential([
iaa.Fliplr(0.5),
iaa.PiecewiseAffine((0.0, 0.1))
])
# generator that yields images
def create_image_generator(nb_batches, size):
for _ in range(nb_batches):
# Add e.g. keypoints=... or bounding_boxes=... here to also augment
# keypoints / bounding boxes on these images.
yield ia.Batch(
images=np.random.randint(0, 255, size=size).astype(np.uint8)
)
# 500 batches of images, each containing 10 images of size 128x128x3
my_generator = create_image_generator(500, (10, 128, 128, 3))
# Start a pool to augment on multiple CPU cores.
# * processes=-1 means that all CPU cores except one are used for the
# augmentation, so one is kept free to move data to the GPU
# * maxtasksperchild=20 restarts child workers every 20 tasks -- only use this
# if you encounter problems such as memory leaks. Restarting child workers
# decreases performance.
# * seed=123 makes the result of the whole augmentation process deterministic
# between runs of this script, i.e. reproducible results.
with aug.pool(processes=-1, maxtasksperchild=20, seed=123) as pool:
# Augment on multiple CPU cores.
# * The result of imap_batches() is also a generator.
# * Use map_batches() if your input is a list.
# * chunksize=10 controls how much data to send to each child worker per
# transfer, set it higher for better performance.
batches_aug_generator = pool.imap_batches(my_generator, chunksize=10)
for i, batch_aug in enumerate(batches_aug_generator):
# show first augmented image in first batch
if i == 0:
ia.imshow(batch_aug.images_aug[0])
def augmentate_image(self, image, bbs, augmentation_mode):
"""
Augmentate image using a defined augmentation mode.
"""
# rotate
if augmentation_mode == self.augmentation_modes["grayscale"]:
gray = iaa.Grayscale(alpha=1.0)
augmented_image, augmented_bbs = gray(image=image,
bounding_boxes=bbs)
if augmentation_mode == self.augmentation_modes["rotate"]:
rotate = iaa.Affine(rotate=(-30, 20))
augmented_image, augmented_bbs = rotate(image=image,
bounding_boxes=bbs)
# flip_horizontal
if augmentation_mode == self.augmentation_modes["flip_horizontal"]:
flip_hr = iaa.Fliplr(p=1.0)
augmented_image, augmented_bbs = flip_hr(image=image,
bounding_boxes=bbs)
# flip_vertical
if augmentation_mode == self.augmentation_modes["flip_vertical"]:
flip_vr = iaa.Flipud(p=1.0)
augmented_image, augmented_bbs = flip_vr(image=image,
bounding_boxes=bbs)
# gaussian_noise
if augmentation_mode == self.augmentation_modes["gaussian_noise"]:
gaussian_noise = iaa.AdditiveGaussianNoise(10, 20)
augmented_image, augmented_bbs = gaussian_noise(image=image,
bounding_boxes=bbs)
# brightness_darker
if augmentation_mode == self.augmentation_modes["brightness_darker"]:
bright_aug = iaa.AddToBrightness((-60, -20))
augmented_image, augmented_bbs = bright_aug(image=image,
bounding_boxes=bbs)
# brightness brighter
if augmentation_mode == self.augmentation_modes["brightness_brighter"]:
bright_aug = iaa.AddToBrightness((20, 40))
augmented_image, augmented_bbs = bright_aug(image=image,
bounding_boxes=bbs)
if self.with_visualisation:
ia.imshow(augmented_bbs.draw_on_image(augmented_image, size=2))
return augmented_image, augmented_bbs
def main():
parser = argparse.ArgumentParser(description="Contrast check script")
parser.add_argument("--per_channel", dest="per_channel", action="store_true")
args = parser.parse_args()
augs = []
for p in [0.25, 0.5, 1.0, 2.0, (0.5, 1.5), [0.5, 1.0, 1.5]]:
augs.append(("GammaContrast " + str(p), iaa.GammaContrast(p, per_channel=args.per_channel)))
for cutoff in [0.25, 0.5, 0.75]:
for gain in [5, 10, 15, 20, 25]:
augs.append(("SigmoidContrast " + str(cutoff) + " " + str(gain), iaa.SigmoidContrast(gain, cutoff, per_channel=args.per_channel)))
for gain in [0.0, 0.25, 0.5, 1.0, 2.0, (0.5, 1.5), [0.5, 1.0, 1.5]]:
augs.append(("LogContrast " + str(gain), iaa.LogContrast(gain, per_channel=args.per_channel)))
for alpha in [-1.0, 0.5, 0, 0.5, 1.0, 2.0, (0.5, 1.5), [0.5, 1.0, 1.5]]:
augs.append(("LinearContrast " + str(alpha), iaa.LinearContrast(alpha, per_channel=args.per_channel)))
augs.append(("AllChannelsHistogramEqualization", iaa.AllChannelsHistogramEqualization()))
augs.append(("HistogramEqualization (Lab)", iaa.HistogramEqualization(to_colorspace=iaa.HistogramEqualization.Lab)))
augs.append(("HistogramEqualization (HSV)", iaa.HistogramEqualization(to_colorspace=iaa.HistogramEqualization.HSV)))
augs.append(("HistogramEqualization (HLS)", iaa.HistogramEqualization(to_colorspace=iaa.HistogramEqualization.HLS)))
for clip_limit in [0.1, 1, 5, 10]:
for tile_grid_size_px in [3, 7]:
augs.append(("AllChannelsCLAHE %d %dx%d" % (clip_limit, tile_grid_size_px, tile_grid_size_px),
iaa.AllChannelsCLAHE(clip_limit=clip_limit, tile_grid_size_px=tile_grid_size_px,
per_channel=args.per_channel)))
for clip_limit in [1, 5, 10, 100, 200]:
for tile_grid_size_px in [3, 7, 15]:
augs.append(("CLAHE %d %dx%d" % (clip_limit, tile_grid_size_px, tile_grid_size_px),
iaa.CLAHE(clip_limit=clip_limit, tile_grid_size_px=tile_grid_size_px)))
images = [data.astronaut()] * 16
images = ia.imresize_many_images(np.uint8(images), (128, 128))
for name, aug in augs:
print("-----------")
print(name)
print("-----------")
images_aug = aug.augment_images(images)
images_aug[0] = images[0]
grid = ia.draw_grid(images_aug, rows=4, cols=4)
ia.imshow(grid)
def main():
image = data.astronaut()
print("image shape:", image.shape)
aug = iaa.WithColorspace(
from_colorspace="RGB",
to_colorspace="HSV",
children=iaa.WithChannels(0, iaa.Add(50))
)
aug_no_colorspace = iaa.WithChannels(0, iaa.Add(50))
img_show = np.hstack([
image,
aug.augment_image(image),
aug_no_colorspace.augment_image(image)
])
ia.imshow(img_show)
def main():
img = ia.quokka(0.5)
augs = [
("iaa.AdditivePoissonNoise(0)", iaa.AdditivePoissonNoise(0)),
("iaa.AdditivePoissonNoise(10.0)", iaa.AdditivePoissonNoise(10.0)),
("iaa.AdditivePoissonNoise(20.0)", iaa.AdditivePoissonNoise(20.0)),
("iaa.AdditivePoissonNoise(50.0)", iaa.AdditivePoissonNoise(50.0)),
("iaa.AdditivePoissonNoise((10.0, 20))",
iaa.AdditivePoissonNoise((10.0, 20))),
("iaa.AdditivePoissonNoise([10.0, 20.0, 50])",
iaa.AdditivePoissonNoise([10.0, 20.0, 50])),
("iaa.AdditivePoissonNoise(20, per_channel=True)",
iaa.AdditivePoissonNoise(50, per_channel=True)),
]
for descr, aug in augs:
print(descr)
imgs_aug = aug.augment_images([img] * 16)
ia.imshow(ia.draw_grid(imgs_aug))
def load_basic_image(self, image_path, xml_path=None):
"""
Load the baisic image and bounding boxes.
"""
image = imageio.imread(image_path)
#print(image.shape)
if image.shape[2] > 3:
image = image[:, :, 0:3]
self.save_new_image(image_path, "", image)
print(image.shape)
if xml_path is None:
xml_path = image_path.split(".")[0] + ".xml"
bbs = self.load_image_bbs(xml_path, image.shape)
if self.with_visualisation:
ia.imshow(bbs.draw_on_image(image, size=2))
return image, bbs
def main():
augs = [
iaa.Rain(speed=(0.1, 0.3)),
iaa.Rain(),
iaa.Rain(drop_size=(0.1, 0.2))
]
image = imageio.imread(
("https://upload.wikimedia.org/wikipedia/commons/8/89/"
"Kukle%2CCzech_Republic..jpg"),
format="jpg")
for aug, size in zip(augs, [0.1, 0.2, 1.0]):
image_rs = ia.imresize_single_image(image, size, "cubic")
print(image_rs.shape)
images_aug = aug.augment_images([image_rs] * 64)
ia.imshow(ia.draw_grid(images_aug))
def main():
image = ia.quokka_square((200, 200))
aug = iaa.Jigsaw(10, 10)
images_aug = aug(images=[image] * 16)
ia.imshow(ia.draw_grid(images_aug))
gen_time = timeit.timeit(
"iaa.generate_jigsaw_destinations(10, 10, 2, rng)",
number=128,
setup=("import imgaug.augmenters as iaa; "
"import imgaug.random as iarandom; "
"rng = iarandom.RNG(0)"))
print("Time to generate 128x dest:", gen_time)
destinations = iaa.generate_jigsaw_destinations(10, 10, 1, random_state=1)
image_jig = iaa.apply_jigsaw(image, destinations)
ia.imshow(image_jig)
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 = ia.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))
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 = ia.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))
def example_background_pool():
print("Example: Background Augmentation via pool()")
import numpy as np
import imgaug as ia
from imgaug import augmenters as iaa
# Basic augmentation sequence. PiecewiseAffine is slow and therefore well suited
# for augmentation on multiple CPU cores.
aug = iaa.Sequential([iaa.Fliplr(0.5), iaa.PiecewiseAffine((0.0, 0.1))])
# generator that yields images
def create_image_generator(nb_batches, size):
for _ in range(nb_batches):
# Add e.g. keypoints=... or bounding_boxes=... here to also augment
# keypoints / bounding boxes on these images.
yield ia.Batch(
images=np.random.randint(0, 255, size=size).astype(np.uint8))
# 500 batches of images, each containing 10 images of size 128x128x3
my_generator = create_image_generator(500, (10, 128, 128, 3))
# Start a pool to augment on multiple CPU cores.
# * processes=-1 means that all CPU cores except one are used for the
# augmentation, so one is kept free to move data to the GPU
# * maxtasksperchild=20 restarts child workers every 20 tasks -- only use this
# if you encounter problems such as memory leaks. Restarting child workers
# decreases performance.
# * seed=123 makes the result of the whole augmentation process deterministic
# between runs of this script, i.e. reproducible results.
with aug.pool(processes=-1, maxtasksperchild=20, seed=123) as pool:
# Augment on multiple CPU cores.
# * The result of imap_batches() is also a generator.
# * Use map_batches() if your input is a list.
# * chunksize=10 controls how much data to send to each child worker per
# transfer, set it higher for better performance.
batches_aug_generator = pool.imap_batches(my_generator, chunksize=10)
for i, batch_aug in enumerate(batches_aug_generator):
# show first augmented image in first batch
if i == 0:
ia.imshow(batch_aug.images_aug[0])
def main():
aug = iaa.BlendAlphaMask(
iaa.SegMapClassIdsMaskGen(1),
iaa.OneOf([iaa.TotalDropout(1.0),
iaa.AveragePooling(8)]))
aug2 = iaa.BlendAlphaSegMapClassIds(
1, iaa.OneOf([iaa.TotalDropout(1.0),
iaa.AveragePooling(8)]))
image = ia.quokka(0.25)
segmap = ia.quokka_segmentation_map(0.25)
images_aug, segmaps_aug = aug(images=[image] * 25,
segmentation_maps=[segmap] * 25)
ia.imshow(ia.draw_grid(images_aug, cols=5, rows=5))
images_aug, segmaps_aug = aug2(images=[image] * 25,
segmentation_maps=[segmap] * 25)
ia.imshow(ia.draw_grid(images_aug, cols=5, rows=5))
def main():
image = imageio.imread("https://upload.wikimedia.org/wikipedia/commons/8/89/Kukle%2CCzech_Republic..jpg",
format="jpg")
augs = [
("iaa.FastSnowyLandscape(64, 1.5)", iaa.FastSnowyLandscape(64, 1.5)),
("iaa.FastSnowyLandscape(128, 1.5)", iaa.FastSnowyLandscape(128, 1.5)),
("iaa.FastSnowyLandscape(200, 1.5)", iaa.FastSnowyLandscape(200, 1.5)),
("iaa.FastSnowyLandscape(64, 2.5)", iaa.FastSnowyLandscape(64, 2.5)),
("iaa.FastSnowyLandscape(128, 2.5)", iaa.FastSnowyLandscape(128, 2.5)),
("iaa.FastSnowyLandscape(200, 2.5)", iaa.FastSnowyLandscape(200, 2.5)),
("iaa.FastSnowyLandscape(64, 3.5)", iaa.FastSnowyLandscape(64, 3.5)),
("iaa.FastSnowyLandscape(128, 3.5)", iaa.FastSnowyLandscape(128, 3.5)),
("iaa.FastSnowyLandscape(200, 3.5)", iaa.FastSnowyLandscape(200, 3.5)),
("iaa.FastSnowyLandscape()", iaa.FastSnowyLandscape())
]
for descr, aug in augs:
print(descr)
images_aug = aug.augment_images([image] * 64)
ia.imshow(ia.draw_grid(images_aug))
def main():
img = data.astronaut()
img = ia.imresize_single_image(img, (64, 64))
aug = iaa.Fliplr(0.5)
unseeded1 = aug.draw_grid(img, cols=8, rows=1)
unseeded2 = aug.draw_grid(img, cols=8, rows=1)
ia.seed(1000)
seeded1 = aug.draw_grid(img, cols=8, rows=1)
seeded2 = aug.draw_grid(img, cols=8, rows=1)
ia.seed(1000)
reseeded1 = aug.draw_grid(img, cols=8, rows=1)
reseeded2 = aug.draw_grid(img, cols=8, rows=1)
ia.seed(1001)
reseeded3 = aug.draw_grid(img, cols=8, rows=1)
reseeded4 = aug.draw_grid(img, cols=8, rows=1)
all_rows = np.vstack([unseeded1, unseeded2, seeded1, seeded2, reseeded1, reseeded2, reseeded3, reseeded4])
ia.imshow(all_rows)
def main():
image = ia.quokka_square((256, 256))
image_q2 = iaa.quantize_kmeans(image, 2)
image_q16 = iaa.quantize_kmeans(image, 16)
ia.imshow(np.hstack([image_q2, image_q16]))
from_cs = "RGB"
to_cs = ["RGB", "Lab"]
kwargs = {"from_colorspace": from_cs, "to_colorspace": to_cs}
augs = [
iaa.KMeansColorQuantization(2, **kwargs),
iaa.KMeansColorQuantization(4, **kwargs),
iaa.KMeansColorQuantization(8, **kwargs),
iaa.KMeansColorQuantization((2, 16), **kwargs),
]
images_aug = []
for aug in augs:
images_aug.extend(aug(images=[image] * 8))
ia.imshow(ia.draw_grid(images_aug, cols=8))
def main():
image = imageio.imread(
"https://upload.wikimedia.org/wikipedia/commons/8/89/Kukle%2CCzech_Republic..jpg",
format="jpg")
augs = [
#("iaa.SnowflakesLayer()", iaa.SnowflakesLayer(density=0.05, flake_size=0.9, angle=(-45, 45), speed=(0.001, 0.04), blur_sigma1_fraction=(0.0001, 0.001), blur_sigma2_fraction=(0.001, 0.05)))
("iaa.SnowflakesLayer()",
iaa.SnowflakesLayer(density=0.05,
density_uniformity=0.5,
flake_size=0.9,
flake_size_uniformity=0.5,
angle=(-45, 45),
speed=(0.001, 0.04),
blur_sigma_fraction=(0.75 * 0.0001, 0.75 * 0.001))
)
]
for descr, aug in augs:
print(descr)
images_aug = aug.augment_images([image] * 64)
ia.imshow(ia.draw_grid(images_aug))
def main():
augs = [
("0", iaa.JpegCompression(compression=0)),
("1", iaa.JpegCompression(compression=1)),
("25", iaa.JpegCompression(compression=25)),
("50", iaa.JpegCompression(compression=50)),
("75", iaa.JpegCompression(compression=75)),
("99", iaa.JpegCompression(compression=99)),
("100", iaa.JpegCompression(compression=100)),
("(0, 50)", iaa.JpegCompression(compression=(0, 50))),
("(50, 100)", iaa.JpegCompression(compression=(50, 100))),
("(0, 100)", iaa.JpegCompression(compression=(0, 100))),
]
image = ia.quokka(size=(256, 256), extract="square")
images = np.uint8([image] * (5*5))
for i, (name, aug) in enumerate(augs):
print(i, name)
images_aug = aug.augment_images(images)
ia.imshow(ia.draw_grid(images_aug, cols=5, rows=5))
def main():
image = ia.quokka(0.25)
for N in [1, 2]:
print("N=%d" % (N, ))
images_aug = []
for M in [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20]:
images_aug.extend(
iaa.RandAugment(n=N, m=M, random_state=1)(images=[image] * 10))
ia.imshow(ia.draw_grid(images_aug, cols=10))
for M in [0, 1, 2, 4, 8, 10]:
print("M=%d" % (M, ))
aug = iaa.RandAugment(m=M, random_state=1)
images_aug = []
for _ in np.arange(6):
images_aug.extend(aug(images=[image] * 16))
ia.imshow(ia.draw_grid(images_aug, cols=16, rows=6))
def analyze_pred_gt_image(data, i, threshold):
filename, img, single_image_yolo_pred = read_ith_pred_result_yolo(
data, i, threshold)
single_image_imgaug_pred = convertYOLO2Other(single_image_yolo_pred)
imgaug_bbox_single_img = BoundingBoxesOnImage.from_xyxy_array(
single_image_imgaug_pred[:, 1:5], shape=img.shape)
for n, bb in enumerate(imgaug_bbox_single_img):
bb.label = single_image_imgaug_pred[n, 0].astype('int')
print(filename)
print(single_image_yolo_pred)
print(imgaug_bbox_single_img)
img_with_yolo = imgaug_bbox_single_img.draw_on_image(img, size=2)
# draw the ground truth
label_file = filename.split('.jpg')[0] + '.txt'
img_with_gt = draw_ground_truth_label(label_file, img)
ia.imshow(np.hstack([img_with_yolo, img_with_gt]))
imageio.imwrite("sampleImages/pred_vs_gt_bbox_" + filename,
np.hstack([img_with_yolo, img_with_gt]))
def main():
augs = [
("0", iaa.JpegCompression(compression=0)),
("1", iaa.JpegCompression(compression=1)),
("25", iaa.JpegCompression(compression=25)),
("50", iaa.JpegCompression(compression=50)),
("75", iaa.JpegCompression(compression=75)),
("99", iaa.JpegCompression(compression=99)),
("100", iaa.JpegCompression(compression=100)),
("(0, 50)", iaa.JpegCompression(compression=(0, 50))),
("(50, 100)", iaa.JpegCompression(compression=(50, 100))),
("(0, 100)", iaa.JpegCompression(compression=(0, 100))),
]
image = ia.quokka(size=(256, 256), extract="square")
images = np.uint8([image] * (5 * 5))
for i, (name, aug) in enumerate(augs):
print(i, name)
images_aug = aug.augment_images(images)
ia.imshow(ia.draw_grid(images_aug, cols=5, rows=5))
def augument(impath):
ia.seed(1)
image = imageio.imread(impath)
bbs = BoundingBoxesOnImage([
BoundingBox(x1=170, y1=130, x2=252, y2=248, label='18'),
BoundingBox(x1=100, y1=154, x2=120, y2=175, label='1')
],
shape=image.shape)
ia.imshow(bbs.draw_on_image(image, size=2))
# apply augumentation
# We choose a simple contrast augmentation (affects only the image) and an affine transformation (affects image and bounding boxes).
seq = iaa.Sequential([
iaa.GammaContrast(1.5),
iaa.Affine(translate_percent={"x": 0.1}, scale=0.8)
])
image_aug, bbs_aug = seq(image=image, bounding_boxes=bbs)
ia.imshow(bbs_aug.draw_on_image(image_aug, size=2))
# we apply an affine transformation consisting only of rotation.
image_aug, bbs_aug = iaa.Affine(rotate=50)(image=image, bounding_boxes=bbs)
ia.imshow(bbs_aug.draw_on_image(image_aug))
def show_sample_image(self):
idx = np.random.choice(len(self.image_paths), 1)[0]
img_path = self.image_paths[idx]
seg_path = self.label_paths[idx]
img = self.load_image(img_path)
seg = self.load_image(seg_path)
# segmap = SegmentationMapsOnImage(seg[..., 0], shape=img.shape)
segmap = SegmentationMapsOnImage(seg, shape=img.shape)
img_aug, seg_aug = self.augment_func(image=img,
segmentation_maps=segmap)
ia.imshow(np.hstack([img[..., ::-1], seg]))
# seg[..., 0] = seg_aug.get_arr_int()
seg = seg_aug.get_arr_int()
# print(np.nonzero(seg[..., 0]))
# non_index = np.nonzero(seg[..., 0])
# for i in range(len(non_index[0])):
# print(seg[..., 0][non_index[0][i], non_index[1][i]])
ia.imshow(np.hstack([img_aug[..., ::-1], seg]))
seg = seg / 255
seg[seg < 0.5] = 0
seg[seg >= 0.5] = 1
ia.imshow(np.hstack([img_aug[..., ::-1], seg]))
def test3():
file_list = "list"
with open(file_list, 'r') as f:
lines = f.readlines()[:1]
for line in lines:
line = line.strip().split()
path = line[0]
landmark = line[1:197]
attribute = line[197:203]
euler_angle = line[203:206]
image = imageio.imread("http://wx4.sinaimg.cn/large/006HcH9cgy1g2ywu5fooxj30oy0gimz1.jpg") # 读取图片数据
# ia.imshow(image)
keypoints = ia.KeypointsOnImage([
ia.Keypoint(x=65, y=100),
ia.Keypoint(x=75, y=200),
ia.Keypoint(x=100, y=100),
ia.Keypoint(x=200, y=80)
], shape=image.shape)
# landmark = np.asarray(landmark, dtype=np.float32)
seq = iaa.Sequential([ # 定义一个sequential，把要进行的图片操作（3个操作）放在里面
iaa.Affine(rotate=(-20, 20)),
# iaa.AdditiveGaussianNoise(scale=(10, 30)),
# iaa.Crop(percent=(0, 0.4))
], random_order=True) # 这3个图片操作以随机顺序作用在图片上
# augment keypoints and images
images_aug, points_aug = seq(images=image, keypoints=keypoints)
# images_aug = [seq.augment_image(image) for _ in range(8)] # 应用data augmentation
# for index,one in enumerate(images_aug):
# cv2.imwrite(str(index)+".jpg",one)
# images_aug,points_aug = [seq(images=image, keypoints=keypoints) for _ in range(8)] # 应用data augmentation
ia.imshow(images_aug) # 显示图片操作效果
def main():
image = ia.quokka(size=0.5)
print(image.shape)
kps = [
ia.KeypointsOnImage(
[
ia.Keypoint(x=123, y=102),
ia.Keypoint(x=182, y=98),
ia.Keypoint(x=155, y=134),
ia.Keypoint(x=-20, y=20)
],
shape=(image.shape[0], image.shape[1])
)
]
print("image shape:", image.shape)
augs = [
iaa.PiecewiseAffine(scale=0.05),
iaa.PiecewiseAffine(scale=0.1),
iaa.PiecewiseAffine(scale=0.2)
]
ia.imshow(kps[0].draw_on_image(image))
print("-----------------")
print("Random aug per image")
print("-----------------")
for aug in augs:
images_aug = []
for _ in range(16):
aug_det = aug.to_deterministic()
img_aug = aug_det.augment_image(image)
kps_aug = aug_det.augment_keypoints(kps)[0]
img_aug_kps = keypoints_draw_on_image(kps_aug, img_aug)
img_aug_kps = np.pad(img_aug_kps, ((1, 1), (1, 1), (0, 0)), mode="constant", constant_values=255)
images_aug.append(img_aug_kps)
print(aug.name)
ia.imshow(ia.draw_grid(images_aug))
def main():
image = ia.quokka(size=0.5)
print(image.shape)
kps = [
ia.KeypointsOnImage([
ia.Keypoint(x=123, y=102),
ia.Keypoint(x=182, y=98),
ia.Keypoint(x=155, y=134),
ia.Keypoint(x=-20, y=20)
],
shape=(image.shape[0], image.shape[1]))
]
print("image shape:", image.shape)
augs = [
iaa.PiecewiseAffine(scale=0.05),
iaa.PiecewiseAffine(scale=0.1),
iaa.PiecewiseAffine(scale=0.2)
]
ia.imshow(kps[0].draw_on_image(image))
print("-----------------")
print("Random aug per image")
print("-----------------")
for aug in augs:
images_aug = []
for _ in range(16):
aug_det = aug.to_deterministic()
img_aug = aug_det.augment_image(image)
kps_aug = aug_det.augment_keypoints(kps)[0]
img_aug_kps = keypoints_draw_on_image(kps_aug, img_aug)
img_aug_kps = np.pad(img_aug_kps, ((1, 1), (1, 1), (0, 0)),
mode="constant",
constant_values=255)
images_aug.append(img_aug_kps)
print(aug.name)
ia.imshow(ia.draw_grid(images_aug))
def test_process_augmentations():
image = ia.quokka(size=(256, 256))
bbs = BoundingBoxesOnImage([
BoundingBox(x1=25, x2=75, y1=25, y2=75),
BoundingBox(x1=100, x2=150, y1=25, y2=75),
BoundingBox(x1=175, x2=225, y1=25, y2=75)
],
shape=image.shape)
seq = iaa.Affine(translate_px={"x": 120})
# clipping those partially inside the image
image_aug1, bbs_aug1 = process_augmentations(seq, image, bbs, 0.3)
# removing those partially inside the image
image_aug2, bbs_aug2 = process_augmentations(seq, image, bbs, 0.2)
image_aug1 = bbs_aug1.draw_on_image(image_aug1,
color=[0, 255, 0],
size=2,
alpha=0.75)
ia.imshow(image_aug1)
image_aug2 = bbs_aug2.draw_on_image(image_aug2,
color=[0, 255, 0],
size=2,
alpha=0.75)
ia.imshow(image_aug2)
def main():
image = ia.quokka_square((200, 200))
kpsoi = ia.quokka_keypoints((200, 200), extract="square")
aug = iaa.Jigsaw(10, 10)
images_aug, kpsois_aug = aug(images=[image] * 16, keypoints=[kpsoi] * 16)
images_show = [
kpsoi_aug.draw_on_image(image_aug)
for image_aug, kpsoi_aug in zip(images_aug, kpsois_aug)
]
ia.imshow(ia.draw_grid(images_show))
gen_time = timeit.timeit(
"iaa.generate_jigsaw_destinations(10, 10, 2, rng)",
number=128,
setup=("import imgaug.augmenters as iaa; "
"import imgaug.random as iarandom; "
"rng = iarandom.RNG(0)"))
print("Time to generate 128x dest:", gen_time)
destinations = iaa.generate_jigsaw_destinations(10, 10, 1, random_state=1)
image_jig = iaa.apply_jigsaw(image, destinations)
ia.imshow(image_jig)
def main():
image = data.astronaut()
image = ia.imresize_single_image(image, (HEIGHT, WIDTH))
kps = []
for y in range(NB_ROWS):
ycoord = BB_Y1 + int(y * (BB_Y2 - BB_Y1) / (NB_COLS - 1))
for x in range(NB_COLS):
xcoord = BB_X1 + int(x * (BB_X2 - BB_X1) / (NB_ROWS - 1))
kp = (xcoord, ycoord)
kps.append(kp)
kps = set(kps)
kps = [
ia.Keypoint(x=xcoord, y=ycoord, vis=None, label=None)
for (xcoord, ycoord) in kps
]
kps = ia.KeypointsOnImage(kps, shape=image.shape)
bb = ia.BoundingBox(x1=BB_X1, x2=BB_X2, y1=BB_Y1, y2=BB_Y2)
bbs = ia.BoundingBoxesOnImage([bb], shape=image.shape)
seq = iaa.Affine(rotate=45)
seq_det = seq.to_deterministic()
image_aug = seq_det.augment_image(image)
kps_aug = seq_det.augment_keypoints([kps])[0]
bbs_aug = seq_det.augment_bounding_boxes([bbs])[0]
image_before = np.copy(image)
image_before = kps.draw_on_image(image_before)
image_before = bbs.draw_on_image(image_before)
image_after = np.copy(image_aug)
image_after = kps_aug.draw_on_image(image_after)
image_after = bbs_aug.draw_on_image(image_after)
ia.imshow(np.hstack([image_before, image_after]))
imageio.imwrite("bb_aug.jpg", np.hstack([image_before, image_after]))
def main():
urls = [
("https://upload.wikimedia.org/wikipedia/commons/thumb/4/43/"
"Sarcophilus_harrisii_taranna.jpg/"
"320px-Sarcophilus_harrisii_taranna.jpg"),
("https://upload.wikimedia.org/wikipedia/commons/thumb/b/ba/"
"Vincent_van_Gogh_-_Wheatfield_with_crows_-_Google_Art_Project.jpg/"
"320px-Vincent_van_Gogh_-_Wheatfield_with_crows_-_Google_Art_Project"
".jpg"),
("https://upload.wikimedia.org/wikipedia/commons/thumb/0/0c/"
"Galerella_sanguinea_Zoo_Praha_2011-2.jpg/207px-Galerella_sanguinea_"
"Zoo_Praha_2011-2.jpg"),
("https://upload.wikimedia.org/wikipedia/commons/thumb/9/96/"
"Ambrosius_Bosschaert_the_Elder_%28Dutch_-_Flower_Still_Life_-_"
"Google_Art_Project.jpg/307px-Ambrosius_Bosschaert_the_Elder_%28"
"Dutch_-_Flower_Still_Life_-_Google_Art_Project.jpg")
]
image = imageio.imread(urls[1])
aug = iaa.RemoveSaturationColorwise(10, 0.1, alpha=[0.0, 1.0])
images_aug = aug(images=[image] * (5*5))
ia.imshow(ia.draw_grid(images_aug))
def example_keypoints():
print("Example: Keypoints")
import imgaug as ia
from imgaug import augmenters as iaa
import random
images = np.random.randint(0, 50, (4, 128, 128, 3), dtype=np.uint8)
# Generate random keypoints.
# The augmenters expect a list of imgaug.KeypointsOnImage.
keypoints_on_images = []
for image in images:
height, width = image.shape[0:2]
keypoints = []
for _ in range(4):
x = random.randint(0, width-1)
y = random.randint(0, height-1)
keypoints.append(ia.Keypoint(x=x, y=y))
keypoints_on_images.append(ia.KeypointsOnImage(keypoints, shape=image.shape))
seq = iaa.Sequential([iaa.GaussianBlur((0, 3.0)), iaa.Affine(scale=(0.5, 0.7))])
seq_det = seq.to_deterministic() # call this for each batch again, NOT only once at the start
# augment keypoints and images
images_aug = seq_det.augment_images(images)
keypoints_aug = seq_det.augment_keypoints(keypoints_on_images)
# Example code to show each image and print the new keypoints coordinates
for img_idx, (image_before, image_after, keypoints_before, keypoints_after) in enumerate(zip(images, images_aug, keypoints_on_images, keypoints_aug)):
image_before = keypoints_before.draw_on_image(image_before)
image_after = keypoints_after.draw_on_image(image_after)
ia.imshow(np.concatenate((image_before, image_after), axis=1)) # before and after
for kp_idx, keypoint in enumerate(keypoints_after.keypoints):
keypoint_old = keypoints_on_images[img_idx].keypoints[kp_idx]
x_old, y_old = keypoint_old.x, keypoint_old.y
x_new, y_new = keypoint.x, keypoint.y
print("[Keypoints for image #%d] before aug: x=%d y=%d | after aug: x=%d y=%d" % (img_idx, x_old, y_old, x_new, y_new))
def example_background_augment_batches():
print("Example: Background Augmentation via augment_batches()")
import imgaug as ia
from imgaug import augmenters as iaa
import numpy as np
from skimage import data
# Number of batches and batch size for this example
nb_batches = 10
batch_size = 32
# Example augmentation sequence to run in the background
augseq = iaa.Sequential([
iaa.Fliplr(0.5),
iaa.CoarseDropout(p=0.1, size_percent=0.1)
])
# For simplicity, we use the same image here many times
astronaut = data.astronaut()
astronaut = ia.imresize_single_image(astronaut, (64, 64))
# Make batches out of the example image (here: 10 batches, each 32 times
# the example image)
batches = []
for _ in range(nb_batches):
batches.append(
np.array(
[astronaut for _ in range(batch_size)],
dtype=np.uint8
)
)
# Show the augmented images.
# Note that augment_batches() returns a generator.
for images_aug in augseq.augment_batches(batches, background=True):
ia.imshow(ia.draw_grid(images_aug, cols=8))
def main():
image = ia.quokka_square((256, 256))
reggrid_sampler = iaa.DropoutPointsSampler(
iaa.RegularGridPointsSampler(n_rows=50, n_cols=50),
0.5
)
uniform_sampler = iaa.UniformPointsSampler(50*50)
for p_replace in [1.0, 0.5, 0.1, 0.0]:
augs = [
iaa.Voronoi(points_sampler=reggrid_sampler, p_replace=p_replace,
max_size=128),
iaa.Voronoi(points_sampler=uniform_sampler, p_replace=p_replace,
max_size=128),
iaa.UniformVoronoi(50*50, p_replace=p_replace, max_size=128),
iaa.RegularGridVoronoi(50, 50, p_drop_points=0.4,
p_replace=p_replace, max_size=128),
iaa.RelativeRegularGridVoronoi(p_replace=p_replace, max_size=128)
]
images = [aug(image=image) for aug in augs]
ia.imshow(np.hstack(images))
def main():
img = data.astronaut()
img = ia.imresize_single_image(img, (64, 64))
aug = iaa.Fliplr(0.5)
unseeded1 = aug.draw_grid(img, cols=8, rows=1)
unseeded2 = aug.draw_grid(img, cols=8, rows=1)
ia.seed(1000)
seeded1 = aug.draw_grid(img, cols=8, rows=1)
seeded2 = aug.draw_grid(img, cols=8, rows=1)
ia.seed(1000)
reseeded1 = aug.draw_grid(img, cols=8, rows=1)
reseeded2 = aug.draw_grid(img, cols=8, rows=1)
ia.seed(1001)
reseeded3 = aug.draw_grid(img, cols=8, rows=1)
reseeded4 = aug.draw_grid(img, cols=8, rows=1)
all_rows = np.vstack([
unseeded1, unseeded2, seeded1, seeded2, reseeded1, reseeded2,
reseeded3, reseeded4
])
ia.imshow(all_rows)
def main():
parser = argparse.ArgumentParser(description="Contrast check script")
parser.add_argument("--per_channel",
dest="per_channel",
action="store_true")
args = parser.parse_args()
augs = []
for p in [0.25, 0.5, 1.0, 2.0, (0.5, 1.5), [0.5, 1.0, 1.5]]:
augs.append(("GammaContrast " + str(p),
iaa.GammaContrast(p, per_channel=args.per_channel)))
for cutoff in [0.25, 0.5, 0.75]:
for gain in [5, 10, 15, 20, 25]:
augs.append(("SigmoidContrast " + str(cutoff) + " " + str(gain),
iaa.SigmoidContrast(gain,
cutoff,
per_channel=args.per_channel)))
for gain in [-1.0, 0.0, 0.25, 0.5, 1.0, 2.0, (0.5, 1.5), [0.5, 1.0, 1.5]]:
augs.append(("LogContrast " + str(gain),
iaa.LogContrast(gain, per_channel=args.per_channel)))
for alpha in [-1.0, 0.5, 0, 0.5, 1.0, 2.0, (0.5, 1.5), [0.5, 1.0, 1.5]]:
augs.append(("LinearContrast " + str(alpha),
iaa.LinearContrast(alpha, per_channel=args.per_channel)))
images = [data.astronaut()] * 16
images = ia.imresize_many_images(np.uint8(images), (128, 128))
for name, aug in augs:
print("-----------")
print(name)
print("-----------")
images_aug = aug.augment_images(images)
grid = ia.draw_grid(images_aug, rows=4, cols=4)
ia.imshow(grid)
def main():
img = ia.data.quokka(0.5)
mul = 0.025
augs = [
("iaa.AdditiveLaplaceNoise(255*(1*mul))",
iaa.AdditiveLaplaceNoise(scale=255 * (1 * mul))),
("iaa.AdditiveLaplaceNoise(255*(2*mul))",
iaa.AdditiveLaplaceNoise(scale=255 * (2 * mul))),
("iaa.AdditiveLaplaceNoise(255*(3*mul))",
iaa.AdditiveLaplaceNoise(scale=255 * (3 * mul))),
("iaa.AdditiveLaplaceNoise(255*(4*mul))",
iaa.AdditiveLaplaceNoise(scale=255 * (4 * mul))),
("iaa.AdditiveLaplaceNoise((255*(0*mul), 255*(4*mul)))",
iaa.AdditiveLaplaceNoise(scale=(255 * (0 * mul), 255 * (4 * mul)))),
("iaa.AdditiveLaplaceNoise([255*(1*mul), 255*(2*mul), 255*(3*mul)])",
iaa.AdditiveLaplaceNoise(
scale=[255 * (1 * mul), 255 * (2 * mul), 255 * (3 * mul)])),
("iaa.AdditiveLaplaceNoise(255*(2*mul), per_channel=True)",
iaa.AdditiveLaplaceNoise(scale=255 * (2 * mul), per_channel=True)),
]
for descr, aug in augs:
print(descr)
imgs_aug = aug.augment_images([img] * 16)
ia.imshow(ia.draw_grid(imgs_aug))
def main():
image = ia.quokka(size=0.5)
kps = [ia.KeypointsOnImage(
[ia.Keypoint(x=245, y=203), ia.Keypoint(x=365, y=195), ia.Keypoint(x=313, y=269)],
shape=(image.shape[0]*2, image.shape[1]*2)
)]
kps[0] = kps[0].on(image.shape)
print("image shape:", image.shape)
augs = [
iaa.PerspectiveTransform(scale=0.01, name="pt001", keep_size=True),
iaa.PerspectiveTransform(scale=0.1, name="pt01", keep_size=True),
iaa.PerspectiveTransform(scale=0.2, name="pt02", keep_size=True),
iaa.PerspectiveTransform(scale=0.3, name="pt03", keep_size=True),
iaa.PerspectiveTransform(scale=(0, 0.3), name="pt00to03", keep_size=True)
]
print("original", image.shape)
ia.imshow(kps[0].draw_on_image(image))
print("-----------------")
print("Random aug per image")
print("-----------------")
for aug in augs:
images_aug = []
for _ in range(16):
aug_det = aug.to_deterministic()
img_aug = aug_det.augment_image(image)
kps_aug = aug_det.augment_keypoints(kps)[0]
img_aug_kps = kps_aug.draw_on_image(img_aug)
img_aug_kps = np.pad(img_aug_kps, ((1, 1), (1, 1), (0, 0)), mode="constant", constant_values=255)
images_aug.append(img_aug_kps)
print(aug.name)
ia.imshow(ia.draw_grid(images_aug))
print("----------------")
print("6 channels")
print("----------------")
image6 = np.dstack([image, image])
image6_aug = augs[1].augment_image(image6)
ia.imshow(
np.hstack([image6_aug[..., 0:3], image6_aug[..., 3:6]])
)
def main():
image = data.astronaut()
image = ia.imresize_single_image(image, (128, 128))
# check if scipy and cv2 remap similarly
rs = ia.new_random_state(1)
aug_scipy = ElasticTransformationScipy(alpha=30, sigma=3, random_state=rs, deterministic=True)
aug_cv2 = ElasticTransformationCv2(alpha=30, sigma=3, random_state=rs, deterministic=True)
augs_scipy = aug_scipy.augment_images([image] * 8)
augs_cv2 = aug_cv2.augment_images([image] * 8)
ia.imshow(ia.draw_grid(augs_scipy + augs_cv2, rows=2))
print("alpha=vary, sigma=0.25")
augs = [iaa.ElasticTransformation(alpha=alpha, sigma=0.25) for alpha in np.arange(0.0, 50.0, 0.1)]
images_aug = [aug.augment_image(image) for aug in augs]
ia.imshow(ia.draw_grid(images_aug, cols=10))
print("alpha=vary, sigma=1.0")
augs = [iaa.ElasticTransformation(alpha=alpha, sigma=1.0) for alpha in np.arange(0.0, 50.0, 0.1)]
images_aug = [aug.augment_image(image) for aug in augs]
ia.imshow(ia.draw_grid(images_aug, cols=10))
print("alpha=vary, sigma=3.0")
augs = [iaa.ElasticTransformation(alpha=alpha, sigma=3.0) for alpha in np.arange(0.0, 50.0, 0.1)]
images_aug = [aug.augment_image(image) for aug in augs]
ia.imshow(ia.draw_grid(images_aug, cols=10))
print("alpha=vary, sigma=5.0")
augs = [iaa.ElasticTransformation(alpha=alpha, sigma=5.0) for alpha in np.arange(0.0, 50.0, 0.1)]
images_aug = [aug.augment_image(image) for aug in augs]
ia.imshow(ia.draw_grid(images_aug, cols=10))
print("alpha=1.0, sigma=vary")
augs = [iaa.ElasticTransformation(alpha=1.0, sigma=sigma) for sigma in np.arange(0.0, 50.0, 0.1)]
images_aug = [aug.augment_image(image) for aug in augs]
ia.imshow(ia.draw_grid(images_aug, cols=10))
print("alpha=10.0, sigma=vary")
augs = [iaa.ElasticTransformation(alpha=10.0, sigma=sigma) for sigma in np.arange(0.0, 50.0, 0.1)]
images_aug = [aug.augment_image(image) for aug in augs]
ia.imshow(ia.draw_grid(images_aug, cols=10))
kps = ia.KeypointsOnImage(
[ia.Keypoint(x=1, y=1),
ia.Keypoint(x=50, y=24), ia.Keypoint(x=42, y=96), ia.Keypoint(x=88, y=106), ia.Keypoint(x=88, y=53),
ia.Keypoint(x=0, y=0), ia.Keypoint(x=128, y=128), ia.Keypoint(x=-20, y=30), ia.Keypoint(x=20, y=-30),
ia.Keypoint(x=-20, y=-30)],
shape=image.shape
)
images = []
params = [
(0.0, 0.0),
(0.2, 0.2),
(2.0, 0.25),
(0.25, 3.0),
(2.0, 3.0),
(6.0, 3.0),
(12.0, 3.0),
(50.0, 5.0),
(100.0, 5.0),
(100.0, 10.0)
]
for (alpha, sigma) in params:
images_row = []
seqs_row = [
iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="constant", cval=0, order=0),
iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="constant", cval=128, order=0),
iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="constant", cval=255, order=0),
iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="constant", cval=0, order=1),
iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="constant", cval=128, order=1),
iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="constant", cval=255, order=1),
iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="constant", cval=0, order=3),
iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="constant", cval=128, order=3),
iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="constant", cval=255, order=3),
iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="nearest", order=0),
iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="nearest", order=1),
iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="nearest", order=2),
iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="nearest", order=3),
iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="reflect", order=0),
iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="reflect", order=1),
iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="reflect", order=2),
iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="reflect", order=3),
iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="wrap", order=0),
iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="wrap", order=1),
iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="wrap", order=2),
iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="wrap", order=3)
]
for seq in seqs_row:
seq_det = seq.to_deterministic()
image_aug = seq_det.augment_image(image)
kps_aug = seq_det.augment_keypoints([kps])[0]
image_aug_kp = np.copy(image_aug)
image_aug_kp = kps_aug.draw_on_image(image_aug_kp, size=3)
images_row.append(image_aug_kp)
images.append(np.hstack(images_row))
ia.imshow(np.vstack(images))
imageio.imwrite("elastic_transformations.jpg", np.vstack(images))
def main():
image = ia.quokka(size=0.5)
kps = [ia.KeypointsOnImage(
[ia.Keypoint(x=245, y=203), ia.Keypoint(x=365, y=195), ia.Keypoint(x=313, y=269)],
shape=(image.shape[0]*2, image.shape[1]*2)
)]
kps[0] = kps[0].on(image.shape)
print("image shape:", image.shape)
augs = [
iaa.CropAndPad(px=50, name="pad-by-50px"),
iaa.CropAndPad(px=(10, 20, 30, 40), name="pad-by-10-20-30-40px"),
iaa.CropAndPad(percent=0.1, name="pad-by-01percent"),
iaa.CropAndPad(percent=(0.01, 0.02, 0.03, 0.04), name="pad-by-001-002-003-004percent"),
iaa.CropAndPad(px=-20, name="crop-by-20px"),
iaa.CropAndPad(px=(-10, -20, -30, -40), name="crop-by-10-20-30-40px"),
iaa.CropAndPad(percent=-0.1, name="crop-by-01percent"),
iaa.CropAndPad(percent=(-0.01, -0.02, -0.03, -0.04), name="crop-by-001-002-003-004percent")
]
augs_many = [
iaa.Crop(px=(0, 50), name="native-crop-0-to-50px"),
iaa.Crop(px=iap.DiscreteUniform(0, 50), name="native-crop-0-to-50px-iap"),
iaa.Pad(px=(0, 50), pad_mode="linear_ramp", pad_cval=(0, 255), name="native-pad-0-to-50px-pad-modes"),
iaa.CropAndPad(px=(0, 50), sample_independently=False, name="pad-by-0-to-50px-same"),
iaa.CropAndPad(px=(0, 50), name="pad-by-0-to-50px"),
iaa.CropAndPad(px=(0, 50), pad_mode=ia.ALL, pad_cval=(0, 255), name="pad-by-0-to-50px-random-pad-modes-cvals"),
iaa.CropAndPad(px=((0, 50), (0, 50), (0, 50), (0, 50)), name="pad-by-0-to-50px-each"),
iaa.CropAndPad(percent=(0, 0.1), sample_independently=False, name="pad-by-0-to-01percent-same"),
iaa.CropAndPad(percent=(0, 0.1), name="pad-by-0-to-01percent"),
iaa.CropAndPad(percent=(0, 0.1), pad_mode=ia.ALL, pad_cval=(0, 255),
name="pad-by-0-to-01percent-random-pad-modes-cvals"),
iaa.CropAndPad(percent=((0, 0.1), (0, 0.1), (0, 0.1), (0, 0.1)), name="pad-by-0-to-01percent-each"),
iaa.CropAndPad(px=(-50, 0), name="crop-by-50-to-0px"),
iaa.CropAndPad(px=((-50, 0), (-50, 0), (-50, 0), (-50, 0)), name="crop-by-50-to-0px-each"),
iaa.CropAndPad(percent=(-0.1, 0), name="crop-by-01-to-0percent"),
iaa.CropAndPad(percent=((-0.1, 0), (-0.1, 0), (-0.1, 0), (-0.1, 0)), name="crop-by-01-to-0percent-each"),
iaa.CropAndPad(px=(-50, 50), name="pad-and-crop-by-50px")
]
print("original", image.shape)
ia.imshow(kps[0].draw_on_image(image))
print("-----------------")
print("Same aug per image")
print("-----------------")
for aug in augs:
img_aug = aug.augment_image(image)
kps_aug = aug.augment_keypoints(kps)[0]
img_aug_kps = kps_aug.draw_on_image(img_aug)
print(aug.name, img_aug_kps.shape, img_aug_kps.shape[1]/img_aug_kps.shape[0])
ia.imshow(img_aug_kps)
print("-----------------")
print("Random aug per image")
print("-----------------")
for aug in augs_many:
images_aug = []
for _ in range(64):
aug_det = aug.to_deterministic()
img_aug = aug_det.augment_image(image)
kps_aug = aug_det.augment_keypoints(kps)[0]
img_aug_kps = kps_aug.draw_on_image(img_aug)
img_aug_kps = np.pad(img_aug_kps, ((1, 1), (1, 1), (0, 0)), mode="constant", constant_values=255)
images_aug.append(img_aug_kps)
print(aug.name)
ia.imshow(ia.draw_grid(images_aug))
def main():
quokka = ia.quokka(size=0.5)
h, w = quokka.shape[0:2]
c = 4
segmap = np.zeros((h, w, c), dtype=np.float32)
segmap[70:120, 90:150, 0] = 1.0
segmap[30:70, 50:65, 1] = 1.0
segmap[20:50, 55:85, 2] = 1.0
segmap[120:140, 0:20, 3] = 1.0
segmap = ia.SegmentationMapOnImage(segmap, quokka.shape)
print("Affine...")
aug = iaa.Affine(translate_px={"x": 20}, mode="constant", cval=128)
quokka_aug = aug.augment_image(quokka)
segmaps_aug = aug.augment_segmentation_maps([segmap])[0]
segmaps_drawn = segmap.draw_on_image(quokka)
segmaps_aug_drawn = segmaps_aug.draw_on_image(quokka_aug)
ia.imshow(
np.hstack([
segmaps_drawn,
segmaps_aug_drawn
])
)
print("Affine with mode=edge...")
aug = iaa.Affine(translate_px={"x": 20}, mode="edge")
quokka_aug = aug.augment_image(quokka)
segmaps_aug = aug.augment_segmentation_maps([segmap])[0]
segmaps_drawn = segmap.draw_on_image(quokka)
segmaps_aug_drawn = segmaps_aug.draw_on_image(quokka_aug)
ia.imshow(
np.hstack([
segmaps_drawn,
segmaps_aug_drawn
])
)
print("PiecewiseAffine...")
aug = iaa.PiecewiseAffine(scale=0.04)
aug_det = aug.to_deterministic()
quokka_aug = aug_det.augment_image(quokka)
segmaps_aug = aug_det.augment_segmentation_maps([segmap])[0]
segmaps_drawn = segmap.draw_on_image(quokka)
segmaps_aug_drawn = segmaps_aug.draw_on_image(quokka_aug)
ia.imshow(
np.hstack([
segmaps_drawn,
segmaps_aug_drawn
])
)
print("PerspectiveTransform...")
aug = iaa.PerspectiveTransform(scale=0.04)
aug_det = aug.to_deterministic()
quokka_aug = aug_det.augment_image(quokka)
segmaps_aug = aug_det.augment_segmentation_maps([segmap])[0]
segmaps_drawn = segmap.draw_on_image(quokka)
segmaps_aug_drawn = segmaps_aug.draw_on_image(quokka_aug)
ia.imshow(
np.hstack([
segmaps_drawn,
segmaps_aug_drawn
])
)
print("ElasticTransformation alpha=3, sig=0.5...")
aug = iaa.ElasticTransformation(alpha=3.0, sigma=0.5)
aug_det = aug.to_deterministic()
quokka_aug = aug_det.augment_image(quokka)
segmaps_aug = aug_det.augment_segmentation_maps([segmap])[0]
segmaps_drawn = segmap.draw_on_image(quokka)
segmaps_aug_drawn = segmaps_aug.draw_on_image(quokka_aug)
ia.imshow(
np.hstack([
segmaps_drawn,
segmaps_aug_drawn
])
)
print("ElasticTransformation alpha=10, sig=3...")
aug = iaa.ElasticTransformation(alpha=10.0, sigma=3.0)
aug_det = aug.to_deterministic()
quokka_aug = aug_det.augment_image(quokka)
segmaps_aug = aug_det.augment_segmentation_maps([segmap])[0]
segmaps_drawn = segmap.draw_on_image(quokka)
segmaps_aug_drawn = segmaps_aug.draw_on_image(quokka_aug)
ia.imshow(
np.hstack([
segmaps_drawn,
segmaps_aug_drawn
])
)
print("CopAndPad mode=constant...")
aug = iaa.CropAndPad(px=(-10, 10, 15, -15), pad_mode="constant", pad_cval=128)
aug_det = aug.to_deterministic()
quokka_aug = aug_det.augment_image(quokka)
segmaps_aug = aug_det.augment_segmentation_maps([segmap])[0]
segmaps_drawn = segmap.draw_on_image(quokka)
segmaps_aug_drawn = segmaps_aug.draw_on_image(quokka_aug)
ia.imshow(
np.hstack([
segmaps_drawn,
segmaps_aug_drawn
])
)
print("CropAndPad mode=edge...")
aug = iaa.CropAndPad(px=(-10, 10, 15, -15), pad_mode="edge")
aug_det = aug.to_deterministic()
quokka_aug = aug_det.augment_image(quokka)
segmaps_aug = aug_det.augment_segmentation_maps([segmap])[0]
segmaps_drawn = segmap.draw_on_image(quokka)
segmaps_aug_drawn = segmaps_aug.draw_on_image(quokka_aug)
ia.imshow(
np.hstack([
segmaps_drawn,
segmaps_aug_drawn
])
)
print("Resize...")
aug = iaa.Resize(0.5, interpolation="nearest")
aug_det = aug.to_deterministic()
quokka_aug = aug_det.augment_image(quokka)
segmaps_aug = aug_det.augment_segmentation_maps([segmap])[0]
segmaps_drawn = segmap.draw_on_image(quokka)
segmaps_aug_drawn = segmaps_aug.draw_on_image(quokka_aug)
ia.imshow(ia.draw_grid([segmaps_drawn, segmaps_aug_drawn], cols=2))
print("Alpha...")
aug = iaa.Alpha(0.7, iaa.Affine(rotate=20))
aug_det = aug.to_deterministic()
quokka_aug = aug_det.augment_image(quokka)
segmaps_aug = aug_det.augment_segmentation_maps([segmap])[0]
segmaps_drawn = segmap.draw_on_image(quokka)
segmaps_aug_drawn = segmaps_aug.draw_on_image(quokka_aug)
ia.imshow(
np.hstack([
segmaps_drawn,
segmaps_aug_drawn
])
)
def main():
params = [
("Binomial(0.1)", Binomial(0.1)),
("Choice", Choice([0, 1, 2])),
("Choice with p", Choice([0, 1, 2], p=[0.1, 0.2, 0.7])),
("DiscreteUniform(0, 10)", DiscreteUniform(0, 10)),
("Poisson(0)", Poisson(0)),
("Poisson(5)", Poisson(5)),
("Discretize(Poisson(5))", Discretize(Poisson(5))),
("Normal(0, 1)", Normal(0, 1)),
("Normal(1, 1)", Normal(1, 1)),
("Normal(1, 2)", Normal(0, 2)),
("Normal(Choice([-1, 1]), 2)", Normal(Choice([-1, 1]), 2)),
("Discretize(Normal(0, 1.0))", Discretize(Normal(0, 1.0))),
("Positive(Normal(0, 1.0))", Positive(Normal(0, 1.0))),
("Positive(Normal(0, 1.0), mode='reroll')", Positive(Normal(0, 1.0), mode="reroll")),
("Negative(Normal(0, 1.0))", Negative(Normal(0, 1.0))),
("Negative(Normal(0, 1.0), mode='reroll')", Negative(Normal(0, 1.0), mode="reroll")),
("Laplace(0, 1.0)", Laplace(0, 1.0)),
("Laplace(1.0, 3.0)", Laplace(1.0, 3.0)),
("Laplace([-1.0, 1.0], 1.0)", Laplace([-1.0, 1.0], 1.0)),
("ChiSquare(1)", ChiSquare(1)),
("ChiSquare([1, 6])", ChiSquare([1, 6])),
("Weibull(0.5)", Weibull(0.5)),
("Weibull((1.0, 3.0))", Weibull((1.0, 3.0))),
("Uniform(0, 10)", Uniform(0, 10)),
("Beta(0.5, 0.5)", Beta(0.5, 0.5)),
("Deterministic(1)", Deterministic(1)),
("Clip(Normal(0, 1), 0, None)", Clip(Normal(0, 1), minval=0, maxval=None)),
("Multiply(Uniform(0, 10), 2)", Multiply(Uniform(0, 10), 2)),
("Add(Uniform(0, 10), 5)", Add(Uniform(0, 10), 5)),
("Absolute(Normal(0, 1))", Absolute(Normal(0, 1))),
("RandomSign(Poisson(1))", RandomSign(Poisson(1))),
("RandomSign(Poisson(1), 0.9)", RandomSign(Poisson(1), 0.9))
]
params_arithmetic = [
("Normal(0, 1.0)", Normal(0.0, 1.0)),
("Normal(0, 1.0) + 5", Normal(0.0, 1.0) + 5),
("5 + Normal(0, 1.0)", 5 + Normal(0.0, 1.0)),
("5 + Normal(0, 1.0)", Add(5, Normal(0.0, 1.0), elementwise=True)),
("Normal(0, 1.0) * 10", Normal(0.0, 1.0) * 10),
("10 * Normal(0, 1.0)", 10 * Normal(0.0, 1.0)),
("10 * Normal(0, 1.0)", Multiply(10, Normal(0.0, 1.0), elementwise=True)),
("Normal(0, 1.0) / 10", Normal(0.0, 1.0) / 10),
("10 / Normal(0, 1.0)", 10 / Normal(0.0, 1.0)),
("10 / Normal(0, 1.0)", Divide(10, Normal(0.0, 1.0), elementwise=True)),
("Normal(0, 1.0) ** 2", Normal(0.0, 1.0) ** 2),
("2 ** Normal(0, 1.0)", 2 ** Normal(0.0, 1.0)),
("2 ** Normal(0, 1.0)", Power(2, Normal(0.0, 1.0), elementwise=True))
]
params_noise = [
("SimplexNoise", SimplexNoise()),
("Sigmoid(SimplexNoise)", Sigmoid(SimplexNoise())),
("SimplexNoise(linear)", SimplexNoise(upscale_method="linear")),
("SimplexNoise(nearest)", SimplexNoise(upscale_method="nearest")),
("FrequencyNoise((-4, 4))", FrequencyNoise(exponent=(-4, 4))),
("FrequencyNoise(-2)", FrequencyNoise(exponent=-2)),
("FrequencyNoise(2)", FrequencyNoise(exponent=2))
]
images_params = [param.draw_distribution_graph() for (title, param) in params]
images_arithmetic = [param.draw_distribution_graph() for (title, param) in params_arithmetic]
images_noise = [param.draw_distribution_graph(size=(1000, 10, 10)) for (title, param) in params_noise]
ia.imshow(np.vstack(images_params))
ia.imshow(np.vstack(images_arithmetic))
ia.imshow(np.vstack(images_noise))
def main():
# test 2d image
ia.imshow(iaa.Resize(64).augment_image(data.camera()))
# test many images
images = [ia.quokka(size=0.5), ia.quokka(size=0.5)]
images_aug = iaa.Resize(64).augment_images(images)
ia.imshow(np.hstack(images_aug))
image = ia.quokka(size=0.5)
kps = [ia.KeypointsOnImage(
[ia.Keypoint(x=245, y=203), ia.Keypoint(x=365, y=195), ia.Keypoint(x=313, y=269)],
shape=(image.shape[0]*2, image.shape[1]*2)
)]
kps[0] = kps[0].on(image.shape)
print("image shape:", image.shape)
augs = [
iaa.Resize("keep", name="keep"),
iaa.Resize(32, name="i32"),
iaa.Resize(0.5, name="f05"),
iaa.Resize({"height": 32}, name="height32"),
iaa.Resize({"width": 32}, name="width32"),
iaa.Resize({"height": "keep", "width": 32}, name="keep-width32"),
iaa.Resize({"height": 32, "width": "keep"}, name="height32-keep"),
iaa.Resize({"height": "keep", "width": "keep"}, name="keep-keep"),
iaa.Resize({"height": 32, "width": 64}, name="height32width64"),
iaa.Resize({"height": 64, "width": "keep-aspect-ratio"}, name="height64width-kar"),
iaa.Resize({"height": "keep-aspect-ratio", "width": 64}, name="height-kar_width64")
]
augs_many = [
iaa.Resize((32, 128), name="tuple-32-128"),
iaa.Resize([32, 64, 128], name="list-32-64-128"),
iaa.Resize({"height": (32, 128), "width": "keep"}, name="height-32-64_width-keep"),
iaa.Resize({"height": (32, 128), "width": "keep-aspect-ratio"}, name="height-32-128_width-kar"),
iaa.Resize({"height": (32, 128), "width": (32, 128)}, name="height-32-128_width-32-128")
]
print("original", image.shape)
ia.imshow(kps[0].draw_on_image(image))
print("-----------------")
print("Same size per image")
print("-----------------")
for aug in augs:
img_aug = aug.augment_image(image)
kps_aug = aug.augment_keypoints(kps)[0]
img_aug_kps = kps_aug.draw_on_image(img_aug)
print(aug.name, img_aug_kps.shape, img_aug_kps.shape[1]/img_aug_kps.shape[0])
ia.imshow(img_aug_kps)
print("-----------------")
print("Random per image")
print("-----------------")
for aug in augs_many:
images_aug = []
for _ in range(64):
aug_det = aug.to_deterministic()
img_aug = aug_det.augment_image(image)
kps_aug = aug_det.augment_keypoints(kps)[0]
img_aug_kps = kps_aug.draw_on_image(img_aug)
images_aug.append(img_aug_kps)
print(aug.name)
ia.imshow(ia.draw_grid(images_aug))
print("nearest/cv2.INTER_NEAREST/cubic")
ia.imshow(np.hstack([
iaa.Resize(64, interpolation="nearest").augment_image(image),
iaa.Resize(64, interpolation=cv2.INTER_NEAREST).augment_image(image),
iaa.Resize(64, interpolation="cubic").augment_image(image)
]))
print("random nearest/cubic")
iaa.Resize(64, interpolation=["nearest", "cubic"]).show_grid([image], 8, 8)
def main():
quokka = ia.quokka(size=0.5)
h, w = quokka.shape[0:2]
heatmap = np.zeros((h, w), dtype=np.float32)
heatmap[70:120, 90:150] = 0.1
heatmap[30:70, 50:65] = 0.5
heatmap[20:50, 55:85] = 1.0
heatmap[120:140, 0:20] = 0.75
heatmaps = ia.HeatmapsOnImage(heatmap[..., np.newaxis], quokka.shape)
print("Affine...")
aug = iaa.Affine(translate_px={"x": 20}, mode="constant", cval=128)
quokka_aug = aug.augment_image(quokka)
heatmaps_aug = aug.augment_heatmaps([heatmaps])[0]
heatmaps_drawn = heatmaps.draw_on_image(quokka)
heatmaps_aug_drawn = heatmaps_aug.draw_on_image(quokka_aug)
ia.imshow(
np.hstack([
heatmaps_drawn[0],
heatmaps_aug_drawn[0]
])
)
print("Affine with mode=edge...")
aug = iaa.Affine(translate_px={"x": 20}, mode="edge")
quokka_aug = aug.augment_image(quokka)
heatmaps_aug = aug.augment_heatmaps([heatmaps])[0]
heatmaps_drawn = heatmaps.draw_on_image(quokka)
heatmaps_aug_drawn = heatmaps_aug.draw_on_image(quokka_aug)
ia.imshow(
np.hstack([
heatmaps_drawn[0],
heatmaps_aug_drawn[0]
])
)
print("PiecewiseAffine...")
aug = iaa.PiecewiseAffine(scale=0.04)
aug_det = aug.to_deterministic()
quokka_aug = aug_det.augment_image(quokka)
heatmaps_aug = aug_det.augment_heatmaps([heatmaps])[0]
heatmaps_drawn = heatmaps.draw_on_image(quokka)
heatmaps_aug_drawn = heatmaps_aug.draw_on_image(quokka_aug)
ia.imshow(
np.hstack([
heatmaps_drawn[0],
heatmaps_aug_drawn[0]
])
)
print("PerspectiveTransform...")
aug = iaa.PerspectiveTransform(scale=0.04)
aug_det = aug.to_deterministic()
quokka_aug = aug_det.augment_image(quokka)
heatmaps_aug = aug_det.augment_heatmaps([heatmaps])[0]
heatmaps_drawn = heatmaps.draw_on_image(quokka)
heatmaps_aug_drawn = heatmaps_aug.draw_on_image(quokka_aug)
ia.imshow(
np.hstack([
heatmaps_drawn[0],
heatmaps_aug_drawn[0]
])
)
print("ElasticTransformation alpha=3, sig=0.5...")
aug = iaa.ElasticTransformation(alpha=3.0, sigma=0.5)
aug_det = aug.to_deterministic()
quokka_aug = aug_det.augment_image(quokka)
heatmaps_aug = aug_det.augment_heatmaps([heatmaps])[0]
heatmaps_drawn = heatmaps.draw_on_image(quokka)
heatmaps_aug_drawn = heatmaps_aug.draw_on_image(quokka_aug)
ia.imshow(
np.hstack([
heatmaps_drawn[0],
heatmaps_aug_drawn[0]
])
)
print("ElasticTransformation alpha=10, sig=3...")
aug = iaa.ElasticTransformation(alpha=10.0, sigma=3.0)
aug_det = aug.to_deterministic()
quokka_aug = aug_det.augment_image(quokka)
heatmaps_aug = aug_det.augment_heatmaps([heatmaps])[0]
heatmaps_drawn = heatmaps.draw_on_image(quokka)
heatmaps_aug_drawn = heatmaps_aug.draw_on_image(quokka_aug)
ia.imshow(
np.hstack([
heatmaps_drawn[0],
heatmaps_aug_drawn[0]
])
)
print("CopAndPad mode=constant...")
aug = iaa.CropAndPad(px=(-10, 10, 15, -15), pad_mode="constant", pad_cval=128)
aug_det = aug.to_deterministic()
quokka_aug = aug_det.augment_image(quokka)
heatmaps_aug = aug_det.augment_heatmaps([heatmaps])[0]
heatmaps_drawn = heatmaps.draw_on_image(quokka)
heatmaps_aug_drawn = heatmaps_aug.draw_on_image(quokka_aug)
ia.imshow(
np.hstack([
heatmaps_drawn[0],
heatmaps_aug_drawn[0]
])
)
print("CopAndPad mode=constant + percent...")
aug = iaa.CropAndPad(percent=(-0.05, 0.05, 0.1, -0.1), pad_mode="constant", pad_cval=128)
aug_det = aug.to_deterministic()
quokka_aug = aug_det.augment_image(quokka)
heatmaps_aug = aug_det.augment_heatmaps([heatmaps])[0]
heatmaps_drawn = heatmaps.draw_on_image(quokka)
heatmaps_aug_drawn = heatmaps_aug.draw_on_image(quokka_aug)
ia.imshow(
np.hstack([
heatmaps_drawn[0],
heatmaps_aug_drawn[0]
])
)
print("CropAndPad mode=edge...")
aug = iaa.CropAndPad(px=(-10, 10, 15, -15), pad_mode="edge")
aug_det = aug.to_deterministic()
quokka_aug = aug_det.augment_image(quokka)
heatmaps_aug = aug_det.augment_heatmaps([heatmaps])[0]
heatmaps_drawn = heatmaps.draw_on_image(quokka)
heatmaps_aug_drawn = heatmaps_aug.draw_on_image(quokka_aug)
ia.imshow(
np.hstack([
heatmaps_drawn[0],
heatmaps_aug_drawn[0]
])
)
print("Resize...")
aug = iaa.Resize(0.5, interpolation="nearest")
aug_det = aug.to_deterministic()
quokka_aug = aug_det.augment_image(quokka)
heatmaps_aug = aug_det.augment_heatmaps([heatmaps])[0]
heatmaps_drawn = heatmaps.draw_on_image(quokka)
heatmaps_aug_drawn = heatmaps_aug.draw_on_image(quokka_aug)
ia.imshow(ia.draw_grid([heatmaps_drawn[0], heatmaps_aug_drawn[0]], cols=2))
print("Alpha...")
aug = iaa.Alpha(0.7, iaa.Affine(rotate=20))
aug_det = aug.to_deterministic()
quokka_aug = aug_det.augment_image(quokka)
heatmaps_aug = aug_det.augment_heatmaps([heatmaps])[0]
heatmaps_drawn = heatmaps.draw_on_image(quokka)
heatmaps_aug_drawn = heatmaps_aug.draw_on_image(quokka_aug)
ia.imshow(
np.hstack([
heatmaps_drawn[0],
heatmaps_aug_drawn[0]
])
)
def main():
image = data.astronaut()
image = ia.imresize_single_image(image, (HEIGHT, WIDTH))
kps = []
for y in range(NB_ROWS):
ycoord = BB_Y1 + int(y * (BB_Y2 - BB_Y1) / (NB_COLS - 1))
for x in range(NB_COLS):
xcoord = BB_X1 + int(x * (BB_X2 - BB_X1) / (NB_ROWS - 1))
kp = (xcoord, ycoord)
kps.append(kp)
kps = set(kps)
kps = [ia.Keypoint(x=xcoord, y=ycoord) for (xcoord, ycoord) in kps]
kps = ia.KeypointsOnImage(kps, shape=image.shape)
bb = ia.BoundingBox(x1=BB_X1, x2=BB_X2, y1=BB_Y1, y2=BB_Y2)
bbs = ia.BoundingBoxesOnImage([bb], shape=image.shape)
pairs = []
params = [
{"rotate": 45},
{"translate_px": 20},
{"translate_percent": 0.1},
{"scale": 1.2},
{"scale": 0.8},
{"shear": 45},
{"rotate": 45, "cval": 255},
{"translate_px": 20, "mode": "constant"},
{"translate_px": 20, "mode": "edge"},
{"translate_px": 20, "mode": "symmetric"},
{"translate_px": 20, "mode": "reflect"},
{"translate_px": 20, "mode": "wrap"},
{"scale": 0.5, "order": 0},
{"scale": 0.5, "order": 1},
{"scale": 0.5, "order": 2},
{"scale": 0.5, "order": 3},
{"scale": 0.5, "order": 4},
{"scale": 0.5, "order": 5},
{"rotate": 45, "translate_px": 20, "scale": 1.2},
{"rotate": 45, "translate_px": 20, "scale": 0.8},
{"rotate": (-45, 45), "translate_px": (-20, 20), "scale": (0.8, 1.2), "order": ia.ALL,
"mode": ia.ALL, "cval": ia.ALL},
{"rotate": (-45, 45), "translate_px": (-20, 20), "scale": (0.8, 1.2), "order": ia.ALL,
"mode": ia.ALL, "cval": ia.ALL},
{"rotate": (-45, 45), "translate_px": (-20, 20), "scale": (0.8, 1.2), "order": ia.ALL,
"mode": ia.ALL, "cval": ia.ALL},
{"rotate": (-45, 45), "translate_px": (-20, 20), "scale": (0.8, 1.2), "order": ia.ALL,
"mode": ia.ALL, "cval": ia.ALL}
]
seqs_skimage = [iaa.Affine(backend="skimage", **p) for p in params]
seqs_cv2 = [iaa.Affine(backend="auto", **p) for p in params]
for seq_skimage, seq_cv2 in zip(seqs_skimage, seqs_cv2):
seq_skimage_det = seq_skimage.to_deterministic()
seq_cv2_det = seq_cv2.to_deterministic()
seq_cv2_det.copy_random_state_(seq_skimage_det)
image_aug_skimage = seq_skimage_det.augment_image(image)
image_aug_cv2 = seq_cv2_det.augment_image(image)
kps_aug_skimage = seq_skimage_det.augment_keypoints([kps])[0]
kps_aug_cv2 = seq_cv2_det.augment_keypoints([kps])[0]
bbs_aug_skimage = seq_skimage_det.augment_bounding_boxes([bbs])[0]
bbs_aug_cv2 = seq_cv2_det.augment_bounding_boxes([bbs])[0]
image_before_skimage = np.copy(image)
image_before_cv2 = np.copy(image)
image_before_skimage = kps.draw_on_image(image_before_skimage)
image_before_cv2 = kps.draw_on_image(image_before_cv2)
image_before_skimage = bbs.draw_on_image(image_before_skimage)
image_before_cv2 = bbs.draw_on_image(image_before_cv2)
image_after_skimage = np.copy(image_aug_skimage)
image_after_cv2 = np.copy(image_aug_cv2)
image_after_skimage = kps_aug_skimage.draw_on_image(image_after_skimage)
image_after_cv2 = kps_aug_cv2.draw_on_image(image_after_cv2)
image_after_skimage = bbs_aug_skimage.draw_on_image(image_after_skimage)
image_after_cv2 = bbs_aug_cv2.draw_on_image(image_after_cv2)
pairs.append(np.hstack((image_before_skimage, image_after_skimage, image_after_cv2)))
ia.imshow(np.vstack(pairs))
imageio.imwrite("affine.jpg", np.vstack(pairs))
def main():
image = ia.quokka(size=0.5)
kps = [ia.KeypointsOnImage(
[ia.Keypoint(x=245, y=203), ia.Keypoint(x=365, y=195), ia.Keypoint(x=313, y=269)],
shape=(image.shape[0]*2, image.shape[1]*2)
)]
kps[0] = kps[0].on(image.shape)
print("image shape:", image.shape)
augs_many = [
iaa.PadToFixedSize(200, 200, name="pad-width200-height200"),
iaa.PadToFixedSize(200, 322, name="pad-width200-height322"),
iaa.PadToFixedSize(200, 400, name="pad-width200-height400"),
iaa.PadToFixedSize(480, 200, name="pad-width480-height200"),
iaa.PadToFixedSize(480, 322, name="pad-width480-height322"), # input size == output size
iaa.PadToFixedSize(480, 400, name="pad-width480-height400"),
iaa.PadToFixedSize(600, 200, name="pad-width600-height200"),
iaa.PadToFixedSize(600, 322, name="pad-width600-height322"),
iaa.PadToFixedSize(600, 400, name="pad-width600-height400"),
iaa.CropToFixedSize(200, 200, name="crop-width200-height200"),
iaa.CropToFixedSize(200, 322, name="crop-width200-height322"),
iaa.CropToFixedSize(200, 400, name="crop-width200-height400"),
iaa.CropToFixedSize(480, 200, name="crop-width480-height200"),
iaa.CropToFixedSize(480, 322, name="crop-width480-height322"), # input size == output size
iaa.CropToFixedSize(480, 400, name="crop-width480-height400"),
iaa.CropToFixedSize(600, 200, name="crop-width600-height200"),
iaa.CropToFixedSize(600, 322, name="crop-width600-height322"),
iaa.CropToFixedSize(600, 400, name="crop-width600-height400"),
iaa.Sequential([
iaa.PadToFixedSize(200, 200),
iaa.CropToFixedSize(200, 200)
], name="pad-crop-width200-height200"),
iaa.Sequential([
iaa.PadToFixedSize(400, 400),
iaa.CropToFixedSize(400, 400)
], name="pad-crop-width400-height400"),
iaa.Sequential([
iaa.PadToFixedSize(600, 600),
iaa.CropToFixedSize(600, 600)
], name="pad-crop-width600-height600"),
iaa.Sequential([
iaa.CropToFixedSize(200, 200),
iaa.PadToFixedSize(200, 200)
], name="crop-pad-width200-height200"),
iaa.Sequential([
iaa.CropToFixedSize(400, 400),
iaa.PadToFixedSize(400, 400)
], name="crop-pad-width400-height400"),
iaa.Sequential([
iaa.CropToFixedSize(600, 600),
iaa.PadToFixedSize(600, 600)
], name="crop-pad-width600-height600"),
]
print("original", image.shape)
ia.imshow(kps[0].draw_on_image(image))
print("-----------------")
print("Random aug per image")
print("-----------------")
for aug in augs_many:
images_aug = []
for _ in range(36):
aug_det = aug.to_deterministic()
img_aug = aug_det.augment_image(image)
kps_aug = aug_det.augment_keypoints(kps)[0]
img_aug_kps = kps_aug.draw_on_image(img_aug)
img_aug_kps = np.pad(img_aug_kps, ((1, 1), (1, 1), (0, 0)), mode="constant", constant_values=255)
images_aug.append(img_aug_kps)
print(aug.name)
ia.imshow(ia.draw_grid(images_aug))
def main():
image = data.astronaut()
image = ia.imresize_single_image(image, (HEIGHT, WIDTH))
kps = []
for y in range(NB_ROWS):
ycoord = BB_Y1 + int(y * (BB_Y2 - BB_Y1) / (NB_COLS - 1))
for x in range(NB_COLS):
xcoord = BB_X1 + int(x * (BB_X2 - BB_X1) / (NB_ROWS - 1))
kp = (xcoord, ycoord)
kps.append(kp)
kps = set(kps)
kps = [ia.Keypoint(x=xcoord, y=ycoord) for (xcoord, ycoord) in kps]
kps = ia.KeypointsOnImage(kps, shape=image.shape)
bb = ia.BoundingBox(x1=BB_X1, x2=BB_X2, y1=BB_Y1, y2=BB_Y2)
bbs = ia.BoundingBoxesOnImage([bb], shape=image.shape)
pairs = []
seqs = [
iaa.AffineCv2(rotate=45),
iaa.AffineCv2(translate_px=20),
iaa.AffineCv2(translate_percent=0.1),
iaa.AffineCv2(scale=1.2),
iaa.AffineCv2(scale=0.8),
iaa.AffineCv2(shear=45),
iaa.AffineCv2(rotate=45, cval=256),
iaa.AffineCv2(translate_px=20, mode=cv2.BORDER_CONSTANT),
iaa.AffineCv2(translate_px=20, mode=cv2.BORDER_REPLICATE),
iaa.AffineCv2(translate_px=20, mode=cv2.BORDER_REFLECT),
iaa.AffineCv2(translate_px=20, mode=cv2.BORDER_REFLECT_101),
iaa.AffineCv2(translate_px=20, mode=cv2.BORDER_WRAP),
iaa.AffineCv2(translate_px=20, mode="constant"),
iaa.AffineCv2(translate_px=20, mode="replicate"),
iaa.AffineCv2(translate_px=20, mode="reflect"),
iaa.AffineCv2(translate_px=20, mode="reflect_101"),
iaa.AffineCv2(translate_px=20, mode="wrap"),
iaa.AffineCv2(scale=0.5, order=cv2.INTER_NEAREST),
iaa.AffineCv2(scale=0.5, order=cv2.INTER_LINEAR),
iaa.AffineCv2(scale=0.5, order=cv2.INTER_CUBIC),
iaa.AffineCv2(scale=0.5, order=cv2.INTER_LANCZOS4),
iaa.AffineCv2(scale=0.5, order="nearest"),
iaa.AffineCv2(scale=0.5, order="linear"),
iaa.AffineCv2(scale=0.5, order="cubic"),
iaa.AffineCv2(scale=0.5, order="lanczos4"),
iaa.AffineCv2(rotate=45, translate_px=20, scale=1.2),
iaa.AffineCv2(rotate=45, translate_px=20, scale=0.8),
iaa.AffineCv2(rotate=(-45, 45), translate_px=(-20, 20), scale=(0.8, 1.2), order=ia.ALL, mode=ia.ALL, cval=ia.ALL),
iaa.AffineCv2(rotate=(-45, 45), translate_px=(-20, 20), scale=(0.8, 1.2), order=ia.ALL, mode=ia.ALL, cval=ia.ALL),
iaa.AffineCv2(rotate=(-45, 45), translate_px=(-20, 20), scale=(0.8, 1.2), order=ia.ALL, mode=ia.ALL, cval=ia.ALL),
iaa.AffineCv2(rotate=(-45, 45), translate_px=(-20, 20), scale=(0.8, 1.2), order=ia.ALL, mode=ia.ALL, cval=ia.ALL)
]
for seq in seqs:
seq_det = seq.to_deterministic()
image_aug = seq_det.augment_image(image)
#print(image_aug.dtype, np.min(image_aug), np.max(image_aug))
kps_aug = seq_det.augment_keypoints([kps])[0]
bbs_aug = seq_det.augment_bounding_boxes([bbs])[0]
image_before = np.copy(image)
image_before = kps.draw_on_image(image_before)
image_before = bbs.draw_on_image(image_before)
image_after = np.copy(image_aug)
image_after = kps_aug.draw_on_image(image_after)
image_after = bbs_aug.draw_on_image(image_after)
pairs.append(np.hstack((image_before, image_after)))
ia.imshow(np.vstack(pairs))
imageio.imwrite("affinecv2.jpg", np.vstack(pairs))
def main():
augseq = iaa.Sequential([
iaa.Fliplr(0.5),
iaa.CoarseDropout(p=0.1, size_percent=0.1)
])
def func_images(images, random_state, parents, hooks):
time.sleep(0.2)
return images
def func_heatmaps(heatmaps, random_state, parents, hooks):
return heatmaps
def func_keypoints(keypoints_on_images, random_state, parents, hooks):
return keypoints_on_images
augseq_slow = iaa.Sequential([
iaa.Fliplr(0.5),
iaa.Lambda(
func_images=func_images,
func_heatmaps=func_heatmaps,
func_keypoints=func_keypoints
)
])
print("------------------")
print(".pool()")
print("------------------")
with augseq.pool() as pool:
time_start = time.time()
batches = list(load_images())
batches_aug = pool.map_batches(batches)
images_aug = []
keypoints_aug = []
for batch_aug in batches_aug:
images_aug.append(batch_aug.images_aug)
keypoints_aug.append(batch_aug.keypoints_aug)
print("Done in %.4fs" % (time.time() - time_start,))
# ia.imshow(draw_grid(images_aug, keypoints_aug))
print("------------------")
print("Pool.map_batches(batches)")
print("------------------")
with multicore.Pool(augseq) as pool:
time_start = time.time()
batches = list(load_images())
batches_aug = pool.map_batches(batches)
images_aug = []
keypoints_aug = []
for batch_aug in batches_aug:
images_aug.append(batch_aug.images_aug)
keypoints_aug.append(batch_aug.keypoints_aug)
print("Done in %.4fs" % (time.time() - time_start,))
# ia.imshow(draw_grid(images_aug, keypoints_aug))
print("------------------")
print("Pool.imap_batches(batches)")
print("------------------")
with multicore.Pool(augseq) as pool:
time_start = time.time()
batches_aug = pool.imap_batches(load_images())
images_aug = []
keypoints_aug = []
for batch in batches_aug:
images_aug.append(batch.images_aug)
keypoints_aug.append(batch.keypoints_aug)
print("Done in %.4fs" % (time.time() - time_start,))
# ia.imshow(draw_grid(images_aug, keypoints_aug))
print("------------------")
print("Pool.imap_batches(batches, chunksize=32)")
print("------------------")
with multicore.Pool(augseq) as pool:
time_start = time.time()
batches_aug = pool.imap_batches(load_images(n_batches=1000), chunksize=32)
count = 0
for batch in batches_aug:
count += 1
assert count == 1000
print("Done in %.4fs" % (time.time() - time_start,))
print("------------------")
print("Pool.imap_batches(batches, chunksize=2)")
print("------------------")
with multicore.Pool(augseq) as pool:
time_start = time.time()
batches_aug = pool.imap_batches(load_images(n_batches=1000), chunksize=2)
count = 0
for batch in batches_aug:
count += 1
assert count == 1000
print("Done in %.4fs" % (time.time() - time_start,))
print("------------------")
print("Pool.imap_batches(batches, chunksize=1)")
print("------------------")
with multicore.Pool(augseq) as pool:
time_start = time.time()
batches_aug = pool.imap_batches(load_images(n_batches=1000), chunksize=1)
count = 0
for batch in batches_aug:
count += 1
assert count == 1000
print("Done in %.4fs" % (time.time() - time_start,))
print("------------------")
print("Pool.map_batches(batches, chunksize=32)")
print("------------------")
with multicore.Pool(augseq) as pool:
time_start = time.time()
batches_aug = pool.map_batches(list(load_images(n_batches=1000)), chunksize=32)
assert len(batches_aug) == 1000
print("Done in %.4fs" % (time.time() - time_start,))
print("------------------")
print("Pool.map_batches chunksize with fast aug")
print("------------------")
def test_fast(processes, chunksize):
augseq = iaa.Dropout(0.1)
with multicore.Pool(augseq, processes=processes) as pool:
batches = list(load_images(n_batches=10000, draw_text=False))
time_start = time.time()
batches_aug = pool.map_batches(batches, chunksize=chunksize)
assert len(batches_aug) == 10000
print("chunksize=%d, worker=%s, time=%.4fs" % (chunksize, processes, time.time() - time_start))
test_fast(-4, 1)
test_fast(1, 1)
test_fast(None, 1)
test_fast(1, 4)
test_fast(None, 4)
test_fast(1, 32)
test_fast(None, 32)
print("------------------")
print("Pool.imap_batches chunksize with fast aug")
print("------------------")
def test_fast_imap(processes, chunksize):
augseq = iaa.Dropout(0.1)
with multicore.Pool(augseq, processes=processes) as pool:
time_start = time.time()
batches_aug = pool.imap_batches(load_images(n_batches=10000, draw_text=False), chunksize=chunksize)
batches_aug = list(batches_aug)
assert len(batches_aug) == 10000
print("chunksize=%d, worker=%s, time=%.4fs" % (chunksize, processes, time.time() - time_start))
test_fast_imap(-4, 1)
test_fast_imap(1, 1)
test_fast_imap(None, 1)
test_fast_imap(1, 4)
test_fast_imap(None, 4)
test_fast_imap(1, 32)
test_fast_imap(None, 32)
print("------------------")
print("Pool.map_batches with computationally expensive aug")
print("------------------")
def test_heavy(processes, chunksize):
augseq_heavy = iaa.PiecewiseAffine(scale=0.2, nb_cols=8, nb_rows=8)
with multicore.Pool(augseq_heavy, processes=processes) as pool:
batches = list(load_images(n_batches=500, draw_text=False))
time_start = time.time()
batches_aug = pool.map_batches(batches, chunksize=chunksize)
assert len(batches_aug) == 500
print("chunksize=%d, worker=%s, time=%.4fs" % (chunksize, processes, time.time() - time_start))
test_heavy(-4, 1)
test_heavy(1, 1)
test_heavy(None, 1)
test_heavy(1, 4)
test_heavy(None, 4)
test_heavy(1, 32)
test_heavy(None, 32)
print("------------------")
print("Pool.imap_batches(batches), slow loading")
print("------------------")
with multicore.Pool(augseq) as pool:
time_start = time.time()
batches_aug = pool.imap_batches(load_images(n_batches=100, sleep=0.2))
images_aug = []
keypoints_aug = []
for batch in batches_aug:
images_aug.append(batch.images_aug)
keypoints_aug.append(batch.keypoints_aug)
print("Done in %.4fs" % (time.time() - time_start,))
print("------------------")
print("Pool.imap_batches(batches), maxtasksperchild=4")
print("------------------")
with multicore.Pool(augseq, maxtasksperchild=4) as pool:
time_start = time.time()
batches_aug = pool.imap_batches(load_images(n_batches=100))
images_aug = []
keypoints_aug = []
for batch in batches_aug:
images_aug.append(batch.images_aug)
keypoints_aug.append(batch.keypoints_aug)
print("Done in %.4fs" % (time.time() - time_start,))
ia.imshow(draw_grid(images_aug, keypoints_aug))
print("------------------")
print("Pool.imap_batches(batches), seed=1")
print("------------------")
# we color here the images of the first worker to see in the grids which images belong to one worker
with PoolWithMarkedWorker(augseq, seed=1) as pool:
time_start = time.time()
batches_aug = pool.imap_batches(load_images(n_batches=4))
images_aug = []
keypoints_aug = []
for batch in batches_aug:
images_aug.append(batch.images_aug)
keypoints_aug.append(batch.keypoints_aug)
print("Done in %.4fs" % (time.time() - time_start,))
grid_a = draw_grid(images_aug, keypoints_aug)
with multicore.Pool(augseq, seed=1) as pool:
time_start = time.time()
batches_aug = pool.imap_batches(load_images(n_batches=4))
images_aug = []
keypoints_aug = []
for batch in batches_aug:
images_aug.append(batch.images_aug)
keypoints_aug.append(batch.keypoints_aug)
print("Done in %.4fs" % (time.time() - time_start,))
grid_b = draw_grid(images_aug, keypoints_aug)
grid_b[:, 0:2, 0] = 0
grid_b[:, 0:2, 1] = 255
grid_b[:, 0:2, 2] = 0
ia.imshow(np.hstack([grid_a, grid_b]))
print("------------------")
print("Pool.imap_batches(batches), seed=None")
print("------------------")
with multicore.Pool(augseq, seed=None) as pool:
time_start = time.time()
batches_aug = pool.imap_batches(load_images(n_batches=4))
images_aug = []
keypoints_aug = []
for batch in batches_aug:
images_aug.append(batch.images_aug)
keypoints_aug.append(batch.keypoints_aug)
print("Done in %.4fs" % (time.time() - time_start,))
grid_a = draw_grid(images_aug, keypoints_aug)
with multicore.Pool(augseq, seed=None) as pool:
time_start = time.time()
batches_aug = pool.imap_batches(load_images(n_batches=4))
images_aug = []
keypoints_aug = []
for batch in batches_aug:
images_aug.append(batch.images_aug)
keypoints_aug.append(batch.keypoints_aug)
print("Done in %.4fs" % (time.time() - time_start,))
grid_b = draw_grid(images_aug, keypoints_aug)
ia.imshow(np.hstack([grid_a, grid_b]))
print("------------------")
print("Pool.imap_batches(batches), maxtasksperchild=4, seed=1")
print("------------------")
with multicore.Pool(augseq, maxtasksperchild=4, seed=1) as pool:
time_start = time.time()
batches_aug = pool.imap_batches(load_images(n_batches=100))
images_aug = []
keypoints_aug = []
for batch in batches_aug:
images_aug.append(batch.images_aug)
keypoints_aug.append(batch.keypoints_aug)
print("Done in %.4fs" % (time.time() - time_start,))
ia.imshow(draw_grid(images_aug, keypoints_aug))
for augseq_i in [augseq, augseq_slow]:
print("------------------")
print("Many very small runs (batches=1)")
print("------------------")
with multicore.Pool(augseq_i) as pool:
time_start = time.time()
for i in range(100):
_ = pool.map_batches(list(load_images(n_batches=1)))
print("Done in %.4fs" % (time.time() - time_start,))
print("------------------")
print("Many very small runs (batches=2)")
print("------------------")
with multicore.Pool(augseq_i) as pool:
time_start = time.time()
for i in range(100):
_ = pool.map_batches(list(load_images(n_batches=2)))
print("Done in %.4fs" % (time.time() - time_start,))
