def logic(self, image):
for param in self.augmentation_params:
self.augmentation_data.append([
str(param.augmentation_value),
iaa.Pepper(p=param.augmentation_value).to_deterministic().
augment_image(image), param.detection_tag
])
def generator(image_list):
for name in image_list:
fileName = name
name = os.path.join(PATH, name)
images = cv2.imread(name)
sometimes = lambda aug: iaa.Sometimes(0.3, aug)
seq = iaa.Sequential([
iaa.Flipud(p=0.5),
iaa.Fliplr(p=0.5),
sometimes(iaa.Pepper(p=0.10)),
sometimes(iaa.Salt(p=0.03)),
sometimes(iaa.AdditivePoissonNoise(lam=8.0)),
sometimes(iaa.JpegCompression(compression=50)),
sometimes(iaa.PiecewiseAffine(scale=0.015)),
sometimes(iaa.MotionBlur(k=7, angle=0)),
sometimes(iaa.MotionBlur(k=5, angle=144))
],
random_order=False)
for i in range(10):
images_aug = seq.augment_image(images)
name = 'aug_' + fileName.split('.')[0] + "-" + str(i) + '.jpg'
name = os.path.join(PATH, name)
cv2.imwrite(name, images_aug)
print(name + " is saved.")
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 train(model, dataset_dir):
"""Train the model."""
# Training dataset.
dataset_train = MangaDataset()
dataset_train.load_Manga(dataset_dir, "train")
dataset_train.prepare() #dataset 클래스의 참조 필요
# Validation dataset
dataset_val = MangaDataset()
dataset_val.load_Manga(dataset_dir, "val")
dataset_val.prepare()
# Image augmentation
augmentation = iaa.SomeOf(
(2, 4),
[
#iaa.Fliplr(0.5),
#iaa.Flipud(0.5),
iaa.OneOf([
iaa.Affine(rotate=15),
iaa.Affine(rotate=10),
iaa.Affine(rotate=20),
iaa.Affine(rotate=25),
iaa.Affine(rotate=30),
iaa.Affine(rotate=350),
iaa.Affine(rotate=345),
iaa.Affine(rotate=340),
iaa.Affine(rotate=330)
]),
#iaa.Multiply((0.8, 1.5)),
#iaa.GaussianBlur(sigma=(0.0, 5.0)),
iaa.Dropout(p=(0.15, 0.25)),
iaa.Pepper(p=(0.2, 0.3)),
iaa.CoarseDropout(p=(0.2, 0.6), size_percent=(0.02, 0.4)),
iaa.AdditiveGaussianNoise(scale=0.05 * 255)
])
# http://imgaug.readthedocs.io/en/latest/source/augmenters.html
#이건 뭐하는걸까? image augmentation인걸 보니 전처리를 해주는가보다.
# *** 수정이 필요하면 맞게 수정하세요 ***
# If starting from imagenet, train heads only for a bit
# since they have random weights
print("Train network heads")
model.train(
dataset_train,
dataset_val,
learning_rate=config.LEARNING_RATE, #config 참조 필요 혹은 직접 러닝레이트 지정
epochs=150,
augmentation=augmentation,
layers='heads')
print("Train all layers")
model.train(dataset_train,
dataset_val,
learning_rate=config.LEARNING_RATE,
epochs=2000,
augmentation=augmentation,
layers='all')
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 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 chapter_augmenters_pepper():
fn_start = "arithmetic/pepper"
aug = iaa.Pepper(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 __init__(self):
#print('[INFO] Applying data augmentation...')
sometimes = lambda aug: iaa.Sometimes(0.5, aug)
rare = lambda aug: iaa.Sometimes(0.25, aug)
self.seq = iaa.Sequential([sometimes(iaa.Affine(
rotate=(-5,5),
translate_percent={'x': (-0.05, 0.05), 'y':(-0.05,0.05)},
shear=(-10,10))),
rare(iaa.Pepper(0.05))])
def aug_before_prepare(self, img, bboxes, masks, polys):
aug = iaa.SomeOf((1, 3), [
iaa.Multiply(((0.7, 1.3))),
iaa.GaussianBlur(sigma=(0, 1.5)),
iaa.ChannelShuffle(1),
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.Add((-10, 10)),
iaa.AverageBlur(k=(1, 3))
])
if (random.random() > 0.5):
img, bboxes, masks = self.random_rotate(img, np.array(polys), masks, 90)
img = aug.augment_image(img)
return img, bboxes, masks
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, input_size=(512, 512), features_pixel=8, aug=False):
self.input_size = input_size
assert input_size[0] % features_pixel == 0
assert input_size[1] % features_pixel == 0
self.feature_pixel = features_pixel
self.feature_size = (
input_size[0] // features_pixel,
input_size[1] // features_pixel,
)
if aug:
self.aug = iaa.Sequential(
[
iaa.ContrastNormalization((0.75, 1.5)),
iaa.AdditiveGaussianNoise(
loc=0, scale=(0.0, 0.05 * 255), per_channel=0.5
),
iaa.Multiply((0.8, 1.2), per_channel=0.2),
iaa.Add((-10, 10), per_channel=0.5),
iaa.Pepper((0, 0.05), per_channel=0.2),
iaa.GaussianBlur((0, 2.0)),
]
)
else:
self.aug = None
augmenters = [
# blur images with a sigma between 0 and 3.0
iaa.Noop(),
iaa.GaussianBlur(sigma=(0.5, 2.0)),
iaa.Add((-50.0, 50.0), per_channel=False),
iaa.AdditiveGaussianNoise(loc=0,
scale=(0.07 * 255, 0.07 * 255),
per_channel=False),
iaa.Dropout(p=0.07, per_channel=False),
iaa.CoarseDropout(p=(0.05, 0.15),
size_percent=(0.1, 0.9),
per_channel=False),
iaa.SaltAndPepper(p=(0.05, 0.15), per_channel=False),
iaa.Salt(p=(0.05, 0.15), per_channel=False),
iaa.Pepper(p=(0.05, 0.15), per_channel=False),
iaa.ContrastNormalization(alpha=(iap.Uniform(0.02, 0.03),
iap.Uniform(1.7, 2.1))),
iaa.ElasticTransformation(alpha=(0.5, 2.0)),
]
seq = iaa.Sequential(iaa.OneOf(augmenters), )
def get_data_from_tip(tip, batch_size):
features = []
labels = []
descriptions = []
for i in range(batch_size):
data = tip.get()
d, f, l = data
features.append(f.reshape((224, 224, 1)))
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)
import shutil
import cv2
from imgaug import augmenters as iaa
PATH = "aug_data2"
for path, dirs, files in os.walk(PATH):
for filename in files:
fullpath = os.path.join(path, filename)
image = cv2.imread(fullpath)
idx = 10
noise = iaa.AdditiveGaussianNoise(scale=(30, 30))
image_aug = noise.augment_image(image)
newpath = fullpath[:-4] + str(idx) + fullpath[-4:]
cv2.imwrite(newpath, image_aug)
idx += 1
noise = iaa.AdditivePoissonNoise(lam=30)
image_aug = noise.augment_image(image)
newpath = fullpath[:-4] + str(idx) + fullpath[-4:]
cv2.imwrite(newpath, image_aug)
idx += 1
noise = iaa.Pepper(p=0.05)
image_aug = noise.augment_image(image)
newpath = fullpath[:-4] + str(idx) + fullpath[-4:]
cv2.imwrite(newpath, image_aug)
idx += 1
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
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':
transform = iaa.CoarseSaltAndPepper(0.05, size_percent=(0.01, 0.1))
transformed_image = transform(image=image)
elif augmentation == 'impulse_noise':
rotate=(-90, 90),
order=1),
iaa.Fliplr(0.5), # horizontally flip 50% of the images
],
random_order=True) # apply augmenters in random order
CBLN = iaa.Sequential(
[
# Normalize contrast by a factor of 0.5 to 1.5, sampled randomly per image. It maight change the color.
iaa.ContrastNormalization((0.9, 1.2)),
# Small gaussian blur with random sigma between 0 and 0.5, But we only blur about 50% of all images.
iaa.Sometimes(0.5, iaa.GaussianBlur(sigma=(1.0, 1.5))),
# endark the image
EnBrightOrEnDark,
# Add SaltAndPepper noise. For 50% of all images, we sample the noise once per pixel.
iaa.Pepper((0.01, 0.02)),
# Drop 0 to 5% of all pixels by converting them to black pixels, but do that on
# a lower-resolution version of the image that has 5% to 50% of the original size, leading to large rectangular areas being dropped:
iaa.CoarseDropout((0.0, 0.02), size_percent=(0.1, 0.35)),
],
random_order=True) # apply augmenters in random order
CBLN1 = iaa.Sequential(
[
# Normalize contrast by a factor of 0.5 to 1.5, sampled randomly per image. It maight change the color.
iaa.ContrastNormalization(0.9),
# Small gaussian blur with random sigma between 0 and 0.5, But we only blur about 50% of all images.
iaa.GaussianBlur(1.0),
# endark the image
EnBrightOrEnDark,
# Add SaltAndPepper noise. For 50% of all images, we sample the noise once per pixel.
def train(tip, iters=None, learning_rate=0.001, batch_norm=False):
import tensorflow as tf
random.seed(datetime.datetime.now())
tf.set_random_seed(seed())
default_device = '/gpu:0'
# default_device = '/cpu:0'
# hyperparams
batch_size = 94
training = True
batch_norms_training = False
# steps
light_summary_steps = 25
heavy_summary_steps = 250
checkpoint_steps = 500
# stats / logging
model_version = 1
time_str = datetime.datetime.now().strftime('%m-%d--%H%M%S')
best_loss = 0.6
batch_num = 0
best_acc = 0
models_to_keep = 3
# glob vars
heavy_sum = []
light_sum = []
models_history = []
train_only_dense = False
dense_size = 64
dropout = True
learning_rate = 1e-6
augmentation = True
with tf.device(default_device):
# config = tf.ConfigProto()
config = tf.ConfigProto(log_device_placement=False, allow_soft_placement=True)
# please do not use the totality of the GPU memory
config.gpu_options.per_process_gpu_memory_fraction = 0.98
# config = tf.ConfigProto(device_count = {'GPU': 0})
config.gpu_options.allow_growth = True
with tf.Session(graph=tf.Graph(), config=config) as sess:
with tf.name_scope("inputs"):
# _images = tf.placeholder(tf.float32, [None, 224, 224, 1])
_images = tf.placeholder(tf.float32, [batch_size, 224, 224, 1])
_is_training = tf.placeholder(tf.bool, name='is_training')
model = vggish.Vggish(_images,
classes=2,
trainable=training,
batch_norm=batch_norm,
dropout=dropout,
only_dense=train_only_dense,
dense_size=dense_size,
bn_trainable=batch_norms_training)
with tf.name_scope("targets"):
_labels = tf.placeholder(tf.float32, shape=(None, 2), name='labels')
with tf.name_scope("outputs"):
logits = model.fc3l
# predictions = tf.nn.softmax(logits, name='predictions')
predictions = tf.nn.sigmoid(logits, name='predictions')
tvars = tf.trainable_variables()
for v in tvars:
print(v)
if 'weights' in v.name:
heavy_sum.append(tf.summary.histogram(v.name, v))
# if 'conv1_1' in v.name:
# light_sum.append(tf.summary.histogram(v.name, v))
for v in tvars:
if 'bias' in v.name:
heavy_sum.append(tf.summary.histogram(v.name, v))
# if 'conv1_1' in v.name:
# light_sum.append(tf.summary.histogram(v.name, v))
light_sum.append(tf.summary.histogram("predictions", predictions))
light_sum.extend(model.summaries)
heavy_sum.extend(model.heavy_summaries)
with tf.name_scope("0_cost"):
cross_entropy = tf.nn.sigmoid_cross_entropy_with_logits(
logits=logits,
labels=_labels,
name='cross_entropy'
)
tvars = tf.trainable_variables()
L2 = [tf.nn.l2_loss(v) for v in tvars if 'bias' not in v.name]
lossL2 = tf.add_n(L2) * 0.01
cost = tf.reduce_mean(cross_entropy, name='cost') + lossL2
light_sum.append(tf.summary.scalar("cost", cost))
def my_capper(t):
print(t)
# return t
if t is None:
return None
return tf.clip_by_value(t, -5., 5.)
log_string = 'logs/{}-vggish/{}-lr-{:.8f}'.format(model_version,
time_str,
learning_rate)
with tf.name_scope("0_train"):
with tf.control_dependencies(tf.get_collection(tf.GraphKeys.UPDATE_OPS)):
vars_to_train = model.get_vars_to_train()
global_step = tf.Variable(0, name='global_step')
learning_rate = tf.train.exponential_decay(learning_rate, global_step, 100000, 0.96, staircase=True)
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
# optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate)
grads_and_vars = optimizer.compute_gradients(cost, var_list=vars_to_train)
grads_and_vars = [(my_capper(gv[0]), gv[1]) for gv in grads_and_vars]
optimizer = optimizer.apply_gradients(grads_and_vars, global_step=global_step)
correct_predictions = tf.equal(tf.argmax(predictions, 1),
tf.argmax(_labels, 1),
name='correct_predictions')
accuracy = tf.reduce_mean(tf.cast(correct_predictions, tf.float32),
name='accuracy')
grad_norm = tf.norm(grads_and_vars[0][0])
light_sum.append(tf.summary.scalar("accuracy", accuracy))
light_sum.append(tf.summary.scalar("gradient", grad_norm))
light_summary = tf.summary.merge(light_sum)
heavy_summary = tf.summary.merge(light_sum + heavy_sum)
sess.run(tf.global_variables_initializer())
saver = tf.train.Saver(tf.global_variables(), max_to_keep=None)
iteration = 0
try:
print('[+] loading startup.json')
startup = json.load(open('startup.vggish.json', 'r'))
print('[+] loading path:', startup['path'])
state = json.load(open(startup['path'], 'r'))
print('[+] loading checkpoint:', state['checkpoint_path'])
last_checkpoint = os.path.dirname(state['checkpoint_path'])
weights_to_load = vggish.conv_vars + vggish.fc_vars
if train_only_dense:
weights_to_load = vggish.conv_vars
model.load_weights(last_checkpoint, vars_names=weights_to_load)
iteration = state['iteration']
best_loss = state['best_loss']
if 'train_loss' in state:
best_loss = state['best_loss']
checkpoint_path = state['checkpoint_path']
except:
print('[!] no models to checkpoint from..')
raise
writer = tf.summary.FileWriter(log_string)
augmenters = [
# blur images with a sigma between 0 and 3.0
iaa.Noop(),
iaa.GaussianBlur(sigma=(0.5, 2.0)),
iaa.Add((-50.0, 50.0), per_channel=False),
iaa.AdditiveGaussianNoise(loc=0,
scale=(0.07*255, 0.07*255),
per_channel=False),
iaa.Dropout(p=0.07, per_channel=False),
iaa.CoarseDropout(p=(0.05, 0.15),
size_percent=(0.1, 0.9),
per_channel=False),
iaa.SaltAndPepper(p=(0.05, 0.15), per_channel=False),
iaa.Salt(p=(0.05, 0.15), per_channel=False),
iaa.Pepper(p=(0.05, 0.15), per_channel=False),
iaa.ContrastNormalization(alpha=(iap.Uniform(0.02, 0.03),
iap.Uniform(1.7, 2.1))),
iaa.ElasticTransformation(alpha=(0.5, 2.0)),
]
if not augmentation:
augmenters = [
iaa.Noop(),
]
seq = iaa.Sequential(
iaa.OneOf(augmenters),
)
while True:
if iters and iteration >= iters:
return
seq.reseed(seed())
np.random.seed(seed())
descriptions, features, labels = get_data_from_tip(tip, batch_size)
iteration += 1
# import pdb; pdb.set_trace()
mean = 0.172840994091
std = 0.206961060284
merged_summaries = light_summary
if iteration % heavy_summary_steps == 0:
merged_summaries = heavy_summary
try:
with np.errstate(all='raise'):
for i in range(5):
newfeatures = seq.augment_images(features * 255) / 255
if not np.isnan(newfeatures).any():
break
print('[!] has nan in newfeatures, retrying', i)
if np.isnan(newfeatures).any():
print('[!] could not get rid of nan.. skipping this batch')
iteration -= 1
continue
features = newfeatures
except Exception:
print("[!] Warning detected augmenting, skipping..")
tb = traceback.format_exc()
open("numpy_warns.log", 'ab').write(str(descriptions).encode('utf-8'))
open("numpy_warns.log", 'ab').write(str(tb).encode('utf-8'))
open("numpy_warns.log", 'a').write('------------------------------------')
# import pdb; pdb.set_trace()
continue
feed_dict = {
_images: features,
_labels: labels,
_is_training: training
}
train_loss, val_acc, _, p, summary, grad, _corr_pred = sess.run(
[cost,
accuracy,
optimizer,
logits,
merged_summaries,
grad_norm,
correct_predictions],
feed_dict=feed_dict
)
print('[+] iteration {}'.format(iteration))
if iteration % light_summary_steps == 0:
if os.path.isfile('nomix_pdb'):
import pdb
pdb.set_trace()
print('[+] writing summary')
writer.add_summary(summary, iteration)
print('\tIteration {} Accuracy: {} Loss: {}/{}'.format(iteration,
val_acc,
train_loss,
best_loss))
# if train_loss < best_loss:
if iteration % checkpoint_steps == 0:
# print('\t\tNew Best Loss!')
best_loss = train_loss
timestamp = datetime.datetime.now().strftime("%Y-%m-%d_%H%M%S")
checkpoint_dir = os.path.join('D:\\checkpoint', timestamp)
checkpoint_path = os.path.join('D:\\checkpoint', timestamp, 'model.ckpt')
print('\t\tSaving model to:' + checkpoint_path)
saver.save(sess, checkpoint_path, global_step=batch_num)
state = {
'iteration': iteration,
'best_acc': float(best_acc),
'best_loss': float(best_loss),
'val_acc': float(val_acc),
'train_loss': float(train_loss),
'checkpoint_path': checkpoint_path,
'log_string': log_string,
}
# state_path = os.path.join('save', timestamp, 'state.json')
state_path = os.path.join('D:\\checkpoint', timestamp, 'state.json')
open(state_path, 'w').write(json.dumps(state))
startup = {
'path': state_path,
}
open('startup.vggish.json', 'w').write(json.dumps(startup))
models_history.append(checkpoint_dir)
while len(models_history) > models_to_keep:
try:
path_to_del = models_history.pop(0)
print('[+] deleting model', path_to_del)
shutil.rmtree(path_to_del)
except:
print('[+] failed to delete')
traceback.print_exc()
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 = '' % (markup_descr, fp, markup_descr)
markups.append(markup)
for markup in markups:
print(markup)
def augument(self, image, bbox_list):
seq = iaa.Sequential([
# 变形
iaa.Sometimes(
0.6,
[
iaa.OneOf([
iaa.Affine(shear={
'x': (-1.5, 1.5),
'y': (-1.5, 1.5)
},
mode="edge"), # 仿射变化程度，单位像素
iaa.Rotate(rotate=(-1, 1), mode="edge"), # 旋转,单位度
])
]),
# 扭曲
iaa.Sometimes(
0.5,
[
iaa.OneOf([
iaa.PiecewiseAffine(
scale=(0, 0.02), nb_rows=2, nb_cols=2), # 局部仿射
iaa.ElasticTransformation( # distort扭曲变形
alpha=(0, 3), # 扭曲程度
sigma=(0.8, 1), # 扭曲后的平滑程度
mode="nearest"),
]),
]),
# 模糊
iaa.Sometimes(
0.5,
[
iaa.OneOf([
iaa.GaussianBlur(sigma=(0, 0.7)),
iaa.AverageBlur(k=(1, 3)),
iaa.MedianBlur(k=(1, 3)),
iaa.BilateralBlur(
d=(1, 5),
sigma_color=(10, 200),
sigma_space=(10, 200)), # 既噪音又模糊，叫双边,
iaa.MotionBlur(k=(3, 5)),
iaa.Snowflakes(flake_size=(0.1, 0.2),
density=(0.005, 0.025)),
iaa.Rain(nb_iterations=1,
drop_size=(0.05, 0.1),
speed=(0.04, 0.08)),
])
]),
# 锐化
iaa.Sometimes(0.3, [
iaa.OneOf([
iaa.Sharpen(),
iaa.GammaContrast(),
iaa.SigmoidContrast()
])
]),
# 噪音
iaa.Sometimes(0.3, [
iaa.OneOf([
iaa.AdditiveGaussianNoise(scale=(1, 5)),
iaa.AdditiveLaplaceNoise(scale=(1, 5)),
iaa.AdditivePoissonNoise(lam=(1, 5)),
iaa.Salt((0, 0.02)),
iaa.Pepper((0, 0.02))
])
]),
# 剪切
iaa.Sometimes(
0.8,
[
iaa.OneOf([
iaa.Crop((0, 2)), # 切边, (0到10个像素采样)
])
]),
])
assert bbox_list is None or type(bbox_list) == list
if bbox_list is None or len(bbox_list) == 0:
polys = None
else:
polys = [ia.Polygon(pos) for pos in bbox_list]
polys = ia.PolygonsOnImage(polys, shape=image.shape)
# 处理部分或者整体出了图像的范围的多边形，参考：https://imgaug.readthedocs.io/en/latest/source/examples_bounding_boxes.html
polys = polys.remove_out_of_image().clip_out_of_image()
images_aug, polygons_aug = seq(images=[image], polygons=polys)
image = images_aug[0]
if polygons_aug is None:
polys = None
else:
polys = []
for p in polygons_aug.polygons:
polys.append(p.coords)
polys = np.array(polys, np.int32).tolist() # (N,2)
return image, polys
X_train_all = np.load('x_train_all_64.npy')
y_train_all = np.load('x_label_all_64.npy')
#define augmnetation
aug1 = iaa.GaussianBlur(sigma=(0, 2.0))
aug2 = iaa.AdditiveGaussianNoise(loc=0, scale=(0.0, 0.05*255), per_channel=0.5)
aug3 = iaa.Multiply((0.8, 1.2), per_channel=0.2)
aug4 = iaa.Affine(
scale={"x": (0.8, 1.2), "y": (0.8, 1.2)},
translate_percent={"x": (-0.2, 0.2), "y": (-0.2, 0.2)},
rotate=(-45, 45),
shear=(-8, 8))
aug5 = iaa.CoarseDropout(p=0.2, size_percent = 0.15)
aug6 = iaa.ContrastNormalization((0.75, 1.5))
aug7 = iaa.Pepper(p=0.05)
def augment_img(img):
i = np.random.randint(0,9)
if i==0:
img_adapteq = img
elif i==1:
img_adapteq = aug4.augment_image(img)
img_adapteq = aug1.augment_image(img_adapteq)
elif i==2:
img_adapteq = aug2.augment_image(img)
def get_aug(self):
#sometimes_bg = lambda aug: iaa.Sometimes(0.3, aug)
sometimes_contrast = lambda aug: iaa.Sometimes(0.3, aug)
sometimes_noise = lambda aug: iaa.Sometimes(0.6, aug)
sometimes_blur = lambda aug: iaa.Sometimes(0.6, aug)
sometimes_degrade_quality = lambda aug: iaa.Sometimes(0.9, aug)
sometimes_blend = lambda aug: iaa.Sometimes(0.2, aug)
seq = iaa.Sequential(
[
# crop some of the images by 0-30% of their height/width
# Execute 0 to 4 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, 4),
# [
# change the background color of some of the images chosing any one technique
# sometimes_bg(iaa.OneOf([
# iaa.AddToHueAndSaturation((-60, 60)),
# iaa.Multiply((0.6, 1), per_channel=True),
# ])),
#change the contrast of the input images chosing any one technique
sometimes_contrast(iaa.OneOf([
iaa.LinearContrast((0.5,1.5)),
iaa.SigmoidContrast(gain=(3, 5), cutoff=(0.4, 0.6)),
iaa.CLAHE(tile_grid_size_px=(3, 21)),
iaa.GammaContrast((0.5,1.0))
])),
#add noise to the input images chosing any one technique
sometimes_noise(iaa.OneOf([
iaa.AdditiveGaussianNoise(scale=(3,8)),
iaa.CoarseDropout((0.001,0.01), size_percent=0.5),
iaa.AdditiveLaplaceNoise(scale=(3,10)),
iaa.CoarsePepper((0.001,0.01), size_percent=(0.5)),
iaa.AdditivePoissonNoise(lam=(3.0,10.0)),
iaa.Pepper((0.001,0.01)),
iaa.Snowflakes(),
iaa.Dropout(0.01,0.01),
])),
#add blurring techniques to the input image
sometimes_blur(iaa.OneOf([
iaa.AverageBlur(k=(3)),
iaa.GaussianBlur(sigma=(1.0)),
])),
# add techniques to degrade the iamge quality
sometimes_degrade_quality(iaa.OneOf([
iaa.Emboss(alpha=(0, 1.0), strength=(0, 2.0)),
iaa.Sharpen(alpha=(0.5), lightness=(0.75,1.5)),
iaa.BlendAlphaSimplexNoise(
foreground=iaa.Multiply(iap.Choice([1.5]), per_channel=False)
)
])),
# blend some patterns in the background
sometimes_blend(iaa.OneOf([
iaa.BlendAlpha(
factor=(0.6,0.8),
foreground=iaa.Sharpen(1.0, lightness=1),
background=iaa.CoarseDropout(p=0.1, size_px=np.random.randint(30))),
iaa.BlendAlphaFrequencyNoise(exponent=(-4),
foreground=iaa.Multiply(iap.Choice([0.5]), per_channel=False)
),
iaa.BlendAlphaSimplexNoise(
foreground=iaa.Multiply(iap.Choice([0.5]), per_channel=True)
)
])),
])
return seq
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 train():
with tf.device(default_device):
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(graph=tf.Graph(), config=config) as sess:
with tf.name_scope("inputs"):
# _images = tf.placeholder(tf.float32, shape=(None, 4096), name='images')
_images = tf.placeholder(tf.float32, [None, 224, 224, 1])
_is_training = tf.placeholder(tf.bool, name='is_training')
_keep_prob = tf.placeholder(tf.float32,
name='keep_probability')
# imgs = tf.placeholder(tf.float32, [None, 224, 224, 1])
model = vgg16.Vgg16(_images,
'../vgg16_weights.npz',
classes=2,
mean=[0.343388929118],
trainable=training)
with tf.name_scope("targets"):
_labels = tf.placeholder(tf.float32,
shape=(None, 2),
name='labels')
with tf.name_scope("outputs"):
output_weights = tf.Variable(initial_value=tf.truncated_normal(
shape=(hidden_layer_size, 2), mean=0.0, stddev=0.01),
dtype=tf.float32,
name="output_weights")
output_bias = tf.Variable(initial_value=tf.zeros(2),
dtype=tf.float32,
name="output_bias")
logits = model.fc3l
predictions = tf.nn.softmax(logits, name='predictions')
tf.summary.histogram("output_weights", output_weights)
tf.summary.histogram("output_bias", output_bias)
tf.summary.histogram("predictions", predictions)
with tf.name_scope("cost"):
cross_entropy = tf.nn.softmax_cross_entropy_with_logits_v2(
logits=logits, labels=_labels, name='cross_entropy')
cost = tf.reduce_mean(cross_entropy, name='cost')
tf.summary.scalar("cost", cost)
with tf.name_scope("train"):
with tf.control_dependencies(
tf.get_collection(tf.GraphKeys.UPDATE_OPS)):
starter_learning_rate = learning_rate
# global_step = tf.Variable(0, trainable=False)
# learning_rate = tf.train.exponential_decay(starter_learning_rate, global_step,
# 100000, 0.96, staircase=True)
optimizer = tf.train.AdamOptimizer(
learning_rate=learning_rate).minimize(cost)
correct_predictions = tf.equal(tf.argmax(predictions, 1),
tf.argmax(_labels, 1),
name='correct_predictions')
accuracy = tf.reduce_mean(tf.cast(correct_predictions,
tf.float32),
name='accuracy')
tf.summary.scalar("accuracy", accuracy)
merged_summaries = tf.summary.merge_all()
sess.run(tf.global_variables_initializer())
iteration = 0
best_loss = 9999999999
batch_num = 0
best_acc = 0
# test_batches = get_batches('TEST', batch_size=batch_size, repeat=True)
log_string = 'logs/{}/{}'.format(model_version, time_str)
saver = tf.train.Saver(tf.global_variables(), max_to_keep=None)
try:
print('[+] loading startup.json')
startup = json.load(open('startup.json', 'r'))
print('[+] loading path:', startup['path'])
state = json.load(open(startup['path'], 'r'))
print('[+] loading checkpoint:', state['checkpoint_path'])
saver.restore(
sess,
tf.train.latest_checkpoint(
os.path.dirname(state['checkpoint_path'])))
# iteration = state['iteration']
# best_acc = state['best_acc']
# best_loss = state['best_loss']
best_acc = state['best_acc']
if 'val_acc' in state:
best_acc = state['val_acc']
best_loss = state['best_loss']
if 'train_loss' in state:
best_loss = state['train_loss']
checkpoint_path = state['checkpoint_path']
# log_string = 'next-' + state['log_string']
except:
print('[!] no models to checkpoint from..')
writer = tf.summary.FileWriter(log_string)
# import numpy as np
# vcol = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES)
# for v in vcol:
# res = sess.run([v])
# np.save(v.name.replace('/', '_').replace(':', '_')+'.npy', res)
seq = iaa.Sequential(
iaa.OneOf([
iaa.GaussianBlur(
(0.45)), # blur images with a sigma between 0 and 3.0
iaa.Add((-90.0, 90.0), per_channel=False),
iaa.Multiply((0.5, 1.5), per_channel=False),
iaa.AdditiveGaussianNoise(loc=0,
scale=(0.07 * 255, 0.07 * 255),
per_channel=False),
iaa.Dropout(p=0.07, per_channel=False),
iaa.CoarseDropout(p=0.05,
size_percent=(0.2, 0.9),
per_channel=False),
iaa.SaltAndPepper(p=0.07, per_channel=False),
iaa.Salt(p=0.07, per_channel=False),
iaa.Pepper(p=0.07, per_channel=False),
iaa.ContrastNormalization(alpha=(1.2, 1.5)),
iaa.ElasticTransformation(alpha=(0.7)),
]), )
cc = cache_file.CacheCollection({
'filename': 'T:\\cache\\AudioToImage',
'seek_policy': 'ONE_SHOT',
'max_size': 2147483648,
'max_split': 50
})
while True:
train = cc.random_iterator(batch_size, test=False)
test = cc.random_iterator(batch_size * 2, test=True)
# train_dataset.shuffle()
# test_dataset.shuffle()
# test_batches = test_dataset.get_batches(batch_size)
# for batch_train_images, batch_train_labels in train_dataset.get_batches(batch_size):
for features, labels in train:
train_loss, _, p, summary = sess.run(
[cost, optimizer, logits, merged_summaries],
feed_dict={
_images: seq.augment_images(features * 255) / 255,
_labels: labels,
_keep_prob: keep_prob,
_is_training: training
})
iteration += 1
print('[+] iteration {}'.format(iteration))
if iteration % accuracy_print_steps == 0:
if not writer == None:
writer.add_summary(summary, iteration)
val_features, val_labels = next(test)
val_acc, val_summary = sess.run(
[accuracy, merged_summaries],
feed_dict={
_images:
seq.augment_images(val_features * 255) / 255,
_labels: val_labels,
_keep_prob: 1.,
_is_training: False
})
print('\tIteration {} Accuracy: {} Loss: {}'.format(
iteration, val_acc, train_loss))
print('\t\t Best Accuracy: {} Best Loss: {}'.format(
iteration, best_acc, best_loss))
if val_acc >= best_acc or train_loss <= best_loss:
if train_loss <= best_loss:
best_loss = train_loss
if val_acc >= best_acc:
best_acc = val_acc
timestamp = datetime.datetime.now().strftime(
"%Y-%m-%d_%H%M%S")
checkpoint_path = os.path.join(
'save', timestamp, 'model.ckpt')
print('\t\tSaving model to:' + checkpoint_path)
saver.save(sess,
checkpoint_path,
global_step=batch_num)
state = {
'iteration': iteration,
'best_acc': float(best_acc),
'best_loss': float(best_loss),
'val_acc': float(val_acc),
'train_loss': float(train_loss),
'checkpoint_path': checkpoint_path,
'log_string': log_string,
}
state_path = os.path.join('save', timestamp,
'state.json')
open(state_path, 'w').write(json.dumps(state))
startup = {
'path': state_path,
}
open('startup.json',
'w').write(json.dumps(startup))
batch_num += 1
if saved_model_path:
### Save graph and trained variables
builder = saved_model_builder.SavedModelBuilder(
saved_model_path)
builder.add_meta_graph_and_variables(
sess, [SERVING],
signature_def_map={
DEFAULT_SERVING_SIGNATURE_DEF_KEY:
predict_signature_def(
inputs={PREDICT_INPUTS: _images},
outputs={PREDICT_OUTPUTS: predictions})
})
builder.save()
# 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
import numpy as np
from document_read_files import load_documents_files
from imgaug import augmenters as iaa
_rotation_plus = iaa.Affine(rotate=3)
_rotation_minus = iaa.Affine(rotate=-3)
_translate_plus = iaa.Affine(translate_percent={"x": 0, "y": 0.2})
_translate_minus = iaa.Affine(translate_percent={"x": 0, "y": -0.2})
_scale_up = iaa.Affine(scale=1.02, order=[0, 1])
_scale_down = iaa.Affine(scale=0.8, order=[0, 1])
_brightness = iaa.Multiply(0.6)
_dropout = iaa.Dropout(p=0.09, per_channel=True)
_gaussian_noise = iaa.AdditiveGaussianNoise(scale=30, per_channel=True)
_gaussian_blur = iaa.GaussianBlur(sigma=(1.5, 1.6))
_pepper = iaa.Pepper(0.05)
_hue_and_saturation = iaa.AddToHueAndSaturation((-25, 15))
_contrast = iaa.ContrastNormalization((0.4, 0.7))
def _apply_perspective(img):
rows, cols, ch = img.shape
param = 0.10 * rows
pts1 = np.float32([[0, 0], [cols, 0], [cols, rows], [0, rows]])
pts2 = np.float32([[param, param], [cols - param, param], [cols, rows - param], [0, rows - param]])
M = cv2.getPerspectiveTransform(pts1, pts2)
dst = cv2.warpPerspective(img, M, (cols, rows))
return dst
if not os.path.isdir(output_dir):
os.makedirs(output_dir)
filename = output_dir + '/' + str(ucode) + '_' + str(
index) + '.jpg'
select = random.randint(0, 20)
# print('select: ', select)
# 加入白色的椒盐噪声
if select >= 1 and select < 3:
add_salt_pepper(region)
# print('white salt peper: ', filename)
# 加入黑色的椒盐噪声
if select > 7 and select < 10:
# add_salt_pepper(region, (0, 0, 0))
numpy_region = np.asarray(region)
noise = iaa.Pepper(0.3)
numpy_region = noise.augment_image(numpy_region)
region = Image.fromarray(numpy_region)
# print('black salt pepper: ', filename)
# 是否添加高斯噪声或扫描件噪声
if select >= 3 and select <= 6:
# 添加高斯背景噪声
background_gauss = np.ones(
(region.size[1], region.size[0])) * 255
cv2.randn(background_gauss, 235, 10)
background_gauss = Image.fromarray(background_gauss).convert(
'L')
region = region.convert('L')
mask = region.point(lambda x: 0
if x == 255 or x == 0 else 255, '1')
# mx, my = mask.size
def __init__(
self,
inputdata,
inputlabels,
augs="basic", #["all","basic","form","valalt","pxlalt","imgalt"]
num_outs=5,
og_out=True,
mode='G',
em=0,
intensity=1.0,
rescaledata=None,
formatd='NCHW',
min_augs=0,
max_augs=5):
if self.mode.lower() == 'g':
self.NM = self.rung
elif self.mode.lower() == 'i':
self.NM = self.runi()
elif self.mode.lower() == 'i2':
self.NM = self.runi2()
else:
print(
"invalid mode, use 'g' for generator or 'i' for iterator or 'i2'"
)
exit()
self.minaug = min_augs
self.maxaug = max_augs
#self.affineopt=["scale","translate_percent","translate_px","rotate","shear"]
#self.chnlopt=[{"per_channel":True},{"per_channel":False}]
if len(inputdata.shape) == 4:
self.D = 4
elif len(inputdata.shape) == 3:
self.D = 3
elif len(inputdata.shape) == 2:
self.D = 2
if formatd == "NCHW":
if self.D == 4:
self.inputd = np.transpose(inputdata, [0, 2, 3, 1])
elif self.D == 3:
self.inputd = np.transpose(inputdata, [1, 2, 0])
else:
self.inputd = inputdata
self.Y = inputlabels
leninten = 8
if isinstance(intensity, (float, int)):
itensity = [intensity for _ in range(leninten)]
else:
assert len(intensity) == leninten
self.datashape = np.array(inputdata.shape) #inputdata[0].shape
if self.datashape.min() == self.datashape[-1]:
self.pixls = self.datashape[:-1]
elif self.datashape.min() == self.datashape[1]:
self.pixls = np.delete(self.datashape, 1)
elif self.datashape.shape == (3, ):
self.pixls = self.datashape[1:]
else:
print("error cannot fin the shape of images")
exit()
# can use "keep-aspect-ratio" for an arg to have a relative and absolute scale
#or can also use list for randomization between options
self.scalevals = (0.5 / (2 * intensity), 1.0) #use % of image
self.augs = augs
self.Pchances = 0.44 * itensity[0]
self.intrange = ((ceil(10 * intensity[1]),
ceil(10 + 140 * itensity[1])))
self.windowrange = (ceil(2 * intensity[2]),
ceil((min(self.pixls) / 5) - 8) * intensity[2]
) #mean/median things
self.relatrange = (0.1 * intensity[3], 0.95 * intensity[3]
) #normalisation,invert
self.bigfloat = (
0.085 * intensity[4], 1.75 * intensity[4]
) #some scale values,multiply,contrastnorm,elasti trans,(sigman&alpha)
self.smallfloat = (0.001 * intensity[5], 0.45 * intensity[5]
) #coarse dropout/droput(p)
self.addrange = (ceil(-140 * intensity[6]),
ceil(140 * intensity[6]))
self.multrange = (-2.0 * intensity[7], 2.0 * intensity[7])
self.perchannelsplit = 0.75 * intensity[
8] #used for per_channel on the mult
self.allaugs = {
"add":
IAGA.Add(value=self.addrange, per_channel=0.75 * intensity),
"scale":
IAGA.Scale(size=self.scalevals),
"adde":
IAGA.AddElementwise(value=self.addrange,
per_channel=0.75 * intensity),
"addg":
IAGA.AdditiveGaussianNoise(scale=(0, self.smallfloat[1] * 255),
per_channel=0.75 * intensity),
"addh":
IAGA.AddToHueAndSaturation(value=self.addrange,
per_channel=0.75 * intensity),
"mult":
IAGA.Multiply(mul=self.bigfloat, per_channel=0.75 * intensity),
"mule":
IAGA.MultiplyElementwise(mul=self.bigfloat,
per_channel=0.75 * intensity),
"drop":
IAGA.Dropout(p=self.smallfloat, per_channel=0.75 * intensity),
"cdrop":
IAGA.CoarseDropout(p=self.smallfloat,
size_px=None,
size_percent=self.smallfloat,
per_channel=True,
min_size=3),
"inv":
IAGA.Invert(p=self.Pchances,
per_channel=0.75 * intensity,
min_value=-255,
max_value=255),
"cont":
IAGA.ContrastNormalization(alpha=self.bigfloat,
per_channel=0.75 * intensity),
"aff":
IAGA.Affine(
scale=self.bigfloat,
translate_percent={
'x': (-40 * intensity, 40 * intensity),
'y': (-40 * intensity, 40 * intensity)
},
translate_px=None, #moving functions
rotate=(-360 * intensity, 360 * intensity),
shear=(-360 * intensity, 360 * intensity),
order=[0, 1] #2,3,4,5 may be too much
,
cval=0, #for filling
mode=["constant", "edge", "reflect", "symmetric",
"wrap"][em], #filling method
deterministic=False,
random_state=None),
"paff":
IAGA.PiecewiseAffine(
scale=(-0.075 * intensity, 0.075 * intensity),
nb_rows=(ceil(2 * intensity), ceil(7 * intensity)),
nb_cols=(ceil(2 * intensity), ceil(7 * intensity)),
order=[0, 1],
cval=0,
mode=["constant", "edge", "reflect", "symmetric",
"wrap"][em],
deterministic=False,
random_state=None),
"elas":
IAGA.ElasticTransformation(alpha=self.bigfloat,
sigma=self.relatrange),
"noop":
IAGA.Noop(name="nope"),
#IAGA.Lambda:{},
"cropad":
IAGA.CropAndPad(
px=None,
percent=(-0.65 * intensity[7], 0.65 * intensity[7]),
pad_mode=[
"constant", "edge", "reflect", "symmetric", "wrap"
][em],
pad_cval=0,
keep_size=True,
sample_independently=True,
),
"fliplr":
IAGA.Fliplr(p=self.Pchances),
"flipud":
IAGA.Flipud(p=self.Pchances),
"spixel":
IAGA.Superpixels(p_replace=self.Pchances,
n_segments=self.intrange),
#IAGA.ChangeColorspace:,
"gray":
IAGA.Grayscale(alpha=self.relatrange),
"gblur":
IAGA.GaussianBlur(sigma=self.bigfloat),
"ablur":
IAGA.AverageBlur(k=self.windowrange),
"mblur":
IAGA.MedianBlur(k=self.windowrange),
#IAGA.BilateralBlur,
#IAGA.Convolve:,
"sharp":
IAGA.Sharpen(alpha=self.relatrange, lightness=self.bigfloat),
"embo":
IAGA.Emboss(alpha=self.relatrange, strenght=self.bigfloat),
"edge":
IAGA.EdgeDetect(alpha=self.relatrange),
"dedge":
IAGA.DirectedEdgeDetect(alpha=self.bigfloat,
direction=(-1.0 * intensity,
1.0 * intensity)),
"pert":
IAGA.PerspectiveTransform(scale=self.smallfloat),
"salt":
IAGA.Salt(p=self.Pchances, per_channel=0.75 * intensity),
#IAGA.CoarseSalt(p=, size_px=None, size_percent=None,per_channel=False, min_size=4),
#IAGA.CoarsePepper(p=, size_px=None, size_percent=None,"per_channel=False, min_size=4),
#IAGA.CoarseSaltAndPepper(p=, size_px=None, size_percent=None,per_channel=False, min_size=4),
"pep":
IAGA.Pepper(p=self.Pchances, per_channel=0.75 * intensity),
"salpep":
IAGA.SaltAndPepper(p=self.Pchances,
per_channel=0.75 * intensity),
#"alph":IAGA.Alpha(factor=,first=,second=,per_channel=0.75*intensity,),
#"aplhe":IAGA.AlphaElementwise(factor=,first=,second=,per_channel=0.75*intensity,),
#IAGA.FrequencyNoiseAlpha(exponent=(-4, 4),first=None, second=None, per_channel=False,size_px_max=(4, 16), upscale_method=None,iterations=(1, 3), aggregation_method=["avg", "max"],sigmoid=0.5, sigmoid_thresh=None,),
#IAGA.SimplexNoiseAlpha(first=None, second=None, per_channel=False,size_px_max=(2, 16), upscale_method=None,iterations=(1, 3), aggregation_method="max",sigmoid=True, sigmoid_thresh=None,),
}
["all", "basic", "form", "valalt", "pxlalt", "imgalt"]
self.augs = []
if (augs == "all") or ("all" in augs):
self.augs = [
"add",
"scale",
"adde",
"addg",
"addh",
"mult",
"mule",
"drop",
"cdrop",
"inv",
"cont",
"aff",
"paff",
"elas",
"noop",
"cropad",
"fliplr",
"flipud",
"spixel",
"gray",
"gblur",
"ablur",
"mblur",
"sharp",
"embo",
"edge",
"dedge",
"pert",
"salt",
"pep",
"salpep",
] #"alph", "aplhe",]
else:
if (augs == "basic") or ("basic" in augs):
self.augs.append([
"add", "scale", "addh", "mult", "drop", "cont", "noop"
])
if (augs == "form") or ("form" in augs):
self.augs + [
"scale", "aff", "paff", "elas", "noop", "pert"
]
if (augs == "valalt") or ("valalt" in augs):
self.augs + [
"mult", "mule", "inv", "fliplr", "flipud", "cropad",
"noop"
]
if (augs == "pxlalt") or ("pxlalt" in augs):
self.augs + [
"addg", "drop", "salt", "pep", "salpep", "noop"
]
if (augs == "imgalt") or ("imgalt" in augs):
self.augs + [
"elas",
"noop",
"spixel",
"gblur",
"ablur",
"mblur",
"sharp",
"embo",
"edge",
"dedge",
]
if len(augs) == 0:
self.augs + [
"add",
"scale",
"addh",
"drop",
"cont",
"aff",
"elas",
"noop",
"cropad",
"gray",
"ablur",
"sharp",
"salpep",
]
self.AUG = IAGA.SomeOf((self.minaug, self.maxaug),
self.augs,
random_order=True)
"""self.affineopts={"scale":self.biglfoat,
"translate_percent":{'x':(-40*intensity,40*intensity),'y':(-40*intensity,40*intensity)}, "translate_px":None,#moving functions
"rotate":(-360*intensity,360*intensity), "shear":(0*intensity,360*intensity),
"order":[0,1]#2,3,4,5 may be too much
, "cval":0,#for filling
"mode":"constant",#filling method
"deterministic":False,
"random_state":None}
self.pieceaffinev={"scale"=(-0.075*intensity,0.075*intensity), "nb_rows"=(ceil(2*intensity),ceil(7*intensity)), "nb_cols"=(ceil(2*intensity),ceil(7*intensity)),
"order"=[0,1], "cval"=0, "mode"="constant",
"deterministic"=False, "random_state"=None}"""
self.num_outs = num_outs - og_out
self.og_out = og_out
self.mode = mode
self.iimg = -1
self.iout = 0
try:
self.len = inputdata.shape[0]
except:
self.len = len(inputdata)
def __iter__(self):
return self
def __next__(self):
return (self.NM())
def next(self):
return (self.NM())
def runi(self):
if self.iimg == self.len:
raise StopIteration
self.iimg += 1
img = self.inputd[self.iimg]
y = self.Y[self.iimg]
out = np.broadcast_to(img, (self.num_out, *img.shape[-3:]))
out = self.AUG.augment_images(out[self.og_out:])
if self.og_out:
if len(img.shape) == 3:
out = np.concatenate(out, np.expand_dims(img, 0))
else:
out = np.concatenate(out, img)
if self.format == "NCHW":
out = np.transpose(out, [0, 3, 1, 2])
return ([(outi, y) for outi in out])
def runi2(self):
if self.iimg == self.len:
raise StopIteration
if (self.iout == self.num_outs) or (self.iimg == -1):
self.iimg += 1
self.iout = 0
img = self.inputd[self.iimg]
y = self.Y[self.iimg]
out = np.broadcast_to(img, (self.num_out, *img.shape[-3:]))
self.out = self.AUG.augment_images(out[self.og_out:])
if self.og_out:
if len(img.shape) == 3:
self.out = np.concatenate(out,
np.expand_dims(img, 0))
else:
self.out = np.concatenate(out, img)
if self.format == "NCHW":
self.out = np.transpose(out, [0, 3, 1, 2])
outp = (self.out[self.iout], y)
else:
self.iout += 1
outp = (self.out[self.iout], self.Y[self.iimg])
return (outp)
def rung(self):
for ix, img in enumerate(self.inputd):
out = np.broadcast_to(img, (self.num_out, img.shape[-3:]))
out = self.AUG.augment_images(out[self.og_out:])
y = self.Y[ix]
if self.og_out:
if len(img.shape) == 3:
out = np.concatenate(out, np.expand_dims(img, 0))
else:
out = np.concatenate(out, img)
if self.format == "NCHW":
out = (np.transpose(out, [0, 3, 1, 2]))
for sout in out:
yield (sout, y)
def next(self):
if not self.is_init:
self.reset()
self.is_init = True
"""Returns the next batch of data."""
#print('in next', self.cur, self.labelcur)
self.nbatch += 1
batch_size = self.batch_size
c, h, w = self.data_shape
batch_data = nd.empty((batch_size, c, h, w))
if self.provide_label is not None:
batch_label = nd.empty(self.provide_label[0][1])
i = 0
try:
while i < batch_size:
label, s, bbox, landmark = self.next_sample()
_data = self.imdecode(s)
if _data.shape[0] != self.data_shape[1]:
_data = mx.image.resize_short(_data, self.data_shape[1])
if self.rand_mirror:
_rd = random.randint(0, 1)
if _rd == 1:
_data = mx.ndarray.flip(data=_data, axis=1)
if self.blur:
aug_blur = iaa.Sequential([
iaa.OneOf([
iaa.GaussianBlur(sigma=(0.5, 2.5)),
iaa.AverageBlur(k=(2, 5)),
iaa.MotionBlur(k=(5, 7)),
iaa.BilateralBlur(d=(3, 4),
sigma_color=(10, 250),
sigma_space=(10, 250)),
iaa.imgcorruptlike.DefocusBlur(severity=1),
iaa.imgcorruptlike.GlassBlur(severity=1),
iaa.imgcorruptlike.Pixelate(severity=(1, 3)),
iaa.Pepper(0.01),
iaa.AdditiveGaussianNoise(scale=(0, 0.1 * 255),
per_channel=True),
iaa.imgcorruptlike.SpeckleNoise(severity=1),
iaa.imgcorruptlike.JpegCompression(severity=(1,
4)),
])
])
_rd = random.randint(0, 1)
if _rd == 1:
_data = aug_blur(images=_data)
if self.maxpooling:
maxpool_aug = iaa.MaxPooling(2)
_rd = random.randint(0, 1)
if _rd == 1:
_data = maxpool_aug(images=_data)
if self.color_jittering > 0:
if self.color_jittering > 1:
_rd = random.randint(0, 1)
if _rd == 1:
_data = self.compress_aug(_data)
#print('do color aug')
_data = _data.astype('float32', copy=False)
#print(_data.__class__)
_data = self.color_aug(_data, 0.125)
if self.nd_mean is not None:
_data = _data.astype('float32', copy=False)
_data -= self.nd_mean
_data *= 0.0078125
if self.cutoff > 0:
_rd = random.randint(0, 1)
if _rd == 1:
#print('do cutoff aug', self.cutoff)
centerh = random.randint(0, _data.shape[0] - 1)
centerw = random.randint(0, _data.shape[1] - 1)
half = self.cutoff // 2
starth = max(0, centerh - half)
endh = min(_data.shape[0], centerh + half)
startw = max(0, centerw - half)
endw = min(_data.shape[1], centerw + half)
#print(starth, endh, startw, endw, _data.shape)
_data[starth:endh, startw:endw, :] = 128
data = [_data]
try:
self.check_valid_image(data)
except RuntimeError as e:
logging.debug('Invalid image, skipping: %s', str(e))
continue
#print('aa',data[0].shape)
#data = self.augmentation_transform(data)
#print('bb',data[0].shape)
for datum in data:
assert i < batch_size, 'Batch size must be multiples of augmenter output length'
#print(datum.shape)
batch_data[i][:] = self.postprocess_data(datum)
batch_label[i][:] = label
i += 1
except StopIteration:
if i < batch_size:
raise StopIteration
return io.DataBatch([batch_data], [batch_label], batch_size - i)
def do_random(image, pos_list):
# 1.先任选5种影响位置的效果之一做位置变换
seq = iaa.Sequential([
iaa.Sometimes(
0.5,
[
iaa.Crop((0, 10)), # 切边, (0到10个像素采样)
]),
iaa.Sometimes(
0.5,
[
iaa.Affine(shear={
'x': (-10, 10),
'y': (-10, 10)
}, mode="edge"),
iaa.Rotate(rotate=(-10, 10), mode="edge"), # 旋转
]),
iaa.Sometimes(
0.5,
[
iaa.PiecewiseAffine(), # 局部仿射
iaa.ElasticTransformation( # distort扭曲变形
alpha=(0.0, 20.0),
sigma=(3.0, 5.0),
mode="nearest"),
]),
# 18种位置不变的效果
iaa.SomeOf(
(1, 3),
[
iaa.GaussianBlur(),
iaa.AverageBlur(),
iaa.MedianBlur(),
iaa.Sharpen(),
iaa.BilateralBlur(), # 既噪音又模糊，叫双边,
iaa.MotionBlur(),
iaa.MeanShiftBlur(),
iaa.GammaContrast(),
iaa.SigmoidContrast(),
iaa.Fog(),
iaa.Clouds(),
iaa.Snowflakes(flake_size=(0.1, 0.2), density=(0.005, 0.025)),
iaa.Rain(nb_iterations=1,
drop_size=(0.05, 0.1),
speed=(0.04, 0.08)),
iaa.AdditiveGaussianNoise(scale=(0, 10)),
iaa.AdditiveLaplaceNoise(scale=(0, 10)),
iaa.AdditivePoissonNoise(lam=(0, 10)),
iaa.Salt((0, 0.02)),
iaa.Pepper((0, 0.02))
])
])
polys = [ia.Polygon(pos) for pos in pos_list]
polygons = ia.PolygonsOnImage(polys, shape=image.shape)
images_aug, polygons_aug = seq(images=[image], polygons=polygons)
image = images_aug[0]
image = polygons_aug.draw_on_image(image, size=2)
new_polys = []
for p in polygons_aug.polygons:
new_polys.append(p.coords)
polys = np.array(new_polys, np.int32).tolist()
return image, polys
