def example_unusual_distributions(): print("Example: Unusual Distributions") from imgaug import augmenters as iaa from imgaug import parameters as iap images = np.random.randint(0, 255, (16, 128, 128, 3), dtype=np.uint8) # Blur by a value sigma which is sampled from a uniform distribution # of range 0.1 <= x < 3.0. # The convenience shortcut for this is: iaa.GaussianBlur((0.1, 3.0)) blurer = iaa.GaussianBlur(iap.Uniform(0.1, 3.0)) images_aug = blurer.augment_images(images) # Blur by a value sigma which is sampled from a normal distribution N(1.0, 0.1), # i.e. sample a value that is usually around 1.0. # Clip the resulting value so that it never gets below 0.1 or above 3.0. blurer = iaa.GaussianBlur(iap.Clip(iap.Normal(1.0, 0.1), 0.1, 3.0)) images_aug = blurer.augment_images(images) # Same again, but this time the mean of the normal distribution is not constant, # but comes itself from a uniform distribution between 0.5 and 1.5. blurer = iaa.GaussianBlur( iap.Clip(iap.Normal(iap.Uniform(0.5, 1.5), 0.1), 0.1, 3.0)) images_aug = blurer.augment_images(images) # Use for sigma one of exactly three allowed values: 0.5, 1.0 or 1.5. blurer = iaa.GaussianBlur(iap.Choice([0.5, 1.0, 1.5])) images_aug = blurer.augment_images(images) # Sample sigma from a discrete uniform distribution of range 1 <= sigma <= 5, # i.e. sigma will have any of the following values: 1, 2, 3, 4, 5. blurer = iaa.GaussianBlur(iap.DiscreteUniform(1, 5)) images_aug = blurer.augment_images(images)
def get_noise_augmenters(augmenter_level): """ Gets an augmenter object of a given level """ # 0 heavy , 1 medium,2 simple if augmenter_level == 0: ####################################################### heavy augmentation ######################################################################### return [ iaa.Sometimes( 0.9, iaa.Crop(percent=((iap.Clip(iap.Normal(0, .5), 0, .6), ) * 4) # random crops top,right,bottom,left )), # some noise iaa.Sometimes(0.9, [ iaa.GaussianBlur(sigma=(0, 0.3)), iaa.Sharpen(alpha=(0.0, .15), lightness=(0.5, 1.5)), iaa.Emboss(alpha=(0.0, 1.0), strength=(0.1, 0.2)) ]), iaa.Sometimes(0.9, iaa.Add((-12, 12), per_channel=1)) ] # rgb jittering elif augmenter_level == 1: ####################################################### medium augmentation ####################################################################### return [ iaa.Sometimes( 0.9, iaa.Crop( percent=((0.0, 0.15), (0.0, 0.15), (0.0, 0.15), (0.0, 0.15)))), # random crops top,right,bottom,left # some noise iaa.Sometimes(0.5, [ iaa.GaussianBlur(sigma=(0, 0.25)), iaa.Sharpen(alpha=(0.0, .1), lightness=(0.5, 1.25)), iaa.Emboss(alpha=(0.0, 1.0), strength=(0.05, 0.1)) ]), iaa.Sometimes(.7, iaa.Add((-10, 10), per_channel=1)) ] # rgb jittering elif augmenter_level == 2: ######################################################## simple augmentation ####################################################################### return [ iaa.Sometimes( 0.6, iaa.Crop( percent=((0.0, 0.1), (0.0, 0.1), (0.0, 0.1), (0.0, 0.1)))), # random crops top,right,bottom,left # some noise iaa.Sometimes(0.35, [ iaa.GaussianBlur(sigma=(0, 0.17)), iaa.Sharpen(alpha=(0.0, .07), lightness=(0.35, 1)), iaa.Emboss(alpha=(0.0, .7), strength=(0.1, 0.7)) ]), iaa.Sometimes(.45, iaa.Add((-7, 7), per_channel=1)) ] # rgb jittering
def example_probability_distributions_as_parameters(): print("Example: Probability Distributions as Parameters") import numpy as np from imgaug import augmenters as iaa from imgaug import parameters as iap images = np.random.randint(0, 255, (16, 128, 128, 3), dtype=np.uint8) # Blur by a value sigma which is sampled from a uniform distribution # of range 10.1 <= x < 13.0. # The convenience shortcut for this is: GaussianBlur((10.1, 13.0)) blurer = iaa.GaussianBlur(10 + iap.Uniform(0.1, 3.0)) images_aug = blurer(images=images) # Blur by a value sigma which is sampled from a gaussian distribution # N(1.0, 0.1), i.e. sample a value that is usually around 1.0. # Clip the resulting value so that it never gets below 0.1 or above 3.0. blurer = iaa.GaussianBlur(iap.Clip(iap.Normal(1.0, 0.1), 0.1, 3.0)) images_aug = blurer(images=images)
def chapter_parameters_special(): ia.seed(1) # ----------------------- # Choice # ----------------------- from imgaug import parameters as iap params = [ iap.Choice([0, 1, 2]), iap.Choice([0, 1, 2], p=[0.15, 0.5, 0.35]), iap.Choice([iap.Normal(-3, 1), iap.Normal(3, 1)]), iap.Choice([iap.Normal(-3, 1), iap.Poisson(3)]) ] gridarr = draw_distributions_grid(params) save("parameters", "special_choice.jpg", gridarr) # ----------------------- # Clip # ----------------------- from imgaug import parameters as iap params = [ iap.Clip(iap.Normal(0, 1), -2, 2), iap.Clip(iap.Normal(0, 1), -2, None) ] gridarr = draw_distributions_grid(params, rows=1) save("parameters", "special_clip.jpg", gridarr) # ----------------------- # Discretize # ----------------------- from imgaug import parameters as iap params = [ iap.Discretize(iap.Normal(0, 1)), iap.Discretize(iap.ChiSquare(3)) ] gridarr = draw_distributions_grid(params, rows=1) save("parameters", "special_discretize.jpg", gridarr) # ----------------------- # Absolute # ----------------------- from imgaug import parameters as iap params = [iap.Absolute(iap.Normal(0, 1)), iap.Absolute(iap.Laplace(0, 1))] gridarr = draw_distributions_grid(params, rows=1) save("parameters", "special_absolute.jpg", gridarr) # ----------------------- # RandomSign # ----------------------- from imgaug import parameters as iap params = [ iap.ChiSquare(3), iap.RandomSign(iap.ChiSquare(3)), iap.RandomSign(iap.ChiSquare(3), p_positive=0.75), iap.RandomSign(iap.ChiSquare(3), p_positive=0.9) ] gridarr = draw_distributions_grid(params) save("parameters", "special_randomsign.jpg", gridarr) # ----------------------- # ForceSign # ----------------------- from imgaug import parameters as iap params = [ iap.ForceSign(iap.Normal(0, 1), positive=True), iap.ChiSquare(3) - 3.0, iap.ForceSign(iap.ChiSquare(3) - 3.0, positive=True, mode="invert"), iap.ForceSign(iap.ChiSquare(3) - 3.0, positive=True, mode="reroll") ] gridarr = draw_distributions_grid(params) save("parameters", "special_forcesign.jpg", gridarr)
def chapter_parameters_arithmetic(): ia.seed(1) # ----------------------- # Add # ----------------------- from imgaug import parameters as iap params = [ iap.Uniform(0, 1) + 1, # identical to: Add(Uniform(0, 1), 1) iap.Add(iap.Uniform(0, 1), iap.Choice([0, 1], p=[0.7, 0.3])), iap.Normal(0, 1) + iap.Uniform(-5.5, -5) + iap.Uniform(5, 5.5), iap.Normal(0, 1) + iap.Uniform(-7, 5) + iap.Poisson(3), iap.Add(iap.Normal(-3, 1), iap.Normal(3, 1)), iap.Add(iap.Normal(-3, 1), iap.Normal(3, 1), elementwise=True) ] gridarr = draw_distributions_grid( params, rows=2, sample_sizes=[ # (iterations, samples per iteration) (1000, 1000), (1000, 1000), (1000, 1000), (1000, 1000), (1, 100000), (1, 100000) ]) save("parameters", "arithmetic_add.jpg", gridarr) # ----------------------- # Multiply # ----------------------- from imgaug import parameters as iap params = [ iap.Uniform(0, 1) * 2, # identical to: Multiply(Uniform(0, 1), 2) iap.Multiply(iap.Uniform(0, 1), iap.Choice([0, 1], p=[0.7, 0.3])), (iap.Normal(0, 1) * iap.Uniform(-5.5, -5)) * iap.Uniform(5, 5.5), (iap.Normal(0, 1) * iap.Uniform(-7, 5)) * iap.Poisson(3), iap.Multiply(iap.Normal(-3, 1), iap.Normal(3, 1)), iap.Multiply(iap.Normal(-3, 1), iap.Normal(3, 1), elementwise=True) ] gridarr = draw_distributions_grid( params, rows=2, sample_sizes=[ # (iterations, samples per iteration) (1000, 1000), (1000, 1000), (1000, 1000), (1000, 1000), (1, 100000), (1, 100000) ]) save("parameters", "arithmetic_multiply.jpg", gridarr) # ----------------------- # Divide # ----------------------- from imgaug import parameters as iap params = [ iap.Uniform(0, 1) / 2, # identical to: Divide(Uniform(0, 1), 2) iap.Divide(iap.Uniform(0, 1), iap.Choice([0, 2], p=[0.7, 0.3])), (iap.Normal(0, 1) / iap.Uniform(-5.5, -5)) / iap.Uniform(5, 5.5), (iap.Normal(0, 1) * iap.Uniform(-7, 5)) / iap.Poisson(3), iap.Divide(iap.Normal(-3, 1), iap.Normal(3, 1)), iap.Divide(iap.Normal(-3, 1), iap.Normal(3, 1), elementwise=True) ] gridarr = draw_distributions_grid( params, rows=2, sample_sizes=[ # (iterations, samples per iteration) (1000, 1000), (1000, 1000), (1000, 1000), (1000, 1000), (1, 100000), (1, 100000) ]) save("parameters", "arithmetic_divide.jpg", gridarr) # ----------------------- # Power # ----------------------- from imgaug import parameters as iap params = [ iap.Uniform(0, 1)**2, # identical to: Power(Uniform(0, 1), 2) iap.Clip(iap.Uniform(-1, 1)**iap.Normal(0, 1), -4, 4) ] gridarr = draw_distributions_grid(params, rows=1) save("parameters", "arithmetic_power.jpg", gridarr)
def _enhance_parameter(level): fparam = _float_parameter(level, 0.9) return iap.Clip( iap.Add(1.0, iap.RandomSign(fparam), elementwise=True), 0.1, 1.9)
def _create_main_augmenters_list(cls, m, cval): # pylint: disable=invalid-name m_max = cls._M_MAX def _float_parameter(level, maxval): maxval_norm = maxval / m_max return iap.Multiply(level, maxval_norm, elementwise=True) def _int_parameter(level, maxval): # paper applies just int(), so we don't round here return iap.Discretize(_float_parameter(level, maxval), round=False) # In the paper's code they use the definition from AutoAugment, # which is 0.1 + M*1.8/10. But that results in 0.1 for M=0, i.e. for # Brightness an almost black image, while M=5 would result in an # unaltered image. For AutoAugment that may be fine, as M is optimized # for each operation individually, but here we have only one fixed M # for all operations. Hence, we rather set this to 1.0 +/- M*0.9/10, # so that M=10 would result in 0.1 or 1.9. def _enhance_parameter(level): fparam = _float_parameter(level, 0.9) return iap.Clip( iap.Add(1.0, iap.RandomSign(fparam), elementwise=True), 0.1, 1.9) def _subtract(a, b): return iap.Subtract(a, b, elementwise=True) def _affine(*args, **kwargs): kwargs["fillcolor"] = cval if "center" not in kwargs: kwargs["center"] = (0.0, 0.0) return pillike.Affine(*args, **kwargs) # we don't add vertical flips here, paper is not really clear about # whether they used them or not return [ meta.Identity(), pillike.Autocontrast(cutoff=0), pillike.Equalize(), arithmetic.Invert(p=1.0), # paper uses 4 - int_parameter(M, 4) pillike.Posterize( nb_bits=_subtract(8, iap.Clip(_int_parameter(m, 6), 0, 6))), # paper uses 256 - int_parameter(M, 256) pillike.Solarize(p=1.0, threshold=iap.Clip( _subtract(256, _int_parameter(m, 256)), 0, 256)), pillike.EnhanceColor(_enhance_parameter(m)), pillike.EnhanceContrast(_enhance_parameter(m)), pillike.EnhanceBrightness(_enhance_parameter(m)), pillike.EnhanceSharpness(_enhance_parameter(m)), # paper code uses 20px on CIFAR (i.e. size 20/32), no information # on ImageNet values so we just use the same values arithmetic.Cutout(1, size=iap.Clip(_float_parameter(m, 20 / 32), 0, 20 / 32), squared=True, fill_mode="constant", cval=cval), pillike.FilterBlur(), pillike.FilterSmooth(), iaa.AdditiveGaussianNoise(scale=(m / 100.) * 255, per_channel=True) ]