def __init__(self):
sometimes = lambda aug: iaa.Sometimes(0.3, aug)
self.aug = iaa.Sequential(iaa.SomeOf((1, 5),
[
# blur
sometimes(iaa.OneOf([iaa.GaussianBlur(sigma=(0, 1.0)),
iaa.MotionBlur(k=3)])),
# color
sometimes(iaa.AddToHueAndSaturation(value=(-10, 10), per_channel=True)),
sometimes(iaa.SigmoidContrast(gain=(3, 10), cutoff=(0.4, 0.6), per_channel=True)),
sometimes(iaa.Invert(0.25, per_channel=0.5)),
sometimes(iaa.Solarize(0.5, threshold=(32, 128))),
sometimes(iaa.Dropout2d(p=0.5)),
sometimes(iaa.Multiply((0.5, 1.5), per_channel=0.5)),
sometimes(iaa.Add((-40, 40), per_channel=0.5)),
sometimes(iaa.JpegCompression(compression=(5, 80))),
# distort
sometimes(iaa.Crop(percent=(0.01, 0.05), sample_independently=True)),
sometimes(iaa.PerspectiveTransform(scale=(0.01, 0.01))),
sometimes(iaa.Affine(scale=(0.7, 1.3), translate_percent=(-0.1, 0.1),
# rotate=(-5, 5), shear=(-5, 5),
order=[0, 1], cval=(0, 255),
mode=ia.ALL)),
sometimes(iaa.PiecewiseAffine(scale=(0.01, 0.01))),
sometimes(iaa.OneOf([iaa.Dropout(p=(0, 0.1)),
iaa.CoarseDropout(p=(0, 0.1), size_percent=(0.02, 0.25))])),
],
random_order=True),
random_order=True)
def apply_augmentation(images):
seq = iaa.Sequential([
# Blur
iaa.SomeOf((0, 1), [
iaa.GaussianBlur(sigma=(1., 2.5)),
iaa.AverageBlur(k=(2, 5))
]),
# Rotation and padding
iaa.SomeOf((0,1), [
iaa.Affine(translate_percent={"x": (-0.1, 0.1), "y": (-0.1, 0.1)}),
]),
# Light
iaa.SomeOf((0,2), [
iaa.GammaContrast((0.5, 2.0)),
iaa.SigmoidContrast(gain=(3, 10), cutoff=(0.4, 0.6)),
iaa.Multiply((0.5, 1.5)),
iaa.ContrastNormalization((0.5, 1.5))
]),
# Noise
iaa.SomeOf((0, 1), [
iaa.AdditiveGaussianNoise(scale=(0, 0.1*255)),
iaa.AdditiveLaplaceNoise(scale=(0, 0.1*255)),
iaa.SaltAndPepper(0.02),
])
])
image = seq(images=images)
return image
def data_aug(images):
seq = iaa.Sometimes(
0.5, iaa.Identity(),
iaa.Sometimes(
0.5,
iaa.Sequential([
iaa.Sometimes(
0.5,
iaa.OneOf([
iaa.AdditiveGaussianNoise(scale=(0, 0.1 * 255)),
iaa.AdditiveLaplaceNoise(scale=(0, 0.1 * 255)),
iaa.ReplaceElementwise(0.03, [0, 255]),
iaa.GaussianBlur(sigma=(0.0, 3.0)),
iaa.BilateralBlur(d=(3, 10),
sigma_color=(10, 250),
sigma_space=(10, 250))
])),
iaa.OneOf([
iaa.Add((-40, 40)),
iaa.AddElementwise((-20, 20)),
iaa.pillike.EnhanceBrightness()
]),
iaa.OneOf([
iaa.GammaContrast((0.2, 2.0)),
iaa.SigmoidContrast(gain=(3, 10), cutoff=(0.4, 0.6)),
iaa.LogContrast(gain=(0.6, 1.4)),
iaa.AllChannelsCLAHE(),
iaa.Sharpen(alpha=(0.0, 1.0), lightness=(0.75, 2.0)),
])
])))
images = seq(images=images)
return images
def augment(self):
data = ParseCoco(path_to_package_images=PATH_TO_PACKAGE_IMAGES,
path_to_json=PATH_TO_JSON,
type_of_labels=TYPE_OF_LABELS)()
loop = 0
while loop != 5: # Fives times make augmentations
for filename, polygons in tqdm(data.items()):
image = imageio.imread(
os.path.join(PATH_TO_PACKAGE_IMAGES, filename))
list_of_poly_objects = []
for polygon in polygons:
poly_object = Polygon(polygon)
list_of_poly_objects.append(poly_object)
psoi = PolygonsOnImage(list_of_poly_objects, shape=image.shape)
aug = iaa.Sequential([
iaa.AdditiveGaussianNoise(scale=(0, 50)),
iaa.SigmoidContrast(gain=(3, 10), cutoff=(0.4, 0.6)),
# iaa.AddToHueAndSaturation((-50, 50)),
iaa.Add((-40, 40)),
iaa.Affine(rotate=(-20, 20),
translate_percent={
"x": 0.1,
"y": 0.1
},
scale=(0.5, 1.8)),
iaa.Fliplr(1.0)
])
image_aug, psoi_aug = aug(image=image, polygons=psoi)
# new_name = filename.split('.')[0]
cv2.imwrite("augmented/{}loop{}.jpg".format(filename, LOOPS),
image_aug)
loop += 1
def imgaugRGB(img):
print(img.shape)
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((-20, 20)),
#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.5, 1.5), per_channel=0.5)
]),
iaa.Add((-10, 10), per_channel=0.5),
iaa.Multiply((0.5, 1.5), per_channel=0.5),
iaa.FrequencyNoiseAlpha(exponent=(-4, 0),
first=iaa.Multiply(
(0.5, 1.5), per_channel=0.5),
second=iaa.ContrastNormalization(
(0.5, 2.0), per_channel=0.5))
]),
#contrast
iaa.SomeOf((0, 2), [
iaa.GammaContrast((0.5, 1.5), 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)
]),
#arithmetic
iaa.SomeOf((0, 3), [
iaa.AdditiveGaussianNoise(scale=(0, 0.05), per_channel=0.5),
iaa.AdditiveLaplaceNoise(scale=(0, 0.05), per_channel=0.5),
iaa.AdditivePoissonNoise(lam=(0, 8), per_channel=0.5),
iaa.Dropout(p=(0, 0.05), per_channel=0.5),
iaa.ImpulseNoise(p=(0, 0.05)),
iaa.SaltAndPepper(p=(0, 0.05)),
iaa.Salt(p=(0, 0.05)),
iaa.Pepper(p=(0, 0.05))
]),
#iaa.Sometimes(p=0.5, iaa.JpegCompression((0, 30)), None),
],
random_order=True)
return seq.augment_image(img)
def augmenter_1(p=0.99):
"""Create augmenter.
Contains no coordinate transforms.
Parameters
----------
p : float
Number in [0, 1] representing the probability of a random augmentation happening.
Returns
-------
seq : iaa.Augmenter
Augmenter where each augmentation was manually inspected and makes
sense.
"""
subsubseq_1 = iaa.Multiply(mul=(0.8, 1.2))
subsubseq_2 = iaa.Sequential([iaa.Sharpen(alpha=(0, 1))])
subsubseq_3 = iaa.Sequential([iaa.EdgeDetect(alpha=(0, 0.9))])
subsubseq_4 = iaa.OneOf(
[iaa.GaussianBlur((0, 3.0)),
iaa.AverageBlur(k=(2, 7))])
subsubseq_5 = iaa.AdditiveGaussianNoise(loc=(0, 0.5), scale=(0, 0.2))
subsubseq_6 = iaa.Add((-0.3, 0.3))
subsubseq_7 = iaa.Invert(p=1)
subsubseq_8 = iaa.CoarseDropout(p=0.25, size_percent=(0.005, 0.06))
subsubseq_9 = iaa.SigmoidContrast(gain=(0.8, 1.2))
subsubseq_10 = iaa.LinearContrast(alpha=(0.8, 1.2))
subsubseq_11 = iaa.Sequential([iaa.Emboss(alpha=(0, 1))])
seq = iaa.Sometimes(
p,
iaa.OneOf([
subsubseq_1,
subsubseq_2,
subsubseq_3,
subsubseq_4,
subsubseq_5,
subsubseq_6,
subsubseq_7,
subsubseq_8,
subsubseq_9,
subsubseq_10,
subsubseq_11,
]),
)
return seq
def contrast():
return iaa.OneOf([
iaa.ContrastNormalization((0.5, 1.5), per_channel=0.5),
iaa.GammaContrast((0.5, 1.5), per_channel=0.5),
iaa.HistogramEqualization(),
iaa.LinearContrast((0.5, 1.5), per_channel=0.5),
iaa.LogContrast((0.5, 1.5), per_channel=0.5),
iaa.SigmoidContrast((5, 20), (0.25, 0.75), per_channel=0.5),
])
def get_preview(images, augmentationList):
"""
Accepts a list of images and augmentationList as input.
Provides a list of augmented images in that order as ouptut.
"""
augmented = []
for image in images:
for augmentation in augmentationList:
aug_id = augmentation['id']
params = augmentation['params']
if (aug_id == 1):
image = iaa.SaltAndPepper(p=params[0],
per_channel=params[1])(image=image)
elif (aug_id == 2):
image = iaa.imgcorruptlike.GaussianNoise(
severity=(params[0], params[1]))(image=image)
elif (aug_id == 3):
image = iaa.Rain(speed=(params[0], params[1]),
drop_size=(params[2], params[3]))(image=image)
elif (aug_id == 4):
image = iaa.imgcorruptlike.Fog(
severity=(params[0], params[1]))(image=image)
elif (aug_id == 5):
image = iaa.imgcorruptlike.Snow(
severity=(params[0], params[1]))(image=image)
elif (aug_id == 6):
image = iaa.imgcorruptlike.Spatter(
severity=(params[0], params[1]))(image=image)
elif (aug_id == 7):
image = iaa.BlendAlphaSimplexNoise(
iaa.EdgeDetect(1))(image=image)
elif (aug_id == 8):
image = iaa.Rotate(rotate=(params[0], params[1]))(image=image)
elif (aug_id == 9):
image = iaa.Affine()(image=image) #to be implemented
elif (aug_id == 10):
image = iaa.MotionBlur(k=params[0],
angle=(params[1],
params[2]))(image=image)
elif (aug_id == 11):
image = iaa.imgcorruptlike.ZoomBlur(
severity=(params[0], params[1]))(image=image)
elif (aug_id == 12):
image = iaa.AddToBrightness()(image=image) #to be implemented
elif (aug_id == 13):
image = iaa.ChangeColorTemperature(
kelvin=(params[0], params[1]))(image=image)
elif (aug_id == 14):
image = iaa.SigmoidContrast()(image=image) #to be implemented
elif (aug_id == 15):
image = iaa.Cutout(nb_iterations=(params[0], params[1]),
size=params[2],
squared=params[3])(image=image)
else:
print("Not implemented")
augmented.append(image)
return augmented
def chapter_augmenters_sigmoidcontrast():
fn_start = "contrast/sigmoidcontrast"
aug = iaa.SigmoidContrast(gain=(3, 10), cutoff=(0.4, 0.6))
run_and_save_augseq(fn_start + ".jpg",
aug,
[ia.quokka(size=(128, 128)) for _ in range(4 * 2)],
cols=4,
rows=2)
aug = iaa.SigmoidContrast(gain=(3, 10),
cutoff=(0.4, 0.6),
per_channel=True)
run_and_save_augseq(fn_start + "_per_channel.jpg",
aug,
[ia.quokka(size=(128, 128)) for _ in range(4 * 2)],
cols=4,
rows=2)
def sigmoid_cont_img(self, image, label, gain_max, gain_min, cutoff_max,
cutoff_min):
gain = random.uniform(gain_max, gain_min)
cutoff = random.uniform(cutoff_max, cutoff_min)
sigmoid_cont = iaa.SigmoidContrast(gain=gain, cutoff=cutoff)
image = sigmoid_cont.augment_image(image)
return image, label
def main(image2bboxes, annot_file):
bbs, images, classes, img_files = [], [], [], []
for img_file in image2bboxes:
bb = image2bboxes[img_file] # this has class, too
images.append(plt.imread(os.path.join('..', img_file)))
img_files.append(img_file)
many_boxes = []
many_classes = []
# Parse out bboxes and classes, adding bboxes as imgaug BoundingBox objects
for box in bb:
box = [int(x) for x in box.split(',')]
many_boxes.append(ia.BoundingBox(x1=box[0], y1=box[1], x2=box[2], y2=box[3]))
many_classes.append(box[4])
bbs.append(many_boxes)
classes.append(many_classes)
# To sometimes apply aug
sometimes = lambda aug: iaa.Sometimes(0.5, aug)
# The transformations!!!
seq = iaa.Sequential([
iaa.AdditiveGaussianNoise(scale=0.05*255),
# iaa.Affine(translate_px={"x": (1, 5)}),
# sometimes(iaa.Fog()),
sometimes(iaa.SigmoidContrast(cutoff=0.7)),
# sometimes(iaa.Multiply(0.5)),
sometimes(iaa.Add(-10)),
sometimes(iaa.Pad(px=(256, 256, 0, 0)))
])
images_aug, bbs_aug = seq(images=images, bounding_boxes=bbs)
# Save images
for i in range(len(images)):
img_file = img_files[i]
# Create new file name and save
name_spl = os.path.basename(img_file).split('.')
ending = name_spl[-1]
new_file_name = '.'.join(name_spl[0:-1]) + '_aug' + '.' + ending
plt.imsave(os.path.join('..', 'data', 'JPEGImages', new_file_name), images_aug[i])
# Save annotations to one file
with open(annot_file.replace('.txt', '_aug.txt'), 'w') as f:
for i in range(len(images)):
items = []
name_spl = os.path.basename(img_files[i]).split('.')
ending = name_spl[-1]
new_file_name = '.'.join(name_spl[0:-1]) + '_aug' + '.' + ending
items.append('data/JPEGImages/' + new_file_name)
many_boxes = bbs_aug[i]
many_classes = classes[i]
for j in range(len(many_boxes)):
box = many_boxes[j]
annot = ','.join([str(int(x)) for x in [box.x1, box.y1, box.x2, box.y2, many_classes[j]]])
items.append(annot)
f.write(' '.join(items) + '\n')
def __init__(self):
sometimes = lambda aug: iaa.Sometimes(0.5, aug)
self.aug = iaa.SomeOf(
3,
[
sometimes(
iaa.AddToHueAndSaturation((-50, 50), per_channel=True)),
sometimes(
iaa.SigmoidContrast(
gain=(3, 10), cutoff=(0.4, 0.6), per_channel=True)),
#sometimes(iaa.PiecewiseAffine(scale=(0.01, 0.02))),
sometimes(iaa.Invert(0.7, per_channel=0.8)),
sometimes(iaa.Rotate((-20, 20)))
])
def main():
parser = argparse.ArgumentParser(description="Contrast check script")
parser.add_argument("--per_channel", dest="per_channel", action="store_true")
args = parser.parse_args()
augs = []
for p in [0.25, 0.5, 1.0, 2.0, (0.5, 1.5), [0.5, 1.0, 1.5]]:
augs.append(("GammaContrast " + str(p), iaa.GammaContrast(p, per_channel=args.per_channel)))
for cutoff in [0.25, 0.5, 0.75]:
for gain in [5, 10, 15, 20, 25]:
augs.append(("SigmoidContrast " + str(cutoff) + " " + str(gain), iaa.SigmoidContrast(gain, cutoff, per_channel=args.per_channel)))
for gain in [0.0, 0.25, 0.5, 1.0, 2.0, (0.5, 1.5), [0.5, 1.0, 1.5]]:
augs.append(("LogContrast " + str(gain), iaa.LogContrast(gain, per_channel=args.per_channel)))
for alpha in [-1.0, 0.5, 0, 0.5, 1.0, 2.0, (0.5, 1.5), [0.5, 1.0, 1.5]]:
augs.append(("LinearContrast " + str(alpha), iaa.LinearContrast(alpha, per_channel=args.per_channel)))
augs.append(("AllChannelsHistogramEqualization", iaa.AllChannelsHistogramEqualization()))
augs.append(("HistogramEqualization (Lab)", iaa.HistogramEqualization(to_colorspace=iaa.HistogramEqualization.Lab)))
augs.append(("HistogramEqualization (HSV)", iaa.HistogramEqualization(to_colorspace=iaa.HistogramEqualization.HSV)))
augs.append(("HistogramEqualization (HLS)", iaa.HistogramEqualization(to_colorspace=iaa.HistogramEqualization.HLS)))
for clip_limit in [0.1, 1, 5, 10]:
for tile_grid_size_px in [3, 7]:
augs.append(("AllChannelsCLAHE %d %dx%d" % (clip_limit, tile_grid_size_px, tile_grid_size_px),
iaa.AllChannelsCLAHE(clip_limit=clip_limit, tile_grid_size_px=tile_grid_size_px,
per_channel=args.per_channel)))
for clip_limit in [1, 5, 10, 100, 200]:
for tile_grid_size_px in [3, 7, 15]:
augs.append(("CLAHE %d %dx%d" % (clip_limit, tile_grid_size_px, tile_grid_size_px),
iaa.CLAHE(clip_limit=clip_limit, tile_grid_size_px=tile_grid_size_px)))
images = [data.astronaut()] * 16
images = ia.imresize_many_images(np.uint8(images), (128, 128))
for name, aug in augs:
print("-----------")
print(name)
print("-----------")
images_aug = aug.augment_images(images)
images_aug[0] = images[0]
grid = ia.draw_grid(images_aug, rows=4, cols=4)
ia.imshow(grid)
def do_all_aug(image):
do_aug(image, iaa.Noop(name="origin"))
do_aug(image, iaa.Crop((0, 10))) # 切边
do_aug(image, iaa.GaussianBlur((0, 3)))
do_aug(image, iaa.AverageBlur(1, 7))
do_aug(image, iaa.MedianBlur(1, 7))
do_aug(image, iaa.Sharpen())
do_aug(image, iaa.BilateralBlur()) # 既噪音又模糊，叫双边
do_aug(image, iaa.MotionBlur())
do_aug(image, iaa.MeanShiftBlur())
do_aug(image, iaa.GammaContrast())
do_aug(image, iaa.SigmoidContrast())
do_aug(image,
iaa.Affine(shear={
'x': (-10, 10),
'y': (-10, 10)
}, mode="edge")) # shear：x轴往左右偏离的像素书，(a,b)是a,b间随机值，[a,b]是二选一
do_aug(image,
iaa.Affine(shear={
'x': (-10, 10),
'y': (-10, 10)
}, mode="edge")) # shear：x轴往左右偏离的像素书，(a,b)是a,b间随机值，[a,b]是二选一
do_aug(image, iaa.Rotate(rotate=(-10, 10), mode="edge"))
do_aug(image, iaa.PiecewiseAffine()) # 局部点变形
do_aug(image, iaa.Fog())
do_aug(image, iaa.Clouds())
do_aug(image, iaa.Snowflakes(flake_size=(0.1, 0.2),
density=(0.005, 0.025)))
do_aug(
image,
iaa.Rain(
nb_iterations=1,
drop_size=(0.05, 0.1),
speed=(0.04, 0.08),
))
do_aug(
image,
iaa.ElasticTransformation(alpha=(0.0, 20.0),
sigma=(3.0, 5.0),
mode="nearest"))
do_aug(image, iaa.AdditiveGaussianNoise(scale=(0, 10)))
do_aug(image, iaa.AdditiveLaplaceNoise(scale=(0, 10)))
do_aug(image, iaa.AdditivePoissonNoise(lam=(0, 10)))
do_aug(image, iaa.Salt((0, 0.02)))
do_aug(image, iaa.Pepper((0, 0.02)))
def __init__(self, img_arr, lbl_arr, transform=False, split_label=False, RGB=False, raw=False, dtype='float32'):
self.img_arr = img_arr
self.labels = lbl_arr.astype(int)
self.transform = transform
self.split_label = split_label
self.RGB = RGB
self.raw = raw
self.dtype = dtype
self.k = np.ones((2, 2), np.uint8)
self.perspective = iaa.PerspectiveTransform(scale=.1, keep_size=True)
self.scale = iaa.CropAndPad(percent=(-.15, .15), pad_mode='constant', pad_cval=0, sample_independently=False)
self.rotate = iaa.Affine(rotate=(-20, 20))
self.shearx = iaa.Affine(shear={"x": (-20, 20)})
self.sheary = iaa.Affine(shear={"y": (-15, 15)})
self.stretchx = iaa.Affine(scale={"x": (0.80, 1.20)})
self.stretchy = iaa.Affine(scale={"y": (0.80, 1.20)})
self.piecewise = iaa.PiecewiseAffine(scale=.03)
self.edgedetect = iaa.DirectedEdgeDetect(alpha=(.01, .99), direction=(0.0, 1.0))
self.contrast = iaa.SigmoidContrast(gain=5, cutoff=(0.4, 0.6))
def _load_augmentation_aug_non_geometric():
return iaa.Sequential([
iaa.Sometimes(0.3, iaa.Multiply((0.5, 1.5), per_channel=0.5)),
iaa.Sometimes(0.2, iaa.JpegCompression(compression=(70, 99))),
iaa.Sometimes(0.2, iaa.GaussianBlur(sigma=(0, 3.0))),
iaa.Sometimes(0.2, iaa.MotionBlur(k=15, angle=[-45, 45])),
iaa.Sometimes(0.2, iaa.MultiplyHue((0.5, 1.5))),
iaa.Sometimes(0.2, iaa.MultiplySaturation((0.5, 1.5))),
iaa.Sometimes(
0.34, iaa.MultiplyHueAndSaturation((0.5, 1.5), per_channel=True)),
iaa.Sometimes(0.34, iaa.Grayscale(alpha=(0.0, 1.0))),
iaa.Sometimes(0.2, iaa.ChangeColorTemperature((1100, 10000))),
iaa.Sometimes(0.1, iaa.GammaContrast((0.5, 2.0))),
iaa.Sometimes(0.2, iaa.SigmoidContrast(gain=(3, 10),
cutoff=(0.4, 0.6))),
iaa.Sometimes(0.1, iaa.CLAHE()),
iaa.Sometimes(0.1, iaa.HistogramEqualization()),
iaa.Sometimes(0.2, iaa.LinearContrast((0.5, 2.0), per_channel=0.5)),
iaa.Sometimes(0.1, iaa.Emboss(alpha=(0, 1.0), strength=(0, 2.0)))
])
def aug(self, img):
seq = iaa.Sequential([
# iaa.Multiply((1.2, 1.5)), # change brightness, doesn't affect keypoints
# iaa.Fliplr(0.5),
iaa.Affine(
rotate=(0, 10), # 0~360随机旋转
# scale=(0.7, 1.0),#通过增加黑边缩小图片
), # rotate by exactly 0~360deg and scale to 70-100%, affects keypoints
iaa.GaussianBlur(
sigma=(0, 3.)
),
# iaa.ChangeColorspace(from_colorspace="RGB", to_colorspace="HSV"),
# iaa.WithChannels(channels=0, children=iaa.Add((50, 100))),
# iaa.ChangeColorspace(from_colorspace="HSV", to_colorspace="RGB"),
iaa.SigmoidContrast(gain=(3, 10), cutoff=(0.3, 0.9)),
iaa.MultiplyHue(mul=(0.5, 1.5))
# iaa.Resize(0.5, 3)
])
seq_def = seq.to_deterministic()
image_aug = seq_def.augment_image(img)
return image_aug
def augmentRGB_V3(img):
seq = iaa.Sequential(
[
# blur
iaa.SomeOf((1, 2), [
iaa.Sometimes(0.5, iaa.GaussianBlur(1.5)),
iaa.Sometimes(0.25, iaa.AverageBlur(k=(3, 7))),
iaa.Sometimes(0.25, iaa.MedianBlur(k=(3, 7))),
iaa.Sometimes(0.25, iaa.BilateralBlur(d=(1, 7))),
iaa.Sometimes(0.25, iaa.MotionBlur(k=(3, 7))),
]),
iaa.Sometimes(0.25, iaa.Add((-25, 25), per_channel=0.3)),
iaa.Sometimes(0.25, iaa.Multiply((0.6, 1.4), per_channel=0.5)),
iaa.Sometimes(
0.25, iaa.ContrastNormalization((0.4, 2.3), per_channel=0.3)),
#iaa.Sometimes(0.25, iaa.AddToHueAndSaturation((-15, 15))),
#iaa.Sometimes(0.25, iaa.Grayscale(alpha=(0.0, 0.2))),
iaa.Sometimes(
0.25,
iaa.FrequencyNoiseAlpha(exponent=(-4, 0),
first=iaa.Add(
(-25, 25), per_channel=0.3),
second=iaa.Multiply(
(0.6, 1.4), per_channel=0.3)),
iaa.SomeOf((0, 1), [
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)
return seq.augment_image(img)
def main():
parser = argparse.ArgumentParser(description="Contrast check script")
parser.add_argument("--per_channel",
dest="per_channel",
action="store_true")
args = parser.parse_args()
augs = []
for p in [0.25, 0.5, 1.0, 2.0, (0.5, 1.5), [0.5, 1.0, 1.5]]:
augs.append(("GammaContrast " + str(p),
iaa.GammaContrast(p, per_channel=args.per_channel)))
for cutoff in [0.25, 0.5, 0.75]:
for gain in [5, 10, 15, 20, 25]:
augs.append(("SigmoidContrast " + str(cutoff) + " " + str(gain),
iaa.SigmoidContrast(gain,
cutoff,
per_channel=args.per_channel)))
for gain in [-1.0, 0.0, 0.25, 0.5, 1.0, 2.0, (0.5, 1.5), [0.5, 1.0, 1.5]]:
augs.append(("LogContrast " + str(gain),
iaa.LogContrast(gain, per_channel=args.per_channel)))
for alpha in [-1.0, 0.5, 0, 0.5, 1.0, 2.0, (0.5, 1.5), [0.5, 1.0, 1.5]]:
augs.append(("LinearContrast " + str(alpha),
iaa.LinearContrast(alpha, per_channel=args.per_channel)))
images = [data.astronaut()] * 16
images = ia.imresize_many_images(np.uint8(images), (128, 128))
for name, aug in augs:
print("-----------")
print(name)
print("-----------")
images_aug = aug.augment_images(images)
grid = ia.draw_grid(images_aug, rows=4, cols=4)
ia.imshow(grid)
# -*- coding: utf-8 -*- # @Time : 20-12-14 下午1:34 # @Author : shargootian # @Email : [email protected] # @File : dataset.py 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 get_imgaug_sequences(low_gblur = 1.0,
high_gblur = 3.0, addgn_base_ref = 0.01,
addgn_base_cons = 0.001, rot_angle = 180,
max_scale = 1.0, add_perspective = False
):
affine_seq = iaa.Sequential([
iaa.Affine(
rotate=(-rot_angle, rot_angle),
scale=(0.8, max_scale),
translate_percent={"x": (-0.05, 0.05), "y": (-0.05, 0.05)},
),
sometimes(iaa.Affine(
shear=(-4, 4),
))
])
affine_list = [affine_seq]
contrast_list = [
iaa.Sequential([
iaa.LinearContrast((0.7, 1.0), per_channel=False), # change contrast
iaa.Add((-30, 30), per_channel=False), # change brightness
]),
iaa.Sequential([
iaa.LinearContrast((0.4, 1.0), per_channel=False), # change contrast
iaa.Add((-80, 80), per_channel=False), # change brightness
])
]
if add_perspective:
print("Adding perspective transform to augmentation")
affine_list = affine_list + [
sometimes(iaa.PerspectiveTransform(scale=(0.01, 0.1)))
]
contrast_list = contrast_list + [
iaa.GammaContrast((0.5, 1.7), per_channel=True),
iaa.SigmoidContrast(gain=(8, 12), cutoff=(0.2,0.8), per_channel=False)
]
ref_seq = iaa.Sequential(affine_list + [
iaa.OneOf(contrast_list),
iaa.OneOf([
iaa.AdditiveGaussianNoise(loc=0, scale=(0.0, 3*addgn_base_ref*255), per_channel=0.5),
iaa.AdditiveGaussianNoise(loc=0, scale=(0.0, addgn_base_ref*255), per_channel=0.5),
]),
iaa.OneOf([
iaa.GaussianBlur(sigma=(0, high_gblur)),
iaa.GaussianBlur(sigma=(0, low_gblur)),
])
])
cons_seq = iaa.Sequential(affine_list + [
iaa.LinearContrast((0.9, 1.1), per_channel=False),
iaa.Add((-10, 10), per_channel=False),
iaa.AdditiveGaussianNoise(loc=0, scale=(0.0, 5*addgn_base_cons*255), per_channel=0.5),
iaa.GaussianBlur(sigma=(0, low_gblur)),
])
return affine_seq, ref_seq, cons_seq
def setup_augmentors(self, augmentations):
self.augmentors = []
for aug_name, aug_config in augmentations.items():
aug = None
if aug_name == 'grayscale':
aug = iaa.Grayscale()
elif aug_name == 'intensity_multiplier':
aug = iaa.Multiply((aug_config.get('min_multiplier', 0.5),
aug_config.get('min_multiplier', 1.5)))
elif aug_name == 'additive_gaussian_noise':
aug = VariableRangeAdditiveGaussianNoise(
aug_config.get('min_scale', 0.05),
aug_config.get('max_scale', 0.25))
elif aug_name == 'gaussian_blur':
aug = iaa.GaussianBlur(
sigma=(aug_config.get('sigma_min', 0.0),
aug_config.get('sigma_max', 0.0)))
elif aug_name == 'defocus':
aug = iaa.imgcorruptlike.DefocusBlur(
severity=(aug_config.get('min_severity', 1),
aug_config.get('min_severity', 3)))
elif aug_name == 'fog':
aug = iaa.imgcorruptlike.Fog(
severity=(aug_config.get('min_severity', 1),
aug_config.get('min_severity', 3)))
elif aug_name == 'quantization':
aug = iaa.KMeansColorQuantization(
n_colors=(aug_config.get('min_colors', 32),
aug_config.get('max_colors', 64)))
elif aug_name == 'contrast':
aug = iaa.SigmoidContrast(
gain=(aug_config.get('min_gain',
6), aug_config.get('max_gain', 10)),
cutoff=(aug_config.get('min_cutoff', 0.2),
aug_config.get('max_cutoff', 0.6)))
elif aug_name == 'spatter':
aug = aug = iaa.imgcorruptlike.Spatter(
severity=aug_config.get('severity', 4))
elif aug_name == 'motion_blur':
# Note: Ground-truth seems to shift a bit, but imgaug does not implement it
aug = iaa.MotionBlur(k=aug_config.get('kernel_size', 15),
angle=(aug_config.get('min_angle', -45),
aug_config.get('max_angle', 45)))
elif aug_name == 'perspective_transform':
aug = iaa.PerspectiveTransform(
scale=(aug_config.get('min_scale', 0),
aug_config.get('max_scale', 0.05)))
elif aug_name == 'elastic_transform':
# Note: Ground-truth seems to shift a bit, but imgaug does not implement it
aug = ElasticTransformCorruption(
severity=(aug_config.get('min_severity', 1),
aug_config.get('min_severity', 3)))
elif aug_name == 'piecewise_affine':
# Note: 10X Costly
aug = iaa.PiecewiseAffine(
scale=(aug_config.get('min_scale', 0),
aug_config.get('max_scale', 0.03)))
if not aug:
continue
aug.name, aug.p, aug.base = aug_name, aug_config[
'probability'], self
self.augmentors.append(aug)
return
def train(model):
"""Train the model."""
# Training dataset.
dataset_train = BubbleDataset()
dataset_train.load_bubble(args.dataset, "train")
dataset_train.prepare()
# Validation dataset
dataset_val = BubbleDataset()
dataset_val.load_bubble(args.dataset, "val")
dataset_val.prepare()
model_inference = modellib.MaskRCNN(mode="inference",
config=_InfConfig(),
model_dir=args.logs)
mean_average_precision_callback = modellib.MeanAveragePrecisionCallback(
model, model_inference, dataset_val, 1, 32, verbose=1)
# Image augmentation
# http://imgaug.readthedocs.io/en/latest/source/augmenters.html
augmentation = iaa.SomeOf(
(0, 10),
[
iaa.Fliplr(0.5),
iaa.Flipud(0.5),
iaa.Add((-40, 40)),
iaa.AdditiveGaussianNoise(scale=(0, 0.2 * 255)),
iaa.Multiply((0.25, 1)),
iaa.MedianBlur(k=(3, 15)),
iaa.SigmoidContrast(gain=(5, 10), cutoff=(0.1, 0.6)),
iaa.Sharpen(alpha=(0.0, 1.0), lightness=(0.75, 1.1)),
iaa.Affine(scale={
"x": (0.5, 2),
"y": (0.1, 1.5)
}), #(0.2,0.6)
iaa.Affine(shear=(-40, 40)),
iaa.PiecewiseAffine(scale=(0.01, 0.06)),
iaa.OneOf([
iaa.Affine(rotate=90),
iaa.Affine(rotate=180),
iaa.Affine(rotate=270)
])
])
# *** This training schedule is an example. Update to your needs ***
# Since we're using a very small dataset, and starting from
# COCO trained weights, we don't need to train too long. Also,
# no need to train all layers, just the heads should do it.
model.train(dataset_train,
dataset_val,
learning_rate=config.LEARNING_RATE / 10,
epochs=10,
augmentation=augmentation,
layers='5+',
custom_callbacks=[mean_average_precision_callback])
model.train(dataset_train,
dataset_val,
learning_rate=config.LEARNING_RATE / 100,
epochs=20,
augmentation=augmentation,
layers='5+',
custom_callbacks=[mean_average_precision_callback])
model.train(dataset_train,
dataset_val,
learning_rate=config.LEARNING_RATE / 1000,
epochs=30,
augmentation=augmentation,
layers='5+',
custom_callbacks=[mean_average_precision_callback])
size_percent=(0.01, 0.5),
per_channel=0.5),
iaa.SaltAndPepper((0.01, 0.3))
]),
# Play with the colors of the image
iaa.OneOf([
iaa.Invert(0.01, per_channel=0.5),
iaa.AddToHueAndSaturation((-1, 1)),
iaa.MultiplyHueAndSaturation((-1, 1))
]),
# Change brightness and contrast
iaa.OneOf([
iaa.Add((-10, 10), per_channel=0.5),
iaa.Multiply((0.5, 1.5), per_channel=0.5),
iaa.GammaContrast(gamma=(0.5, 1.75), per_channel=0.5),
iaa.SigmoidContrast(cutoff=(0, 1), per_channel=0.5),
iaa.LogContrast(gain=(0.5, 1), per_channel=0.5),
iaa.LinearContrast(alpha=(0.25, 1.75), per_channel=0.5),
iaa.HistogramEqualization()
]),
sometimes(iaa.ElasticTransformation(alpha=(0.5, 3.5),
sigma=0.25)),
# move pixels locally around (with random strengths)
sometimes(iaa.PiecewiseAffine(scale=(0.01, 0.05))),
# sometimes move parts of the image around
sometimes(iaa.PerspectiveTransform(scale=(0.01, 0.2))),
iaa.JpegCompression((0.1, 1))
]
),
# With 10 % probability apply one the of the weather conditions
iaa.Sometimes(0.2, iaa.OneOf([
def __init__(self,
dataset_type,
dataset_path,
real_path,
mesh_path,
mesh_info,
object_id,
batch_size,
img_res=(224, 224, 3),
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 + '_rgb.png'
img_path = os.path.join(self.dataset_path, 'images',
self.data_type, name)
# print(name)
self.image_ids.append(img_path)
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()
self.dataset_length = len(self.image_ids)
def build_augmentation_pipeline(self,
height=None,
width=None,
apply_prob=0.5):
sometimes = lambda aug: iaa.Sometimes(apply_prob, aug)
pipeline = iaa.Sequential(random_order=False)
cfg = self.cfg
if cfg["mirror"]:
opt = cfg["mirror"] # fliplr
if type(opt) == int:
pipeline.add(sometimes(iaa.Fliplr(opt)))
else:
pipeline.add(sometimes(iaa.Fliplr(0.5)))
if cfg["rotation"] > 0:
pipeline.add(
iaa.Sometimes(
cfg["rotratio"],
iaa.Affine(rotate=(-cfg["rotation"], cfg["rotation"])),
))
if cfg["motion_blur"]:
opts = cfg["motion_blur_params"]
pipeline.add(sometimes(iaa.MotionBlur(**opts)))
if cfg["covering"]:
pipeline.add(
sometimes(
iaa.CoarseDropout(0.02, size_percent=0.3,
per_channel=0.5)))
if cfg["elastic_transform"]:
pipeline.add(sometimes(iaa.ElasticTransformation(sigma=5)))
if cfg.get("gaussian_noise", False):
opt = cfg.get("gaussian_noise", False)
if type(opt) == int or type(opt) == float:
pipeline.add(
sometimes(
iaa.AdditiveGaussianNoise(loc=0,
scale=(0.0, opt),
per_channel=0.5)))
else:
pipeline.add(
sometimes(
iaa.AdditiveGaussianNoise(loc=0,
scale=(0.0, 0.05 * 255),
per_channel=0.5)))
if cfg.get("grayscale", False):
pipeline.add(sometimes(iaa.Grayscale(alpha=(0.5, 1.0))))
def get_aug_param(cfg_value):
if isinstance(cfg_value, dict):
opt = cfg_value
else:
opt = {}
return opt
cfg_cnt = cfg.get("contrast", {})
cfg_cnv = cfg.get("convolution", {})
contrast_aug = ["histeq", "clahe", "gamma", "sigmoid", "log", "linear"]
for aug in contrast_aug:
aug_val = cfg_cnt.get(aug, False)
cfg_cnt[aug] = aug_val
if aug_val:
cfg_cnt[aug + "ratio"] = cfg_cnt.get(aug + "ratio", 0.1)
convolution_aug = ["sharpen", "emboss", "edge"]
for aug in convolution_aug:
aug_val = cfg_cnv.get(aug, False)
cfg_cnv[aug] = aug_val
if aug_val:
cfg_cnv[aug + "ratio"] = cfg_cnv.get(aug + "ratio", 0.1)
if cfg_cnt["histeq"]:
opt = get_aug_param(cfg_cnt["histeq"])
pipeline.add(
iaa.Sometimes(cfg_cnt["histeqratio"],
iaa.AllChannelsHistogramEqualization(**opt)))
if cfg_cnt["clahe"]:
opt = get_aug_param(cfg_cnt["clahe"])
pipeline.add(
iaa.Sometimes(cfg_cnt["claheratio"],
iaa.AllChannelsCLAHE(**opt)))
if cfg_cnt["log"]:
opt = get_aug_param(cfg_cnt["log"])
pipeline.add(
iaa.Sometimes(cfg_cnt["logratio"], iaa.LogContrast(**opt)))
if cfg_cnt["linear"]:
opt = get_aug_param(cfg_cnt["linear"])
pipeline.add(
iaa.Sometimes(cfg_cnt["linearratio"],
iaa.LinearContrast(**opt)))
if cfg_cnt["sigmoid"]:
opt = get_aug_param(cfg_cnt["sigmoid"])
pipeline.add(
iaa.Sometimes(cfg_cnt["sigmoidratio"],
iaa.SigmoidContrast(**opt)))
if cfg_cnt["gamma"]:
opt = get_aug_param(cfg_cnt["gamma"])
pipeline.add(
iaa.Sometimes(cfg_cnt["gammaratio"], iaa.GammaContrast(**opt)))
if cfg_cnv["sharpen"]:
opt = get_aug_param(cfg_cnv["sharpen"])
pipeline.add(
iaa.Sometimes(cfg_cnv["sharpenratio"], iaa.Sharpen(**opt)))
if cfg_cnv["emboss"]:
opt = get_aug_param(cfg_cnv["emboss"])
pipeline.add(
iaa.Sometimes(cfg_cnv["embossratio"], iaa.Emboss(**opt)))
if cfg_cnv["edge"]:
opt = get_aug_param(cfg_cnv["edge"])
pipeline.add(
iaa.Sometimes(cfg_cnv["edgeratio"], iaa.EdgeDetect(**opt)))
if height is not None and width is not None:
if not cfg.get("crop_by", False):
crop_by = 0.15
else:
crop_by = cfg.get("crop_by", False)
pipeline.add(
iaa.Sometimes(
cfg.get("cropratio", 0.4),
iaa.CropAndPad(percent=(-crop_by, crop_by),
keep_size=False),
))
pipeline.add(iaa.Resize({"height": height, "width": width}))
return pipeline
def test_SigmoidContrast():
reseed()
img = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
img = np.uint8(img)
img3d = np.tile(img[:, :, np.newaxis], (1, 1, 3))
# check basic functionality with per_chanenl on/off (makes no difference due to deterministic
# parameters)
for per_channel in [False, 0, 0.0, True, 1, 1.0]:
for gain, cutoff in itertools.product([5, 10], [0.25, 0.75]):
aug = iaa.SigmoidContrast(gain=iap.Deterministic(gain),
cutoff=iap.Deterministic(cutoff),
per_channel=per_channel)
img_aug = aug.augment_image(img)
img3d_aug = aug.augment_image(img3d)
assert img_aug.dtype.type == np.uint8
assert img3d_aug.dtype.type == np.uint8
assert np.array_equal(
img_aug,
skimage.exposure.adjust_sigmoid(img, gain=gain, cutoff=cutoff))
assert np.array_equal(
img3d_aug,
skimage.exposure.adjust_sigmoid(img3d,
gain=gain,
cutoff=cutoff))
# check that tuple to uniform works
# note that gain and cutoff are saved in inverted order in _ContrastFuncWrapper to match
# the order of skimage's function
aug = iaa.SigmoidContrast(gain=(1, 2), cutoff=(0.25, 0.75))
assert isinstance(aug.params1d[0], iap.Uniform)
assert isinstance(aug.params1d[0].a, iap.Deterministic)
assert isinstance(aug.params1d[0].b, iap.Deterministic)
assert np.allclose(aug.params1d[0].a.value, 0.25)
assert np.allclose(aug.params1d[0].b.value, 0.75)
assert isinstance(aug.params1d[1], iap.Uniform)
assert isinstance(aug.params1d[1].a, iap.Deterministic)
assert isinstance(aug.params1d[1].b, iap.Deterministic)
assert aug.params1d[1].a.value == 1
assert aug.params1d[1].b.value == 2
# check that list to choice works
# note that gain and cutoff are saved in inverted order in _ContrastFuncWrapper to match
# the order of skimage's function
aug = iaa.SigmoidContrast(gain=[1, 2], cutoff=[0.25, 0.75])
assert isinstance(aug.params1d[0], iap.Choice)
assert all([
np.allclose(val, val_choice)
for val, val_choice in zip([0.25, 0.75], aug.params1d[0].a)
])
assert isinstance(aug.params1d[1], iap.Choice)
assert all([val in aug.params1d[1].a for val in [1, 2]])
# check that per_channel at 50% prob works
aug = iaa.SigmoidContrast(gain=(1, 10),
cutoff=(0.25, 0.75),
per_channel=0.5)
seen = [False, False]
img1000d = np.zeros((1, 1, 1000), dtype=np.uint8) + 128
for _ in sm.xrange(100):
img_aug = aug.augment_image(img1000d)
assert img_aug.dtype.type == np.uint8
l = len(set(img_aug.flatten().tolist()))
if l == 1:
seen[0] = True
else:
seen[1] = True
if all(seen):
break
assert all(seen)
# check that keypoints are not changed
kpsoi = ia.KeypointsOnImage([ia.Keypoint(1, 1)], shape=(3, 3, 3))
kpsoi_aug = iaa.SigmoidContrast(gain=10,
cutoff=0.5).augment_keypoints([kpsoi])
assert keypoints_equal([kpsoi], kpsoi_aug)
# check that heatmaps are not changed
heatmaps = ia.HeatmapsOnImage(np.zeros((3, 3, 1), dtype=np.float32) + 0.5,
shape=(3, 3, 3))
heatmaps_aug = iaa.SigmoidContrast(gain=10,
cutoff=0.5).augment_heatmaps([heatmaps
])[0]
assert np.allclose(heatmaps.arr_0to1, heatmaps_aug.arr_0to1)
###################
# test other dtypes
###################
# uint, int
for dtype in [
np.uint8, np.uint16, np.uint32, np.uint64, np.int8, np.int16,
np.int32, np.int64
]:
min_value, center_value, max_value = meta.get_value_range_of_dtype(
dtype)
gains = [5, 20]
cutoffs = [0.25, 0.75]
values = [0, 100, int(center_value + 0.1 * max_value)]
tmax = 1e-8 * max_value if dtype in [np.uint64, np.int64] else 0
tolerances = [tmax, tmax, tmax]
for gain, cutoff in itertools.product(gains, cutoffs):
aug = iaa.SigmoidContrast(gain=gain, cutoff=cutoff)
for value, tolerance in zip(values, tolerances):
image = np.full((3, 3), value, dtype=dtype)
# 1/(1 + exp(gain*(cutoff - I_ij/max)))
expected = (1 / (1 + np.exp(
gain * (cutoff - image.astype(np.float128) / max_value))))
expected = (expected * max_value).astype(dtype)
image_aug = aug.augment_image(image)
assert image_aug.dtype == np.dtype(dtype)
assert len(np.unique(image_aug)) == 1
value_aug = int(image_aug[0, 0])
value_expected = int(expected[0, 0])
diff = abs(value_aug - value_expected)
assert diff <= tolerance
# float
for dtype in [np.float16, np.float32, np.float64]:
def _allclose(a, b):
atol = 1e-3 if dtype == np.float16 else 1e-8
return np.allclose(a, b, atol=atol, rtol=0)
gains = [5, 20]
cutoffs = [0.25, 0.75]
isize = np.dtype(dtype).itemsize
values = [0, 1.0, 50.0, 100**(isize - 1)]
for gain, cutoff in itertools.product(gains, cutoffs):
aug = iaa.SigmoidContrast(gain=gain, cutoff=cutoff)
for value in values:
image = np.full((3, 3), value, dtype=dtype)
expected = (1 /
(1 + np.exp(gain *
(cutoff - image.astype(np.float128))))
).astype(dtype)
image_aug = aug.augment_image(image)
assert image_aug.dtype == np.dtype(dtype)
assert _allclose(image_aug, expected)
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])),
]),
iaa.OneOf([
iaa.Clouds(),
iaa.Snowflakes(flake_size=(0.1, 0.4), speed=(0.01, 0.05)),
iaa.Rain(speed=(0.1, 0.3))
])
],
random_order=True)
train_label[tokens[0]] = label_encoding_dict[tokens[1]]
else:
test_label[tokens[0]] = label_encoding_dict[tokens[1]]
sharp = iaa.Sharpen(alpha=(0.0, 1.0), lightness=(0.75, 2.0))
for image in os.listdir(train_img_dir):
if image.endswith(".jpeg"):
img = cv2.imread(os.path.join(train_img_dir, image))
img_aug = sharp(image=img)
cv2.imwrite(
os.path.join(save_dir,
os.path.splitext(image)[0] + "_sharp.jpeg"), img_aug)
train_label[os.path.splitext(image)[0] +
"_sharp.jpeg"] = train_label[image]
sig_contrast = iaa.SigmoidContrast(gain=(3, 10), cutoff=(0.4, 0.6))
for image in os.listdir(train_img_dir):
if image.endswith(".jpeg"):
img = cv2.imread(os.path.join(train_img_dir, image))
img_aug = sig_contrast(image=img)
cv2.imwrite(
os.path.join(save_dir,
os.path.splitext(image)[0] + "_sig_contrast.jpeg"),
img_aug)
train_label[os.path.splitext(image)[0] +
"_sig_contrast.jpeg"] = train_label[image]
gammma_contrast = iaa.GammaContrast((1.1, 2.0))
for image in os.listdir(train_img_dir):
if image.endswith(".jpeg"):
img = cv2.imread(os.path.join(train_img_dir, image))
def __init__(self,aug_level):
frequently = lambda aug: iaa.Sometimes(0.9, aug)
often = lambda aug: iaa.Sometimes(0.7, aug)
sometimes = lambda aug: iaa.Sometimes(0.5, aug)
occasionally = lambda aug: iaa.Sometimes(0.3, aug)
rarely = lambda aug: iaa.Sometimes(0.1, aug)
if aug_level == 'high':
self.aug = iaa.Sequential([
sometimes(iaa.Crop(percent=(0, 0.1))),
rarely(iaa.ContrastNormalization((0.75, 1.5))),
occasionally(iaa.SigmoidContrast(gain=(3, 10), cutoff=(0.1, 0.2))),
sometimes(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=(-20, 20),
shear=(-8, 8),
order=[0, 1],
cval=(0, 255),
mode=ia.ALL
)),
iaa.SomeOf((0, 5),
[
# Blur each image with varying strength using
# gaussian blur (sigma between 0 and 3.0),
# average/uniform blur (kernel size between 2x2 and 7x7)
# median blur (kernel size between 3x3 and 11x11).
iaa.OneOf([
iaa.GaussianBlur((0, 3.0)),
iaa.AverageBlur(k=(2, 7)),
iaa.MedianBlur(k=(3, 11)),
]),
# Sharpen each image, overlay the result with the original
# image using an alpha between 0 (no sharpening) and 1
# (full sharpening effect).
iaa.Sharpen(alpha=(0, 1.0), lightness=(0.75, 1.5)),
# Search in some images either for all edges or for
# directed edges. These edges are then marked in a black
# and white image and overlayed with the original image
# using an alpha of 0 to 0.7.
sometimes(iaa.OneOf([
iaa.EdgeDetect(alpha=(0, 0.7)),
iaa.DirectedEdgeDetect(
alpha=(0, 0.7), direction=(0.0, 1.0)
),
])),
# Add gaussian noise to some images.
# In 50% of these cases, the noise is randomly sampled per
# channel and pixel.
# In the other 50% of all cases it is sampled once per
# pixel (i.e. brightness change).
iaa.AdditiveGaussianNoise(
loc=0, scale=(0.0, 0.03*255), per_channel=0.5
),
# Either drop randomly 1 to 10% of all pixels (i.e. set
# them to black) or drop them on an image with 2-5% percent
# of the original size, leading to large dropped
# rectangles.
iaa.OneOf([
iaa.Dropout((0.01, 0.1), per_channel=0.5),
iaa.CoarseDropout(
(0.03, 0.15), size_percent=(0.01, 0.02),
per_channel=0.2
),
]),
# Invert each image's channel with 5% probability.
# This sets each pixel value v to 255-v.
iaa.Invert(0.05, per_channel=True), # invert color channels
# Add a value of -10 to 10 to each pixel.
iaa.Add((-10, 10), per_channel=0.5),
# Change brightness of images (50-150% of original value).
iaa.Multiply((0.5, 1.0), per_channel=0.5),
# Improve or worsen the contrast of images.
iaa.LinearContrast((0.5, 2.0), per_channel=0.5),
# In some images move pixels locally around (with random
# strengths).
sometimes(
iaa.ElasticTransformation(alpha=(0.5, 3.5), sigma=0.25)
),
# In some images distort local areas with varying strength.
sometimes(iaa.PiecewiseAffine(scale=(0.01, 0.05)))
], random_order=True)
], random_order=True)
elif aug_level == 'low':
self.aug = iaa.Sequential([
iaa.OneOf([
iaa.Sometimes(0.5, iaa.AdditiveGaussianNoise(scale=(0.0, 0.1*255))),
iaa.Sometimes(0.1, iaa.AdditiveGaussianNoise(scale=(0.0, 0.3*255)))
]),
iaa.Sometimes(0.5, iaa.GammaContrast((0.5, 2.0))),
iaa.Sometimes(0.5, iaa.imgcorruptlike.Brightness(severity=2)),
iaa.Sometimes(0.5, iaa.Affine(
rotate=(-20, 20),
)),
], random_order=True)
else:
raise NotImplementedError
