def rgbmore(self, im):
return_im = []
add_return_im = lambda im: return_im.extend(im)
grey = np.array(im.convert(mode='L'))
im = np.array(im)
rgb_grey = np.dstack((im, grey))
edge = iaa.EdgeDetect(alpha=1)(images=rgb_grey)
dir_edge = lambda d: iaa.DirectedEdgeDetect(alpha=1, direction=d)(images=
grey)
dir_edges = np.array(
[dir_edge(d) for d in np.linspace(0, 1, num=3, endpoint=False)])
dir_edges = np.transpose(dir_edges, (1, 2, 0))
canny = iaa.Canny(alpha=1.0,
hysteresis_thresholds=128,
sobel_kernel_size=4,
deterministic=True,
colorizer=iaa.RandomColorsBinaryImageColorizer(
color_true=255, color_false=0))(images=grey)
avg_pool = iaa.AveragePooling(2)(images=grey)
max_pool = iaa.MaxPooling(2)(images=grey)
min_pool = iaa.MinPooling(2)(images=grey)
add_return_im([im, grey])
add_return_im([edge, dir_edges, canny])
add_return_im([avg_pool, max_pool, min_pool])
return np.dstack(return_im)
def get_seq():
import imgaug.augmenters as iaa
sometimes = lambda aug: iaa.Sometimes(0.1, aug)
seq = iaa.Sequential(
[
sometimes(iaa.AdditiveGaussianNoise(scale=0.07 * 255)),
sometimes(iaa.GaussianBlur(sigma=(0, 3.0))),
sometimes(iaa.MedianBlur(k=(1, 5))),
sometimes(iaa.AverageBlur(k=((1, 5), (1, 3)))),
sometimes(iaa.AveragePooling([1, 5])),
sometimes(iaa.MaxPooling([1, 5])),
sometimes(iaa.MaxPooling([1, 5])),
sometimes(
iaa.CropAndPad(percent=(0, 0.2),
pad_mode=["constant", "edge"],
pad_cval=(0, 128))),
sometimes(
iaa.Sequential([
iaa.Resize({
"height": 64,
"width": 64
}),
iaa.Resize({
"height": input_shape[0],
"width": input_shape[1]
}),
])),
sometimes(
iaa.Sequential([
iaa.Resize({
"height": 16,
"width": 16
}),
iaa.Resize({
"height": input_shape[0],
"width": input_shape[1]
}),
])),
],
random_order=True,
)
return seq
def test_augment_images(self):
aug = iaa.MaxPooling(2, keep_size=False)
image = np.uint8([[50 - 2, 50 - 1, 120 - 4, 120 + 4],
[50 + 1, 50 + 2, 120 + 1, 120 - 1]])
image = np.tile(image[:, :, np.newaxis], (1, 1, 3))
expected = np.uint8([[50 + 2, 120 + 4]])
expected = np.tile(expected[:, :, np.newaxis], (1, 1, 3))
image_aug = aug.augment_image(image)
diff = np.abs(image_aug.astype(np.int32) - expected)
assert image_aug.shape == (1, 2, 3)
assert np.all(diff <= 1)
def get_seq_val():
sometimes = lambda aug: iaa.Sometimes(0.5, aug, random_state=STATE, )
seq_val = iaa.Sequential([
iaa.OneOf([
sometimes(iaa.GaussianBlur(sigma=(0.1, 1), random_state=STATE, )),
sometimes(iaa.AverageBlur(k=(3, 7))),
sometimes(iaa.MotionBlur(k=(3, 7))),
sometimes(iaa.AveragePooling((2, 8))),
sometimes(iaa.MaxPooling((2, 8))),
sometimes(iaa.MedianPooling((2, 8))),
sometimes(iaa.MinPooling((2, 8))),
]),
iaa.Multiply((0.8, 1.2)),
], random_order=True)
return seq_val
def test_augment_images__different_channels(self):
aug = iaa.MaxPooling((iap.Deterministic(1), iap.Deterministic(4)),
keep_size=False)
c1 = np.arange(start=1, stop=8 + 1).reshape((1, 8, 1))
c2 = (100 + np.arange(start=1, stop=8 + 1)).reshape((1, 8, 1))
image = np.dstack([c1, c2]).astype(np.uint8)
c1_expected = np.uint8([4, 8]).reshape((1, 2, 1))
c2_expected = np.uint8([100 + 4, 100 + 8]).reshape((1, 2, 1))
image_expected = np.dstack([c1_expected, c2_expected])
image_aug = aug.augment_image(image)
diff = np.abs(image_aug.astype(np.int32) - image_expected)
assert image_aug.shape == (1, 2, 2)
assert np.all(diff <= 1)
def __init__(self, *args, **kwargs):
"""
Args:
annotations (Union[pandas.DataFrame, list[pandas.DataFrame]]): query and support annotations. If a single
dataframe is given, it will be used both for query and support set.
batch_size (int): number of images per batch
"""
super().__init__(*args, **kwargs)
self.query_preprocessing = self.preprocessings[0]
self.support_preprocessing = self.preprocessings[-1]
self.query_annotations = self.annotations[0]
self.support_annotations = self.annotations[-1]
self.support_annotations_by_label = {group[0]: group[1] for group in self.support_annotations.groupby("label")}
self.query_samples = pd.DataFrame()
self.support_samples = pd.DataFrame()
self.target_augmenter = iaa.MaxPooling((32, 32), keep_size=False, deterministic=True)
def get_seq():
import imgaug.augmenters as iaa
sometimes = lambda aug: iaa.Sometimes(0.1, aug)
seq = iaa.Sequential(
[
sometimes(iaa.AdditiveGaussianNoise(scale=0.07 * 255)),
sometimes(iaa.GaussianBlur(sigma=(0, 3.0))),
sometimes(iaa.MedianBlur(k=(1, 5))),
sometimes(iaa.AverageBlur(k=((5, 11), (1, 3)))),
sometimes(iaa.AveragePooling([2, 8])),
sometimes(iaa.MaxPooling([2, 8])),
sometimes(
iaa.Sequential([
iaa.Resize({
"height": 64,
"width": 64
}),
iaa.Resize({
"height": input_shape[0],
"width": input_shape[1]
}),
])),
sometimes(
iaa.Sequential([
iaa.Resize({
"height": 512,
"width": 512
}),
iaa.Resize({
"height": input_shape[0],
"width": input_shape[1]
}),
])),
],
random_order=True,
)
return seq
iaa.WithChannels(0, iaa.Add((-50, 50))),
iaa.WithChannels(1, iaa.Add((-50, 50))),
iaa.WithChannels(2, iaa.Add((-50, 50))),
iaa.ChangeColorspace(from_colorspace="HSV", to_colorspace="RGB"),
iaa.Add((-80, 80), per_channel=0.5),
iaa.Multiply((0.5, 1.5), per_channel=0.5),
iaa.AverageBlur(k=((5), (1, 3))),
iaa.AveragePooling(2),
iaa.AddElementwise((-20, -5)),
iaa.AdditiveGaussianNoise(scale=(0, 0.05 * 255)),
iaa.JpegCompression(compression=(50, 99)),
iaa.MultiplyHueAndSaturation(mul_hue=(0.5, 1.5)),
iaa.WithBrightnessChannels(iaa.Add((-50, 50))),
iaa.WithBrightnessChannels(iaa.Add((-50, 50)),
to_colorspace=[iaa.CSPACE_Lab, iaa.CSPACE_HSV]),
iaa.MaxPooling(2),
iaa.MinPooling((1, 2)),
# iaa.Superpixels(p_replace=(0.1, 0.2), n_segments=(16, 128)),
iaa.Clouds(),
iaa.Fog(),
iaa.AdditiveGaussianNoise(scale=0.1 * 255, per_channel=True),
iaa.Dropout(p=(0, 0.2)),
# iaa.WithChannels(0, iaa.Affine(rotate=(0, 0))),
iaa.ChannelShuffle(0.35),
iaa.WithColorspace(to_colorspace="HSV",
from_colorspace="RGB",
children=iaa.WithChannels(0, iaa.Add((0, 50)))),
#
iaa.WithHueAndSaturation([
iaa.WithChannels(0, iaa.Add((-30, 10))),
d=(3, 10), sigma_color=(10, 250), sigma_space=(10, 250)),
iaa.MotionBlur(k=(3, 9), angle=[-45, 45]),
iaa.MeanShiftBlur(spatial_radius=(5.0, 10.0),
color_radius=(5.0, 10.0)),
iaa.AllChannelsCLAHE(clip_limit=(1, 10)),
iaa.AllChannelsHistogramEqualization(),
iaa.GammaContrast((0.5, 1.5), per_channel=True),
iaa.GammaContrast((0.5, 1.5)),
iaa.SigmoidContrast(gain=(3, 10), cutoff=(0.4, 0.6), per_channel=True),
iaa.SigmoidContrast(gain=(3, 10), cutoff=(0.4, 0.6)),
iaa.HistogramEqualization(),
iaa.Sharpen(alpha=0.5)
]),
iaa.OneOf([
iaa.AveragePooling([2, 3]),
iaa.MaxPooling(([2, 3], [2, 3])),
]),
iaa.OneOf([
iaa.Clouds(),
iaa.Snowflakes(flake_size=(0.1, 0.4), speed=(0.01, 0.05)),
iaa.Rain(speed=(0.1, 0.3))
])
],
random_order=True)
def get_color_augmentation(augment_prob):
return iaa.Sometimes(augment_prob, aug_transform).augment_image
class SegCompose(object):
def create_augmenters(height, width, height_augmentable, width_augmentable,
only_augmenters):
def lambda_func_images(images, random_state, parents, hooks):
return images
def lambda_func_heatmaps(heatmaps, random_state, parents, hooks):
return heatmaps
def lambda_func_keypoints(keypoints, random_state, parents, hooks):
return keypoints
def assertlambda_func_images(images, random_state, parents, hooks):
return True
def assertlambda_func_heatmaps(heatmaps, random_state, parents, hooks):
return True
def assertlambda_func_keypoints(keypoints, random_state, parents, hooks):
return True
augmenters_meta = [
iaa.Sequential([iaa.Noop(), iaa.Noop()],
random_order=False,
name="Sequential_2xNoop"),
iaa.Sequential([iaa.Noop(), iaa.Noop()],
random_order=True,
name="Sequential_2xNoop_random_order"),
iaa.SomeOf((1, 3),
[iaa.Noop(), iaa.Noop(), iaa.Noop()],
random_order=False,
name="SomeOf_3xNoop"),
iaa.SomeOf((1, 3),
[iaa.Noop(), iaa.Noop(), iaa.Noop()],
random_order=True,
name="SomeOf_3xNoop_random_order"),
iaa.OneOf([iaa.Noop(), iaa.Noop(), iaa.Noop()], name="OneOf_3xNoop"),
iaa.Sometimes(0.5, iaa.Noop(), name="Sometimes_Noop"),
iaa.WithChannels([1, 2], iaa.Noop(), name="WithChannels_1_and_2_Noop"),
iaa.Noop(name="Noop"),
iaa.Lambda(func_images=lambda_func_images,
func_heatmaps=lambda_func_heatmaps,
func_keypoints=lambda_func_keypoints,
name="Lambda"),
iaa.AssertLambda(func_images=assertlambda_func_images,
func_heatmaps=assertlambda_func_heatmaps,
func_keypoints=assertlambda_func_keypoints,
name="AssertLambda"),
iaa.AssertShape((None, height_augmentable, width_augmentable, None),
name="AssertShape"),
iaa.ChannelShuffle(0.5, name="ChannelShuffle")
]
augmenters_arithmetic = [
iaa.Add((-10, 10), name="Add"),
iaa.AddElementwise((-10, 10), name="AddElementwise"),
#iaa.AddElementwise((-500, 500), name="AddElementwise"),
iaa.AdditiveGaussianNoise(scale=(5, 10), name="AdditiveGaussianNoise"),
iaa.AdditiveLaplaceNoise(scale=(5, 10), name="AdditiveLaplaceNoise"),
iaa.AdditivePoissonNoise(lam=(1, 5), name="AdditivePoissonNoise"),
iaa.Multiply((0.5, 1.5), name="Multiply"),
iaa.MultiplyElementwise((0.5, 1.5), name="MultiplyElementwise"),
iaa.Dropout((0.01, 0.05), name="Dropout"),
iaa.CoarseDropout((0.01, 0.05),
size_percent=(0.01, 0.1),
name="CoarseDropout"),
iaa.ReplaceElementwise((0.01, 0.05), (0, 255),
name="ReplaceElementwise"),
#iaa.ReplaceElementwise((0.95, 0.99), (0, 255), name="ReplaceElementwise"),
iaa.SaltAndPepper((0.01, 0.05), name="SaltAndPepper"),
iaa.ImpulseNoise((0.01, 0.05), name="ImpulseNoise"),
iaa.CoarseSaltAndPepper((0.01, 0.05),
size_percent=(0.01, 0.1),
name="CoarseSaltAndPepper"),
iaa.Salt((0.01, 0.05), name="Salt"),
iaa.CoarseSalt((0.01, 0.05),
size_percent=(0.01, 0.1),
name="CoarseSalt"),
iaa.Pepper((0.01, 0.05), name="Pepper"),
iaa.CoarsePepper((0.01, 0.05),
size_percent=(0.01, 0.1),
name="CoarsePepper"),
iaa.Invert(0.1, name="Invert"),
# ContrastNormalization
iaa.JpegCompression((50, 99), name="JpegCompression")
]
augmenters_blend = [
iaa.Alpha((0.01, 0.99), iaa.Noop(), name="Alpha"),
iaa.AlphaElementwise((0.01, 0.99), iaa.Noop(),
name="AlphaElementwise"),
iaa.SimplexNoiseAlpha(iaa.Noop(), name="SimplexNoiseAlpha"),
iaa.FrequencyNoiseAlpha((-2.0, 2.0),
iaa.Noop(),
name="FrequencyNoiseAlpha")
]
augmenters_blur = [
iaa.GaussianBlur(sigma=(1.0, 5.0), name="GaussianBlur"),
iaa.AverageBlur(k=(3, 11), name="AverageBlur"),
iaa.MedianBlur(k=(3, 11), name="MedianBlur"),
iaa.BilateralBlur(d=(3, 11), name="BilateralBlur"),
iaa.MotionBlur(k=(3, 11), name="MotionBlur")
]
augmenters_color = [
# InColorspace (deprecated)
iaa.WithColorspace(to_colorspace="HSV",
children=iaa.Noop(),
name="WithColorspace"),
iaa.WithHueAndSaturation(children=iaa.Noop(),
name="WithHueAndSaturation"),
iaa.MultiplyHueAndSaturation((0.8, 1.2),
name="MultiplyHueAndSaturation"),
iaa.MultiplyHue((-1.0, 1.0), name="MultiplyHue"),
iaa.MultiplySaturation((0.8, 1.2), name="MultiplySaturation"),
iaa.AddToHueAndSaturation((-10, 10), name="AddToHueAndSaturation"),
iaa.AddToHue((-10, 10), name="AddToHue"),
iaa.AddToSaturation((-10, 10), name="AddToSaturation"),
iaa.ChangeColorspace(to_colorspace="HSV", name="ChangeColorspace"),
iaa.Grayscale((0.01, 0.99), name="Grayscale"),
iaa.KMeansColorQuantization((2, 16), name="KMeansColorQuantization"),
iaa.UniformColorQuantization((2, 16), name="UniformColorQuantization")
]
augmenters_contrast = [
iaa.GammaContrast(gamma=(0.5, 2.0), name="GammaContrast"),
iaa.SigmoidContrast(gain=(5, 20),
cutoff=(0.25, 0.75),
name="SigmoidContrast"),
iaa.LogContrast(gain=(0.7, 1.0), name="LogContrast"),
iaa.LinearContrast((0.5, 1.5), name="LinearContrast"),
iaa.AllChannelsCLAHE(clip_limit=(2, 10),
tile_grid_size_px=(3, 11),
name="AllChannelsCLAHE"),
iaa.CLAHE(clip_limit=(2, 10),
tile_grid_size_px=(3, 11),
to_colorspace="HSV",
name="CLAHE"),
iaa.AllChannelsHistogramEqualization(
name="AllChannelsHistogramEqualization"),
iaa.HistogramEqualization(to_colorspace="HSV",
name="HistogramEqualization"),
]
augmenters_convolutional = [
iaa.Convolve(np.float32([[0, 0, 0], [0, 1, 0], [0, 0, 0]]),
name="Convolve_3x3"),
iaa.Sharpen(alpha=(0.01, 0.99), lightness=(0.5, 2), name="Sharpen"),
iaa.Emboss(alpha=(0.01, 0.99), strength=(0, 2), name="Emboss"),
iaa.EdgeDetect(alpha=(0.01, 0.99), name="EdgeDetect"),
iaa.DirectedEdgeDetect(alpha=(0.01, 0.99), name="DirectedEdgeDetect")
]
augmenters_edges = [iaa.Canny(alpha=(0.01, 0.99), name="Canny")]
augmenters_flip = [
iaa.Fliplr(1.0, name="Fliplr"),
iaa.Flipud(1.0, name="Flipud")
]
augmenters_geometric = [
iaa.Affine(scale=(0.9, 1.1),
translate_percent={
"x": (-0.05, 0.05),
"y": (-0.05, 0.05)
},
rotate=(-10, 10),
shear=(-10, 10),
order=0,
mode="constant",
cval=(0, 255),
name="Affine_order_0_constant"),
iaa.Affine(scale=(0.9, 1.1),
translate_percent={
"x": (-0.05, 0.05),
"y": (-0.05, 0.05)
},
rotate=(-10, 10),
shear=(-10, 10),
order=1,
mode="constant",
cval=(0, 255),
name="Affine_order_1_constant"),
iaa.Affine(scale=(0.9, 1.1),
translate_percent={
"x": (-0.05, 0.05),
"y": (-0.05, 0.05)
},
rotate=(-10, 10),
shear=(-10, 10),
order=3,
mode="constant",
cval=(0, 255),
name="Affine_order_3_constant"),
iaa.Affine(scale=(0.9, 1.1),
translate_percent={
"x": (-0.05, 0.05),
"y": (-0.05, 0.05)
},
rotate=(-10, 10),
shear=(-10, 10),
order=1,
mode="edge",
cval=(0, 255),
name="Affine_order_1_edge"),
iaa.Affine(scale=(0.9, 1.1),
translate_percent={
"x": (-0.05, 0.05),
"y": (-0.05, 0.05)
},
rotate=(-10, 10),
shear=(-10, 10),
order=1,
mode="constant",
cval=(0, 255),
backend="skimage",
name="Affine_order_1_constant_skimage"),
# TODO AffineCv2
iaa.PiecewiseAffine(scale=(0.01, 0.05),
nb_rows=4,
nb_cols=4,
order=1,
mode="constant",
name="PiecewiseAffine_4x4_order_1_constant"),
iaa.PiecewiseAffine(scale=(0.01, 0.05),
nb_rows=4,
nb_cols=4,
order=0,
mode="constant",
name="PiecewiseAffine_4x4_order_0_constant"),
iaa.PiecewiseAffine(scale=(0.01, 0.05),
nb_rows=4,
nb_cols=4,
order=1,
mode="edge",
name="PiecewiseAffine_4x4_order_1_edge"),
iaa.PiecewiseAffine(scale=(0.01, 0.05),
nb_rows=8,
nb_cols=8,
order=1,
mode="constant",
name="PiecewiseAffine_8x8_order_1_constant"),
iaa.PerspectiveTransform(scale=(0.01, 0.05),
keep_size=False,
name="PerspectiveTransform"),
iaa.PerspectiveTransform(scale=(0.01, 0.05),
keep_size=True,
name="PerspectiveTransform_keep_size"),
iaa.ElasticTransformation(
alpha=(1, 10),
sigma=(0.5, 1.5),
order=0,
mode="constant",
cval=0,
name="ElasticTransformation_order_0_constant"),
iaa.ElasticTransformation(
alpha=(1, 10),
sigma=(0.5, 1.5),
order=1,
mode="constant",
cval=0,
name="ElasticTransformation_order_1_constant"),
iaa.ElasticTransformation(
alpha=(1, 10),
sigma=(0.5, 1.5),
order=1,
mode="nearest",
cval=0,
name="ElasticTransformation_order_1_nearest"),
iaa.ElasticTransformation(
alpha=(1, 10),
sigma=(0.5, 1.5),
order=1,
mode="reflect",
cval=0,
name="ElasticTransformation_order_1_reflect"),
iaa.Rot90((1, 3), keep_size=False, name="Rot90"),
iaa.Rot90((1, 3), keep_size=True, name="Rot90_keep_size")
]
augmenters_pooling = [
iaa.AveragePooling(kernel_size=(1, 16),
keep_size=False,
name="AveragePooling"),
iaa.AveragePooling(kernel_size=(1, 16),
keep_size=True,
name="AveragePooling_keep_size"),
iaa.MaxPooling(kernel_size=(1, 16), keep_size=False,
name="MaxPooling"),
iaa.MaxPooling(kernel_size=(1, 16),
keep_size=True,
name="MaxPooling_keep_size"),
iaa.MinPooling(kernel_size=(1, 16), keep_size=False,
name="MinPooling"),
iaa.MinPooling(kernel_size=(1, 16),
keep_size=True,
name="MinPooling_keep_size"),
iaa.MedianPooling(kernel_size=(1, 16),
keep_size=False,
name="MedianPooling"),
iaa.MedianPooling(kernel_size=(1, 16),
keep_size=True,
name="MedianPooling_keep_size")
]
augmenters_segmentation = [
iaa.Superpixels(p_replace=(0.05, 1.0),
n_segments=(10, 100),
max_size=64,
interpolation="cubic",
name="Superpixels_max_size_64_cubic"),
iaa.Superpixels(p_replace=(0.05, 1.0),
n_segments=(10, 100),
max_size=64,
interpolation="linear",
name="Superpixels_max_size_64_linear"),
iaa.Superpixels(p_replace=(0.05, 1.0),
n_segments=(10, 100),
max_size=128,
interpolation="linear",
name="Superpixels_max_size_128_linear"),
iaa.Superpixels(p_replace=(0.05, 1.0),
n_segments=(10, 100),
max_size=224,
interpolation="linear",
name="Superpixels_max_size_224_linear"),
iaa.UniformVoronoi(n_points=(250, 1000), name="UniformVoronoi"),
iaa.RegularGridVoronoi(n_rows=(16, 31),
n_cols=(16, 31),
name="RegularGridVoronoi"),
iaa.RelativeRegularGridVoronoi(n_rows_frac=(0.07, 0.14),
n_cols_frac=(0.07, 0.14),
name="RelativeRegularGridVoronoi"),
]
augmenters_size = [
iaa.Resize((0.8, 1.2), interpolation="nearest", name="Resize_nearest"),
iaa.Resize((0.8, 1.2), interpolation="linear", name="Resize_linear"),
iaa.Resize((0.8, 1.2), interpolation="cubic", name="Resize_cubic"),
iaa.CropAndPad(percent=(-0.2, 0.2),
pad_mode="constant",
pad_cval=(0, 255),
keep_size=False,
name="CropAndPad"),
iaa.CropAndPad(percent=(-0.2, 0.2),
pad_mode="edge",
pad_cval=(0, 255),
keep_size=False,
name="CropAndPad_edge"),
iaa.CropAndPad(percent=(-0.2, 0.2),
pad_mode="constant",
pad_cval=(0, 255),
name="CropAndPad_keep_size"),
iaa.Pad(percent=(0.05, 0.2),
pad_mode="constant",
pad_cval=(0, 255),
keep_size=False,
name="Pad"),
iaa.Pad(percent=(0.05, 0.2),
pad_mode="edge",
pad_cval=(0, 255),
keep_size=False,
name="Pad_edge"),
iaa.Pad(percent=(0.05, 0.2),
pad_mode="constant",
pad_cval=(0, 255),
name="Pad_keep_size"),
iaa.Crop(percent=(0.05, 0.2), keep_size=False, name="Crop"),
iaa.Crop(percent=(0.05, 0.2), name="Crop_keep_size"),
iaa.PadToFixedSize(width=width + 10,
height=height + 10,
pad_mode="constant",
pad_cval=(0, 255),
name="PadToFixedSize"),
iaa.CropToFixedSize(width=width - 10,
height=height - 10,
name="CropToFixedSize"),
iaa.KeepSizeByResize(iaa.CropToFixedSize(height=height - 10,
width=width - 10),
interpolation="nearest",
name="KeepSizeByResize_CropToFixedSize_nearest"),
iaa.KeepSizeByResize(iaa.CropToFixedSize(height=height - 10,
width=width - 10),
interpolation="linear",
name="KeepSizeByResize_CropToFixedSize_linear"),
iaa.KeepSizeByResize(iaa.CropToFixedSize(height=height - 10,
width=width - 10),
interpolation="cubic",
name="KeepSizeByResize_CropToFixedSize_cubic"),
]
augmenters_weather = [
iaa.FastSnowyLandscape(lightness_threshold=(100, 255),
lightness_multiplier=(1.0, 4.0),
name="FastSnowyLandscape"),
iaa.Clouds(name="Clouds"),
iaa.Fog(name="Fog"),
iaa.CloudLayer(intensity_mean=(196, 255),
intensity_freq_exponent=(-2.5, -2.0),
intensity_coarse_scale=10,
alpha_min=0,
alpha_multiplier=(0.25, 0.75),
alpha_size_px_max=(2, 8),
alpha_freq_exponent=(-2.5, -2.0),
sparsity=(0.8, 1.0),
density_multiplier=(0.5, 1.0),
name="CloudLayer"),
iaa.Snowflakes(name="Snowflakes"),
iaa.SnowflakesLayer(density=(0.005, 0.075),
density_uniformity=(0.3, 0.9),
flake_size=(0.2, 0.7),
flake_size_uniformity=(0.4, 0.8),
angle=(-30, 30),
speed=(0.007, 0.03),
blur_sigma_fraction=(0.0001, 0.001),
name="SnowflakesLayer")
]
augmenters = (augmenters_meta + augmenters_arithmetic + augmenters_blend +
augmenters_blur + augmenters_color + augmenters_contrast +
augmenters_convolutional + augmenters_edges +
augmenters_flip + augmenters_geometric + augmenters_pooling +
augmenters_segmentation + augmenters_size +
augmenters_weather)
if only_augmenters is not None:
augmenters_reduced = []
for augmenter in augmenters:
if any([
re.search(pattern, augmenter.name)
for pattern in only_augmenters
]):
augmenters_reduced.append(augmenter)
augmenters = augmenters_reduced
return augmenters
def next(self):
if not self.is_init:
self.reset()
self.is_init = True
"""Returns the next batch of data."""
#print('in next', self.cur, self.labelcur)
self.nbatch += 1
batch_size = self.batch_size
c, h, w = self.data_shape
batch_data = nd.empty((batch_size, c, h, w))
if self.provide_label is not None:
batch_label = nd.empty(self.provide_label[0][1])
i = 0
try:
while i < batch_size:
label, s, bbox, landmark = self.next_sample()
_data = self.imdecode(s)
if _data.shape[0] != self.data_shape[1]:
_data = mx.image.resize_short(_data, self.data_shape[1])
if self.rand_mirror:
_rd = random.randint(0, 1)
if _rd == 1:
_data = mx.ndarray.flip(data=_data, axis=1)
if self.blur:
aug_blur = iaa.Sequential([
iaa.OneOf([
iaa.GaussianBlur(sigma=(0.5, 2.5)),
iaa.AverageBlur(k=(2, 5)),
iaa.MotionBlur(k=(5, 7)),
iaa.BilateralBlur(d=(3, 4),
sigma_color=(10, 250),
sigma_space=(10, 250)),
iaa.imgcorruptlike.DefocusBlur(severity=1),
iaa.imgcorruptlike.GlassBlur(severity=1),
iaa.imgcorruptlike.Pixelate(severity=(1, 3)),
iaa.Pepper(0.01),
iaa.AdditiveGaussianNoise(scale=(0, 0.1 * 255),
per_channel=True),
iaa.imgcorruptlike.SpeckleNoise(severity=1),
iaa.imgcorruptlike.JpegCompression(severity=(1,
4)),
])
])
_rd = random.randint(0, 1)
if _rd == 1:
_data = aug_blur(images=_data)
if self.maxpooling:
maxpool_aug = iaa.MaxPooling(2)
_rd = random.randint(0, 1)
if _rd == 1:
_data = maxpool_aug(images=_data)
if self.color_jittering > 0:
if self.color_jittering > 1:
_rd = random.randint(0, 1)
if _rd == 1:
_data = self.compress_aug(_data)
#print('do color aug')
_data = _data.astype('float32', copy=False)
#print(_data.__class__)
_data = self.color_aug(_data, 0.125)
if self.nd_mean is not None:
_data = _data.astype('float32', copy=False)
_data -= self.nd_mean
_data *= 0.0078125
if self.cutoff > 0:
_rd = random.randint(0, 1)
if _rd == 1:
#print('do cutoff aug', self.cutoff)
centerh = random.randint(0, _data.shape[0] - 1)
centerw = random.randint(0, _data.shape[1] - 1)
half = self.cutoff // 2
starth = max(0, centerh - half)
endh = min(_data.shape[0], centerh + half)
startw = max(0, centerw - half)
endw = min(_data.shape[1], centerw + half)
#print(starth, endh, startw, endw, _data.shape)
_data[starth:endh, startw:endw, :] = 128
data = [_data]
try:
self.check_valid_image(data)
except RuntimeError as e:
logging.debug('Invalid image, skipping: %s', str(e))
continue
#print('aa',data[0].shape)
#data = self.augmentation_transform(data)
#print('bb',data[0].shape)
for datum in data:
assert i < batch_size, 'Batch size must be multiples of augmenter output length'
#print(datum.shape)
batch_data[i][:] = self.postprocess_data(datum)
batch_label[i][:] = label
i += 1
except StopIteration:
if i < batch_size:
raise StopIteration
return io.DataBatch([batch_data], [batch_label], batch_size - i)
def maxPooling(self, X, kernel_size):
aug = iaa.MaxPooling(kernel_size, keep_size=False)
return aug.augment_images(X)
transformed_image = transform(image=image)
## Edges
elif augmentation == 'canny':
transform = iaa.Canny(alpha=(0.0, 0.9))
transformed_image = transform(image=image)
## Pooling
elif augmentation == 'average_pooling':
transform = iaa.AveragePooling(5)
transformed_image = transform(image=image)
elif augmentation == 'max_pooling':
transform = iaa.MaxPooling(5)
transformed_image = transform(image=image)
elif augmentation == 'min_pooling':
transform = iaa.MinPooling(5)
transformed_image = transform(image=image)
elif augmentation == 'median_pooling':
transform = iaa.MedianPooling(5)
transformed_image = transform(image=image)
## Segmentation
elif augmentation == 'superpixels':
transform = iaa.Superpixels(p_replace=0.5, n_segments=512)
transformed_image = transform(image=image)
def aug1(self, img):
seq = iaa.Sequential([
iaa.MaxPooling(kernel_size=2) #=2 or 3
])
img_au = seq(image=img)
return img_au
