import numpy as np
import cv2
from PIL import Image
aug_transform = iaa.SomeOf((0, None), [
iaa.OneOf([
iaa.MultiplyAndAddToBrightness(mul=(0.3, 1.6), add=(-50, 50)),
iaa.MultiplyHueAndSaturation((0.5, 1.5), per_channel=True),
iaa.ChannelShuffle(0.5),
iaa.RemoveSaturation(),
iaa.Grayscale(alpha=(0.0, 1.0)),
iaa.ChangeColorTemperature((1100, 35000)),
]),
iaa.OneOf([
iaa.MedianBlur(k=(3, 7)),
iaa.BilateralBlur(
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])),
def data_aug(images):
seq = iaa.Sometimes(
0.5, iaa.Identity(),
iaa.Sometimes(
0.5,
iaa.Sequential([
iaa.Fliplr(0.5),
iaa.Sometimes(
0.5,
iaa.OneOf([
iaa.Add((-40, 40)),
iaa.AddElementwise((-40, 40)),
iaa.AdditiveGaussianNoise(scale=(0, 0.2 * 255)),
iaa.AdditiveLaplaceNoise(scale=(0, 0.2 * 255)),
iaa.AdditivePoissonNoise((0, 40)),
iaa.MultiplyElementwise((0.5, 1.5)),
iaa.ReplaceElementwise(0.1, [0, 255]),
iaa.SaltAndPepper(0.1)
])),
iaa.OneOf([
iaa.Cutout(nb_iterations=2,
size=0.15,
cval=0,
squared=False),
iaa.CoarseDropout((0.0, 0.05), size_percent=(0.02, 0.25)),
iaa.Dropout(p=(0, 0.2)),
iaa.CoarseSaltAndPepper(0.05, size_percent=(0.01, 0.1)),
iaa.Cartoon(),
iaa.BlendAlphaVerticalLinearGradient(iaa.TotalDropout(1.0),
min_value=0.2,
max_value=0.8),
iaa.GaussianBlur(sigma=(0.0, 3.0)),
iaa.AverageBlur(k=(2, 11)),
iaa.MedianBlur(k=(3, 11)),
iaa.BilateralBlur(d=(3, 10),
sigma_color=(10, 250),
sigma_space=(10, 250)),
iaa.MotionBlur(k=20),
iaa.AllChannelsCLAHE(),
iaa.Sharpen(alpha=(0.0, 1.0), lightness=(0.75, 2.0)),
iaa.Emboss(alpha=(0.0, 1.0), strength=(0.5, 1.5)),
iaa.Affine(scale=(0.5, 1.5)),
iaa.Affine(translate_px={
"x": (-20, 20),
"y": (-20, 20)
}),
iaa.Affine(shear=(-16, 16)),
iaa.pillike.EnhanceSharpness()
]),
iaa.OneOf([
iaa.GammaContrast((0.5, 2.0)),
iaa.SigmoidContrast(gain=(3, 10), cutoff=(0.4, 0.6)),
iaa.LogContrast(gain=(0.6, 1.4)),
iaa.LinearContrast((0.4, 1.6)),
iaa.pillike.EnhanceBrightness()
])
]),
iaa.Sometimes(0.5, iaa.RandAugment(n=2, m=9),
iaa.RandAugment(n=(0, 3), m=(0, 9)))))
images = seq(images=images)
return images
def test_dtype_preservation():
reseed()
size = (4, 16, 16, 3)
images = [
np.random.uniform(0, 255, size).astype(np.uint8),
np.random.uniform(0, 65535, size).astype(np.uint16),
np.random.uniform(0, 4294967295, size).astype(np.uint32),
np.random.uniform(-128, 127, size).astype(np.int16),
np.random.uniform(-32768, 32767, size).astype(np.int32),
np.random.uniform(0.0, 1.0, size).astype(np.float32),
np.random.uniform(-1000.0, 1000.0, size).astype(np.float16),
np.random.uniform(-1000.0, 1000.0, size).astype(np.float32),
np.random.uniform(-1000.0, 1000.0, size).astype(np.float64)
]
default_dtypes = set([arr.dtype for arr in images])
# Some dtypes are here removed per augmenter, because the respective
# augmenter does not support them. This test currently only checks whether
# dtypes are preserved from in- to output for all dtypes that are supported
# per augmenter.
# dtypes are here removed via list comprehension instead of
# `default_dtypes - set([dtype])`, because the latter one simply never
# removed the dtype(s) for some reason
def _not_dts(dts):
return [dt for dt in default_dtypes if dt not in dts]
augs = [
(iaa.Add((-5, 5),
name="Add"), _not_dts([np.uint32, np.int32, np.float64])),
(iaa.AddElementwise((-5, 5), name="AddElementwise"),
_not_dts([np.uint32, np.int32, np.float64])),
(iaa.AdditiveGaussianNoise(0.01 * 255, name="AdditiveGaussianNoise"),
_not_dts([np.uint32, np.int32, np.float64])),
(iaa.Multiply((0.95, 1.05), name="Multiply"),
_not_dts([np.uint32, np.int32, np.float64])),
(iaa.Dropout(0.01, name="Dropout"),
_not_dts([np.uint32, np.int32, np.float64])),
(iaa.CoarseDropout(0.01, size_px=6, name="CoarseDropout"),
_not_dts([np.uint32, np.int32, np.float64])),
(iaa.Invert(0.01, per_channel=True, name="Invert"), default_dtypes),
(iaa.GaussianBlur(sigma=(0.95, 1.05),
name="GaussianBlur"), _not_dts([np.float16])),
(iaa.AverageBlur((3, 5), name="AverageBlur"),
_not_dts([np.uint32, np.int32, np.float16])),
(iaa.MedianBlur((3, 5), name="MedianBlur"),
_not_dts([np.uint32, np.int32, np.float16, np.float64])),
(iaa.BilateralBlur((3, 5), name="BilateralBlur"),
_not_dts([
np.uint16, np.uint32, np.int16, np.int32, np.float16, np.float64
])),
(iaa.Sharpen((0.0, 0.1), lightness=(1.0, 1.2), name="Sharpen"),
_not_dts([np.uint32, np.int32, np.float16, np.uint32])),
(iaa.Emboss(alpha=(0.0, 0.1), strength=(0.5, 1.5), name="Emboss"),
_not_dts([np.uint32, np.int32, np.float16, np.uint32])),
(iaa.EdgeDetect(alpha=(0.0, 0.1), name="EdgeDetect"),
_not_dts([np.uint32, np.int32, np.float16, np.uint32])),
(iaa.DirectedEdgeDetect(alpha=(0.0, 0.1),
direction=0,
name="DirectedEdgeDetect"),
_not_dts([np.uint32, np.int32, np.float16, np.uint32])),
(iaa.Fliplr(0.5, name="Fliplr"), default_dtypes),
(iaa.Flipud(0.5, name="Flipud"), default_dtypes),
(iaa.Affine(translate_px=(-5, 5), name="Affine-translate-px"),
_not_dts([np.uint32, np.int32])),
(iaa.Affine(translate_percent=(-0.05, 0.05),
name="Affine-translate-percent"),
_not_dts([np.uint32, np.int32])),
(iaa.Affine(rotate=(-20, 20),
name="Affine-rotate"), _not_dts([np.uint32, np.int32])),
(iaa.Affine(shear=(-20, 20),
name="Affine-shear"), _not_dts([np.uint32, np.int32])),
(iaa.Affine(scale=(0.9, 1.1),
name="Affine-scale"), _not_dts([np.uint32, np.int32])),
(iaa.PiecewiseAffine(scale=(0.001, 0.005),
name="PiecewiseAffine"), default_dtypes),
(iaa.ElasticTransformation(alpha=(0.1, 0.2),
sigma=(0.1, 0.2),
name="ElasticTransformation"),
_not_dts([np.float16])),
(iaa.Sequential([iaa.Identity(), iaa.Identity()],
name="SequentialNoop"), default_dtypes),
(iaa.SomeOf(1, [iaa.Identity(), iaa.Identity()],
name="SomeOfNoop"), default_dtypes),
(iaa.OneOf([iaa.Identity(), iaa.Identity()],
name="OneOfNoop"), default_dtypes),
(iaa.Sometimes(0.5, iaa.Identity(),
name="SometimesNoop"), default_dtypes),
(iaa.Sequential([iaa.Add(
(-5, 5)), iaa.AddElementwise((-5, 5))],
name="Sequential"),
_not_dts([np.uint32, np.int32, np.float64])),
(iaa.SomeOf(1, [iaa.Add(
(-5, 5)), iaa.AddElementwise((-5, 5))],
name="SomeOf"), _not_dts([np.uint32, np.int32,
np.float64])),
(iaa.OneOf([iaa.Add(
(-5, 5)), iaa.AddElementwise((-5, 5))],
name="OneOf"), _not_dts([np.uint32, np.int32, np.float64])),
(iaa.Sometimes(0.5, iaa.Add((-5, 5)), name="Sometimes"),
_not_dts([np.uint32, np.int32, np.float64])),
(iaa.Identity(name="Identity"), default_dtypes),
(iaa.Alpha((0.0, 0.1), iaa.Identity(),
name="AlphaIdentity"), default_dtypes),
(iaa.AlphaElementwise(
(0.0, 0.1), iaa.Identity(),
name="AlphaElementwiseIdentity"), default_dtypes),
(iaa.SimplexNoiseAlpha(iaa.Identity(),
name="SimplexNoiseAlphaIdentity"),
default_dtypes),
(iaa.FrequencyNoiseAlpha(exponent=(-2, 2),
first=iaa.Identity(),
name="SimplexNoiseAlphaIdentity"),
default_dtypes),
(iaa.Alpha((0.0, 0.1), iaa.Add(10),
name="Alpha"), _not_dts([np.uint32, np.int32, np.float64])),
(iaa.AlphaElementwise((0.0, 0.1), iaa.Add(10),
name="AlphaElementwise"),
_not_dts([np.uint32, np.int32, np.float64])),
(iaa.SimplexNoiseAlpha(iaa.Add(10), name="SimplexNoiseAlpha"),
_not_dts([np.uint32, np.int32, np.float64])),
(iaa.FrequencyNoiseAlpha(exponent=(-2, 2),
first=iaa.Add(10),
name="SimplexNoiseAlpha"),
_not_dts([np.uint32, np.int32, np.float64])),
(iaa.Superpixels(p_replace=0.01, n_segments=64),
_not_dts([np.float16, np.float32, np.float64])),
(iaa.Resize({
"height": 4,
"width": 4
}, name="Resize"),
_not_dts([
np.uint16, np.uint32, np.int16, np.int32, np.float32, np.float16,
np.float64
])),
(iaa.CropAndPad(px=(-10, 10), name="CropAndPad"),
_not_dts([
np.uint16, np.uint32, np.int16, np.int32, np.float32, np.float16,
np.float64
])),
(iaa.Pad(px=(0, 10), name="Pad"),
_not_dts([
np.uint16, np.uint32, np.int16, np.int32, np.float32, np.float16,
np.float64
])),
(iaa.Crop(px=(0, 10), name="Crop"),
_not_dts([
np.uint16, np.uint32, np.int16, np.int32, np.float32, np.float16,
np.float64
]))
]
for (aug, allowed_dtypes) in augs:
for images_i in images:
if images_i.dtype in allowed_dtypes:
images_aug = aug.augment_images(images_i)
assert images_aug.dtype == images_i.dtype
# Adds coarse pepper noise to image, i.e. rectangles that contain noisy black-ish pixels
# Replaces percent of all pixels with salt in an image that has lo to hi percent of the input image size,
# then upscales the results to the input image size, leading to large rectangular areas being replaced.
"Coarse_Pepper": lambda percent, lo, hi: iaa.CoarsePepper(percent, size_percent=(lo, hi)),
# In an alpha blending, two images are naively mixed. E.g. Let A be the foreground image, B be the background
# image and a is the alpha value. Each pixel intensity is then computed as a * A_ij + (1-a) * B_ij.
# Images passed in must be a numpy array of type (height, width, channel)
"Blend_Alpha": lambda image_fg, image_bg, alpha: iaa.blend_alpha(image_fg, image_bg, alpha),
# Blur/Denoise an image using a bilateral filter.
# Bilateral filters blur homogeneous and textured areas, while trying to preserve edges.
# Blurs all images using a bilateral filter with max distance d_lo to d_hi with ranges for sigma_colour
# and sigma space being define by sc_lo/sc_hi and ss_lo/ss_hi
"Bilateral_Blur": lambda d_lo, d_hi, sc_lo, sc_hi, ss_lo, ss_hi:
iaa.BilateralBlur(d=(d_lo, d_hi), sigma_color=(sc_lo, sc_hi), sigma_space=(ss_lo, ss_hi)),
# Augmenter that sharpens images and overlays the result with the original image.
# Create a motion blur augmenter with kernel size of (kernel x kernel) and a blur angle of either x or y degrees
# (randomly picked per image).
"Motion_Blur": lambda kernel, x, y: iaa.MotionBlur(k=kernel, angle=[x, y]),
# Augmenter to apply standard histogram equalization to images (similar to CLAHE)
"Histogram_Equalization": iaa.HistogramEqualization(),
# Augmenter to perform standard histogram equalization on images, applied to all channels of each input image
"All_Channels_Histogram_Equalization": iaa.AllChannelsHistogramEqualization(),
# Contrast Limited Adaptive Histogram Equalization (CLAHE). This augmenter applies CLAHE to images, a form of
# histogram equalization that normalizes within local image patches.
# Creates a CLAHE augmenter with clip limit uniformly sampled from [cl_lo..cl_hi], i.e. 1 is rather low contrast
def black_and_white_aug():
alpha_seconds = iaa.OneOf([
iaa.Affine(rotate=(-3, 3)),
iaa.Affine(translate_percent={
"x": (0.95, 1.05),
"y": (0.95, 1.05)
}),
iaa.Affine(scale={
"x": (0.95, 1.05),
"y": (0.95, 1.05)
}),
iaa.Affine(shear=(-2, 2)),
iaa.CoarseDropout(p=0.1, size_percent=(0.08, 0.02)),
])
first_set = iaa.OneOf([
iaa.Multiply(iap.Choice([0.5, 1.5]), per_channel=True),
iaa.EdgeDetect((0.1, 1)),
])
second_set = iaa.OneOf([
iaa.AddToHueAndSaturation((-40, 40)),
iaa.ContrastNormalization((0.5, 2.0), per_channel=True)
])
color_aug = iaa.Sequential(
[
# Original Image Domain ==================================================
# Geometric Rigid
iaa.Fliplr(0.5),
iaa.OneOf([
iaa.Noop(),
iaa.Affine(rotate=90),
iaa.Affine(rotate=180),
iaa.Affine(rotate=270),
]),
iaa.OneOf([
iaa.Noop(),
iaa.Crop(percent=(0, 0.1)), # Random Crops
iaa.PerspectiveTransform(scale=(0.05, 0.15)),
]),
# Affine
sometimes(
iaa.PiecewiseAffine(
scale=(0.01, 0.07), nb_rows=(3, 6), nb_cols=(3, 6))),
fewtimes(
iaa.Affine(scale={
"x": (0.8, 1.2),
"y": (0.8, 1.2)
},
translate_percent={
"x": (-0.2, 0.2),
"y": (-0.2, 0.2)
},
rotate=(-45, 45),
shear=(-16, 16),
order=[0, 1],
cval=0)),
# Transformations outside Image domain ==============================================
# COLOR, CONTRAST, HUE
iaa.Invert(0.5, name='Invert'),
fewtimes(iaa.Add((-10, 10), per_channel=0.5, name='Add')),
fewtimes(
iaa.AddToHueAndSaturation(
(-40, 40), per_channel=0.5, name='AddToHueAndSaturation')),
# Intensity / contrast
fewtimes(
iaa.ContrastNormalization(
(0.8, 1.1), name='ContrastNormalization')),
# Add to hue and saturation
fewtimes(
iaa.Multiply(
(0.5, 1.5), per_channel=0.5, name='HueAndSaturation')),
# Noise ===========================================================================
fewtimes(
iaa.AdditiveGaussianNoise(loc=0,
scale=(0.0, 0.15 * 255),
per_channel=0.5,
name='AdditiveGaussianNoise')),
fewtimes(
iaa.Alpha(factor=(0.5, 1),
first=iaa.ContrastNormalization(
(0.5, 2.0), per_channel=True),
second=alpha_seconds,
per_channel=0.5,
name='AlphaNoise'), ),
fewtimes(
iaa.SimplexNoiseAlpha(first=first_set,
second=second_set,
per_channel=0.5,
aggregation_method="max",
sigmoid=False,
upscale_method='cubic',
size_px_max=(2, 12),
name='SimplexNoiseAlpha'), ),
fewtimes(
iaa.FrequencyNoiseAlpha(first=first_set,
second=second_set,
per_channel=0.5,
aggregation_method="max",
sigmoid=False,
upscale_method='cubic',
size_px_max=(2, 12),
name='FrequencyNoiseAlpha'), ),
# Blur
fewtimes(
iaa.OneOf([
iaa.GaussianBlur((0, 3.0)),
iaa.AverageBlur(k=(2, 7)),
iaa.MedianBlur(k=(3, 11)),
iaa.BilateralBlur(d=(3, 10),
sigma_color=(10, 250),
sigma_space=(10, 250))
],
name='Blur')),
# Regularization ======================================================================
unlikely(
iaa.OneOf([
iaa.Dropout((0.01, 0.1), per_channel=0.5, name='Dropout'),
iaa.CoarseDropout((0.03, 0.15),
size_percent=(0.02, 0.05),
per_channel=0.5,
name='CoarseDropout'),
], )),
],
random_order=True)
seq = iaa.Sequential(
[
iaa.Sequential(
[
# Texture
rarely(
iaa.Superpixels(p_replace=(0.3, 1.0),
n_segments=(500, 1000),
name='Superpixels')),
rarely(
iaa.Sharpen(alpha=(0, 0.5),
lightness=(0.75, 1.0),
name='Sharpen')),
rarely(
iaa.Emboss(
alpha=(0, 1.0), strength=(0, 1.0), name='Emboss')),
rarely(
iaa.OneOf([
iaa.EdgeDetect(alpha=(0, 0.5)),
iaa.DirectedEdgeDetect(alpha=(0, 0.5),
direction=(0.0, 1.0)),
],
name='EdgeDetect')),
rarely(
iaa.ElasticTransformation(
alpha=(0.5, 3.5),
sigma=0.25,
name='ElasticTransformation')),
],
random_order=True),
color_aug,
iaa.Grayscale(alpha=1.0, name='Grayscale')
],
random_order=False)
def activator_masks(images, augmenter, parents, default):
if 'Unnamed' not in augmenter.name:
return False
else:
return default
hooks_masks = ia.HooksImages(activator=activator_masks)
return seq, hooks_masks
def __init__(self):
self.seq = iaa.Sequential(
[
iaa.Fliplr(0.5),
iaa.Sometimes(0.5, iaa.Crop(percent=(0, 0.1))),
iaa.Sometimes(0.5, iaa.Affine(
rotate=(-20, 20), # 旋转±20度
# shear=(-16, 16), # 剪切变换±16度，矩形变平行四边形
# order=[0, 1], # 使用最近邻插值 或 双线性插值
cval=0, # 填充值
mode=ia.ALL # 定义填充图像外区域的方法
)),
# 使用0~3个方法进行图像增强
iaa.SomeOf((0, 3),
[
iaa.Sometimes(0.8, iaa.OneOf([
iaa.GaussianBlur((0, 2.0)), # 高斯模糊
iaa.AverageBlur(k=(1, 5)), # 平均模糊，磨砂
])),
# 要么运动，要么美颜
iaa.Sometimes(0.8, iaa.OneOf([
iaa.MotionBlur(k=(3, 11)), # 运动模糊
iaa.BilateralBlur(d=(1, 5),
sigma_color=(10, 250),
sigma_space=(10, 250)), # 双边滤波，美颜
])),
# 模仿雪花
iaa.Sometimes(0.8, iaa.OneOf([
iaa.SaltAndPepper(p=(0., 0.03)),
iaa.AdditiveGaussianNoise(loc=0, scale=(0., 0.05 * 255), per_channel=False)
])),
# 对比度
iaa.Sometimes(0.8, iaa.LinearContrast((0.6, 1.4), per_channel=0.5)),
# 锐化
iaa.Sometimes(0.8, iaa.Sharpen(alpha=(0, 1.0), lightness=(0.75, 1.5))),
# 整体亮度
iaa.Sometimes(0.8, iaa.OneOf([
# 加性调整
iaa.AddToBrightness((-30, 30)),
# 线性调整
iaa.MultiplyBrightness((0.5, 1.5)),
# 加性 & 线性
iaa.MultiplyAndAddToBrightness(mul=(0.5, 1.5), add=(-30, 30)),
])),
# 饱和度
iaa.Sometimes(0.8, iaa.OneOf([
iaa.AddToSaturation((-75, 75)),
iaa.MultiplySaturation((0., 3.)),
])),
# 色相
iaa.Sometimes(0.8, iaa.OneOf([
iaa.AddToHue((-255, 255)),
iaa.MultiplyHue((-3.0, 3.0)),
])),
# 云雾
# iaa.Sometimes(0.3, iaa.Clouds()),
# 卡通化
# iaa.Sometimes(0.01, iaa.Cartoon()),
],
random_order=True
)
],
random_order=True
)
def __init__(self,list_file,train,transform, device, little_train=False, with_file_path=False, with_mask=False, S=7, B = 2, C = 20, test_mode=False):
print('data init')
self.train = train
self.transform=transform
self.fnames = []
self.boxes = []
self.labels = []
self.resize = 448
self.with_mask = with_mask
self.S = S
self.B = B
self.C = C
self.device = device
self._test = test_mode
self.with_file_path = with_file_path
self.img_augsometimes = lambda aug: iaa.Sometimes(0.25, aug)
self.bbox_augsometimes = lambda aug: iaa.Sometimes(0.5, aug)
self.augmentation = iaa.Sequential(
[
# augment without change bboxes
self.img_augsometimes(
iaa.SomeOf((1, 3), [
iaa.Dropout([0.05, 0.2]), # drop 5% or 20% of all pixels
iaa.Sharpen((0.1, .8)), # sharpen the image
# iaa.GaussianBlur(sigma=(2., 3.5)),
iaa.OneOf([
iaa.GaussianBlur(sigma=(2., 3.5)),
iaa.AverageBlur(k=(2, 5)),
iaa.BilateralBlur(d=(7, 12), sigma_color=(10, 250), sigma_space=(10, 250)),
iaa.MedianBlur(k=(3, 7)),
]),
iaa.AddElementwise((-50, 50)),
iaa.AdditiveGaussianNoise(scale=(0, 0.1 * 255)),
iaa.JpegCompression(compression=(80, 95)),
iaa.Multiply((0.5, 1.5)),
iaa.MultiplyElementwise((0.5, 1.5)),
iaa.ReplaceElementwise(0.05, [0, 255]),
# iaa.WithColorspace(to_colorspace="HSV", from_colorspace="RGB",
# children=iaa.WithChannels(2, iaa.Add((-10, 50)))),
iaa.OneOf([
iaa.WithColorspace(to_colorspace="HSV", from_colorspace="RGB",
children=iaa.WithChannels(1, iaa.Add((-10, 50)))),
iaa.WithColorspace(to_colorspace="HSV", from_colorspace="RGB",
children=iaa.WithChannels(2, iaa.Add((-10, 50)))),
]),
], random_order=True)
),
# iaa.Fliplr(.5),
# iaa.Flipud(.125),
# # augment changing bboxes
# self.bbox_augsometimes(
# iaa.Affine(
# # translate_px={"x": 40, "y": 60},
# scale={"x": (0.8, 1.2), "y": (0.8, 1.2)},
# translate_percent={"x": (-0.1, 0.1), "y": (-0.1, 0.1)},
# rotate=(-5, 5),
# )
# )
],
random_order=True
)
# torch.manual_seed(23)
with open(list_file) as f:
lines = f.readlines()
if little_train:
lines = lines[:64*8]
for line in lines:
splited = line.strip().split()
self.fnames.append(splited[0])
self.num_samples = len(self.fnames)
pos_risk = pos_risk / len(input)
return {'loss': loss, 'neg_risk': neg_risk, 'pos_risk': pos_risk}
if __name__ == "__main__":
from ksptrack.pu.set_explorer import SetExplorer
from torch.utils.data import DataLoader
from imgaug import augmenters as iaa
from ksptrack.pu.utils import df_to_tgt
import matplotlib.pyplot as plt
transf = iaa.Sequential([
iaa.OneOf([
iaa.BilateralBlur(d=8,
sigma_color=(100, 150),
sigma_space=(100, 150)),
iaa.AdditiveGaussianNoise(scale=(0, 0.06 * 255)),
iaa.GammaContrast((1., 2.))
])
# iaa.Flipud(p=0.5),
# iaa.Fliplr(p=.5),
# iaa.Rot90((1, 3))
])
dl = SetExplorer('/home/ubelix/lejeune/data/medical-labeling/Dataset00',
augmentations=transf,
normalization='rescale',
resize_shape=512)
criterion = PULoss(pxls=True)
dl = DataLoader(dl, collate_fn=dl.collate_fn)
transformed_image = transform(image=image)['image']
elif augmentation == 'median_blur':
transform = MedianBlur(always_apply=True, blur_limit=(18, 25))
transformed_image = transform(image=image)['image']
elif augmentation == 'motion_blur':
transform = iaa.MotionBlur(k=15)
transformed_image = transform(image=image)
elif augmentation == 'average_blur':
transform = iaa.AverageBlur(k=(2, 11))
transformed_image = transform(image=image)
elif augmentation == 'bilateral_blur':
transform = iaa.BilateralBlur(d=(3, 10), sigma_color=(250),
sigma_space=(250))
transformed_image = transform(image=image)
elif augmentation == 'mean_shift_blur':
transform = iaa.MeanShiftBlur()
transformed_image = transform(image=image)
elif augmentation == 'glass_blur':
transform = GlassBlur(always_apply=True)
transformed_image = transform(image=image)['image']
elif augmentation == 'defocus_blur':
transform = iaa.imgcorruptlike.DefocusBlur(severity=2)
transformed_image = transform(image=image)
elif augmentation == 'zoom_blur':
def det_aug(image, polys_np=None):
"""
随机对图像做以下的增强操作
:param image: cv2 read
:param polys_np:[N, 4, 2]
:return:
"""
aug_sample = random.sample(cfg.TRAIN.AUG_TOOL, 1)[0] #从数组中随机取出一个增强的功能
rotate_sample = random.choice([0, 1])
######################################################################################################
# blur-模糊
aug = None
# 高斯滤波 sigma 为1-10的保留小数点后一位的float的随机值,可根据情况调整
if aug_sample == 'GaussianBlur':
sigma = random.uniform(1, 2)
sigma = round(sigma, 10)
aug = iaa.GaussianBlur(sigma)
# 平均模糊 k 为1-10的随机 奇 数,范围根据情况调整
if aug_sample == 'AverageBlur':
k = random.randint(8, 10) * 2 + 1
aug = iaa.AverageBlur(k)
# 中值滤波 k 为1-10的随机 奇 数,范围根据情况调整
if aug_sample == 'MedianBlur':
k = random.randint(8, 10) * 2 + 1
aug = iaa.MedianBlur(k)
# 双边滤波 d=1 为 奇 数, sigma_color=(10, 250), sigma_space=(10, 250)
if aug_sample == 'BilateralBlur':
d = random.randint(0, 2) * 2 + 1
sigma_color = random.randint(10, 250)
sigma_space = random.randint(10, 250)
aug = iaa.BilateralBlur(d, sigma_color, sigma_space)
# 运动模糊 k=5 一定大于3 的 奇 数, angle=(0, 360), direction=(-1.0, 1.0)
if aug_sample == 'MotionBlur':
k = random.randint(15, 20) * 2 + 1
angle = random.randint(0, 360)
direction = random.uniform(-1, 1)
direction = round(direction, 1)
aug = iaa.MotionBlur(k, angle, direction)
######################################################################################################
# geometric 几何学
# 弹性变换
if aug_sample == 'ElasticTransformation':
alpha = random.uniform(10, 20)
alpha = round(alpha, 1)
sigma = random.uniform(5, 10)
sigma = round(sigma, 1)
# print(alpha, sigma)
aug = iaa.ElasticTransformation(alpha, sigma)
# 透视
if aug_sample == 'PerspectiveTransform':
scale = random.uniform(0, 0.15)
scale = round(scale, 3)
aug = iaa.PerspectiveTransform(scale)
# 旋转角度
if aug_sample == 'Affine_rot':
rotate = random.randint(-180, 180)
while rotate == 0:
rotate = random.randint(-180, 180)
if rotate_sample == 0:
aug = iaa.Affine(rotate=rotate, fit_output=True)
else:
aug = iaa.Affine(rotate=rotate)
if aug_sample == 'Affine_scale':
scale = random.uniform(0, 2)
scale = round(scale, 1)
while scale == 0 or scale <= 0.3:
scale = random.uniform(0, 2)
scale = round(scale, 1)
if rotate_sample == 0:
aug = iaa.Affine(scale=scale, fit_output=True)
else:
aug = iaa.Affine(scale=scale)
######################################################################################################
# flip 镜像
# 水平镜像
if aug_sample == 'Fliplr':
aug = iaa.Fliplr(1)
#
# 垂直镜像
if aug_sample == 'Flipud':
aug = iaa.Flipud(1)
######################################################################################################
# size 尺寸
# if aug_sample == 'CropAndPad':
# top = random.randint(0, 10)
# right = random.randint(0, 10)
# bottom = random.randint(0, 10)
# left = random.randint(0, 10)
# aug = iaa.CropAndPad(px=(top, right, bottom, left)) # 上 右 下 左 各crop多少像素,然后进行padding
if aug_sample == 'Crop':
top = random.randint(0, 10)
right = random.randint(0, 10)
bottom = random.randint(0, 10)
left = random.randint(0, 10)
aug = iaa.Crop(px=(top, right, bottom, left)) # 上 右 下 左
if aug_sample == 'Pad':
top = random.randint(0, 10)
right = random.randint(0, 10)
bottom = random.randint(0, 10)
left = random.randint(0, 10)
aug = iaa.Pad(px=(top, right, bottom, left)) # 上 右 下 左
# if aug_sample == 'PadToFixedSize':
# height = image.shape[0] + 32
# width = image.shape[1] + 100
# aug = iaa.PadToFixedSize(width=width, height=height)z
# if aug_sample == 'CropToFixedSize':
# height = image.shape[0] - 32
# width = image.shape[1] - 100
# aug = iaa.CropToFixedSize(width=width, height=height)
if polys_np is not None:
if aug is not None:
# print(aug_sample)
h, w, _ = image.shape
boxes_info_list = []
for box in polys_np:
boxes_info_list.append(Polygon(box))
psoi = ia.PolygonsOnImage(boxes_info_list,
shape=image.shape) # 生成单个图像上所有多边形的对象
image, psoi_aug = aug(image=image, polygons=psoi)
pts_list = []
for each_poly in psoi_aug.polygons:
pts_list.append(np.array(each_poly.exterior).reshape((4, 2)))
return image, np.array(pts_list, np.float32).reshape((-1, 4, 2))
else:
return image, polys_np
else:
if aug is not None:
image = aug(image=image)
else:
image = image
return image
'addPN': iaa.AdditivePoissonNoise(lam=16.00),
'addPNp': iaa.AdditivePoissonNoise(lam=16.00, per_channel=True),
'mul-': iaa.Multiply(mul=0.50),
'mul+': iaa.Multiply(mul=1.50),
'mulp-': iaa.Multiply(mul=0.50, per_channel=True),
'mulp+': iaa.Multiply(mul=1.50, per_channel=True),
'jpeg': iaa.JpegCompression(compression=62),
'jpeg+': iaa.JpegCompression(compression=75),
'jpeg++': iaa.JpegCompression(compression=87)
}
blur = {
'GBlur': iaa.GaussianBlur(sigma=1.00),
'ABlur': iaa.AverageBlur(k=3),
'MBlur': iaa.MedianBlur(k=3),
'BBlur': iaa.BilateralBlur(sigma_color=250, sigma_space=250, d=5),
'MoBlur': iaa.MotionBlur(angle=0, k=7),
'MoBlurAng': iaa.MotionBlur(angle=144, k=5)
}
color = {
'ATHAS-': iaa.AddToHueAndSaturation(value=-45),
'ATHAS+': iaa.AddToHueAndSaturation(value=45),
'Gray': iaa.Grayscale(alpha=0.2)
}
contrast = {
'GContrast-': iaa.GammaContrast(gamma=0.81),
'GContrast+': iaa.GammaContrast(gamma=1.44),
'SContrast': iaa.SigmoidContrast(cutoff=0.5, gain=10),
'LContrast': iaa.LogContrast(gain=0.88),
def __init__(self, image):
self.img = image
# 随机通道处理,加减100以内
# self.aug_WithChannels = iaa.WithChannels((0,2), iaa.Add((-100, 100)))
# 随机裁剪和填充，percent为裁剪与填充比例，负数为放大后裁剪，正数为缩小和填充，pad_mode为填充方式，pad_cval为当空白填充时，填充像素值
self.aug_CropAndPad = iaa.CropAndPad(percent=(-0.05, 0.1),
pad_mode=ia.ALL,
pad_cval=(0, 255))
# 随机水平翻转,参数为概率
self.aug_Fliplr = iaa.Fliplr(0.5)
# 随机垂直翻转,参数为概率
self.aug_Flipud = iaa.Flipud(0.5)
# 超像素表示,p_replace被超像素代替的百分比,n_segments分割块数
self.aug_Superpixels = iaa.Superpixels(p_replace=(0, 1.0),
n_segments=(20, 200))
# 灰度化 (0.0,1.0),前者为偏彩色部分，后者为偏灰度部分，随机灰度化
self.aug_GrayScale = iaa.Grayscale(alpha=(0.0, 0.6))
# 高斯模糊
self.aug_GaussianBlur = iaa.GaussianBlur(sigma=(0, 3.0))
# 均值模糊，k为kernel size
self.aug_AverageBlur = iaa.AverageBlur(k=(2, 7))
# 中值模糊, k为kernel size
self.aug_MedianBlur = iaa.MedianBlur(k=(3, 11))
# 双边滤波,d为kernel size,sigma_color为颜色域标准差,sigma_space为空间域标准差
self.aug_BilateralBlur = iaa.BilateralBlur(sigma_color=(0, 250),
sigma_space=(0, 250),
d=(3, 7))
# 锐化
self.aug_Sharpen = iaa.Sharpen(alpha=(0.0, 1.0), lightness=(0.75, 2.0))
# 浮雕效果
self.aug_Emboss = iaa.Emboss(alpha=(0.0, 1.0), strength=(0.0, 1.5))
# 边缘检测
self.aug_EdgeDetect = iaa.EdgeDetect(alpha=(0.0, 1.0))
# 方向性边缘检测
self.aug_DirectedEdgeDetece = iaa.DirectedEdgeDetect(alpha=(0.0, 1.0),
direction=(0.0,
1.0))
# 暴力叠加像素值,每个像素统一加一个值
self.aug_Add = iaa.Add((-40, 40))
# 暴力叠加像素值，每个像素加不同的值
self.aug_AddElementwise = iaa.AddElementwise((-40, 40))
# 随机高斯加性噪声
self.aug_AdditiveGaussianNoise = iaa.AdditiveGaussianNoise(scale=(0.0,
0.1 *
255))
# 暴力乘法,每个像素统一乘以一个值
self.aug_Multiply = iaa.Multiply((0.8, 1.2))
# 暴力乘法,每个像素乘以不同值
self.aug_MultiplyElementwise = iaa.MultiplyElementwise((0.8, 1.2))
# 随机dropout像素值
self.aug_Dropout = iaa.Dropout(p=(0, 0.2))
# 随机粗dropout,2*2方块像素被dropout
self.aug_CoarseDropout = iaa.CoarseDropout(0.02, size_percent=0.5)
# 50%的图片,p概率反转颜色
self.aug_Invert = iaa.Invert(0.25, per_channel=0.5)
# 对比度归一化
self.aug_ContrastNormalization = iaa.ContrastNormalization((0.5, 1.5))
# 仿射变换
self.aug_Affine = iaa.Affine(rotate=(0, 20),
scale={
"x": (0.8, 1.2),
"y": (0.8, 1.2)
})
# 仿射变换, 局部像素仿射扭曲
self.aug_PiecewiseAffine = iaa.PiecewiseAffine(scale=(0.01, 0.05))
# 单应性变换
self.aug_PerspectiveTransform = iaa.PerspectiveTransform(scale=(0.01,
0.1))
# 弹性变换
self.aug_ElasticTransformation = iaa.ElasticTransformation(alpha=(0,
5.0),
sigma=0.25)
# 简单的加噪,小黑块
self.aug_SimplexNoiseAlpha = iaa.SimplexNoiseAlpha(
iaa.OneOf([
iaa.EdgeDetect(alpha=(0.0, 0.5)),
iaa.DirectedEdgeDetect(alpha=(0.0, 0.5), direction=(0.0, 1.0)),
]))
# 频域加噪，表现为色彩的块状变换
self.aug_FrequencyNoiseAlpha = iaa.FrequencyNoiseAlpha(
exponent=(-4, 0),
first=iaa.Multiply((0.5, 1.5), per_channel=True),
second=iaa.ContrastNormalization((0.5, 2.0)))
def do_random(image, pos_list):
# 1.先任选5种影响位置的效果之一做位置变换
seq = iaa.Sequential([
iaa.Sometimes(
0.5,
[
iaa.Crop((0, 10)), # 切边, (0到10个像素采样)
]),
iaa.Sometimes(
0.5,
[
iaa.Affine(shear={
'x': (-10, 10),
'y': (-10, 10)
}, mode="edge"),
iaa.Rotate(rotate=(-10, 10), mode="edge"), # 旋转
]),
iaa.Sometimes(
0.5,
[
iaa.PiecewiseAffine(), # 局部仿射
iaa.ElasticTransformation( # distort扭曲变形
alpha=(0.0, 20.0),
sigma=(3.0, 5.0),
mode="nearest"),
]),
# 18种位置不变的效果
iaa.SomeOf(
(1, 3),
[
iaa.GaussianBlur(),
iaa.AverageBlur(),
iaa.MedianBlur(),
iaa.Sharpen(),
iaa.BilateralBlur(), # 既噪音又模糊，叫双边,
iaa.MotionBlur(),
iaa.MeanShiftBlur(),
iaa.GammaContrast(),
iaa.SigmoidContrast(),
iaa.Fog(),
iaa.Clouds(),
iaa.Snowflakes(flake_size=(0.1, 0.2), density=(0.005, 0.025)),
iaa.Rain(nb_iterations=1,
drop_size=(0.05, 0.1),
speed=(0.04, 0.08)),
iaa.AdditiveGaussianNoise(scale=(0, 10)),
iaa.AdditiveLaplaceNoise(scale=(0, 10)),
iaa.AdditivePoissonNoise(lam=(0, 10)),
iaa.Salt((0, 0.02)),
iaa.Pepper((0, 0.02))
])
])
polys = [ia.Polygon(pos) for pos in pos_list]
polygons = ia.PolygonsOnImage(polys, shape=image.shape)
images_aug, polygons_aug = seq(images=[image], polygons=polygons)
image = images_aug[0]
image = polygons_aug.draw_on_image(image, size=2)
new_polys = []
for p in polygons_aug.polygons:
new_polys.append(p.coords)
polys = np.array(new_polys, np.int32).tolist()
return image, polys
def draw_per_augmenter_images(img_path, idx):
print("[draw_per_augmenter_images] Loading image...")
image = ndimage.imread(img_path)
print(img_path)
textPath = img_path.replace('.jpg', '.txt')
f = open(textPath, 'r')
rows_keypoints = []
classId = []
while True:
line = f.readline()
if not line: break
values = line.split(' ')
classId.append(values[0])
cx = image.shape[1] * float(values[1])
cy = image.shape[0] * float(values[2])
w = image.shape[1] * float(values[3])
h = image.shape[0] * float(values[4].replace('\n', ''))
keypoints = [
ia.Keypoint(x=(cx - w / 2), y=(cy - h / 2)),
ia.Keypoint(x=(cx - w / 2), y=(cy + h / 2)),
ia.Keypoint(x=(cx + w / 2), y=(cy + h / 2)),
ia.Keypoint(x=(cx + w / 2), y=(cy - h / 2))
]
rows_keypoints.append(keypoints[0])
rows_keypoints.append(keypoints[1])
rows_keypoints.append(keypoints[2])
rows_keypoints.append(keypoints[3])
f.close()
keypoints = [ia.KeypointsOnImage(rows_keypoints, shape=image.shape)]
print("[draw_per_augmenter_images] Initializing...")
rows_augmenters = [
(0, "Crop\n(top, right,\nbottom, left)",
[(str(vals), iaa.Crop(px=vals))
for vals in [(64, 128, 64,
0), (0, 64, 64, 128), (64, 0, 64, 64), (64, 64, 0,
128)]]),
(0, "Fliplr", [(str(p), iaa.Fliplr(p)) for p in [1]]),
(0, "Flipud", [(str(p), iaa.Flipud(p)) for p in [1]]),
(0, "Add", [("value=%d" % (val, ), iaa.Add(val))
for val in [-45, -25, 25, 45]]),
(0, "Multiply", [("value=%.2f" % (val, ), iaa.Multiply(val))
for val in [0.25, 0.5, 1.25, 1.5]]),
(0, "GaussianBlur", [("sigma=%.2f" % (sigma, ),
iaa.GaussianBlur(sigma=sigma))
for sigma in [0.25, 0.50, 1.0, 2.0, 4.0]]),
(0, "BilateralBlur\nsigma_color=250,\nsigma_space=250",
[("d=%d" % (d, ),
iaa.BilateralBlur(d=d, sigma_color=250, sigma_space=250))
for d in [1, 3, 5, 7, 9]]),
(0, "Sharpen\n(alpha=1)", [("lightness=%.2f" % (lightness, ),
iaa.Sharpen(alpha=1, lightness=lightness))
for lightness in [0.5, 1.0, 1.5, 2.0]]),
(0, "Emboss\n(alpha=1)", [("strength=%.2f" % (strength, ),
iaa.Emboss(alpha=1, strength=strength))
for strength in [0, 0.5, 1.0, 1.5, 2.0]]),
(0, "AdditiveGaussianNoise",
[("scale=%.2f*255" % (scale, ),
iaa.AdditiveGaussianNoise(scale=scale * 255))
for scale in [0.025, 0.05, 0.1, 0.2, 0.3]]),
(0, "Dropout", [("p=%.2f" % (p, ), iaa.Dropout(p=p))
for p in [0.025, 0.05, 0.1, 0.2, 0.4]]),
(0, "SaltAndPepper", [("p=%.2f" % (p, ), iaa.SaltAndPepper(p=p))
for p in [0.025, 0.05, 0.1, 0.2, 0.4]]),
(0, "CoarseSaltAndPepper\n(p=0.2)",
[("size_percent=%.2f" % (size_percent, ),
iaa.CoarseSaltAndPepper(p=0.2,
size_percent=size_percent,
min_size=2))
for size_percent in [0.3, 0.2, 0.1, 0.05, 0.02]]),
(0, "ContrastNormalization",
[("alpha=%.1f" % (alpha, ), iaa.ContrastNormalization(alpha=alpha))
for alpha in [0.5, 0.75, 1.0, 1.25, 1.50]]),
(6, "PerspectiveTransform",
[("scale=%.3f" % (scale, ), iaa.PerspectiveTransform(scale=scale))
for scale in [0.075, 0.075, 0.10, 0.125, 0.125]]),
(0, "Affine: Scale", [("%.1fx" % (scale, ), iaa.Affine(scale=scale))
for scale in [0.25, 0.5, 1.5, 2.0]]),
(0, "Affine: Translate",
[("x=%d y=%d" % (x, y), iaa.Affine(translate_px={
"x": x,
"y": y
})) for x, y in [(
int(-image.shape[1] *
0.1), int(-image.shape[1] * 0.1)
), (int(-image.shape[1] * 0.2),
int(-image.shape[1] *
0.1)), (
int(-image.shape[1] * 0.1), int(-image.shape[1] * 0.2)
), (int(image.shape[1] * 0.1), int(image.shape[1] * 0.1)
), (int(image.shape[1] * 0.2), int(image.shape[1] * 0.2))]
]),
(0, "Affine: Rotate",
[("%d deg" % (rotate, ), iaa.Affine(rotate=rotate))
for rotate in [-90, -75, -45, -30, -15, 15, 30, 45, 75, 90]]),
(0, "Affine: Shear", [("%d deg" % (shear, ), iaa.Affine(shear=shear))
for shear in [-45, -25, 25, 45]]),
(0, "Affine: Modes", [(mode, iaa.Affine(translate_px=-32, mode=mode))
for mode in ["edge"]]),
(
2,
"Affine: all",
[
(
"",
iaa.Affine(
scale={
"x": (0.25, 0.75),
"y": (0.25, 0.75)
},
# scale images to 80-120% of their size, individually per axis
translate_percent={
"x": (-0.25, 0.25),
"y": (-0.25, 0.25)
},
# translate by -20 to +20 percent (per axis)
rotate=(-45, 45), # rotate by -45 to +45 degrees
shear=(-25, 25), # shear by -16 to +16 degrees
)) for _ in sm.xrange(5)
])
]
print("[draw_per_augmenter_images] Augmenting...")
rows = []
for (row_seed, row_name, augmenters) in rows_augmenters:
ia.seed(row_seed)
row_images = []
row_keypoints = []
row_titles = []
for img_title, augmenter in augmenters:
aug_det = augmenter.to_deterministic()
row_images.append(aug_det.augment_image(image))
row_keypoints.append(aug_det.augment_keypoints(keypoints)[0])
row_titles.append(img_title)
rows.append((row_name, row_images, row_keypoints, row_titles))
# routine to draw many single files
seen = defaultdict(lambda: 0)
markups = []
m = 0
for (row_name, row_images, row_keypoints, row_titles) in rows:
#output_image = ExamplesImage(128, 128, 128+64, 32)
for image, keypoints in zip(row_images, row_keypoints):
m += 1
#print("[draw_per_augmenter_images] Saving augmented images...")
keypoints.draw_on_image(image, size=40)
misc.imsave("DB/image_%05d_%05d.jpg" % (m, idx), image)
#misc.imsave("DB/kpt_image_%05d_%05d.jpg" % (m, idx), image)
ff = open("DB/image_%05d_%05d.txt" % (m, idx), 'a')
x = 0
while True:
if 4 * x == len(keypoints.keypoints): break
cx_ = (keypoints.keypoints[4 * x].x +
keypoints.keypoints[2 + 4 * x].x) / (2 * image.shape[1])
cy_ = (keypoints.keypoints[4 * x].y +
keypoints.keypoints[2 + 4 * x].y) / (2 * image.shape[0])
w_ = (keypoints.keypoints[2 + 4 * x].x -
keypoints.keypoints[4 * x].x) / image.shape[1]
h_ = (keypoints.keypoints[2 + 4 * x].y -
keypoints.keypoints[4 * x].y) / image.shape[0]
if (w_ < 1 / (13.0) or h_ < 1 / (13.0)):
data = str('32') + ' ' + str(cx_) + ' ' + str(
cy_) + ' ' + str(w_) + ' ' + str(h_) + '\n'
elif ((w_ < 3.0 / (13.0) and w_ > 1 / (13.0))
or (h_ < 3.0 / (13.0) and h_ > 3.0 / (13.0))):
data = str('33') + ' ' + str(cx_) + ' ' + str(
cy_) + ' ' + str(w_) + ' ' + str(h_) + '\n'
else:
data = str('15') + ' ' + str(cx_) + ' ' + str(
cy_) + ' ' + str(w_) + ' ' + str(h_) + '\n'
ff.write(data)
x += 1
ff.close()
def augument(self, image, bbox_list):
seq = iaa.Sequential([
# 变形
iaa.Sometimes(
0.6,
[
iaa.OneOf([
iaa.Affine(shear={
'x': (-1.5, 1.5),
'y': (-1.5, 1.5)
},
mode="edge"), # 仿射变化程度，单位像素
iaa.Rotate(rotate=(-1, 1), mode="edge"), # 旋转,单位度
])
]),
# 扭曲
iaa.Sometimes(
0.5,
[
iaa.OneOf([
iaa.PiecewiseAffine(
scale=(0, 0.02), nb_rows=2, nb_cols=2), # 局部仿射
iaa.ElasticTransformation( # distort扭曲变形
alpha=(0, 3), # 扭曲程度
sigma=(0.8, 1), # 扭曲后的平滑程度
mode="nearest"),
]),
]),
# 模糊
iaa.Sometimes(
0.5,
[
iaa.OneOf([
iaa.GaussianBlur(sigma=(0, 0.7)),
iaa.AverageBlur(k=(1, 3)),
iaa.MedianBlur(k=(1, 3)),
iaa.BilateralBlur(
d=(1, 5),
sigma_color=(10, 200),
sigma_space=(10, 200)), # 既噪音又模糊，叫双边,
iaa.MotionBlur(k=(3, 5)),
iaa.Snowflakes(flake_size=(0.1, 0.2),
density=(0.005, 0.025)),
iaa.Rain(nb_iterations=1,
drop_size=(0.05, 0.1),
speed=(0.04, 0.08)),
])
]),
# 锐化
iaa.Sometimes(0.3, [
iaa.OneOf([
iaa.Sharpen(),
iaa.GammaContrast(),
iaa.SigmoidContrast()
])
]),
# 噪音
iaa.Sometimes(0.3, [
iaa.OneOf([
iaa.AdditiveGaussianNoise(scale=(1, 5)),
iaa.AdditiveLaplaceNoise(scale=(1, 5)),
iaa.AdditivePoissonNoise(lam=(1, 5)),
iaa.Salt((0, 0.02)),
iaa.Pepper((0, 0.02))
])
]),
# 剪切
iaa.Sometimes(
0.8,
[
iaa.OneOf([
iaa.Crop((0, 2)), # 切边, (0到10个像素采样)
])
]),
])
assert bbox_list is None or type(bbox_list) == list
if bbox_list is None or len(bbox_list) == 0:
polys = None
else:
polys = [ia.Polygon(pos) for pos in bbox_list]
polys = ia.PolygonsOnImage(polys, shape=image.shape)
# 处理部分或者整体出了图像的范围的多边形，参考：https://imgaug.readthedocs.io/en/latest/source/examples_bounding_boxes.html
polys = polys.remove_out_of_image().clip_out_of_image()
images_aug, polygons_aug = seq(images=[image], polygons=polys)
image = images_aug[0]
if polygons_aug is None:
polys = None
else:
polys = []
for p in polygons_aug.polygons:
polys.append(p.coords)
polys = np.array(polys, np.int32).tolist() # (N,2)
return image, polys
def __init__(self,
list_file,
train,
transform,
device,
little_train=False,
S=7):
print('data init')
self.train = train
self.transform = transform
self.fnames = []
self.boxes = []
self.labels = []
self.S = S
self.B = 2
self.C = 20
self.device = device
self.augmentation = iaa.Sometimes(
0.5,
iaa.SomeOf(
(1, 6),
[
iaa.Dropout([0.05, 0.2]), # drop 5% or 20% of all pixels
iaa.Sharpen((0.1, 1.0)), # sharpen the image
iaa.GaussianBlur(sigma=(2., 3.5)),
iaa.OneOf([
iaa.GaussianBlur(sigma=(2., 3.5)),
iaa.AverageBlur(k=(2, 5)),
iaa.BilateralBlur(d=(7, 12),
sigma_color=(10, 250),
sigma_space=(10, 250)),
iaa.MedianBlur(k=(3, 7)),
]),
# iaa.Fliplr(1.0),
# iaa.Flipud(1.0),
iaa.AddElementwise((-50, 50)),
iaa.AdditiveGaussianNoise(scale=(0, 0.1 * 255)),
iaa.JpegCompression(compression=(80, 95)),
iaa.Multiply((0.5, 1.5)),
iaa.MultiplyElementwise((0.5, 1.5)),
iaa.ReplaceElementwise(0.05, [0, 255]),
iaa.WithColorspace(to_colorspace="HSV",
from_colorspace="RGB",
children=iaa.WithChannels(
2, iaa.Add((-10, 50)))),
iaa.OneOf([
iaa.WithColorspace(to_colorspace="HSV",
from_colorspace="RGB",
children=iaa.WithChannels(
1, iaa.Add((-10, 50)))),
iaa.WithColorspace(to_colorspace="HSV",
from_colorspace="RGB",
children=iaa.WithChannels(
2, iaa.Add((-10, 50)))),
]),
],
random_order=True))
torch.manual_seed(23)
with open(list_file) as f:
lines = f.readlines()
if little_train:
lines = lines[:64]
for line in lines:
splited = line.strip().split()
self.fnames.append(splited[0])
self.num_samples = len(self.fnames)
def __init__(self,
imgdirs_list,
annfiles_list,
train,
transform,
device,
little_train=False,
with_file_path=False,
S=7,
B=2,
C=20,
test_mode=False):
print('data init')
self.imgdirs_list = imgdirs_list
self.anns_list = annfiles_list
self.train = train
self.transform = transform
self.fnames = []
self.boxes = []
self.labels = []
self.dataset_list = []
self.resize = 448
self.S = S
self.B = B
self.C = C
self.device = device
self._test = test_mode
self.with_file_path = with_file_path
self.img_augsometimes = lambda aug: iaa.Sometimes(0.25, aug)
self.bbox_augsometimes = lambda aug: iaa.Sometimes(0.5, aug)
self.augmentation = iaa.Sequential(
[
# augment without change bboxes
self.img_augsometimes(
iaa.SomeOf(
(1, 3),
[
iaa.Dropout([0.05, 0.2
]), # drop 5% or 20% of all pixels
iaa.Sharpen((0.1, .8)), # sharpen the image
# iaa.GaussianBlur(sigma=(2., 3.5)),
iaa.OneOf([
iaa.GaussianBlur(sigma=(2., 3.5)),
iaa.AverageBlur(k=(2, 5)),
iaa.BilateralBlur(d=(7, 12),
sigma_color=(10, 250),
sigma_space=(10, 250)),
iaa.MedianBlur(k=(3, 7)),
]),
iaa.AddElementwise((-50, 50)),
iaa.AdditiveGaussianNoise(scale=(0, 0.1 * 255)),
# iaa.JpegCompression(compression=(80, 95)),
iaa.Multiply((0.5, 1.5)),
iaa.MultiplyElementwise((0.5, 1.5)),
iaa.ReplaceElementwise(0.05, [0, 255]),
# iaa.WithColorspace(to_colorspace="HSV", from_colorspace="RGB",
# children=iaa.WithChannels(2, iaa.Add((-10, 50)))),
iaa.OneOf([
iaa.WithColorspace(to_colorspace="HSV",
from_colorspace="RGB",
children=iaa.WithChannels(
1, iaa.Add((-10, 50)))),
iaa.WithColorspace(to_colorspace="HSV",
from_colorspace="RGB",
children=iaa.WithChannels(
2, iaa.Add((-10, 50)))),
]),
],
random_order=True)),
iaa.Fliplr(.5),
iaa.Flipud(.125),
# augment changing bboxes
self.bbox_augsometimes(
iaa.Affine(
# translate_px={"x": 40, "y": 60},
scale={
"x": (0.8, 1.2),
"y": (0.8, 1.2)
},
translate_percent={
"x": (-0.1, 0.1),
"y": (-0.1, 0.1)
},
rotate=(-5, 5),
))
],
random_order=True)
for imgdir, annfile in zip(self.imgdirs_list, self.anns_list):
print('handle dataset:\n\t' + imgdir + '\n\t' + annfile)
annfile_json = json.load(open(annfile, 'r'))
images = annfile_json['images']
annotations = annfile_json['annotations']
ann_dicts = {}
for ann in annotations:
if ann['image_id'] not in ann_dicts.keys():
ann_dicts[ann['image_id']] = []
ann_dicts[ann['image_id']].append(ann)
for img in images:
img['file_name'] = os.path.join(imgdir, img['file_name'])
if img['id'] in ann_dicts.keys():
anns = ann_dicts[img['id']]
else:
continue
image_ann = {'image_info': img, 'ann': anns}
self.dataset_list.append(image_ann)
self.num_samples = len(self.dataset_list)
print('There are %d pics in datasets.' % (self.num_samples))
def get_optimistic_img_aug():
texture = iaa.OneOf([
iaa.Superpixels(p_replace=(0.1, 0.3),
n_segments=(500, 1000),
interpolation="cubic",
name='Superpixels'),
iaa.Sharpen(alpha=(0, 1.0), lightness=(0.5, 1.0), name='Sharpen'),
iaa.Emboss(alpha=(0, 1.0), strength=(0.1, 0.3), name='Emboss'),
iaa.OneOf([
iaa.EdgeDetect(alpha=(0, 0.4)),
iaa.DirectedEdgeDetect(alpha=(0, 0.7), direction=(0.0, 1.0)),
],
name='EdgeDetect'),
iaa.ElasticTransformation(alpha=(0.5, 1.0),
sigma=0.2,
name='ElasticTransformation'),
])
blur = iaa.OneOf([
iaa.GaussianBlur((1, 5.0), name='GaussianBlur'),
iaa.AverageBlur(k=(2, 15), name='AverageBlur'),
iaa.MedianBlur(k=(3, 15), name='MedianBlur'),
iaa.BilateralBlur(d=(3, 15),
sigma_color=(10, 250),
sigma_space=(10, 250),
name='BilaBlur'),
])
affine = iaa.OneOf([
iaa.Affine(rotate=(-3, 3)),
iaa.Affine(translate_percent={
"x": (0.95, 1.05),
"y": (0.95, 1.05)
}),
iaa.Affine(scale={
"x": (0.95, 1.05),
"y": (0.95, 1.05)
}),
iaa.Affine(shear=(-2, 2)),
])
factors = iaa.OneOf([
iaa.Multiply(iap.Choice([0.75, 1.25]), per_channel=False),
iaa.EdgeDetect(1.0),
])
seq = iaa.Sequential(
[
# Size and shape ==================================================
iaa.Sequential([
iaa.Fliplr(0.5),
iaa.OneOf([
iaa.Noop(),
iaa.Affine(rotate=90),
iaa.Affine(rotate=180),
iaa.Affine(rotate=270),
]),
half_times(
iaa.SomeOf(
(1, 2),
[
iaa.Crop(percent=(0.1, 0.4)), # Random Crops
iaa.PerspectiveTransform(scale=(0.10, 0.175)),
iaa.PiecewiseAffine(scale=(0.01, 0.06),
nb_rows=(3, 6),
nb_cols=(3, 6)),
])),
]),
# Texture ==================================================
sometimes(
iaa.SomeOf((1, 2), [
texture,
iaa.Alpha((0.0, 1.0), first=texture, per_channel=False)
],
random_order=True,
name='Texture')),
half_times(
iaa.SomeOf((1, 2), [
blur,
iaa.Alpha((0.0, 1.0), first=blur, per_channel=False),
iaa.Alpha(factor=(0.2, 0.8),
first=iaa.Sequential([
affine,
blur,
]),
per_channel=False),
],
random_order=True,
name='Blur')),
# Noise ==================================================
sometimes(
iaa.SomeOf(
(1, 2),
[
# Just noise
iaa.AdditiveGaussianNoise(
loc=0,
scale=(0.0, 0.15 * 255),
per_channel=False,
name='AdditiveGaussianNoise'),
iaa.SaltAndPepper(
0.05, per_channel=False, name='SaltAndPepper'),
# Regularization
iaa.Dropout(
(0.01, 0.1), per_channel=False, name='Dropout'),
iaa.CoarseDropout((0.03, 0.15),
size_percent=(0.02, 0.05),
per_channel=False,
name='CoarseDropout'),
iaa.Alpha(
factor=(0.2, 0.8),
first=texture,
second=iaa.CoarseDropout(
p=0.1, size_percent=(0.02, 0.05)),
per_channel=False,
),
# Perlin style noise
iaa.SimplexNoiseAlpha(first=factors,
per_channel=False,
aggregation_method="max",
sigmoid=False,
upscale_method='cubic',
size_px_max=(2, 12),
name='SimplexNoiseAlpha'),
iaa.FrequencyNoiseAlpha(first=factors,
per_channel=False,
aggregation_method="max",
sigmoid=False,
upscale_method='cubic',
size_px_max=(2, 12),
name='FrequencyNoiseAlpha'),
],
random_order=True,
name='Noise')),
],
random_order=False)
def activator_masks(images, augmenter, parents, default):
if 'Unnamed' not in augmenter.name:
return False
else:
return default
hooks_masks = ia.HooksImages(activator=activator_masks)
return seq, hooks_masks
def __init__(self,
data_dir,
image_size=128,
augmentations=50,
crop_percent=(-0.07, 0.1),
affine_scale=(0.8, 1.2),
hue_range=(0, 20),
translate_percent=(-0.1, 0.1),
rotation=(-10, 10)):
"""
Args:
data_dir:
image_size:
jpeg_pics:
different_crops:
crop_diff_w:
crop_diff_h:
keep_close_aspect_ratio: If None will randomly keep aspect ratio
"""
self.data_dir = data_dir
self._data = []
self.image_size = image_size
self.num_augmentations = augmentations
self.seq = iaa.Sequential(
[
iaa.OneOf([
# Crop images to -7% to 10% of their width/height
sometimes(iaa.CropAndPad(percent=crop_percent, ),
chance=0.2),
# Scale image between 80% to 120% of original size
# Translate the picture -10% to 10% on both axes
sometimes(iaa.Affine(
scale=affine_scale,
translate_percent=translate_percent,
),
chance=0.4)
]),
# Rotate and shear image
sometimes(iaa.Affine(
rotate=rotation, shear=(-3, 3), mode=ia.ALL),
chance=0.2),
# Changes gamma contrast
sometimes(iaa.GammaContrast(gamma=(0.8, 1.3)), chance=0.3),
# Change to HSV and add hue then transfer back to RGB
sometimes([
iaa.ChangeColorspace(from_colorspace="RGB",
to_colorspace="HSV"),
iaa.WithChannels(0, iaa.Add(hue_range)),
iaa.ChangeColorspace(from_colorspace="HSV",
to_colorspace="RGB")
],
chance=0.2),
# Add one type of blur
sometimes(iaa.OneOf([
iaa.GaussianBlur(sigma=(0.1, 2)),
iaa.AverageBlur(k=(1, 6)),
iaa.MedianBlur(k=(1, 7)),
iaa.BilateralBlur(
d=(1, 7), sigma_color=250, sigma_space=250)
]),
chance=0.4),
sometimes(iaa.Sharpen(alpha=(0, 0.4)), chance=0.4)
],
random_order=True)
def apply_transform(matrix, image, params):
# rgb
# seq describes an object for rgb image augmentation using aleju/imgaug
seq = iaa.Sequential(
[
# blur
iaa.SomeOf((0, 2), [
iaa.GaussianBlur((0.0, 2.0)),
iaa.AverageBlur(k=(3, 7)),
iaa.MedianBlur(k=(3, 7)),
iaa.BilateralBlur(d=(1, 7)),
iaa.MotionBlur(k=(3, 7))
]),
# color
iaa.SomeOf(
(0, 2),
[
# iaa.WithColorspace(),
iaa.AddToHueAndSaturation((-15, 15)),
# iaa.ChangeColorspace(to_colorspace[], alpha=0.5),
iaa.Grayscale(alpha=(0.0, 0.2))
]),
# brightness
iaa.OneOf([
iaa.Sequential([
iaa.Add((-10, 10), per_channel=0.5),
iaa.Multiply((0.75, 1.25), per_channel=0.5)
]),
iaa.Add((-10, 10), per_channel=0.5),
iaa.Multiply((0.75, 1.25), per_channel=0.5),
iaa.FrequencyNoiseAlpha(exponent=(-4, 0),
first=iaa.Multiply(
(0.75, 1.25), per_channel=0.5),
second=iaa.LinearContrast(
(0.7, 1.3), per_channel=0.5))
]),
# contrast
iaa.SomeOf((0, 2), [
iaa.GammaContrast((0.75, 1.25), per_channel=0.5),
iaa.SigmoidContrast(
gain=(0, 10), cutoff=(0.25, 0.75), per_channel=0.5),
iaa.LogContrast(gain=(0.75, 1), per_channel=0.5),
iaa.LinearContrast(alpha=(0.7, 1.3), per_channel=0.5)
]),
],
random_order=True)
image = seq.augment_image(image)
'''
seq = iaa.Sequential([
iaa.Sometimes(0.5, iaa.CoarseDropout(p=0.2, size_percent=(0.1, 0.25))),
iaa.Sometimes(0.5, iaa.GaussianBlur(1.2*np.random.rand())),
iaa.Sometimes(0.5, iaa.Add((-25, 25), per_channel=0.3)),
iaa.Sometimes(0.5, iaa.Invert(0.2, per_channel=True)),
iaa.Sometimes(0.5, iaa.Multiply((0.6, 1.4), per_channel=0.5)),
iaa.Sometimes(0.5, iaa.Multiply((0.6, 1.4))),
iaa.Sometimes(0.5, iaa.ContrastNormalization((0.5, 2.2), per_channel=0.3))
], random_order=False)
image = seq.augment_image(image)
'''
image = cv2.warpAffine(
image,
matrix[:2, :],
dsize=(image.shape[1], image.shape[0]),
flags=params.cvInterpolation(),
borderMode=params.cvBorderMode(),
borderValue=params.cval,
)
return image
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 main():
parser = argparse.ArgumentParser(description="Check augmenters visually.")
parser.add_argument(
"--only",
default=None,
help=
"If this is set, then only the results of an augmenter with this name will be shown. "
"Optionally, comma-separated list.",
required=False)
args = parser.parse_args()
images = [
ia.quokka_square(size=(128, 128)),
ia.imresize_single_image(data.astronaut(), (128, 128))
]
keypoints = [
ia.KeypointsOnImage([
ia.Keypoint(x=50, y=40),
ia.Keypoint(x=70, y=38),
ia.Keypoint(x=62, y=52)
],
shape=images[0].shape),
ia.KeypointsOnImage([
ia.Keypoint(x=55, y=32),
ia.Keypoint(x=42, y=95),
ia.Keypoint(x=75, y=89)
],
shape=images[1].shape)
]
bounding_boxes = [
ia.BoundingBoxesOnImage([
ia.BoundingBox(x1=10, y1=10, x2=20, y2=20),
ia.BoundingBox(x1=40, y1=50, x2=70, y2=60)
],
shape=images[0].shape),
ia.BoundingBoxesOnImage([
ia.BoundingBox(x1=10, y1=10, x2=20, y2=20),
ia.BoundingBox(x1=40, y1=50, x2=70, y2=60)
],
shape=images[1].shape)
]
augmenters = [
iaa.Sequential([
iaa.CoarseDropout(p=0.5, size_percent=0.05),
iaa.AdditiveGaussianNoise(scale=0.1 * 255),
iaa.Crop(percent=0.1)
],
name="Sequential"),
iaa.SomeOf(2,
children=[
iaa.CoarseDropout(p=0.5, size_percent=0.05),
iaa.AdditiveGaussianNoise(scale=0.1 * 255),
iaa.Crop(percent=0.1)
],
name="SomeOf"),
iaa.OneOf(children=[
iaa.CoarseDropout(p=0.5, size_percent=0.05),
iaa.AdditiveGaussianNoise(scale=0.1 * 255),
iaa.Crop(percent=0.1)
],
name="OneOf"),
iaa.Sometimes(0.5,
iaa.AdditiveGaussianNoise(scale=0.1 * 255),
name="Sometimes"),
iaa.WithColorspace("HSV",
children=[iaa.Add(20)],
name="WithColorspace"),
iaa.WithChannels([0], children=[iaa.Add(20)], name="WithChannels"),
iaa.AddToHueAndSaturation((-20, 20),
per_channel=True,
name="AddToHueAndSaturation"),
iaa.Noop(name="Noop"),
iaa.Resize({
"width": 64,
"height": 64
}, name="Resize"),
iaa.CropAndPad(px=(-8, 8), name="CropAndPad-px"),
iaa.Pad(px=(0, 8), name="Pad-px"),
iaa.Crop(px=(0, 8), name="Crop-px"),
iaa.Crop(percent=(0, 0.1), name="Crop-percent"),
iaa.Fliplr(0.5, name="Fliplr"),
iaa.Flipud(0.5, name="Flipud"),
iaa.Superpixels(p_replace=0.75, n_segments=50, name="Superpixels"),
iaa.Grayscale(0.5, name="Grayscale0.5"),
iaa.Grayscale(1.0, name="Grayscale1.0"),
iaa.GaussianBlur((0, 3.0), name="GaussianBlur"),
iaa.AverageBlur(k=(3, 11), name="AverageBlur"),
iaa.MedianBlur(k=(3, 11), name="MedianBlur"),
iaa.BilateralBlur(d=10, name="BilateralBlur"),
iaa.Sharpen(alpha=(0.1, 1.0), lightness=(0, 2.0), name="Sharpen"),
iaa.Emboss(alpha=(0.1, 1.0), strength=(0, 2.0), name="Emboss"),
iaa.EdgeDetect(alpha=(0.1, 1.0), name="EdgeDetect"),
iaa.DirectedEdgeDetect(alpha=(0.1, 1.0),
direction=(0, 1.0),
name="DirectedEdgeDetect"),
iaa.Add((-50, 50), name="Add"),
iaa.Add((-50, 50), per_channel=True, name="AddPerChannel"),
iaa.AddElementwise((-50, 50), name="AddElementwise"),
iaa.AdditiveGaussianNoise(loc=0,
scale=(0.0, 0.1 * 255),
name="AdditiveGaussianNoise"),
iaa.Multiply((0.5, 1.5), name="Multiply"),
iaa.Multiply((0.5, 1.5), per_channel=True, name="MultiplyPerChannel"),
iaa.MultiplyElementwise((0.5, 1.5), name="MultiplyElementwise"),
iaa.Dropout((0.0, 0.1), name="Dropout"),
iaa.CoarseDropout(p=0.05,
size_percent=(0.05, 0.5),
name="CoarseDropout"),
iaa.Invert(p=0.5, name="Invert"),
iaa.Invert(p=0.5, per_channel=True, name="InvertPerChannel"),
iaa.ContrastNormalization(alpha=(0.5, 2.0),
name="ContrastNormalization"),
iaa.SaltAndPepper(p=0.05, name="SaltAndPepper"),
iaa.Salt(p=0.05, name="Salt"),
iaa.Pepper(p=0.05, name="Pepper"),
iaa.CoarseSaltAndPepper(p=0.05,
size_percent=(0.01, 0.1),
name="CoarseSaltAndPepper"),
iaa.CoarseSalt(p=0.05, size_percent=(0.01, 0.1), name="CoarseSalt"),
iaa.CoarsePepper(p=0.05, size_percent=(0.01, 0.1),
name="CoarsePepper"),
iaa.Affine(scale={
"x": (0.8, 1.2),
"y": (0.8, 1.2)
},
translate_px={
"x": (-16, 16),
"y": (-16, 16)
},
rotate=(-45, 45),
shear=(-16, 16),
order=ia.ALL,
cval=(0, 255),
mode=ia.ALL,
name="Affine"),
iaa.PiecewiseAffine(scale=0.03,
nb_rows=(2, 6),
nb_cols=(2, 6),
name="PiecewiseAffine"),
iaa.PerspectiveTransform(scale=0.1, name="PerspectiveTransform"),
iaa.ElasticTransformation(alpha=(0.5, 8.0),
sigma=1.0,
name="ElasticTransformation"),
iaa.Alpha(factor=(0.0, 1.0),
first=iaa.Add(100),
second=iaa.Dropout(0.5),
per_channel=False,
name="Alpha"),
iaa.Alpha(factor=(0.0, 1.0),
first=iaa.Add(100),
second=iaa.Dropout(0.5),
per_channel=True,
name="AlphaPerChannel"),
iaa.Alpha(factor=(0.0, 1.0),
first=iaa.Affine(rotate=(-45, 45)),
per_channel=True,
name="AlphaAffine"),
iaa.AlphaElementwise(factor=(0.0, 1.0),
first=iaa.Add(50),
second=iaa.ContrastNormalization(2.0),
per_channel=False,
name="AlphaElementwise"),
iaa.AlphaElementwise(factor=(0.0, 1.0),
first=iaa.Add(50),
second=iaa.ContrastNormalization(2.0),
per_channel=True,
name="AlphaElementwisePerChannel"),
iaa.AlphaElementwise(factor=(0.0, 1.0),
first=iaa.Affine(rotate=(-45, 45)),
per_channel=True,
name="AlphaElementwiseAffine"),
iaa.SimplexNoiseAlpha(first=iaa.EdgeDetect(1.0),
per_channel=False,
name="SimplexNoiseAlpha"),
iaa.FrequencyNoiseAlpha(first=iaa.EdgeDetect(1.0),
per_channel=False,
name="FrequencyNoiseAlpha")
]
augmenters.append(
iaa.Sequential([iaa.Sometimes(0.2, aug.copy()) for aug in augmenters],
name="Sequential"))
augmenters.append(
iaa.Sometimes(0.5, [aug.copy() for aug in augmenters],
name="Sometimes"))
for augmenter in augmenters:
if args.only is None or augmenter.name in [
v.strip() for v in args.only.split(",")
]:
print("Augmenter: %s" % (augmenter.name, ))
grid = []
for image, kps, bbs in zip(images, keypoints, bounding_boxes):
aug_det = augmenter.to_deterministic()
imgs_aug = aug_det.augment_images(
np.tile(image[np.newaxis, ...], (16, 1, 1, 1)))
kps_aug = aug_det.augment_keypoints([kps] * 16)
bbs_aug = aug_det.augment_bounding_boxes([bbs] * 16)
imgs_aug_drawn = [
kps_aug_one.draw_on_image(img_aug)
for img_aug, kps_aug_one in zip(imgs_aug, kps_aug)
]
imgs_aug_drawn = [
bbs_aug_one.draw_on_image(img_aug)
for img_aug, bbs_aug_one in zip(imgs_aug_drawn, bbs_aug)
]
grid.append(np.hstack(imgs_aug_drawn))
ia.imshow(np.vstack(grid))
def __init__(self,
dataset_type,
dataset_path,
real_path,
mesh_path,
mesh_info,
object_id,
batch_size,
img_res=(224, 224),
is_testing=False):
self.data_type = dataset_type
self.img_res = img_res
self.dataset_path = dataset_path
self.real_path = [
os.path.join(real_path, x) for x in os.listdir(real_path)
]
self.batch_size = batch_size
self.is_testing = is_testing
self.ply_path = mesh_path
self.obj_id = int(object_id)
# annotate
self.train_info = os.path.join(self.dataset_path, 'annotations',
'instances_' + 'train' + '.json')
self.val_info = os.path.join(self.dataset_path, 'annotations',
'instances_' + 'val' + '.json')
# self.mesh_info = os.path.join(self.dataset_path, 'annotations', 'models_info' + '.yml')
self.mesh_info = mesh_info
with open(self.train_info, 'r') as js:
data = json.load(js)
image_ann = data["images"]
anno_ann = data["annotations"]
self.image_ids = []
self.Anns = []
# init renderer
# < 11 ms;
self.ren = bop_renderer.Renderer()
self.ren.init(640, 480)
self.ren.add_object(self.obj_id, self.ply_path)
stream = open(self.mesh_info, 'r')
for key, value in yaml.load(stream).items():
# for key, value in yaml.load(open(self.mesh_info)).items():
if int(key) == self.obj_id + 1:
self.model_dia = value['diameter']
for ann in anno_ann:
y_mean = (ann['bbox'][0] + ann['bbox'][2] * 0.5)
x_mean = (ann['bbox'][1] + ann['bbox'][3] * 0.5)
max_side = np.max(ann['bbox'][2:])
x_min = int(x_mean - max_side * 0.75)
x_max = int(x_mean + max_side * 0.75)
y_min = int(y_mean - max_side * 0.75)
y_max = int(y_mean + max_side * 0.75)
if ann['category_id'] != 2 or ann[
'feature_visibility'] < 0.5 or x_min < 0 or x_max > 639 or y_min < 0 or y_max > 479:
continue
else:
self.Anns.append(ann)
# for img_info in image_ann:
# print(img_info)
# if img_info['id'] == ann['id']:
# self.image_ids.append(img_info['file_name'])
# print(img_info['file_name'])
template_name = '00000000000'
id = str(ann['image_id'])
# print(ann['id'])
name = template_name[:-len(id)] + id + '.png'
# print(name)
self.image_ids.append(name)
self.fx = image_ann[0]["fx"]
self.fy = image_ann[0]["fy"]
self.cx = image_ann[0]["cx"]
self.cy = image_ann[0]["cy"]
#self.image_idxs = range(len(self.image_ids))
c = list(zip(self.Anns, self.image_ids)) #, self.image_idxs))
np.random.shuffle(c)
self.Anns, self.image_ids = zip(*c)
self.img_seq = iaa.Sequential(
[
# blur
iaa.SomeOf((0, 2), [
iaa.GaussianBlur((0.0, 2.0)),
iaa.AverageBlur(k=(3, 7)),
iaa.MedianBlur(k=(3, 7)),
iaa.BilateralBlur(d=(1, 7)),
iaa.MotionBlur(k=(3, 7))
]),
# color
iaa.SomeOf(
(0, 2),
[
# iaa.WithColorspace(),
iaa.AddToHueAndSaturation((-15, 15)),
# iaa.ChangeColorspace(to_colorspace[], alpha=0.5),
iaa.Grayscale(alpha=(0.0, 0.2))
]),
# brightness
iaa.OneOf([
iaa.Sequential([
iaa.Add((-10, 10), per_channel=0.5),
iaa.Multiply((0.75, 1.25), per_channel=0.5)
]),
iaa.Add((-10, 10), per_channel=0.5),
iaa.Multiply((0.75, 1.25), per_channel=0.5),
iaa.FrequencyNoiseAlpha(exponent=(-4, 0),
first=iaa.Multiply(
(0.75, 1.25), per_channel=0.5),
second=iaa.LinearContrast(
(0.7, 1.3), per_channel=0.5))
]),
# contrast
iaa.SomeOf((0, 2), [
iaa.GammaContrast((0.75, 1.25), per_channel=0.5),
iaa.SigmoidContrast(
gain=(0, 10), cutoff=(0.25, 0.75), per_channel=0.5),
iaa.LogContrast(gain=(0.75, 1), per_channel=0.5),
iaa.LinearContrast(alpha=(0.7, 1.3), per_channel=0.5)
]),
],
random_order=True)
self.n_batches = int(np.floor(len(self.image_ids) / self.batch_size))
self.on_epoch_end()
def draw_per_augmenter_images():
print("[draw_per_augmenter_images] Loading image...")
#image = misc.imresize(ndimage.imread("quokka.jpg")[0:643, 0:643], (128, 128))
image = ia.quokka_square(size=(128, 128))
keypoints = [
ia.Keypoint(x=34, y=15),
ia.Keypoint(x=85, y=13),
ia.Keypoint(x=63, y=73)
] # left ear, right ear, mouth
keypoints = [ia.KeypointsOnImage(keypoints, shape=image.shape)]
print("[draw_per_augmenter_images] Initializing...")
rows_augmenters = [
(0, "Noop", [("", iaa.Noop()) for _ in sm.xrange(5)]),
(0, "Crop\n(top, right,\nbottom, left)", [
(str(vals), iaa.Crop(px=vals))
for vals in [(2, 0, 0, 0), (0, 8, 8, 0), (4, 0, 16,
4), (8, 0, 0,
32), (32, 64, 0, 0)]
]),
(0, "Pad\n(top, right,\nbottom, left)", [
(str(vals), iaa.Pad(px=vals))
for vals in [(2, 0, 0, 0), (0, 8, 8, 0), (4, 0, 16,
4), (8, 0, 0,
32), (32, 64, 0, 0)]
]), (0, "Fliplr", [(str(p), iaa.Fliplr(p)) for p in [0, 0, 1, 1, 1]]),
(0, "Flipud", [(str(p), iaa.Flipud(p)) for p in [0, 0, 1, 1, 1]]),
(0, "Superpixels\np_replace=1",
[("n_segments=%d" % (n_segments, ),
iaa.Superpixels(p_replace=1.0, n_segments=n_segments))
for n_segments in [25, 50, 75, 100, 125]]),
(0, "Superpixels\nn_segments=100",
[("p_replace=%.2f" % (p_replace, ),
iaa.Superpixels(p_replace=p_replace, n_segments=100))
for p_replace in [0, 0.25, 0.5, 0.75, 1.0]]),
(0, "Invert", [("p=%d" % (p, ), iaa.Invert(p=p))
for p in [0, 0, 1, 1, 1]]),
(0, "Invert\n(per_channel)", [("p=%.2f" % (p, ),
iaa.Invert(p=p, per_channel=True))
for p in [0.5, 0.5, 0.5, 0.5, 0.5]]),
(0, "Add", [("value=%d" % (val, ), iaa.Add(val))
for val in [-45, -25, 0, 25, 45]]),
(0, "Add\n(per channel)", [
("value=(%d, %d)" % (
vals[0],
vals[1],
), iaa.Add(vals, per_channel=True))
for vals in [(-55, -35), (-35, -15), (-10, 10), (15, 35), (35, 55)]
]),
(0, "AddToHueAndSaturation", [("value=%d" % (val, ),
iaa.AddToHueAndSaturation(val))
for val in [-45, -25, 0, 25, 45]]),
(0, "Multiply", [("value=%.2f" % (val, ), iaa.Multiply(val))
for val in [0.25, 0.5, 1.0, 1.25, 1.5]]),
(1, "Multiply\n(per channel)",
[("value=(%.2f, %.2f)" % (
vals[0],
vals[1],
), iaa.Multiply(vals, per_channel=True))
for vals in [(0.15, 0.35), (0.4, 0.6), (0.9, 1.1), (1.15,
1.35), (1.4,
1.6)]]),
(0, "GaussianBlur", [("sigma=%.2f" % (sigma, ),
iaa.GaussianBlur(sigma=sigma))
for sigma in [0.25, 0.50, 1.0, 2.0, 4.0]]),
(0, "AverageBlur", [("k=%d" % (k, ), iaa.AverageBlur(k=k))
for k in [1, 3, 5, 7, 9]]),
(0, "MedianBlur", [("k=%d" % (k, ), iaa.MedianBlur(k=k))
for k in [1, 3, 5, 7, 9]]),
(0, "BilateralBlur\nsigma_color=250,\nsigma_space=250",
[("d=%d" % (d, ),
iaa.BilateralBlur(d=d, sigma_color=250, sigma_space=250))
for d in [1, 3, 5, 7, 9]]),
(0, "Sharpen\n(alpha=1)", [("lightness=%.2f" % (lightness, ),
iaa.Sharpen(alpha=1, lightness=lightness))
for lightness in [0, 0.5, 1.0, 1.5, 2.0]]),
(0, "Emboss\n(alpha=1)", [("strength=%.2f" % (strength, ),
iaa.Emboss(alpha=1, strength=strength))
for strength in [0, 0.5, 1.0, 1.5, 2.0]]),
(0, "EdgeDetect", [("alpha=%.2f" % (alpha, ),
iaa.EdgeDetect(alpha=alpha))
for alpha in [0.0, 0.25, 0.5, 0.75, 1.0]]),
(0, "DirectedEdgeDetect\n(alpha=1)",
[("direction=%.2f" % (direction, ),
iaa.DirectedEdgeDetect(alpha=1, direction=direction))
for direction in [
0.0, 1 * (360 / 5) / 360, 2 * (360 / 5) / 360, 3 * (360 / 5) /
360, 4 * (360 / 5) / 360
]]),
(0, "AdditiveGaussianNoise",
[("scale=%.2f*255" % (scale, ),
iaa.AdditiveGaussianNoise(scale=scale * 255))
for scale in [0.025, 0.05, 0.1, 0.2, 0.3]]),
(0, "AdditiveGaussianNoise\n(per channel)",
[("scale=%.2f*255" % (scale, ),
iaa.AdditiveGaussianNoise(scale=scale * 255, per_channel=True))
for scale in [0.025, 0.05, 0.1, 0.2, 0.3]]),
(0, "Dropout", [("p=%.2f" % (p, ), iaa.Dropout(p=p))
for p in [0.025, 0.05, 0.1, 0.2, 0.4]]),
(0, "Dropout\n(per channel)", [("p=%.2f" % (p, ),
iaa.Dropout(p=p, per_channel=True))
for p in [0.025, 0.05, 0.1, 0.2, 0.4]]),
(0, "CoarseDropout\n(p=0.2)",
[("size_percent=%.2f" % (size_percent, ),
iaa.CoarseDropout(p=0.2, size_percent=size_percent, min_size=2))
for size_percent in [0.3, 0.2, 0.1, 0.05, 0.02]]),
(0, "CoarseDropout\n(p=0.2, per channel)",
[("size_percent=%.2f" % (size_percent, ),
iaa.CoarseDropout(p=0.2,
size_percent=size_percent,
per_channel=True,
min_size=2))
for size_percent in [0.3, 0.2, 0.1, 0.05, 0.02]]),
(0, "ContrastNormalization",
[("alpha=%.1f" % (alpha, ), iaa.ContrastNormalization(alpha=alpha))
for alpha in [0.5, 0.75, 1.0, 1.25, 1.50]]),
(0, "ContrastNormalization\n(per channel)",
[("alpha=(%.2f, %.2f)" % (
alphas[0],
alphas[1],
), iaa.ContrastNormalization(alpha=alphas, per_channel=True))
for alphas in [(0.4, 0.6), (0.65,
0.85), (0.9, 1.1), (1.15,
1.35), (1.4, 1.6)]]),
(0, "Grayscale", [("alpha=%.1f" % (alpha, ),
iaa.Grayscale(alpha=alpha))
for alpha in [0.0, 0.25, 0.5, 0.75, 1.0]]),
(6, "PerspectiveTransform",
[("scale=%.3f" % (scale, ), iaa.PerspectiveTransform(scale=scale))
for scale in [0.025, 0.05, 0.075, 0.10, 0.125]]),
(0, "PiecewiseAffine",
[("scale=%.3f" % (scale, ), iaa.PiecewiseAffine(scale=scale))
for scale in [0.015, 0.03, 0.045, 0.06, 0.075]]),
(0, "Affine: Scale", [("%.1fx" % (scale, ), iaa.Affine(scale=scale))
for scale in [0.1, 0.5, 1.0, 1.5, 1.9]]),
(0, "Affine: Translate",
[("x=%d y=%d" % (x, y), iaa.Affine(translate_px={
"x": x,
"y": y
}))
for x, y in [(-32, -16), (-16, -32), (-16, -8), (16, 8), (16, 32)]]),
(0, "Affine: Rotate", [("%d deg" % (rotate, ),
iaa.Affine(rotate=rotate))
for rotate in [-90, -45, 0, 45, 90]]),
(0, "Affine: Shear", [("%d deg" % (shear, ), iaa.Affine(shear=shear))
for shear in [-45, -25, 0, 25, 45]]),
(0, "Affine: Modes",
[(mode, iaa.Affine(translate_px=-32, mode=mode))
for mode in ["constant", "edge", "symmetric", "reflect", "wrap"]]),
(0, "Affine: cval", [("%d" % (int(cval * 255), ),
iaa.Affine(translate_px=-32,
cval=int(cval * 255),
mode="constant"))
for cval in [0.0, 0.25, 0.5, 0.75, 1.0]]),
(2, "Affine: all", [("",
iaa.Affine(scale={
"x": (0.5, 1.5),
"y": (0.5, 1.5)
},
translate_px={
"x": (-32, 32),
"y": (-32, 32)
},
rotate=(-45, 45),
shear=(-32, 32),
mode=ia.ALL,
cval=(0.0, 1.0)))
for _ in sm.xrange(5)]),
(1, "ElasticTransformation\n(sigma=0.2)",
[("alpha=%.1f" % (alpha, ),
iaa.ElasticTransformation(alpha=alpha, sigma=0.2))
for alpha in [0.1, 0.5, 1.0, 3.0, 9.0]])
]
print("[draw_per_augmenter_images] Augmenting...")
rows = []
for (row_seed, row_name, augmenters) in rows_augmenters:
ia.seed(row_seed)
#for img_title, augmenter in augmenters:
# #aug.reseed(1000)
# pass
row_images = []
row_keypoints = []
row_titles = []
for img_title, augmenter in augmenters:
aug_det = augmenter.to_deterministic()
row_images.append(aug_det.augment_image(image))
row_keypoints.append(aug_det.augment_keypoints(keypoints)[0])
row_titles.append(img_title)
rows.append((row_name, row_images, row_keypoints, row_titles))
# matplotlib drawin routine
"""
print("[draw_per_augmenter_images] Plotting...")
width = 8
height = int(1.5 * len(rows_augmenters))
fig = plt.figure(figsize=(width, height))
grid_rows = len(rows)
grid_cols = 1 + 5
gs = gridspec.GridSpec(grid_rows, grid_cols, width_ratios=[2, 1, 1, 1, 1, 1])
axes = []
for i in sm.xrange(grid_rows):
axes.append([plt.subplot(gs[i, col_idx]) for col_idx in sm.xrange(grid_cols)])
fig.tight_layout()
#fig.subplots_adjust(bottom=0.2 / grid_rows, hspace=0.22)
#fig.subplots_adjust(wspace=0.005, hspace=0.425, bottom=0.02)
fig.subplots_adjust(wspace=0.005, hspace=0.005, bottom=0.02)
for row_idx, (row_name, row_images, row_keypoints, row_titles) in enumerate(rows):
axes_row = axes[row_idx]
for col_idx in sm.xrange(grid_cols):
ax = axes_row[col_idx]
ax.cla()
ax.axis("off")
ax.get_xaxis().set_visible(False)
ax.get_yaxis().set_visible(False)
if col_idx == 0:
ax.text(0, 0.5, row_name, color="black")
else:
cell_image = row_images[col_idx-1]
cell_keypoints = row_keypoints[col_idx-1]
cell_image_kp = cell_keypoints.draw_on_image(cell_image, size=5)
ax.imshow(cell_image_kp)
x = 0
y = 145
#ax.text(x, y, row_titles[col_idx-1], color="black", backgroundcolor="white", fontsize=6)
ax.text(x, y, row_titles[col_idx-1], color="black", fontsize=7)
fig.savefig("examples.jpg", bbox_inches="tight")
#plt.show()
"""
# simpler and faster drawing routine
"""
output_image = ExamplesImage(128, 128, 128+64, 32)
for (row_name, row_images, row_keypoints, row_titles) in rows:
row_images_kps = []
for image, keypoints in zip(row_images, row_keypoints):
row_images_kps.append(keypoints.draw_on_image(image, size=5))
output_image.add_row(row_name, row_images_kps, row_titles)
misc.imsave("examples.jpg", output_image.draw())
"""
# routine to draw many single files
seen = defaultdict(lambda: 0)
markups = []
for (row_name, row_images, row_keypoints, row_titles) in rows:
output_image = ExamplesImage(128, 128, 128 + 64, 32)
row_images_kps = []
for image, keypoints in zip(row_images, row_keypoints):
row_images_kps.append(keypoints.draw_on_image(image, size=5))
output_image.add_row(row_name, row_images_kps, row_titles)
if "\n" in row_name:
row_name_clean = row_name[0:row_name.find("\n") + 1]
else:
row_name_clean = row_name
row_name_clean = re.sub(r"[^a-z0-9]+", "_", row_name_clean.lower())
row_name_clean = row_name_clean.strip("_")
if seen[row_name_clean] > 0:
row_name_clean = "%s_%d" % (row_name_clean,
seen[row_name_clean] + 1)
fp = os.path.join(IMAGES_DIR, "examples_%s.jpg" % (row_name_clean, ))
#misc.imsave(fp, output_image.draw())
save(fp, output_image.draw())
seen[row_name_clean] += 1
markup_descr = row_name.replace('"', '') \
.replace("\n", " ") \
.replace("(", "") \
.replace(")", "")
markup = '' % (markup_descr, fp, markup_descr)
markups.append(markup)
for markup in markups:
print(markup)
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
import os
import json
import random
import cv2 as cv
import numpy as np
from imgaug import augmenters as iaa
aug = [
iaa.LinearContrast(alpha=2),
iaa.SigmoidContrast(gain=10),
iaa.GammaContrast(gamma=2),
iaa.CLAHE(clip_limit=(1, 5)),
iaa.Grayscale(alpha=1.0),
iaa.AddToHueAndSaturation((-20, 20), per_channel=True),
iaa.BilateralBlur(d=6),
iaa.MotionBlur(k=7),
iaa.MedianBlur(k=3),
iaa.AverageBlur(k=3),
iaa.AdditiveGaussianNoise(loc=0.8, scale=(0.01, 0.08 * 255)),
iaa.ContrastNormalization((0.3, 1.5)),
iaa.Sharpen(alpha=0, lightness=1)
]
class Dataset(object):
def __init__(self, args):
self.args = args
self.char = json.load(open(self.args.char, mode='r'))
def get_file(self, data_path):
def __init__(self, rgb_mean, randomImg, insize):
sometimes = lambda aug: iaa.Sometimes(0.7, aug)
self.rand_img_dir = randomImg
self.rgb_mean = rgb_mean
self.inp_dim = insize
#
self.randomImgList = glob.glob( randomImg + '*.jpg')
self.aug = iaa.Sequential([
sometimes(iaa.Affine(
scale={"x": (0.8, 1.2), "y": (0.8, 1.2)}, # scale images to 80-120% of their size, individually per axis
translate_percent={"x": (-0.1, 0.1), "y": (-0.1, 0.1)}, # translate by -20 to +20 percent (per axis)
rotate=(-25, 25), # rotate by -45 to +45 degrees
shear=(-6, 6), # shear by -16 to +16 degrees
order=[0, 1], # use nearest neighbour or bilinear interpolation (fast)
cval=(0, 255), # if mode is constant, use a cval between 0 and 255
mode=ia.ALL # use any of scikit-image's warping modes (see 2nd image from the top for examples)
)),
iaa.OneOf([
iaa.Fliplr(0.5),
iaa.GaussianBlur(
sigma=iap.Uniform(0.0, 1.0)
),
iaa.BlendAlphaSimplexNoise(
foreground=iaa.BlendAlphaSimplexNoise(
foreground=iaa.EdgeDetect(1.0),
background=iaa.LinearContrast((0.1, .8)),
per_channel=True
),
background=iaa.BlendAlphaFrequencyNoise(
exponent=(-.5, -.1),
foreground=iaa.Affine(
rotate=(-10, 10),
translate_px={"x": (-1, 1), "y": (-1, 1)}
),
# background=iaa.AddToHueAndSaturation((-4, 4)),
# per_channel=True
),
per_channel=True,
aggregation_method="max",
sigmoid=False
),
iaa.BlendAlpha(
factor=(0.2, 0.8),
foreground=iaa.Sharpen(1.0, lightness=2),
background=iaa.CoarseDropout(p=0.1, size_px=8)
),
iaa.BlendAlpha(
factor=(0.2, 0.8),
foreground=iaa.Affine(rotate=(-5, 5)),
per_channel=True
),
iaa.MotionBlur(k=15, angle=[-5, 5]),
iaa.BlendAlphaCheckerboard(nb_rows=2, nb_cols=(1, 4),
foreground=iaa.AddToHue((-10, 10))),
iaa.BlendAlphaElementwise((0, 1.0), iaa.AddToHue(10)),
iaa.BilateralBlur(
d=(3, 10), sigma_color=(1, 5), sigma_space=(1, 5)),
iaa.AdditiveGaussianNoise(scale=0.02 * 255),
iaa.AddElementwise((-5, 5), per_channel=0.5),
iaa.AdditiveLaplaceNoise(scale=0.01 * 255),
iaa.AdditivePoissonNoise(20),
iaa.Cutout(fill_mode="gaussian", fill_per_channel=True),
iaa.CoarseDropout(0.02, size_percent=0.1),
iaa.SaltAndPepper(0.1, per_channel=True),
iaa.JpegCompression(compression=(70, 99)),
iaa.ImpulseNoise(0.02),
iaa.Dropout(p=(0, 0.04)),
iaa.Sharpen(alpha=0.1),
]) # oneof
])
def __init__(self,
base_data_path,
train,
transform,
id_name_path,
device,
little_train=False,
read_mode='jpeg4py',
input_size=224,
C=2048,
test_mode=False):
print('data init')
self.train = train
self.base_data_path = base_data_path
self.transform = transform
self.fnames = []
self.resize = input_size
self.little_train = little_train
self.id_name_path = id_name_path
self.C = C
self.read_mode = read_mode
self.device = device
self._test = test_mode
self.fnames = self.get_data_list(base_data_path)
self.num_samples = len(self.fnames)
self.get_id_map()
self.cls_path_map = self.get_cls_pathlist_map()
self.img_augsometimes = lambda aug: iaa.Sometimes(0.5, aug)
self.augmentation = iaa.Sequential(
[
# augment without change bboxes
self.img_augsometimes(
iaa.SomeOf(
(1, 4),
[
iaa.Dropout([0.05, 0.2
]), # drop 5% or 20% of all pixels
iaa.Sharpen((0.1, .8)), # sharpen the image
# iaa.GaussianBlur(sigma=(2., 3.5)),
iaa.OneOf([
iaa.GaussianBlur(sigma=(2., 3.5)),
iaa.AverageBlur(k=(2, 5)),
iaa.BilateralBlur(d=(7, 12),
sigma_color=(10, 250),
sigma_space=(10, 250)),
iaa.MedianBlur(k=(3, 7)),
]),
iaa.AddElementwise((-50, 50)),
iaa.AdditiveGaussianNoise(scale=(0, 0.1 * 255)),
iaa.JpegCompression(compression=(80, 95)),
iaa.Multiply((0.5, 1.5)),
iaa.MultiplyElementwise((0.5, 1.5)),
iaa.ReplaceElementwise(0.05, [0, 255]),
# iaa.WithColorspace(to_colorspace="HSV", from_colorspace="RGB",
# children=iaa.WithChannels(2, iaa.Add((-10, 50)))),
iaa.OneOf([
iaa.WithColorspace(to_colorspace="HSV",
from_colorspace="RGB",
children=iaa.WithChannels(
1, iaa.Add((-10, 50)))),
iaa.WithColorspace(to_colorspace="HSV",
from_colorspace="RGB",
children=iaa.WithChannels(
2, iaa.Add((-10, 50)))),
]),
iaa.Affine(scale={
"x": (0.8, 1.2),
"y": (0.8, 1.2)
},
translate_percent={
"x": (-0.2, 0.2),
"y": (-0.2, 0.2)
},
rotate=(-25, 25),
shear=(-8, 8))
],
random_order=True)),
iaa.Fliplr(.5),
iaa.Flipud(.25),
],
random_order=True)
class AugmentationScheme:
# Dictionary containing all possible augmentation functions
Augmentations = {
# Convert images to HSV, then increase each pixel's Hue (H), Saturation (S) or Value/lightness (V) [0, 1, 2]
# value by an amount in between lo and hi:
"HSV":
lambda channel, lo, hi: iaa.WithColorspace(
to_colorspace="HSV",
from_colorspace="RGB",
children=iaa.WithChannels(channel, iaa.Add((lo, hi)))),
# The augmenter first transforms images to HSV color space, then adds random values (lo to hi)
# to the H and S channels and afterwards converts back to RGB.
# (independently per channel and the same value for all pixels within that channel)
"Add_To_Hue_And_Saturation":
lambda lo, hi: iaa.AddToHueAndSaturation((lo, hi), per_channel=True),
# Increase each pixel’s channel-value (redness/greenness/blueness) [0, 1, 2] by value in between lo and hi:
"Increase_Channel":
lambda channel, lo, hi: iaa.WithChannels(channel, iaa.Add((lo, hi))),
# Rotate each image’s channel [R=0, G=1, B=2] by value in between lo and hi degrees:
"Rotate_Channel":
lambda channel, lo, hi: iaa.WithChannels(channel,
iaa.Affine(rotate=(lo, hi))),
# Augmenter that never changes input images (“no operation”).
"No_Operation":
iaa.Noop(),
# Pads images, i.e. adds columns/rows to them. Pads image by value in between lo and hi
# percent relative to its original size (only accepts positive values in range[0, 1]):
# If s_i is false, The value will be sampled once per image and used for all sides
# (i.e. all sides gain/lose the same number of rows/columns)
# NOTE: automatically resizes images back to their original size after it has augmented them.
"Pad_Percent":
lambda lo, hi, s_i: iaa.Pad(
percent=(lo, hi), keep_size=True, sample_independently=s_i),
# Pads images by a number of pixels between lo and hi
# If s_i is false, The value will be sampled once per image and used for all sides
# (i.e. all sides gain/lose the same number of rows/columns)
"Pad_Pixels":
lambda lo, hi, s_i: iaa.Pad(
px=(lo, hi), keep_size=True, sample_independently=s_i),
# Crops/cuts away pixels at the sides of the image.
# Crops images by value in between lo and hi (only accepts positive values in range[0, 1]):
# If s_i is false, The value will be sampled once per image and used for all sides
# (i.e. all sides gain/lose the same number of rows/columns)
# NOTE: automatically resizes images back to their original size after it has augmented them.
"Crop_Percent":
lambda lo, hi, s_i: iaa.Crop(
percent=(lo, hi), keep_size=True, sample_independently=s_i),
# Crops images by a number of pixels between lo and hi
# If s_i is false, The value will be sampled once per image and used for all sides
# (i.e. all sides gain/lose the same number of rows/columns)
"Crop_Pixels":
lambda lo, hi, s_i: iaa.Crop(
px=(lo, hi), keep_size=True, sample_independently=s_i),
# Flip/mirror percent (i.e 0.5) of the input images horizontally
# The default probability is 0, so to flip all images, percent=1
"Flip_lr":
iaa.Fliplr(1),
# Flip/mirror percent (i.e 0.5) of the input images vertically
# The default probability is 0, so to flip all images, percent=1
"Flip_ud":
iaa.Flipud(1),
# Completely or partially transform images to their superpixel representation.
# Generate s_pix_lo to s_pix_hi superpixels per image. Replace each superpixel with a probability between
# prob_lo and prob_hi with range[0, 1] (sampled once per image) by its average pixel color.
"Superpixels":
lambda prob_lo, prob_hi, s_pix_lo, s_pix_hi: iaa.Superpixels(
p_replace=(prob_lo, prob_hi), n_segments=(s_pix_lo, s_pix_hi)),
# Change images to grayscale and overlay them with the original image by varying strengths,
# effectively removing alpha_lo to alpha_hi of the color:
"Grayscale":
lambda alpha_lo, alpha_hi: iaa.Grayscale(alpha=(alpha_lo, alpha_hi)),
# Blur each image with a gaussian kernel with a sigma between sigma_lo and sigma_hi:
"Gaussian_Blur":
lambda sigma_lo, sigma_hi: iaa.GaussianBlur(sigma=(sigma_lo, sigma_hi)
),
# Blur each image using a mean over neighbourhoods that have random sizes,
# which can vary between h_lo and h_hi in height and w_lo and w_hi in width:
"Average_Blur":
lambda h_lo, h_hi, w_lo, w_hi: iaa.AverageBlur(k=((h_lo, h_hi),
(w_lo, w_hi))),
# Blur each image using a median over neighbourhoods that have a random size between lo x lo and hi x hi:
"Median_Blur":
lambda lo, hi: iaa.MedianBlur(k=(lo, hi)),
# Sharpen an image, then overlay the results with the original using an alpha between alpha_lo and alpha_hi:
"Sharpen":
lambda alpha_lo, alpha_hi, lightness_lo, lightness_hi: iaa.
Sharpen(alpha=(alpha_lo, alpha_hi),
lightness=(lightness_lo, lightness_hi)),
# Emboss an image, then overlay the results with the original using an alpha between alpha_lo and alpha_hi:
"Emboss":
lambda alpha_lo, alpha_hi, strength_lo, strength_hi: iaa.Emboss(
alpha=(alpha_lo, alpha_hi), strength=(strength_lo, strength_hi)),
# Detect edges in images, turning them into black and white images and
# then overlay these with the original images using random alphas between alpha_lo and alpha_hi:
"Detect_Edges":
lambda alpha_lo, alpha_hi: iaa.EdgeDetect(alpha=(alpha_lo, alpha_hi)),
# Detect edges having random directions between dir_lo and dir_hi (i.e (0.0, 1.0) = 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 alpha_lo and alpha_hi:
"Directed_edge_Detect":
lambda alpha_lo, alpha_hi, dir_lo, dir_hi: iaa.DirectedEdgeDetect(
alpha=(alpha_lo, alpha_hi), direction=(dir_lo, dir_hi)),
# Add random values between lo and hi to images. In percent of all images the values differ per channel
# (3 sampled value). In the rest of the images the value is the same for all channels:
"Add":
lambda lo, hi, percent: iaa.Add((lo, hi), per_channel=percent),
# Adds random values between lo and hi to images, with each value being sampled per pixel.
# In percent of all images the values differ per channel (3 sampled value). In the rest of the images
# the value is the same for all channels:
"Add_Element_Wise":
lambda lo, hi, percent: iaa.AddElementwise(
(lo, hi), per_channel=percent),
# Add gaussian noise (aka white noise) to an image, sampled once per pixel from a normal
# distribution N(0, s), where s is sampled per image and varies between lo and hi*255 for percent of all
# images (sampled once for all channels) and sampled three (RGB) times (channel-wise)
# for the rest from the same normal distribution:
"Additive_Gaussian_Noise":
lambda lo, hi, percent: iaa.AdditiveGaussianNoise(scale=(lo, hi),
per_channel=percent),
# Multiply in percent of all images each pixel with random values between lo and hi and multiply
# the pixels in the rest of the images channel-wise,
# i.e. sample one multiplier independently per channel and pixel:
"Multiply":
lambda lo, hi, percent: iaa.Multiply((lo, hi), per_channel=percent),
# 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 lo and hi:
"Multiply_Element_Wise":
lambda lo, hi, percent: iaa.MultiplyElementwise(
(0.5, 1.5), per_channel=0.5),
# Augmenter that sets a certain fraction of pixels in images to zero.
# Sample per image a value p from the range lo<=p<=hi 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 percent of all images
"Dropout":
lambda lo, hi, percent: iaa.Dropout(p=(lo, hi), per_channel=percent),
# Augmenter that sets rectangular areas within images to zero.
# Drop d_lo to d_hi percent of all pixels by converting them to black pixels,
# but do that on a lower-resolution version of the image that has s_lo to s_hi percent of the original size,
# Also do this in percent of all images channel-wise, so that only the information of some
# channels is set to 0 while others remain untouched:
"Coarse_Dropout":
lambda d_lo, d_hi, s_lo, s_hi, percent: iaa.CoarseDropout(
(d_lo, d_hi), size_percent=(s_hi, s_hi), per_channel=percent),
# Augmenter that inverts all values in images, i.e. sets a pixel from value v to 255-v.
# For c_percent of all images, invert all pixels in these images channel-wise with probability=i_percent
# (per image). In the rest of the images, invert i_percent of all channels:
"Invert":
lambda i_percent, c_percent: iaa.Invert(i_percent,
per_channel=c_percent),
# Augmenter that changes the contrast of images.
# Normalize contrast by a factor of lo to hi, sampled randomly per image
# and for percent of all images also independently per channel:
"Contrast_Normalisation":
lambda lo, hi, percent: iaa.ContrastNormalization(
(lo, hi), per_channel=percent),
# Scale images to a value of lo to hi percent of their original size but do this independently per axis:
"Scale":
lambda x_lo, x_hi, y_lo, y_hi: iaa.Affine(scale={
"x": (x_lo, x_hi),
"y": (y_lo, y_hi)
}),
# Translate images by lo to hi percent on x-axis and y-axis independently:
"Translate_Percent":
lambda x_lo, x_hi, y_lo, y_hi: iaa.Affine(translate_percent={
"x": (x_lo, x_hi),
"y": (y_lo, y_hi)
}),
# Translate images by lo to hi pixels on x-axis and y-axis independently:
"Translate_Pixels":
lambda x_lo, x_hi, y_lo, y_hi: iaa.Affine(translate_px={
"x": (x_lo, x_hi),
"y": (y_lo, y_hi)
}),
# Rotate images by lo to hi degrees:
"Rotate":
lambda lo, hi: iaa.Affine(rotate=(lo, hi)),
# Shear images by lo to hi degrees:
"Shear":
lambda lo, hi: iaa.Affine(shear=(lo, hi)),
# 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 lo to hi:
"Piecewise_Affine":
lambda lo, hi: iaa.PiecewiseAffine(scale=(lo, hi)),
# 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 sigma_lo to sigma_hi. The strength of the movement is sampled per pixel from the range
# alpha_lo to alpha_hi:
"Elastic_Transformation":
lambda alpha_lo, alpha_hi, sigma_lo, sigma_hi: iaa.
ElasticTransformation(alpha=(alpha_lo, alpha_hi),
sigma=(sigma_lo, sigma_hi)),
# Weather augmenters are computationally expensive and will not work effectively on certain data sets
# Augmenter to draw clouds in images.
"Clouds":
iaa.Clouds(),
# Augmenter to draw fog in images.
"Fog":
iaa.Fog(),
# Augmenter to add falling snowflakes to images.
"Snowflakes":
iaa.Snowflakes(),
# Replaces percent of all pixels in an image by either x or y
"Replace_Element_Wise":
lambda percent, x, y: iaa.ReplaceElementwise(percent, [x, y]),
# Adds laplace noise (somewhere between gaussian and salt and peeper noise) to an image, sampled once per pixel
# from a laplace distribution Laplace(0, s), where s is sampled per image and varies between lo and hi*255 for
# percent of all images (sampled once for all channels) and sampled three (RGB) times (channel-wise)
# for the rest from the same laplace distribution:
"Additive_Laplace_Noise":
lambda lo, hi, percent: iaa.AdditiveLaplaceNoise(scale=(lo, hi),
per_channel=percent),
# Adds poisson noise (similar to gaussian but different distribution) to an image, sampled once per pixel from
# a poisson distribution Poisson(s), where s is sampled per image and varies between lo and hi for percent of
# all images (sampled once for all channels) and sampled three (RGB) times (channel-wise)
# for the rest from the same poisson distribution:
"Additive_Poisson_Noise":
lambda lo, hi, percent: iaa.AdditivePoissonNoise(lam=(lo, hi),
per_channel=percent),
# Adds salt and pepper noise to an image, i.e. some white-ish and black-ish pixels.
# Replaces percent of all pixels with salt and pepper noise
"Salt_And_Pepper":
lambda percent: iaa.SaltAndPepper(percent),
# Adds coarse salt and pepper noise to image, i.e. rectangles that contain noisy white-ish and black-ish pixels
# Replaces percent of all pixels with salt/pepper in an image that has lo to hi percent of the input image size,
# then upscales the results to the input image size, leading to large rectangular areas being replaced.
"Coarse_Salt_And_Pepper":
lambda percent, lo, hi: iaa.CoarseSaltAndPepper(percent,
size_percent=(lo, hi)),
# Adds salt noise to an image, i.e white-ish pixels
# Replaces percent of all pixels with salt noise
"Salt":
lambda percent: iaa.Salt(percent),
# Adds coarse salt noise to image, i.e. rectangles that contain noisy white-ish pixels
# Replaces percent of all pixels with salt in an image that has lo to hi percent of the input image size,
# then upscales the results to the input image size, leading to large rectangular areas being replaced.
"Coarse_Salt":
lambda percent, lo, hi: iaa.CoarseSalt(percent, size_percent=(lo, hi)),
# Adds Pepper noise to an image, i.e Black-ish pixels
# Replaces percent of all pixels with Pepper noise
"Pepper":
lambda percent: iaa.Pepper(percent),
# Adds coarse pepper noise to image, i.e. rectangles that contain noisy black-ish pixels
# Replaces percent of all pixels with salt in an image that has lo to hi percent of the input image size,
# then upscales the results to the input image size, leading to large rectangular areas being replaced.
"Coarse_Pepper":
lambda percent, lo, hi: iaa.CoarsePepper(percent,
size_percent=(lo, hi)),
# In an alpha blending, two images are naively mixed. E.g. Let A be the foreground image, B be the background
# image and a is the alpha value. Each pixel intensity is then computed as a * A_ij + (1-a) * B_ij.
# Images passed in must be a numpy array of type (height, width, channel)
"Blend_Alpha":
lambda image_fg, image_bg, alpha: iaa.blend_alpha(
image_fg, image_bg, alpha),
# Blur/Denoise an image using a bilateral filter.
# Bilateral filters blur homogeneous and textured areas, while trying to preserve edges.
# Blurs all images using a bilateral filter with max distance d_lo to d_hi with ranges for sigma_colour
# and sigma space being define by sc_lo/sc_hi and ss_lo/ss_hi
"Bilateral_Blur":
lambda d_lo, d_hi, sc_lo, sc_hi, ss_lo, ss_hi: iaa.BilateralBlur(
d=(d_lo, d_hi),
sigma_color=(sc_lo, sc_hi),
sigma_space=(ss_lo, ss_hi)),
# Augmenter that sharpens images and overlays the result with the original image.
# Create a motion blur augmenter with kernel size of (kernel x kernel) and a blur angle of either x or y degrees
# (randomly picked per image).
"Motion_Blur":
lambda kernel, x, y: iaa.MotionBlur(k=kernel, angle=[x, y]),
# Augmenter to apply standard histogram equalization to images (similar to CLAHE)
"Histogram_Equalization":
iaa.HistogramEqualization(),
# Augmenter to perform standard histogram equalization on images, applied to all channels of each input image
"All_Channels_Histogram_Equalization":
iaa.AllChannelsHistogramEqualization(),
# Contrast Limited Adaptive Histogram Equalization (CLAHE). This augmenter applies CLAHE to images, a form of
# histogram equalization that normalizes within local image patches.
# Creates a CLAHE augmenter with clip limit uniformly sampled from [cl_lo..cl_hi], i.e. 1 is rather low contrast
# and 50 is rather high contrast. Kernel sizes of SxS, where S is uniformly sampled from [t_lo..t_hi].
# Sampling happens once per image. (Note: more parameters are available for further specification)
"CLAHE":
lambda cl_lo, cl_hi, t_lo, t_hi: iaa.CLAHE(
clip_limit=(cl_lo, cl_hi), tile_grid_size_px=(t_lo, t_hi)),
# Contrast Limited Adaptive Histogram Equalization (refer above), applied to all channels of the input images.
# CLAHE performs histogram equalization within image patches, i.e. over local neighbourhoods
"All_Channels_CLAHE":
lambda cl_lo, cl_hi, t_lo, t_hi: iaa.AllChannelsCLAHE(
clip_limit=(cl_lo, cl_hi), tile_grid_size_px=(t_lo, t_hi)),
# Augmenter that changes the contrast of images using a unique formula (using gamma).
# Multiplier for gamma function is between lo and hi,, sampled randomly per image (higher values darken image)
# For percent of all images values are sampled independently per channel.
"Gamma_Contrast":
lambda lo, hi, percent: iaa.GammaContrast(
(lo, hi), per_channel=percent),
# Augmenter that changes the contrast of images using a unique formula (linear).
# Multiplier for linear function is between lo and hi, sampled randomly per image
# For percent of all images values are sampled independently per channel.
"Linear_Contrast":
lambda lo, hi, percent: iaa.LinearContrast(
(lo, hi), per_channel=percent),
# Augmenter that changes the contrast of images using a unique formula (using log).
# Multiplier for log function is between lo and hi, sampled randomly per image.
# For percent of all images values are sampled independently per channel.
# Values around 1.0 lead to a contrast-adjusted images. Values above 1.0 quickly lead to partially broken
# images due to exceeding the datatype’s value range.
"Log_Contrast":
lambda lo, hi, percent: iaa.LogContrast((lo, hi), per_channel=percent),
# Augmenter that changes the contrast of images using a unique formula (sigmoid).
# Multiplier for sigmoid function is between lo and hi, sampled randomly per image. c_lo and c_hi decide the
# cutoff value that shifts the sigmoid function in horizontal direction (Higher values mean that the switch
# from dark to light pixels happens later, i.e. the pixels will remain darker).
# For percent of all images values are sampled independently per channel:
"Sigmoid_Contrast":
lambda lo, hi, c_lo, c_hi, percent: iaa.SigmoidContrast(
(lo, hi), (c_lo, c_hi), per_channel=percent),
# Augmenter that calls a custom (lambda) function for each batch of input image.
# Extracts Canny Edges from images (refer to description in CO)
# Good default values for min and max are 100 and 200
'Custom_Canny_Edges':
lambda min_val, max_val: iaa.Lambda(func_images=CO.Edges(
min_value=min_val, max_value=max_val)),
}
# AugmentationScheme objects require images and labels.
# 'augs' is a list that contains all data augmentations in the scheme
def __init__(self):
self.augs = [iaa.Flipud(1)]
def __call__(self, image):
image = np.array(image)
aug_scheme = iaa.Sometimes(
0.5,
iaa.SomeOf(random.randrange(1,
len(self.augs) + 1),
self.augs,
random_order=True))
aug_img = self.aug_scheme.augment_image(image)
# fixes negative strides
aug_img = aug_img[..., ::1] - np.zeros_like(aug_img)
return aug_img
