def processInput(i): img = cv2.imread("all/train/"+i) img_resized = cv2.resize(img, (size,size)) encoded = df.query('ImageId=="'+i+'"')['EncodedPixels'].tolist() if str(encoded[0]) == 'nan': name = "noship" seq = iaa.Sequential([ sometimes1(iaa.CoarseSalt(p=0.07, size_percent=0.02)), sometimes1(iaa.GaussianBlur((0, 2.0))) ]) images_aug = seq.augment_images([img_resized]) img_resized = images_aug[0] cv2.imwrite("all/resize/"+str(size)+"/"+str(name)+"/"+i,img_resized) else: name = "ship" cv2.imwrite("all/resize/"+str(size)+"/"+str(name)+"/"+i,img_resized) seq = iaa.Sequential([ iaa.Fliplr(0.5), iaa.Flipud(0.5), sometimes3(iaa.CoarseSalt(p=0.07, size_percent=0.02)), sometimes3(iaa.Affine(rotate=(-45, 45))), sometimes3(iaa.GaussianBlur((0, 2.0))) ]) images_aug = seq.augment_images([img_resized]) cv2.imwrite("all/resize/"+str(size)+"/"+str(name)+"/2-"+i,images_aug[0])
def train(self, sess, data, labels, learning_rate): ### do hiding? if len(self.do_hide) > 0: # do_hide is num of grid N = np.random.choice(self.do_hide, 1)[0] ### if N == 0: use full image if N != 0: n, w, h, _ = data.shape mask = net.gen_random_patch(shape=(n, w, h), N=N) mask = np.expand_dims(mask, axis=3) data = data * mask + (1 - mask) * self.image_mean ### do augmentation? if self.do_augmentation == 1: data = iaa.Sequential([ iaa.Fliplr(0.25), iaa.Flipud(0.25), iaa.Sometimes(0.25, iaa.Affine(rotate=(-180, 180))), iaa.Sometimes( 0.2, iaa.Affine(translate_percent={ 'x': (-0.15, 0.15), 'y': (-0.15, 0.15) })) ]).augment_images(data) elif self.do_augmentation == 2: data = iaa.Sequential([ iaa.Fliplr(0.25), iaa.Flipud(0.25), iaa.Sometimes(0.25, iaa.Affine(rotate=(-180, 180))), iaa.Sometimes( 0.2, iaa.Affine(translate_percent={ 'x': (-0.1, 0.1), 'y': (-0.1, 0.1) })), iaa.Sometimes( 0.2, iaa.OneOf([ iaa.CoarseDropout(0.2, size_percent=(0.05, 0.1)), iaa.CoarseSalt(0.2, size_percent=(0.05, 0.1)), iaa.CoarsePepper(0.2, size_percent=(0.05, 0.1)), iaa.CoarseSaltAndPepper(0.2, size_percent=(0.05, 0.1)) ])) ]).augment_images(data) _, loss, scores, hits, summary = sess.run( [ self.train_op, self.loss_op, self.score_op, self.hit_op, self.summary_op ], feed_dict={ self.inputs: data, self.labels: labels, self.learning_rate: learning_rate, self.is_training: True }) return loss, scores, hits, summary
def get_augmentation_sequence(): sometimes = lambda aug: iaa.Sometimes(0.5, aug) seq = iaa.Sequential([ sometimes(iaa.Fliplr(0.5)), iaa.Sometimes(0.1, iaa.Add((-70, 70))), 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 )), sometimes(iaa.PiecewiseAffine(scale=(0.01, 0.01))), iaa.Sometimes( 0.1, iaa.SimplexNoiseAlpha(iaa.OneOf( [iaa.Add((150, 255)), iaa.Add((-100, 100))]), sigmoid_thresh=5)), iaa.Sometimes( 0.1, iaa.OneOf([ iaa.CoarseDropout((0.01, 0.15), size_percent=(0.02, 0.08)), iaa.CoarseSaltAndPepper(p=0.2, size_percent=0.01), iaa.CoarseSalt(p=0.2, size_percent=0.02) ])), iaa.Sometimes(0.25, slice_thickness_augmenter) ]) return seq
def image_aug(image): """ @param image: @return: """ seq = iaa.SomeOf( (1, 3), [ iaa.Crop(px=(0, 16)), # 裁剪 iaa.Multiply((0.7, 1.3)), # 改变色调 iaa.Affine(scale=(0.5, 0.7)), # 放射变换 iaa.GaussianBlur(sigma=(0, 1.5)), # 高斯模糊 iaa.AddToHueAndSaturation(value=(25, -25)), iaa.ChannelShuffle(1), # RGB三通道随机交换 iaa.ElasticTransformation(alpha=0.1), iaa.Grayscale(alpha=(0.2, 0.5)), iaa.Pepper(p=0.03), iaa.AdditiveGaussianNoise(scale=(0.03 * 255, 0.05 * 255)), iaa.Dropout(p=(0.03, 0.05)), iaa.Salt(p=(0.03, 0.05)), iaa.AverageBlur(k=(1, 3)), iaa.Add((-10, 10)), iaa.CoarseSalt(size_percent=0.01) ]) seq_det = seq.to_deterministic() image_aug = seq_det.augment_images([image])[0] return image_aug
def main(): # datapath为存放训练图片的地方 datapath = '/home/zhex/data/OID_origin/train/Umbrella/' # original_file为需要被增强的 original_file = '/home/zhex/data/OID_origin/tools/new_txt/Umbrella.txt' # 需要被增强的训练真值txt # aug_file只记录了新增的增强后图片的box,要得到原始+增强的所有label:cat original_file augfile>finalfile(txt拼接) # aug_file输出是pdpd需要的格式,pytorch需要另行转换(可以拼接得到finalfile后直接将finalfile转换) aug_file = 'augfile_Umbrella.txt' dict_before = readlist(original_file) new_fp = open(aug_file, 'w') # augscene = {'Umbrellad':10,'hat':2} # 需要哪些场景,新增几倍数量的新数据 augscene = {'Umbrella': 5} for scene in augscene: # scene = Umbrella img_id = scene for i in range(augscene[scene]): for img_id in dict_before.keys(): img = Image.open(datapath + img_id) img = np.array(img) bbs = ia.BoundingBoxesOnImage([ ia.BoundingBox(x1=x, y1=y, x2=x + w, y2=y + h) for [x, y, w, h] in dict_before[img_id] ], shape=img.shape) # 设置数据增强方式 seq = iaa.SomeOf( (1, 3), [ iaa.Crop(px=(0, 16)), #裁剪 iaa.Multiply((0.7, 1.3)), #改变色调 iaa.Affine(scale=(0.5, 0.7)), #放射变换 iaa.GaussianBlur(sigma=(0, 1.5)), #高斯模糊 # iaa.AddToHueAndSaturation(value=(25,-25)), iaa.ChannelShuffle(1), # RGB三通道随机交换 iaa.ElasticTransformation(alpha=0.1), # iaa.Grayscale(alpha=(0.2, 0.5)), iaa.Pepper(p=0.03), iaa.AdditiveGaussianNoise(scale=(0.03 * 255, 0.05 * 255)), iaa.Dropout(p=(0.03, 0.05)), iaa.Salt(p=(0.03, 0.05)), iaa.AverageBlur(k=(1, 3)), iaa.Add((-10, 10)), iaa.CoarseSalt(size_percent=0.01) ]) seq_det = seq.to_deterministic( ) # 保持坐标和图像同步改变,每个batch都要调用一次,不然每次的增强都是一样的 image_aug = seq_det.augment_images([img])[0] bbs_aug = seq_det.augment_bounding_boxes([bbs])[0] pic_name = img_id.split('.')[0] # datapath = '/home/zhex/OID/train/Umbrella' if not os.path.exists(datapath + 'myaug/'): os.makedirs(datapath + 'myaug/') new_img_id = 'myaug/' + pic_name + '_{}'.format(i) + '.jpg' print('new_img_id = ', new_img_id) Image.fromarray(image_aug).save(datapath + new_img_id) new_fp = writelist(new_fp, new_img_id, bbs_aug.bounding_boxes)
def logic(self, image): for param in self.augmentation_params: self.augmentation_data.append([ str(param.augmentation_value), iaa.CoarseSalt( p=0.2, size_percent=param.augmentation_value, min_size=2).to_deterministic().augment_image(image), param.detection_tag ])
def chapter_augmenters_coarsesalt(): fn_start = "arithmetic/coarsesalt" aug = iaa.CoarseSalt(0.05, size_percent=(0.01, 0.1)) run_and_save_augseq(fn_start + ".jpg", aug, [ia.quokka(size=(128, 128)) for _ in range(8)], cols=4, rows=2, quality=95)
def setup_augmentation(self): # Augmentation # aug = iaa.Sequential([ # #iaa.Sometimes(0.5, iaa.PerspectiveTransform(0.05)), # #iaa.Sometimes(0.5, iaa.CropAndPad(percent=(-0.05, 0.1))), # #iaa.Sometimes(0.5, iaa.Affine(scale=(1.0, 1.2))), # iaa.Sometimes(0.5, iaa.CoarseDropout( p=0.05, size_percent=0.01) ),F # iaa.Sometimes(0.5, iaa.GaussianBlur(1.2*np.random.rand())), # iaa.Sometimes(0.5, iaa.Add((-0.1, 0.1), per_channel=0.3)), # iaa.Sometimes(0.3, 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) # aug = iaa.Sequential([ # #iaa.Sometimes(0.5, iaa.CoarseDropout( p=0.25, size_percent=0.02) ), # iaa.Sometimes(0.5, iaa.GaussianBlur(1.2*np.random.rand())), # iaa.Sometimes(0.5, iaa.Add((-60, 60), per_channel=0.3)), # 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) aug = iaa.Sequential( [ #iaa.Sometimes(0.5, PerspectiveTransform(0.05)), #iaa.Sometimes(0.5, CropAndPad(percent=(-0.05, 0.1))), iaa.Sometimes(0.5, iaa.Affine(scale=(1.0, 1.2))), #iaa.Sometimes(0.5, iaa.CoarseDropout( p=0.2, size_percent=0.05) ), iaa.Sometimes( 0.5, iaa.SomeOf(2, [ iaa.CoarseDropout(p=0.2, size_percent=0.05), iaa.Cutout(fill_mode="constant", cval=(0, 255), fill_per_channel=0.5), iaa.Cutout(fill_mode="constant", cval=(255)), iaa.CoarseSaltAndPepper(0.05, size_px=(4, 16)), iaa.CoarseSalt(0.05, size_percent=(0.01, 0.1)) ])), 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.3, 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) return aug
def DA_CoarseSaltAndPepper(inputimg): assert inputimg.ndim in [2, 3], "input invalid! Please check input" values = np.arange(0.0, 0.21, 0.02) p_channels = np.arange(0.0, 1.01, 0.1) ret = [] for i in np.arange(len(values)): for j in np.arange(len(p_channels)): Name = "DA_CoarseSalt" + str(values[i]) + "_" + str(p_channels[j]) VALUE = str(values[i]) + "_" + str(p_channels[j]) aug_img = iaa.CoarseSalt(p=values[i],size_percent=(0.5, 1.0), per_channel=p_channels[j]).augment_image(inputimg) ret.append((Name, VALUE, aug_img)) Name = "DA_CoarseSaltAndPepper" + str(values[i]) + "_" + str(p_channels[j]) VALUE = str(values[i]) + "_" + str(p_channels[j]) aug_img1 = iaa.CoarseSaltAndPepper(p=values[i], size_percent=(0.5, 1.0), per_channel=p_channels[j]).augment_image(inputimg) ret.append((Name, VALUE, aug_img1)) assert len(ret) == 242, "DA_CoarseDropout output size not match!" return ret
def get_augmentation_sequence(): sometimes = lambda aug: iaa.Sometimes(0.5, aug) slice_thickness_augmenter = iaa.Lambda( func_images=slice_thickness_func_images, func_keypoints=slice_thickness_func_keypoints) seq = iaa.Sequential([ sometimes(iaa.Fliplr(0.5)), iaa.Sometimes(0.1, iaa.Add((-70, 70))), 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 )), # sometimes(iaa.Multiply((0.5, 1.5))), # sometimes(iaa.ContrastNormalization((0.5, 2.0))), # sometimes(iaa.Affine( # translate_percent={"x": (-0.02, 0.02), "y": (-0.02, 0.02)}, # translate by -20 to +20 percent (per axis) # rotate=(-2, 2), # rotate by -45 to +45 degrees # shear=(-2, 2), # 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='constant' # use any of scikit-image's warping modes (see 2nd image from the top for examples) # )), # sometimes(iaa.CoarseDropout((0.03, 0.15), size_percent=(0.02, 0.05))), sometimes(iaa.PiecewiseAffine(scale=(0.01, 0.01))), iaa.Sometimes( 0.1, iaa.SimplexNoiseAlpha(iaa.OneOf( [iaa.Add((150, 255)), iaa.Add((-100, 100))]), sigmoid_thresh=5)), iaa.Sometimes( 0.1, iaa.OneOf([ iaa.CoarseDropout((0.01, 0.15), size_percent=(0.02, 0.08)), iaa.CoarseSaltAndPepper(p=0.2, size_percent=0.01), iaa.CoarseSalt(p=0.2, size_percent=0.02) ])), iaa.Sometimes(0.25, slice_thickness_augmenter) ]) return seq
def get_augmentation_sequence(): sometimes = lambda aug: iaa.Sometimes(0.1, aug) seq = iaa.Sequential([ iaa.Sometimes( 0.01, iaa.OneOf([ iaa.CoarseDropout((0.01, 0.15), size_percent=(0.02, 0.08)), iaa.CoarseSaltAndPepper(p=0.2, size_percent=0.01), iaa.CoarseSalt(p=0.2, size_percent=0.02) ])), iaa.Sometimes(0.2, iaa.LinearContrast((0.25, 0.8))), iaa.Sometimes(0.2, iaa.Add((-20, 20))), ]) seq2 = iaa.Sequential([ sometimes(iaa.PiecewiseAffine(scale=(0.01, 0.01), cval=0)), iaa.Sometimes( 0.2, iaa.ElasticTransformation(alpha=(15, 25), sigma=6, cval=0)) ]) return seq, seq2
def check_augmentation(): augmenter = iaa.Sequential([ iaa.AdditiveGaussianNoise( loc=0, scale=(0.1 * 255, 0.5 * 255), per_channel=False), # Add Gaussian noise to images. iaa.CoarseSalt(p=(0.1, 0.3), size_percent=(0.2, 0.9), per_channel=False), #iaa.CoarsePepper(p=(0.1, 0.3), size_percent=(0.2, 0.9), per_channel=False), ]) image_filepath = './image.jpg' try: image = Image.open(image_filepath) except IOError as ex: print('Failed to load an image {}.'.format(image_filepath)) return images = np.expand_dims(np.asarray(image, dtype=np.uint8), axis=0) if True: images_aug = augmenter.augment_images(images) else: augmenter_det = augmenter.to_deterministic( ) # Call this for each batch again, NOT only once at the start. images_aug = augmenter_det.augment_images(images) labels_aug = augmenter_det.augment_images(labels) for img, img_aug in zip(images, images_aug): #for img, lbl, img_aug, lbl_aug in zip(images, labels, images_aug, labels_aug): """ img = Image.fromarray(img) img_aug = Image.fromarray(img_aug) img.show() img_aug.show() #img_aug.save('./imgaug_test.png') #img_aug.convert('L').save('./imgaug_test.png') # Save as a grayscale image. """ import cv2 cv2.imshow('Image', img) cv2.imshow('Image Aug', img_aug) cv2.waitKey(0)
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]]), (3, "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, "SaltAndPepper", [("p=%.2f" % (p,), iaa.SaltAndPepper(p=p)) for p in [0.025, 0.05, 0.1, 0.2, 0.4]]), (0, "Salt", [("p=%.2f" % (p,), iaa.Salt(p=p)) for p in [0.025, 0.05, 0.1, 0.2, 0.4]]), (0, "Pepper", [("p=%.2f" % (p,), iaa.Pepper(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, "CoarseSalt\n(p=0.2)", [("size_percent=%.2f" % (size_percent,), iaa.CoarseSalt(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, "CoarsePepper\n(p=0.2)", [("size_percent=%.2f" % (size_percent,), iaa.CoarsePepper(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]]), (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]]), (0, "Alpha\nwith EdgeDetect(1.0)", [("factor=%.1f" % (factor,), iaa.Alpha(factor=factor, first=iaa.EdgeDetect(1.0))) for factor in [0.0, 0.25, 0.5, 0.75, 1.0]]), (4, "Alpha\nwith EdgeDetect(1.0)\n(per channel)", [("factor=(%.2f, %.2f)" % (factor[0], factor[1]), iaa.Alpha(factor=factor, first=iaa.EdgeDetect(1.0), per_channel=0.5)) for factor in [(0.0, 0.2), (0.15, 0.35), (0.4, 0.6), (0.65, 0.85), (0.8, 1.0)]]), (15, "SimplexNoiseAlpha\nwith EdgeDetect(1.0)", [("", iaa.SimplexNoiseAlpha(first=iaa.EdgeDetect(1.0))) for alpha in [0.0, 0.25, 0.5, 0.75, 1.0]]), (9, "FrequencyNoiseAlpha\nwith EdgeDetect(1.0)", [("exponent=%.1f" % (exponent,), iaa.FrequencyNoiseAlpha(exponent=exponent, first=iaa.EdgeDetect(1.0), size_px_max=16, upscale_method="linear", sigmoid=False)) for exponent in [-4, -2, 0, 2, 4]]) ] 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 = '![%s](%s?raw=true "%s")' % (markup_descr, fp, markup_descr) markups.append(markup) for markup in markups: print(markup)
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
# 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),
transformed_image = transform(image=image)['image'] elif augmentation == 'channel_droput': transform = ChannelDropout(always_apply=True) transformed_image = transform(image=image)['image'] elif augmentation == 'grid_dropout': transform = GridDropout(always_apply=True) transformed_image = transform(image=image)['image'] elif augmentation == 'salt': transform = iaa.Salt(0.1) transformed_image = transform(image=image) elif augmentation == 'coarse_salt': transform = iaa.CoarseSalt(0.05, size_percent=(0.01, 0.1)) transformed_image = transform(image=image) elif augmentation == 'pepper': transform = iaa.Pepper(0.1) transformed_image = transform(image=image) elif augmentation == 'coarse_pepper': transform = iaa.CoarsePepper(0.05, size_percent=(0.01, 0.1)) transformed_image = transform(image=image) elif augmentation == 'salt_and_papper': transform = iaa.SaltAndPepper(0.1) transformed_image = transform(image=image) elif augmentation == 'coarse_salt_and_papper':
def create_augmenters(height, width, height_augmentable, width_augmentable, only_augmenters): def lambda_func_images(images, random_state, parents, hooks): return images def lambda_func_heatmaps(heatmaps, random_state, parents, hooks): return heatmaps def lambda_func_keypoints(keypoints, random_state, parents, hooks): return keypoints def assertlambda_func_images(images, random_state, parents, hooks): return True def assertlambda_func_heatmaps(heatmaps, random_state, parents, hooks): return True def assertlambda_func_keypoints(keypoints, random_state, parents, hooks): return True augmenters_meta = [ iaa.Sequential([iaa.Noop(), iaa.Noop()], random_order=False, name="Sequential_2xNoop"), iaa.Sequential([iaa.Noop(), iaa.Noop()], random_order=True, name="Sequential_2xNoop_random_order"), iaa.SomeOf((1, 3), [iaa.Noop(), iaa.Noop(), iaa.Noop()], random_order=False, name="SomeOf_3xNoop"), iaa.SomeOf((1, 3), [iaa.Noop(), iaa.Noop(), iaa.Noop()], random_order=True, name="SomeOf_3xNoop_random_order"), iaa.OneOf([iaa.Noop(), iaa.Noop(), iaa.Noop()], name="OneOf_3xNoop"), iaa.Sometimes(0.5, iaa.Noop(), name="Sometimes_Noop"), iaa.WithChannels([1, 2], iaa.Noop(), name="WithChannels_1_and_2_Noop"), iaa.Noop(name="Noop"), iaa.Lambda(func_images=lambda_func_images, func_heatmaps=lambda_func_heatmaps, func_keypoints=lambda_func_keypoints, name="Lambda"), iaa.AssertLambda(func_images=assertlambda_func_images, func_heatmaps=assertlambda_func_heatmaps, func_keypoints=assertlambda_func_keypoints, name="AssertLambda"), iaa.AssertShape((None, height_augmentable, width_augmentable, None), name="AssertShape"), iaa.ChannelShuffle(0.5, name="ChannelShuffle") ] augmenters_arithmetic = [ iaa.Add((-10, 10), name="Add"), iaa.AddElementwise((-10, 10), name="AddElementwise"), #iaa.AddElementwise((-500, 500), name="AddElementwise"), iaa.AdditiveGaussianNoise(scale=(5, 10), name="AdditiveGaussianNoise"), iaa.AdditiveLaplaceNoise(scale=(5, 10), name="AdditiveLaplaceNoise"), iaa.AdditivePoissonNoise(lam=(1, 5), name="AdditivePoissonNoise"), iaa.Multiply((0.5, 1.5), name="Multiply"), iaa.MultiplyElementwise((0.5, 1.5), name="MultiplyElementwise"), iaa.Dropout((0.01, 0.05), name="Dropout"), iaa.CoarseDropout((0.01, 0.05), size_percent=(0.01, 0.1), name="CoarseDropout"), iaa.ReplaceElementwise((0.01, 0.05), (0, 255), name="ReplaceElementwise"), #iaa.ReplaceElementwise((0.95, 0.99), (0, 255), name="ReplaceElementwise"), iaa.SaltAndPepper((0.01, 0.05), name="SaltAndPepper"), iaa.ImpulseNoise((0.01, 0.05), name="ImpulseNoise"), iaa.CoarseSaltAndPepper((0.01, 0.05), size_percent=(0.01, 0.1), name="CoarseSaltAndPepper"), iaa.Salt((0.01, 0.05), name="Salt"), iaa.CoarseSalt((0.01, 0.05), size_percent=(0.01, 0.1), name="CoarseSalt"), iaa.Pepper((0.01, 0.05), name="Pepper"), iaa.CoarsePepper((0.01, 0.05), size_percent=(0.01, 0.1), name="CoarsePepper"), iaa.Invert(0.1, name="Invert"), # ContrastNormalization iaa.JpegCompression((50, 99), name="JpegCompression") ] augmenters_blend = [ iaa.Alpha((0.01, 0.99), iaa.Noop(), name="Alpha"), iaa.AlphaElementwise((0.01, 0.99), iaa.Noop(), name="AlphaElementwise"), iaa.SimplexNoiseAlpha(iaa.Noop(), name="SimplexNoiseAlpha"), iaa.FrequencyNoiseAlpha((-2.0, 2.0), iaa.Noop(), name="FrequencyNoiseAlpha") ] augmenters_blur = [ iaa.GaussianBlur(sigma=(1.0, 5.0), name="GaussianBlur"), iaa.AverageBlur(k=(3, 11), name="AverageBlur"), iaa.MedianBlur(k=(3, 11), name="MedianBlur"), iaa.BilateralBlur(d=(3, 11), name="BilateralBlur"), iaa.MotionBlur(k=(3, 11), name="MotionBlur") ] augmenters_color = [ # InColorspace (deprecated) iaa.WithColorspace(to_colorspace="HSV", children=iaa.Noop(), name="WithColorspace"), iaa.WithHueAndSaturation(children=iaa.Noop(), name="WithHueAndSaturation"), iaa.MultiplyHueAndSaturation((0.8, 1.2), name="MultiplyHueAndSaturation"), iaa.MultiplyHue((-1.0, 1.0), name="MultiplyHue"), iaa.MultiplySaturation((0.8, 1.2), name="MultiplySaturation"), iaa.AddToHueAndSaturation((-10, 10), name="AddToHueAndSaturation"), iaa.AddToHue((-10, 10), name="AddToHue"), iaa.AddToSaturation((-10, 10), name="AddToSaturation"), iaa.ChangeColorspace(to_colorspace="HSV", name="ChangeColorspace"), iaa.Grayscale((0.01, 0.99), name="Grayscale"), iaa.KMeansColorQuantization((2, 16), name="KMeansColorQuantization"), iaa.UniformColorQuantization((2, 16), name="UniformColorQuantization") ] augmenters_contrast = [ iaa.GammaContrast(gamma=(0.5, 2.0), name="GammaContrast"), iaa.SigmoidContrast(gain=(5, 20), cutoff=(0.25, 0.75), name="SigmoidContrast"), iaa.LogContrast(gain=(0.7, 1.0), name="LogContrast"), iaa.LinearContrast((0.5, 1.5), name="LinearContrast"), iaa.AllChannelsCLAHE(clip_limit=(2, 10), tile_grid_size_px=(3, 11), name="AllChannelsCLAHE"), iaa.CLAHE(clip_limit=(2, 10), tile_grid_size_px=(3, 11), to_colorspace="HSV", name="CLAHE"), iaa.AllChannelsHistogramEqualization( name="AllChannelsHistogramEqualization"), iaa.HistogramEqualization(to_colorspace="HSV", name="HistogramEqualization"), ] augmenters_convolutional = [ iaa.Convolve(np.float32([[0, 0, 0], [0, 1, 0], [0, 0, 0]]), name="Convolve_3x3"), iaa.Sharpen(alpha=(0.01, 0.99), lightness=(0.5, 2), name="Sharpen"), iaa.Emboss(alpha=(0.01, 0.99), strength=(0, 2), name="Emboss"), iaa.EdgeDetect(alpha=(0.01, 0.99), name="EdgeDetect"), iaa.DirectedEdgeDetect(alpha=(0.01, 0.99), name="DirectedEdgeDetect") ] augmenters_edges = [iaa.Canny(alpha=(0.01, 0.99), name="Canny")] augmenters_flip = [ iaa.Fliplr(1.0, name="Fliplr"), iaa.Flipud(1.0, name="Flipud") ] augmenters_geometric = [ iaa.Affine(scale=(0.9, 1.1), translate_percent={ "x": (-0.05, 0.05), "y": (-0.05, 0.05) }, rotate=(-10, 10), shear=(-10, 10), order=0, mode="constant", cval=(0, 255), name="Affine_order_0_constant"), iaa.Affine(scale=(0.9, 1.1), translate_percent={ "x": (-0.05, 0.05), "y": (-0.05, 0.05) }, rotate=(-10, 10), shear=(-10, 10), order=1, mode="constant", cval=(0, 255), name="Affine_order_1_constant"), iaa.Affine(scale=(0.9, 1.1), translate_percent={ "x": (-0.05, 0.05), "y": (-0.05, 0.05) }, rotate=(-10, 10), shear=(-10, 10), order=3, mode="constant", cval=(0, 255), name="Affine_order_3_constant"), iaa.Affine(scale=(0.9, 1.1), translate_percent={ "x": (-0.05, 0.05), "y": (-0.05, 0.05) }, rotate=(-10, 10), shear=(-10, 10), order=1, mode="edge", cval=(0, 255), name="Affine_order_1_edge"), iaa.Affine(scale=(0.9, 1.1), translate_percent={ "x": (-0.05, 0.05), "y": (-0.05, 0.05) }, rotate=(-10, 10), shear=(-10, 10), order=1, mode="constant", cval=(0, 255), backend="skimage", name="Affine_order_1_constant_skimage"), # TODO AffineCv2 iaa.PiecewiseAffine(scale=(0.01, 0.05), nb_rows=4, nb_cols=4, order=1, mode="constant", name="PiecewiseAffine_4x4_order_1_constant"), iaa.PiecewiseAffine(scale=(0.01, 0.05), nb_rows=4, nb_cols=4, order=0, mode="constant", name="PiecewiseAffine_4x4_order_0_constant"), iaa.PiecewiseAffine(scale=(0.01, 0.05), nb_rows=4, nb_cols=4, order=1, mode="edge", name="PiecewiseAffine_4x4_order_1_edge"), iaa.PiecewiseAffine(scale=(0.01, 0.05), nb_rows=8, nb_cols=8, order=1, mode="constant", name="PiecewiseAffine_8x8_order_1_constant"), iaa.PerspectiveTransform(scale=(0.01, 0.05), keep_size=False, name="PerspectiveTransform"), iaa.PerspectiveTransform(scale=(0.01, 0.05), keep_size=True, name="PerspectiveTransform_keep_size"), iaa.ElasticTransformation( alpha=(1, 10), sigma=(0.5, 1.5), order=0, mode="constant", cval=0, name="ElasticTransformation_order_0_constant"), iaa.ElasticTransformation( alpha=(1, 10), sigma=(0.5, 1.5), order=1, mode="constant", cval=0, name="ElasticTransformation_order_1_constant"), iaa.ElasticTransformation( alpha=(1, 10), sigma=(0.5, 1.5), order=1, mode="nearest", cval=0, name="ElasticTransformation_order_1_nearest"), iaa.ElasticTransformation( alpha=(1, 10), sigma=(0.5, 1.5), order=1, mode="reflect", cval=0, name="ElasticTransformation_order_1_reflect"), iaa.Rot90((1, 3), keep_size=False, name="Rot90"), iaa.Rot90((1, 3), keep_size=True, name="Rot90_keep_size") ] augmenters_pooling = [ iaa.AveragePooling(kernel_size=(1, 16), keep_size=False, name="AveragePooling"), iaa.AveragePooling(kernel_size=(1, 16), keep_size=True, name="AveragePooling_keep_size"), iaa.MaxPooling(kernel_size=(1, 16), keep_size=False, name="MaxPooling"), iaa.MaxPooling(kernel_size=(1, 16), keep_size=True, name="MaxPooling_keep_size"), iaa.MinPooling(kernel_size=(1, 16), keep_size=False, name="MinPooling"), iaa.MinPooling(kernel_size=(1, 16), keep_size=True, name="MinPooling_keep_size"), iaa.MedianPooling(kernel_size=(1, 16), keep_size=False, name="MedianPooling"), iaa.MedianPooling(kernel_size=(1, 16), keep_size=True, name="MedianPooling_keep_size") ] augmenters_segmentation = [ iaa.Superpixels(p_replace=(0.05, 1.0), n_segments=(10, 100), max_size=64, interpolation="cubic", name="Superpixels_max_size_64_cubic"), iaa.Superpixels(p_replace=(0.05, 1.0), n_segments=(10, 100), max_size=64, interpolation="linear", name="Superpixels_max_size_64_linear"), iaa.Superpixels(p_replace=(0.05, 1.0), n_segments=(10, 100), max_size=128, interpolation="linear", name="Superpixels_max_size_128_linear"), iaa.Superpixels(p_replace=(0.05, 1.0), n_segments=(10, 100), max_size=224, interpolation="linear", name="Superpixels_max_size_224_linear"), iaa.UniformVoronoi(n_points=(250, 1000), name="UniformVoronoi"), iaa.RegularGridVoronoi(n_rows=(16, 31), n_cols=(16, 31), name="RegularGridVoronoi"), iaa.RelativeRegularGridVoronoi(n_rows_frac=(0.07, 0.14), n_cols_frac=(0.07, 0.14), name="RelativeRegularGridVoronoi"), ] augmenters_size = [ iaa.Resize((0.8, 1.2), interpolation="nearest", name="Resize_nearest"), iaa.Resize((0.8, 1.2), interpolation="linear", name="Resize_linear"), iaa.Resize((0.8, 1.2), interpolation="cubic", name="Resize_cubic"), iaa.CropAndPad(percent=(-0.2, 0.2), pad_mode="constant", pad_cval=(0, 255), keep_size=False, name="CropAndPad"), iaa.CropAndPad(percent=(-0.2, 0.2), pad_mode="edge", pad_cval=(0, 255), keep_size=False, name="CropAndPad_edge"), iaa.CropAndPad(percent=(-0.2, 0.2), pad_mode="constant", pad_cval=(0, 255), name="CropAndPad_keep_size"), iaa.Pad(percent=(0.05, 0.2), pad_mode="constant", pad_cval=(0, 255), keep_size=False, name="Pad"), iaa.Pad(percent=(0.05, 0.2), pad_mode="edge", pad_cval=(0, 255), keep_size=False, name="Pad_edge"), iaa.Pad(percent=(0.05, 0.2), pad_mode="constant", pad_cval=(0, 255), name="Pad_keep_size"), iaa.Crop(percent=(0.05, 0.2), keep_size=False, name="Crop"), iaa.Crop(percent=(0.05, 0.2), name="Crop_keep_size"), iaa.PadToFixedSize(width=width + 10, height=height + 10, pad_mode="constant", pad_cval=(0, 255), name="PadToFixedSize"), iaa.CropToFixedSize(width=width - 10, height=height - 10, name="CropToFixedSize"), iaa.KeepSizeByResize(iaa.CropToFixedSize(height=height - 10, width=width - 10), interpolation="nearest", name="KeepSizeByResize_CropToFixedSize_nearest"), iaa.KeepSizeByResize(iaa.CropToFixedSize(height=height - 10, width=width - 10), interpolation="linear", name="KeepSizeByResize_CropToFixedSize_linear"), iaa.KeepSizeByResize(iaa.CropToFixedSize(height=height - 10, width=width - 10), interpolation="cubic", name="KeepSizeByResize_CropToFixedSize_cubic"), ] augmenters_weather = [ iaa.FastSnowyLandscape(lightness_threshold=(100, 255), lightness_multiplier=(1.0, 4.0), name="FastSnowyLandscape"), iaa.Clouds(name="Clouds"), iaa.Fog(name="Fog"), iaa.CloudLayer(intensity_mean=(196, 255), intensity_freq_exponent=(-2.5, -2.0), intensity_coarse_scale=10, alpha_min=0, alpha_multiplier=(0.25, 0.75), alpha_size_px_max=(2, 8), alpha_freq_exponent=(-2.5, -2.0), sparsity=(0.8, 1.0), density_multiplier=(0.5, 1.0), name="CloudLayer"), iaa.Snowflakes(name="Snowflakes"), iaa.SnowflakesLayer(density=(0.005, 0.075), density_uniformity=(0.3, 0.9), flake_size=(0.2, 0.7), flake_size_uniformity=(0.4, 0.8), angle=(-30, 30), speed=(0.007, 0.03), blur_sigma_fraction=(0.0001, 0.001), name="SnowflakesLayer") ] augmenters = (augmenters_meta + augmenters_arithmetic + augmenters_blend + augmenters_blur + augmenters_color + augmenters_contrast + augmenters_convolutional + augmenters_edges + augmenters_flip + augmenters_geometric + augmenters_pooling + augmenters_segmentation + augmenters_size + augmenters_weather) if only_augmenters is not None: augmenters_reduced = [] for augmenter in augmenters: if any([ re.search(pattern, augmenter.name) for pattern in only_augmenters ]): augmenters_reduced.append(augmenter) augmenters = augmenters_reduced return augmenters
def 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 main(): # datapath为存放训练图片的地方 datapath = '/home/zhex/data/yuncong/' # original_file为需要被增强的 original_file = '/home/zhex/data/yuncong/Mall_train.txt' # 需要被增强的训练真值txt # aug_file只记录了新增的增强后图片的box,要得到原始+增强的所有label:cat original_file augfile>finalfile(txt拼接) # aug_file输出是pdpd需要的格式,pytorch需要另行转换(可以拼接得到finalfile后直接将finalfile转换) aug_file = 'augfile_Mall.txt' dict_before = readlist(original_file) new_fp = open(aug_file, 'w') # augscene = {'Mall': 3, 'Part_B': 10, 'Part_A': 13} # 需要哪些场景,新增几倍数量的新数据 augscene = {'Mall': 3} for scene in augscene: for i in range(augscene[scene]): for img_id in dict_before.keys(): if scene in img_id: print(img_id) img = Image.open( datapath + img_id) # img.convert('RGB')->img.save('filename.jpg') img = np.array(img) bbs = ia.BoundingBoxesOnImage([ ia.BoundingBox(x1=x, y1=y, x2=x + w, y2=y + h) for [x, y, w, h] in dict_before[img_id] ], shape=img.shape) # 设置数据增强方式 # import imgaug.augmenters as iaa # List augmenter that applies only some of its children to images ''' iaa.SomeOf(n=None, children=None, random_order=False, name=None, deterministic=False, random_state=None) n: 从总的Augmenters中选择多少个来处理图片,类型可以是int,tuple,list,或者随机值 random_order: 是否每次顺序一样,默认值False(即每次顺序一样) ''' seq = iaa.SomeOf( (1, 3), [ #每次使用1~3个Augmenter来处理图片,每个batch的顺序一样 iaa.Crop(px=(0, 16)), #裁剪 iaa.Multiply((0.7, 1.3)), #改变色调 iaa.Affine(scale=(0.5, 0.7)), #仿射变换 iaa.GaussianBlur(sigma=(0, 1.5)), #高斯模糊 iaa.AddToHueAndSaturation(value=(25, -25)), iaa.ChannelShuffle(1), # RGB三通道随机交换 iaa.ElasticTransformation(alpha=0.1), iaa.Grayscale(alpha=(0.2, 0.5)), iaa.Pepper(p=0.03), iaa.AdditiveGaussianNoise(scale=(0.03 * 255, 0.05 * 255)), iaa.Dropout(p=(0.03, 0.05)), iaa.Salt(p=(0.03, 0.05)), iaa.AverageBlur(k=(1, 3)), iaa.Add((-10, 10)), iaa.CoarseSalt(size_percent=0.01) ], random_order=False) seq_det = seq.to_deterministic( ) # 保持坐标和图像同步改变,每个batch都要调用一次,不然每次的增强都是一样的 image_aug = seq_det.augment_images([img])[0] bbs_aug = seq_det.augment_bounding_boxes([bbs])[0] pic_name = img_id.split('/')[-1].split('.')[0] pic_dir = img_id.split(pic_name)[0] if not os.path.exists(datapath + 'myaug/' + pic_dir): os.makedirs(datapath + 'myaug/' + pic_dir) new_img_id = 'myaug/' + pic_dir + pic_name + '_{}'.format( i) + '.jpg' Image.fromarray(image_aug).save(datapath + new_img_id) new_fp = writelist(new_fp, new_img_id, bbs_aug.bounding_boxes)
# prepare the training dataset dataset_train = DetectorDataset(image_fps_train, image_annotations, ORIG_SIZE, ORIG_SIZE) dataset_train.prepare() # prepare the validation dataset dataset_val = DetectorDataset(image_fps_val, image_annotations, ORIG_SIZE, ORIG_SIZE) dataset_val.prepare() #### MODEL model = modellib.MaskRCNN(mode='training', config=config, model_dir=ROOT_MODEL) # Image augmentation augmentation = iaa.Sequential([ iaa.Sometimes(0.50, iaa.Fliplr(0.5)), iaa.Sometimes(0.50, iaa.Flipud(0.5)), iaa.Sometimes(0.30, iaa.CoarseSalt(p=0.10, size_percent=0.02)), iaa.Sometimes(0.30, iaa.Affine(rotate=(-25, 25))), iaa.Sometimes(0.30, iaa.GaussianBlur((0, 3.0))) ]) NUM_EPOCHS = 1 model.train(dataset_train, dataset_val, learning_rate=config.LEARNING_RATE, epochs=NUM_EPOCHS, layers='all', augmentation=augmentation)
def simple_imgaug_example(): image_dir_path = dataset_home_dir_path + '/phenotyping/cvppp2017_lsc_lcc_challenge/package/CVPPP2017_LSC_training/training/A1' label_dir_path = dataset_home_dir_path + '/phenotyping/cvppp2017_lsc_lcc_challenge/package/CVPPP2017_LSC_training/training/A1' images, labels = prepare_dataset(image_dir_path, label_dir_path) image_width, image_height = 200, 200 # FIXME [decide] >> Before or after random transformation? # Preprocessing (normalization, standardization, etc). images_pp = images.astype(np.float) #images_pp /= 255.0 images_pp = standardize_samplewise(images_pp) #images_pp = standardize_featurewise(images_pp) if True: augmenter = iaa.SomeOf( (1, 2), [ iaa.OneOf([ 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 -10 to +10 percent (per axis). rotate=(-10, 10), # Rotate by -10 to +10 degrees. shear=(-5, 5), # Shear by -5 to +5 degrees. #order=[0, 1], # Use nearest neighbour or bilinear interpolation (fast). order= 0, # 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). #mode='edge' # Use any of scikit-image's warping modes (see 2nd image from the top for examples). ), #iaa.PiecewiseAffine(scale=(0.01, 0.05)), # Move parts of the image around. Slow. iaa.PerspectiveTransform(scale=(0.01, 0.1)), iaa.ElasticTransformation( alpha=(20.0, 50.0), sigma=(6.5, 8.5) ), # Move pixels locally around (with random strengths). ]), iaa.OneOf([ iaa.GaussianBlur(sigma=( 0, 3.0)), # Blur images with a sigma between 0 and 3.0. iaa.AverageBlur( k=(2, 7) ), # Blur image using local means with kernel sizes between 2 and 7. iaa.MedianBlur( k=(3, 11) ), # Blur image using local medians with kernel sizes between 2 and 7. iaa.MotionBlur(k=(5, 11), angle=(0, 360), direction=(-1.0, 1.0), order=1), ]), iaa.OneOf([ iaa.AdditiveGaussianNoise( loc=0, scale=(0.1 * 255, 0.5 * 255), per_channel=False), # Add Gaussian noise to images. iaa.AdditiveLaplaceNoise(loc=0, scale=(0.1 * 255, 0.4 * 255), per_channel=False), iaa.AdditivePoissonNoise(lam=(32, 96), per_channel=False), iaa.CoarseSaltAndPepper(p=(0.1, 0.3), size_percent=(0.2, 0.9), per_channel=False), iaa.CoarseSalt(p=(0.1, 0.3), size_percent=(0.2, 0.9), per_channel=False), iaa.CoarsePepper(p=(0.1, 0.3), size_percent=(0.2, 0.9), per_channel=False), iaa.CoarseDropout(p=(0.1, 0.3), size_percent=(0.05, 0.3), per_channel=False), ]), iaa.OneOf([ iaa.MultiplyHueAndSaturation(mul=(-10, 10), per_channel=False), iaa.AddToHueAndSaturation(value=(-255, 255), per_channel=False), iaa.LinearContrast( alpha=(0.5, 1.5), per_channel=False), # Improve or worsen the contrast. iaa.Invert(p=1, per_channel=False), # Invert color channels. iaa.Sharpen(alpha=(0, 1.0), lightness=(0.75, 1.5)), # Sharpen images. iaa.Emboss(alpha=(0, 1.0), strength=(0, 2.0)), # Emboss images. ]), ], random_order=True) elif False: augmenter = iaa.Sequential( [ # Apply the following augmenters to most images. iaa.Fliplr(0.5), # Horizontally flip 50% of all images. iaa.Flipud(0.2), # Vertically flip 20% of all images. # Crop images by -5% to 10% of their height/width. iaa.Sometimes( 0.5, iaa.CropAndPad(percent=(-0.05, 0.1), pad_mode=ia.ALL, pad_cval=(0, 255))), iaa.Sometimes( 0.5, 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.2, 0.2), 'y': (-0.2, 0.2) }, # Translate by -20 to +20 percent (per axis). rotate=(-45, 45), # Rotate by -45 to +45 degrees. shear=(-16, 16), # 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). )), # Execute 0 to 5 of the following (less important) augmenters per image. # Don't execute all of them, as that would often be way too strong. iaa.SomeOf( (0, 5), [ iaa.Sometimes( 0.5, iaa.Superpixels(p_replace=(0, 1.0), n_segments=(20, 200)) ), # Convert images into their superpixel representation. iaa.OneOf([ iaa.GaussianBlur( (0, 3.0) ), # Blur images with a sigma between 0 and 3.0. iaa.AverageBlur( k=(2, 7) ), # Blur image using local means with kernel sizes between 2 and 7. iaa.MedianBlur( k=(3, 11) ), # Blur image using local medians with kernel sizes between 2 and 7. ]), iaa.Sharpen(alpha=(0, 1.0), lightness=(0.75, 1.5)), # Sharpen images. iaa.Emboss(alpha=(0, 1.0), strength=(0, 2.0)), # Emboss images. # Search either for all edges or for directed edges, blend the result with the original image using a blobby mask. iaa.SimplexNoiseAlpha( iaa.OneOf([ iaa.EdgeDetect(alpha=(0.5, 1.0)), iaa.DirectedEdgeDetect(alpha=(0.5, 1.0), direction=(0.0, 1.0)), ])), iaa.AdditiveGaussianNoise( loc=0, scale=(0.0, 0.05 * 255), per_channel=0.5), # Add gaussian noise to images. iaa.OneOf([ iaa.Dropout( (0.01, 0.1), per_channel=0.5 ), # Randomly remove up to 10% of the pixels. iaa.CoarseDropout((0.03, 0.15), size_percent=(0.02, 0.05), per_channel=0.2), ]), iaa.Invert(0.05, per_channel=True), # Invert color channels. iaa.Add( (-10, 10), per_channel=0.5 ), # Change brightness of images (by -10 to 10 of original value). iaa.AddToHueAndSaturation( (-20, 20)), # Change hue and saturation. # Either change the brightness of the whole image (sometimes per channel) or change the brightness of subareas. iaa.OneOf([ iaa.Multiply((0.5, 1.5), per_channel=0.5), iaa.FrequencyNoiseAlpha( exponent=(-4, 0), first=iaa.Multiply( (0.5, 1.5), per_channel=True), second=iaa.ContrastNormalization((0.5, 2.0))) ]), iaa.ContrastNormalization( (0.5, 2.0), per_channel=0.5 ), # Improve or worsen the contrast. iaa.Grayscale(alpha=(0.0, 1.0)), iaa.Sometimes( 0.5, iaa.ElasticTransformation(alpha=(0.5, 3.5), sigma=0.25) ), # Move pixels locally around (with random strengths). iaa.Sometimes( 0.5, iaa.PiecewiseAffine(scale=(0.01, 0.05)) ), # Sometimes move parts of the image around. iaa.Sometimes( 0.5, iaa.PerspectiveTransform(scale=(0.01, 0.1))) ], random_order=True) ], random_order=True) else: augmenter = iaa.Sequential([ iaa.SomeOf( 1, [ #iaa.Sometimes(0.5, iaa.Crop(px=(0, 100))), # Crop images from each side by 0 to 16px (randomly chosen). iaa.Sometimes(0.5, iaa.Crop(percent=( 0, 0.1))), # Crop images by 0-10% of their height/width. iaa.Fliplr(0.5), # Horizontally flip 50% of the images. iaa.Flipud(0.5), # Vertically flip 50% of the images. iaa.Sometimes( 0.5, 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.2, 0.2), 'y': (-0.2, 0.2) }, # Translate by -20 to +20 percent (per axis). rotate=(-45, 45), # Rotate by -45 to +45 degrees. shear=(-16, 16), # Shear by -16 to +16 degrees. #order=[0, 1], # Use nearest neighbour or bilinear interpolation (fast). order= 0, # 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). #mode='edge' # Use any of scikit-image's warping modes (see 2nd image from the top for examples). )), iaa.Sometimes(0.5, iaa.GaussianBlur( sigma=(0, 3.0))) # Blur images with a sigma of 0 to 3.0. ]), iaa.Scale(size={ 'height': image_height, 'width': image_width }) # Resize. ]) for idx in range(images.shape[0]): images_pp[idx] = (images_pp[idx] - np.min(images_pp[idx])) / ( np.max(images_pp[idx]) - np.min(images_pp[idx])) * 255 images_pp = images_pp.astype(np.uint8) # Test 1 (good). augmenter_det = augmenter.to_deterministic( ) # Call this for each batch again, NOT only once at the start. #images_aug1 = augmenter_det.augment_images(images) images_aug1 = augmenter_det.augment_images(images_pp) labels_aug1 = augmenter_det.augment_images(labels) augmenter_det = augmenter.to_deterministic( ) # Call this for each batch again, NOT only once at the start. #images_aug2 = augmenter_det.augment_images(images) images_aug2 = augmenter_det.augment_images(images_pp) labels_aug2 = augmenter_det.augment_images(labels) #export_images(images, labels, './augmented1/img', '') export_images(images_pp, labels, './augmented1/img', '') export_images(images_aug1, labels_aug1, './augmented1/img', '_aug1') export_images(images_aug2, labels_aug2, './augmented1/img', '_aug2') # Test 2 (bad). augmenter_det = augmenter.to_deterministic( ) # Call this for each batch again, NOT only once at the start. #images_aug1 = augmenter_det.augment_images(images) images_aug1 = augmenter_det.augment_images(images_pp) labels_aug1 = augmenter_det.augment_images(labels) #images_aug2 = augmenter_det.augment_images(images) images_aug2 = augmenter_det.augment_images(images_pp) labels_aug2 = augmenter_det.augment_images(labels) #export_images(images, labels, './augmented2/img', '') export_images(images_pp, labels, './augmented2/img', '') export_images(images_aug1, labels_aug1, './augmented2/img', '_aug1') export_images(images_aug2, labels_aug2, './augmented2/img', '_aug2') print('*********************************', images_pp.dtype)