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