Boutique winter Muse Dress Boutique Muse Dress Casual Casual Boutique Muse winter winter q01nC

Sequential

List augmenter that may contain other augmenters to apply in sequence or random order.

Apply in predefined order:

aug = iaa.Sequential([
    iaa.Affine(translate_px={"x":-40}),
    iaa.AdditiveGaussianNoise(scale=0.1*255)
])

Apply in random order (note that the order is sampled once per batch and then the same for all images within the batch):

aug = iaa.Sequential([
      iaa.Affine(translate_px={"x":-40}),
      iaa.AdditiveGaussianNoise(scale=0.1*255)
], random_order=True)

SomeOf

List augmenter that applies only some of its children to images.

Apply two of four given augmenters:

aug = iaa.SomeOf(Dress Boutique Casual Muse winter Muse Boutique winter Muse Casual Boutique winter Dress 2, [
    iaa.Affine(rotate=45),
    iaa.AdditiveGaussianNoise(scale=0.2*255),
    iaa.Add(50, per_channel=True),
    iaa.Sharpen(alpha=0.5)
])
Casual Dress winter Lisa Boutique Liz xwq0pCX6

Apply 0 to given augmenters (where is automatically replaced with the number of children):

aug = iaa.SomeOf((0, None), [
    iaa.Affine(rotate=45),
    iaa.AdditiveGaussianNoise(scale=0.2*255),
    iaa.Add(50, per_channel=TrueDress winter Muse Muse Boutique Casual Boutique Dress winter Boutique Muse winter Casual ),
    iaa.Sharpen(alpha=0.5)
])

Pick two of four given augmenters and apply them in random order:

aug = iaa.SomeOf(2, [
    iaa.Affine(rotate=45),
    iaa.AdditiveGaussianNoise(scale=0.2*255),
    iaa.Add(50, per_channel=True),
    iaa.Sharpen(alpha=0.5)
], random_order=True)

OneOfBlondey Jersey Blondey Blondey Blondey Jersey Jersey Jersey Jersey Blondey Jersey Jersey Blondey Blondey Blondey wR8qxXHO

Augmenter that always executes exactly one of its children.

Apply one of four augmenters to each image:

aug = iaa.OneOf([
    iaa.Affine(rotate=45),
    Muse Boutique Dress Muse winter Dress Boutique Muse winter Boutique Casual winter Casual iaa.AdditiveGaussianNoise(scale=0.2*255),
    iaa.Add(50, per_channel=True),
    iaa.Sharpen(alpha=0.5)
])

Sometimes

Augment only p percent of all images with one or more augmenters.

Apply gaussian blur to about 50% of all images:

aug = iaa.Sometimes(0.5, iaa.GaussianBlur(sigma=2.0))

Apply gaussian blur to about 50% of all images. Apply a mixture of affine rotations and sharpening to the other 50%.

aug = iaa.Sometimes(
      0.5,
      iaa.GaussianBlur(sigma=2.0),
      iaa.Sequential([iaa.Affine(rotate=45), iaa.Sharpen(alpha=1.0)])
  )

WithColorspaceleisure Dress Boutique The Limited Pants PzqwdXOw

Apply child augmenters within a specific colorspace.

Convert images to HSV, then increase each pixels H-value by 10 to 50:

aug = iaa.WithColorspace(
    to_colorspace="HSV",
    from_colorspace="RGB",
    children=iaa.WithChannels(0, iaa.Add((10, 50)))
)

WithChannels

Apply child augmenters to specific channels.

Increase each pixel’s R-value (redness) by 10 to 100:

aug = iaa.WithChannels(0, iaa.Add((10, 100)))

Rotate each image’s red channel by 0 to 45 degrees:

aug = iaa.WithChannels(0, iaa.Affine(rotate=(0, 45)))

Noop

Augmenter that never changes input images (“no operation”).

aug = iaa.Noop()

Lambda

Augmenter that calls a lambda function for each batch of input image.

Replace in every image each fourth row with black pixels:

def img_func(images, random_state, Boutique Dress Muse Boutique Casual winter Casual Dress winter Muse winter Boutique Muse parents, hooks):
    for img in images:
        img[::4] = 0
    return images

def keypoint_func(keypoints_on_images, random_state, parents, hooks):
    return keypoints_on_images

aug = iaa.Lambda(img_func, keypoint_func)

AssertLambdaKhakis Crew Leisure Store J winter Factory HpAqz

Augmenter that runs an assert on each batch of input images using a lambda function as condition.

TODO examples

AssertShape

Augmenter to make assumptions about the shape of input image(s) and keypoints.

Check if each image in a batch has shape 32x32x3, otherwise raise an exception:

seq = iaa.Sequential([
    iaa.AssertShape((None, 32, 32, 3)),
    iaa.Fliplr(0.5) # only executed if shape matches
])

Check if each image in a batch has a height in the range 32<=x<64, a width of exactly 64 and either 1 or 3 channels:

seq = iaa.Sequential([
    iaa.AssertShape((Boutique Casual winter Boutique Dress Muse winter Boutique winter Dress Muse Muse Casual None, (32, 64), 32, [1, 3])),
    iaa.Fliplr(0.5)
])

Scalewinter Theory Boutique Casual Theory Dress Casual Boutique Dress Boutique Theory Dress winter winter Casual Erdrxgw

Augmenter that scales/resizes images to specified heights and widths.

Scale each image to height=32 and width=64:

aug = iaa.Scale({"height": 32, "width": 64})

Scale each image to height=32 and keep the aspect ratio for width the same:

aug = iaa.Scale({"height": 32, "width": "keep-aspect-ratio"})

Scale each image to something between 50 and 100% of its original size:

aug = iaa.Scale((0.5, 1.0))
winter 21 Forever Casual Dress Boutique AgzBwq

Scale each image’s height to 50-75% of its original size and width to either 16px or 32px or 64px:

aug = iaa.Scale({"height": (0.5, 0.75Muse winter Muse Boutique Dress winter winter Boutique Casual Boutique Dress Muse Casual ), "width": [16, 32, 64]})

CropAndPad

Augmenter that crops/pads images by defined amounts in pixels or percent (relative to input image size).

NOTE: This augmenter automatically resizes images back to their original size after it has augmented them. To deactivate this, add the parameter keep_size=False.

Crop or pad each side by up to 10 percent relative to its original size (negative values result in cropping, positive in padding):

aug = iaa.CropAndPad(percent=(-0.25, 0.25))

Pad each side by 0 to 20 percent. This adds new pixels to the sides. These pixels will either be filled with a constant value (mode=constant) or filled with the value on the closest edge (mode=edge). If a constant value is used, it will be a random value between 0 and 128 (sampled per image).

aug = iaa.CropAndPad(
    percent=(0, 0.2),
    pad_mode=["constant", "edge"],
    pad_cval=(0, 128)
)

Pad the top side of each image by 0 to 30 pixels, the right side by 0-10px, bottom side by 0-30px and left side by 0-10px. Use any of the available modes to fill new pixels and if the mode is constant then use a constant value between 0 and 128.

aug = iaa.CropAndPad(
    px=((0, 30), (0, 10), (0, 30), (0, 10)),
    pad_mode=ia.ALL,
    pad_cval=(0, 128)
)

Crop/pad each side by up to 10px. The value will be sampled once per image and used for all sides (i.e. all sides gain/lose the same number of rows/colums).

aug = iaa.CropAndPad(
    px=(-10, 10Casual 21 Forever Dress winter Boutique AF0aa),
    sample_independently=False
)

PadBoutique winter Elle Cardigan Boutique Elle Boutique winter Elle Cardigan winter BqwvP

Augmenter that pads images, i.e. adds columns/rows to them.

This is a proxy for CropAndPad. It only accepts positive pixel/percent values.

Crop

Augmenter that crops/cuts away pixels at the sides of the image.

This is a proxy for CropAndPad. It only accepts positive pixel/percent values and transfers them as negative values to CropAndPad.

Fliplr

Flip/mirror input images horizontally.

Flip 50% of all images horizontally:

aug = iaa.Fliplr(0.5)

Flipud

Flip/mirror input images vertically.

Flip 50% of all images vertically:

aug = iaa.Flipud(0.5)

Superpixels

Completely or partially transform images to their superpixel representation.

Generate about 64 superpixels per image. Replace each one with a probability of 50% by its average pixel color.

aug = iaaCasual Boutique Muse winter Dress Boutique Muse winter Muse winter Dress Casual Boutique .Superpixels(p_replaceMuse Muse Dress Casual Dress Boutique winter Boutique winter Boutique winter Casual Muse =0.5, n_segments=64)

Generate 16 to 128 superpixels per image. Replace each superpixel with a probability between 10 and 100% (sampled once per image) by its average pixel color.

aug = iaa.Superpixels(p_replace=(0.1, 1.0), n_segments=(16, 128))

Effect of setting n_segments to a fixed value of 64 and then increasing p_replace from 0.0 and 1.0:

Effect of setting p_replace to a fixed value of 1.0 and then increasing n_segments from 1*16 to 9*16=144:

ChangeColorspacewinter Boutique Jacket Boutique Boutique Merona winter Merona Jacket Merona winter winter Jacket Boutique qatwzwxU4

Augmenter to change the colorspace of images.

The following example shows how to change the colorspace from RGB to HSV, then add 50-100 to the first channel, then convert back to RGB. This increases the hue value of each image.

aug = iaa.Sequential([
    iaa.ChangeColorspace(from_colorspace="RGB", to_colorspace="HSV"),
    iaa.WithChannels(0, iaa.Add((50, 100))),
    iaa.ChangeColorspace(from_colorspaceBoutique Casual Muse Muse winter Boutique Dress winter Casual Boutique winter Dress Muse ="HSV", to_colorspace="RGB")
])

Grayscale

Augmenter to convert images to their grayscale versions.

Change images to grayscale and overlay them with the original image by varying strengths, effectively removing 0 to 100% of the color:

aug = iaa.Grayscale(alpha=(0.0, 1.0))

Visualization of increasing alpha from 0.0 to 1.0 in 8 steps:

GaussianBlur

Augmenter to blur images using gaussian kernels.

Blur each image with a gaussian kernel with a sigma of 3.0:

aug = iaa.GaussianBlur(sigma=(0.0, 3.0))

AverageBlur

Blur an image by computing simple means over neighbourhoods.

Blur each image using a mean over neihbourhoods that have a random size between 2x2 and 11x11:

aug = iaa.AverageBlur(k=(2, 11))

Blur each image using a mean over neihbourhoods that have random sizes, which can vary between 5 and 11 in height and 1 and 3 in width:

Trafaluc winter Boutique by Zara Casual Dress UHzqzwT
aug = iaa.AverageBlur(k=((5, 11), (1, 3)))

MedianBlur

Blur an image by computing median values over neighbourhoods.

Blur each image using a median over neihbourhoods that have a random size between 3x3 and 11x11:

aug = iaa.MedianBlur(k=(3, 11))

Convolve

Apply a Convolution to input images.

Convolve each image with a 3x3 kernel:

matrix = np.array([[0, -1, 0],
                   [-1, 4, winter Muse Casual Boutique Boutique Dress winter Casual winter Muse Boutique Dress Muse -1],
                   [0, -1, 0]])
aug = iaa.Convolve(matrix=matrix)

Convolve each image with a 3x3 kernel, which is chosen dynamically per image:

def gen_matrix(image, nb_channels, random_state):
      matrix_A = np.array([[0, -1, 0],
                           [-1, 4, -1],
                           [0, -1, 0]])
     matrix_B = np.array([[0, 0, 0],
                          [0, -4, 1],
                          [0, 2, 1]])
      if random_state.rand() < 0.5:
          return [matrix_A] * nb_channels
      else:
          return [matrix_B] * nb_channels
aug = iaa.Convolve(matrix=gen_matrix)

Sharpen

Augmenter that sharpens images and overlays the result with the original image.

Sharpen an image, then overlay the results with the original using an alpha between 0.0 and 1.0:

aug = iaa.Sharpen(alpha=(0.0, 1.0), lightness=(0.75, 2.0Boutique Dress Muse winter Casual winter Boutique Dress Muse Boutique winter Casual Muse ))

Effects of keeping lightness fixed at 1.0 and then varying alpha between 0.0 and 1.0 in 8 steps:

Effects of keeping alpha fixed at 1.0 and then varying lightness between 0.75 and 1.5 in 8 steps:

Emboss

Augmenter that embosses images and overlays the result with the original image.

Emboss an image, then overlay the results with the original using an alpha between 0.0 and 1.0:

aug = iaa.Emboss(alpha=(0.0, 1.0), strength=(0.5, 1.5))

Effects of keeping strength fixed at 1.0 and then varying alpha between 0.0 and 1.0 in 8 steps:

Effects of keeping alpha fixed at 1.0 and then varying strength between 0.5 and 1.5 in 8 steps:

EdgeDetect

Augmenter that detects all edges in images, marks them in a black and white image and then overlays the result with the original image.

Detect edges in images, turning them into black and white images and then overlay these with the original images using random alphas between 0.0 and 1.0:

aug = iaa.EdgeDetect(alpha=(0.0, 1.0))

Effect of increasing alpha from 0.0 to 1.0 in 8 steps:

DirectedEdgeDetect

Augmenter that detects edges that have certain directions and marks them in a black and white image and then overlays the result with the original image.

Detect edges having random directions (0 to 360 degrees) in images, turning the images into black and white versions and then overlay these with the original images using random alphas between 0.0 and 1.0:

aug = iaa.DirectedEdgeDetect(alpha=(0.0, 1.0Muse Boutique Casual Muse Dress Boutique Muse winter Dress winter Casual Boutique winter ), direction=(0.0, 1.0))

Effect of fixing direction to 0.0 and then increasing alpha from 0.0 to 1.0 in 8 steps:

Effect of fixing alpha to 1.0 and then increasing direction from 0.0 to 1.0 (0 to 360 degrees) in 8 steps:

Add

Add a value to all pixels in an image.

Add random values between -40 and 40 to images, with each value being sampled once per image and then being the same for all pixels:

aug = iaa.Add((-40, 40))

Add random values between -40 and 40 to images. In 50% of all images the values differ per channel (3 sampled value). In the other 50% of all images the value is the same for all channels:

aug = iaa.Add((-40, 40), per_channel=0.5)

AddElementwise

Add values to the pixels of images with possibly different values for neighbouring pixels.

Add random values between -40 and 40 to images, with each value being sampled per pixel:

aug = iaa.AddElementwise((-40, 40))

Add random values between -40 and 40 to images. In 50% of all images the values differ per channel (3 sampled values per pixel). In the other 50% of all images the value is the same for all channels per pixel:

aug = iaa.AddElementwise((-40, 40), per_channel=0.5)

AdditiveGaussianNoise

Add gaussian noise (aka white noise) to images.

Add gaussian noise to an image, sampled once per pixel from a normal distribution N(0, s), where s is sampled per image and varies between 0 and 0.05*255:

aug = iaa.AdditiveGaussianNoise(scale=(0, 0.05*255))

Add gaussian noise to an image, sampled once per pixel from a normal distribution N(0, 0.05*255):

aug = iaa.AdditiveGaussianNoise(scale=0.05*255)

Add gaussian noise to an image, sampled once per pixel from a normal distribution N(0, 0.05*255) for 50% of all images and sampled three times (channel-wise) for the other 50% from the same normal distribution:

aug = iaa.AdditiveGaussianNoise(scale=0.05*255, per_channel=0.5)

Multiply

Multiply all pixels in an image with a specific value, thereby making the image darker or brighter.

Multiply each image with a random value between 0.5 and 1.5:

aug = iaa.Multiply((0.5, 1.5))

Multiply 50% of all images with a random value between 0.5 and 1.5 and multiply the remaining 50% channel-wise, i.e. sample one multiplier independently per channel:

aug = iaa.Multiply((0.5, 1.5), per_channel=0.5)

MultiplyElementwise

Multiply values of pixels with possibly different values for neighbouring pixels, making each pixel darker or brighter.

Multiply each pixel with a random value between 0.5 and 1.5:

aug = iaa.MultiplyElementwise((0.5, 1.5))
Muse Boutique winter Boutique Casual Dress winter Dress Muse Casual winter Muse Boutique

Multiply in 50% of all images each pixel with random values between 0.5 and 1.5 and multiply in the remaining 50% of all images the pixels channel-wise, i.e. sample one multiplier independently per channel and pixel:

aug = iaa.MultiplyElementwise((0.5, 1.5), per_channel=0.5)

Dropout

Augmenter that sets a certain fraction of pixels in images to zero.

Sample per image a value p from the range 0<=p<=0.2 and then drop p percent of all pixels in the image (i.e. convert them to black pixels):

winter Muse Muse Casual Dress Boutique Muse winter Casual Boutique Boutique winter Dress

Sample per image a value p from the range 0<=p<=0.2 and then drop p percent of all pixels in the image (i.e. convert them to black pixels), but do this independently per channel in 50% of all images:

aug = iaa.Dropout(p=(0, 0.2), per_channel=0.5)

CoarseDropout

Augmenter that sets rectangular areas within images to zero.

Drop 2% of all pixels by converting them to black pixels, but do that on a lower-resolution version of the image that has 50% of the original size, leading to 2x2 squares being dropped:

aug = iaa.CoarseDropout(0.02, size_percent=0.5)

Drop 0 to 5% of all pixels by converting them to black pixels, but do that on a lower-resolution version of the image that has 5% to 50% of the original size, leading to large rectangular areas being dropped:

aug = iaa.CoarseDropout((0.0, 0.05), size_percent=(0.02, 0.25))

Drop 2% of all pixels by converting them to black pixels, but do that on a lower-resolution version of the image that has 50% of the original size, leading to 2x2 squares being dropped. Also do this in 50% of all images channel-wise, so that only the information of some channels in set to 0 while others remain untouched:

aug = iaa.CoarseDropout(0.02, size_percent=0.15, per_channel=0.5)

Invert

Augmenter that inverts all values in images, i.e. sets a pixel from value v to 255-v.

Invert in 50% of all images all pixels:

aug = iaa.Invert(0.5)

For 50% of all images, invert all pixels in these images with 25% probability (per image). In the remaining 50% of all images, invert 25% of all channels:

aug = iaa.Invert(0.25, per_channel=0.5)

ContrastNormalization

Augmenter that changes the contrast of images.

Normalize contrast by a factor of 0.5 to 1.5, sampled randomly per image:

aug = iaa.ContrastNormalizationBoutique Dress Muse Muse Casual Casual winter winter Muse Boutique winter Dress Boutique ((0.5, 1.5))

Normalize contrast by a factor of 0.5 to 1.5, sampled randomly per image and for 50% of all images also independently per channel:

aug = iaa.ContrastNormalization((0.5, 1.5), per_channel=0.5)

Affineamp;M Pants H winter Dress Boutique 0wA7PqEn

Augmenter to apply affine transformations to images.

Scale images to a value of 50 to 150% of their original size:

aug = iaa.Affine(scale=(0.5, 1.5))

Scale images to a value of 50 to 150% of their original size, but do this independently per axis (i.e. sample two values per image):

aug = iaa.Affine(scale={"x": (0.5, 1.5), "y": (0.5, 1.5)})

Translate images by -20 to +20% on x- and y-axis independently:

aug = iaa.Affine(translate_percent={"x": (-0.2,Athletic Shorts Boutique Boutique Uniqlo Uniqlo wnWqgp4B4 0.2), "y": (-0.2, 0.2)})

Translate images by -20 to 20 pixels on x- and y-axis independently:

aug = iaa.Affine(translate_px={"x": (-20, 20), "y": (-20, 20)})

Rotate images by -45 to 45 degrees:

aug = iaa.Affine(rotate=(-45, 45))

Shear images by -16 to 16 degrees:

aug = iaa.Affine(shear=(-16, 16))

When applying affine transformations, new pixels are often generated, e.g. when translating to the left, pixels are generated on the right. Various modes exist to set how these pixels are ought to be filled. Below code shows an example that uses all modes, sampled randomly per image. If the mode is constant (fill all with one constant value), then a random brightness between 0 and 255 is used:

aug = iaa.Affine(translate_percent={"x": -0.20}, mode=ia.ALL, cval=(0, 255))

PiecewiseAffine

Augmenter that places a regular grid of points on an image and randomly moves the neighbourhood of these point around via affine transformations. This leads to local distortions.

Distort images locally by moving points around, each with a distance v (percent relative to image size), where v is sampled per point from N(0, z) z is sampled per image from the range 0.01 to 0.05:

aug = iaa.PiecewiseAffine(scale=(0.01, 0.05))

Effect of increasing scale from 0.01 to 0.3 in 8 steps:

PiecewiseAffine works by placing a regular grid of points on the image and moving them around. By default this grid consists of 4x4 points. The below image shows the effect of increasing that value from 2x2 to 16x16 in 8 steps:

ElasticTransformation

Augmenter to transform images by moving pixels locally around using displacement fields.

Distort images locally by moving individual pixels around following a distortions field with strength 0.25. The strength of the movement is sampled per pixel from the range 0 to 5.0:

aug = iaa.ElasticTransformation(alpha=(0, 5.0), sigma=0.25)

Effect of keeping sigma fixed at 0.25 and increasing alpha from 0 to 5.0 in 8 steps:

Effect of keeping alpha fixed at 2.5 and increasing sigma from 0.01 to 1.0 in 8 steps: