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()
dataset_val_test = DetectorDataset(image_fps_val_test, image_annotations,
ORIG_SIZE, ORIG_SIZE)
dataset_val_test.prepare()
# Image augmentation (light but constant)
augmentation = iaa.Sequential([
iaa.Fliplr(0.1),
iaa.OneOf([ ## geometric transform
iaa.Affine(
scale={
"x": (0.98, 1.02),
"y": (0.98, 1.04)
},
translate_percent={
"x": (-0.02, 0.02),
"y": (-0.04, 0.04)
},
rotate=(-2, 2),
shear=(-1, 1),
),
iaa.PiecewiseAffine(scale=(0.01, 0.025)),
]),
def augmentation_seq():
"""
Note imgaug expects RGB not BGR
:return:
"""
# TODO this is a reference of transforms that were helpful in keras so use them in imgaug
# rescale=None,
# shear_range=0.2,
# rotation_range=0.2,
# width_shift_range=0.3,
# height_shift_range=0.3,
# zoom_range=[.85, 1.2],
# fill_mode='nearest',
# horizontal_flip=False,
# vertical_flip=False,
seq_simple = iaa.Sequential([
iaa.Affine(rotate=(-45, 45))
# iaa.Crop(px=(1, 16), keep_size=False),
# iaa.Fliplr(0.5),
# iaa.GaussianBlur(sigma=(0, 3.0))
])
_sometimes = lambda aug: iaa.Sometimes(0.85, aug)
seq_complex = 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
# _sometimes(iaa.CropAndPad(
# percent=(-0.05, 0.1),
# pad_mode=ia.ALL,
# pad_cval=(0, 255)
# )),
_sometimes(iaa.Resize((0.5, 3))),
# 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(
(3, 5),
[
# _sometimes(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(
(-5, 5)), # 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=(-1, 0),
# first=iaa.Multiply((0.85, 1.15), per_channel=True),
# second=iaa.LinearContrast((0.8, 1.2))
# )
# ]),
# iaa.LinearContrast((0.75, 1.25), per_channel=0.2), # improve or worsen the contrast
# iaa.Grayscale(alpha=(0.0, 1.0)),
# _sometimes(iaa.ElasticTransformation(alpha=(0.5, 3.5), sigma=0.25)),
# # move pixels locally around (with random strengths)
# _sometimes(iaa.PiecewiseAffine(scale=(0.01, 0.05))),
# # sometimes move parts of the image around
# _sometimes(iaa.PerspectiveTransform(scale=(0.01, 0.1)))
],
random_order=True),
_sometimes(
iaa.Affine(
# scale={"x": (0.5, 2.5), "y": (0.5, 2.5)},
# 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)
# shear=(-16, 16), # shear by -16 to +16 degrees
# order=[0, 1], # use nearest neighbour or bilinear interpolation (fast)
# TODO add this back cval=(0, 100), # if mode is constant, use a cval between 0 and 255
rotate=(-45, 45), # rotate by -45 to +45 degrees
# mode=ia.ALL # use any of scikit-image's warping modes (see 2nd image from the top for examples)
), ),
],
random_order=False)
return seq_complex
from imgaug import augmenters as iaa
augmenter = iaa.Sequential(
[
iaa.Fliplr(0.5),
iaa.Crop(px=(
0,
12)), # crop images from each side by 0 to 12px (randomly chosen)
],
random_order=True,
)
def data_gen(data, batch_size):
# Get total number of samples in the data
n = len(data)
steps = n//batch_size
# Define two numpy arrays for containing batch data and labels
batch_data = np.zeros((batch_size, 224, 224, 3), dtype=np.float32)
batch_labels = np.zeros((batch_size,2), dtype=np.float32)
# Get a numpy array of all the indices of the input data
indices = np.arange(n)
# Initialize a counter
i =0
while True:
np.random.shuffle(indices)
# Get the next batch
count = 0
next_batch = indices[(i*batch_size):(i+1)*batch_size]
for j, idx in enumerate(next_batch):
img_name = data.iloc[idx]['images']
label = data.iloc[idx]['labels']
# one hot encoding
encoded_label = to_categorical(label, num_classes=2)
# read the image and resize
img = cv2.imread(str(img_name))
img = cv2.resize(img, (224,224))
# check if it's grayscale
if img.shape[2]==1:
img = np.dstack([img, img, img])
# cv2 reads in BGR mode by default
orig_img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
# normalize the image pixels
orig_img = img.astype(np.float32)/255.
#segmentation
oig_img=slic(orig_img)
batch_data[count] = orig_img
batch_labels[count] = encoded_label
#augmentation
seq = iaa.OneOf([
iaa.Fliplr(), # horizontal flips
iaa.Affine(rotate=20), # roatation
iaa.Multiply((1.2, 1.5))]) #random brightness
# generating more samples of the undersampled class
if label==0 and count < batch_size-2:
aug_img1 = seq.augment_image(img)
aug_img2 = seq.augment_image(img)
aug_img1 = cv2.cvtColor(aug_img1, cv2.COLOR_BGR2RGB)
aug_img2 = cv2.cvtColor(aug_img2, cv2.COLOR_BGR2RGB)
aug_img1 = aug_img1.astype(np.float32)/255.
aug_img2 = aug_img2.astype(np.float32)/255.
batch_data[count+1] = aug_img1
batch_labels[count+1] = encoded_label
batch_data[count+2] = aug_img2
batch_labels[count+2] = encoded_label
count +=2
else:
count+=1
if count==batch_size-1:
break
i+=1
yield batch_data, batch_labels
if i>=steps:
i=0
from imgaug import augmenters as iaa
import numpy as np
import cv2
images = cv2.imread('00000323_4.PNG')
images = cv2.cvtColor(images, cv2.COLOR_BGR2RGB)
#images = np.random.randint(0, 255, (16, 128, 128, 3), dtype=np.uint8)
seq = iaa.Sequential([iaa.Fliplr(0.5),
iaa.GaussianBlur((0, 3.0))])
img_aug = seq.augment_images(images)
cv2.imshow('before', images)
cv2.imshow('aaa', img_aug)
cv2.waitKey(0)
cv2.destroyAllWindows()
dicom = pydicom.dcmread(train_img_path + train_df.index[101] + ".dcm")
fig, ax = plt.subplots(1, 2)
ax[0].imshow(window_testing(dicom, window_without_correction), cmap=plt.cm.bone);
ax[0].set_title("original")
ax[1].imshow(window_testing(dicom, window_with_correction), cmap=plt.cm.bone);
ax[1].set_title("corrected");
# ### Random image augmentation
# Image Augmentation
sometimes = lambda aug: iaa.Sometimes(0.25, aug)
augmentation = iaa.Sequential([ iaa.Fliplr(0.25),
iaa.Flipud(0.10),
iaa.AdditiveGaussianNoise(loc=0, scale=(0.0, 0.05*255), per_channel=0.5),
iaa.Sometimes(0.5,iaa.GaussianBlur(sigma=(0, 0.5))),# Strengthen or weaken the contrast in each image.
iaa.ContrastNormalization((0.75, 1.5)),
sometimes(iaa.Crop(px=(0, 25), keep_size = True, sample_independently = False))
], random_order = True)
# Generators
class DataGenerator_Train(keras.utils.Sequence):
def __init__(self, dataset, labels, batch_size = batch_size, image_shape = input_image_shape, image_path = train_img_path, augment = False, *args, **kwargs):
self.dataset = dataset
self.ids = dataset.index
self.labels = labels
def sometimes(aug):
return iaa.Sometimes(0.7, aug)
def sometimes_p9(aug):
return iaa.Sometimes(0.9, aug)
def sometimes_p5(aug):
return iaa.Sometimes(0.5, aug)
simple_seq = iaa.Sequential(
[
iaa.Fliplr(0.5), # horizontally flip 50% of all images
iaa.Flipud(0.5), # vertically flip 20% of all images
sometimes_p5(iaa.Rot90(k=ia.ALL)),
# sometimes_p5(iaa.Cutout(nb_iterations=2, size=0.05, cval=0)),
],
random_order=True)
seq = iaa.Sequential(
[
iaa.Fliplr(0.5), # horizontally flip 50% of all images
iaa.Flipud(0.5), # vertically flip 20% of all images
sometimes_p5(iaa.Cutout(nb_iterations=5, size=0.05, cval=0)),
sometimes_p5([
iaa.CropToFixedSize(width=1024 - 50, height=1024 - 50),
# iaa.CropToFixedSize(width=900, height=900),
iaa.Resize((1024, 1024)),
def tf_softmax(x):
return tf.nn.softmax(x)
def unpickle(file):
import pickle
with open(file, 'rb') as fo:
dict = pickle.load(fo, encoding='bytes')
return dict
# data aug
seq = iaa.Sequential(
[
iaa.Fliplr(1.0), # horizontal flips
iaa.Affine(scale={
"x": (0.9, 1.2),
"y": (0.9, 1.2)
},
translate_percent={
"x": (-0.1, 0.1),
"y": (-0.1, 0.1)
},
rotate=(-25, 25),
shear=(-4, 4)),
],
random_order=True) # apply augmenters in random order
# code from: https://github.com/tensorflow/tensorflow/issues/8246
iaa.Sometimes(0.1,
iaa.Affine(
translate_percent={"x": (-0.2, 0.2), "y": (-0.2, 0.2)},
)
),
iaa.Sometimes(0.1,
iaa.Affine(
rotate=(-25, 25),
)
),
iaa.Sometimes(0.1,
iaa.Affine(
scale={"x": (0.8, 1.2), "y": (0.8, 1.2)},
)
),
iaa.Fliplr(1.0), # Horizonatl flips
], random_order=True) # apply augmenters in random order
# class
class CNN():
def __init__(self,k,inc,out):
self.w = tf.Variable(tf.random_normal([k,k,inc,out],stddev=0.05))
self.m,self.v_prev = tf.Variable(tf.zeros_like(self.w)),tf.Variable(tf.zeros_like(self.w))
self.v_hat_prev = tf.Variable(tf.zeros_like(self.w))
def getw(self): return self.w
def feedforward(self,input,stride=1,padding='SAME'):
self.input = input
self.layer = tf.nn.conv2d(input,self.w,strides=[1,stride,stride,1],padding=padding)
self.layerA = tf_elu(self.layer)
def test_dtype_preservation():
reseed()
size = (4, 16, 16, 3)
images = [
np.random.uniform(0, 255, size).astype(np.uint8),
np.random.uniform(0, 65535, size).astype(np.uint16),
np.random.uniform(0, 4294967295, size).astype(np.uint32),
np.random.uniform(-128, 127, size).astype(np.int16),
np.random.uniform(-32768, 32767, size).astype(np.int32),
np.random.uniform(0.0, 1.0, size).astype(np.float32),
np.random.uniform(-1000.0, 1000.0, size).astype(np.float16),
np.random.uniform(-1000.0, 1000.0, size).astype(np.float32),
np.random.uniform(-1000.0, 1000.0, size).astype(np.float64)
]
default_dtypes = set([arr.dtype for arr in images])
# Some dtypes are here removed per augmenter, because the respective
# augmenter does not support them. This test currently only checks whether
# dtypes are preserved from in- to output for all dtypes that are supported
# per augmenter.
# dtypes are here removed via list comprehension instead of
# `default_dtypes - set([dtype])`, because the latter one simply never
# removed the dtype(s) for some reason?!
def _not_dts(dts):
return [dt for dt in default_dtypes if dt not in dts]
augs = [
(iaa.Add((-5, 5),
name="Add"), _not_dts([np.uint32, np.int32, np.float64])),
(iaa.AddElementwise((-5, 5), name="AddElementwise"),
_not_dts([np.uint32, np.int32, np.float64])),
(iaa.AdditiveGaussianNoise(0.01 * 255, name="AdditiveGaussianNoise"),
_not_dts([np.uint32, np.int32, np.float64])),
(iaa.Multiply((0.95, 1.05), name="Multiply"),
_not_dts([np.uint32, np.int32, np.float64])),
(iaa.Dropout(0.01, name="Dropout"),
_not_dts([np.uint32, np.int32, np.float64])),
(iaa.CoarseDropout(0.01, size_px=6, name="CoarseDropout"),
_not_dts([np.uint32, np.int32, np.float64])),
(iaa.Invert(0.01, per_channel=True, name="Invert"), default_dtypes),
(iaa.ContrastNormalization(
(0.95, 1.05), name="ContrastNormalization"), default_dtypes),
(iaa.GaussianBlur(sigma=(0.95, 1.05),
name="GaussianBlur"), _not_dts([np.float16])),
(iaa.AverageBlur((3, 5), name="AverageBlur"),
_not_dts([np.uint32, np.int32, np.float16])),
(iaa.MedianBlur((3, 5), name="MedianBlur"),
_not_dts([np.uint32, np.int32, np.float16, np.float64])),
(iaa.BilateralBlur((3, 5), name="BilateralBlur"),
_not_dts([
np.uint16, np.uint32, np.int16, np.int32, np.float16, np.float64
])),
# WithColorspace ?
# iaa.AddToHueAndSaturation((-5, 5), name="AddToHueAndSaturation"), # works only with RGB/uint8
# ChangeColorspace ?
# iaa.Grayscale((0.0, 0.1), name="Grayscale"), # works only with RGB/uint8
# Convolve ?
(iaa.Sharpen((0.0, 0.1), lightness=(1.0, 1.2), name="Sharpen"),
_not_dts([np.uint32, np.int32, np.float16, np.uint32])),
(iaa.Emboss(alpha=(0.0, 0.1), strength=(0.5, 1.5), name="Emboss"),
_not_dts([np.uint32, np.int32, np.float16, np.uint32])),
(iaa.EdgeDetect(alpha=(0.0, 0.1), name="EdgeDetect"),
_not_dts([np.uint32, np.int32, np.float16, np.uint32])),
(iaa.DirectedEdgeDetect(alpha=(0.0, 0.1),
direction=0,
name="DirectedEdgeDetect"),
_not_dts([np.uint32, np.int32, np.float16, np.uint32])),
(iaa.Fliplr(0.5, name="Fliplr"), default_dtypes),
(iaa.Flipud(0.5, name="Flipud"), default_dtypes),
(iaa.Affine(translate_px=(-5, 5), name="Affine-translate-px"),
_not_dts([np.uint32, np.int32])),
(iaa.Affine(translate_percent=(-0.05, 0.05),
name="Affine-translate-percent"),
_not_dts([np.uint32, np.int32])),
(iaa.Affine(rotate=(-20, 20),
name="Affine-rotate"), _not_dts([np.uint32, np.int32])),
(iaa.Affine(shear=(-20, 20),
name="Affine-shear"), _not_dts([np.uint32, np.int32])),
(iaa.Affine(scale=(0.9, 1.1),
name="Affine-scale"), _not_dts([np.uint32, np.int32])),
(iaa.PiecewiseAffine(scale=(0.001, 0.005),
name="PiecewiseAffine"), default_dtypes),
# (iaa.PerspectiveTransform(scale=(0.01, 0.10), name="PerspectiveTransform"), not_dts([np.uint32])),
(iaa.ElasticTransformation(alpha=(0.1, 0.2),
sigma=(0.1, 0.2),
name="ElasticTransformation"),
_not_dts([np.float16])),
(iaa.Sequential([iaa.Noop(), iaa.Noop()],
name="SequentialNoop"), default_dtypes),
(iaa.SomeOf(1, [iaa.Noop(), iaa.Noop()],
name="SomeOfNoop"), default_dtypes),
(iaa.OneOf([iaa.Noop(), iaa.Noop()],
name="OneOfNoop"), default_dtypes),
(iaa.Sometimes(0.5, iaa.Noop(), name="SometimesNoop"), default_dtypes),
(iaa.Sequential([iaa.Add(
(-5, 5)), iaa.AddElementwise((-5, 5))],
name="Sequential"),
_not_dts([np.uint32, np.int32, np.float64])),
(iaa.SomeOf(1, [iaa.Add(
(-5, 5)), iaa.AddElementwise((-5, 5))],
name="SomeOf"), _not_dts([np.uint32, np.int32,
np.float64])),
(iaa.OneOf([iaa.Add(
(-5, 5)), iaa.AddElementwise((-5, 5))],
name="OneOf"), _not_dts([np.uint32, np.int32, np.float64])),
(iaa.Sometimes(0.5, iaa.Add((-5, 5)), name="Sometimes"),
_not_dts([np.uint32, np.int32, np.float64])),
# WithChannels
(iaa.Noop(name="Noop"), default_dtypes),
# Lambda
# AssertLambda
# AssertShape
(iaa.Alpha((0.0, 0.1), iaa.Noop(), name="AlphaNoop"), default_dtypes),
(iaa.AlphaElementwise((0.0, 0.1),
iaa.Noop(),
name="AlphaElementwiseNoop"), default_dtypes),
(iaa.SimplexNoiseAlpha(iaa.Noop(),
name="SimplexNoiseAlphaNoop"), default_dtypes),
(iaa.FrequencyNoiseAlpha(exponent=(-2, 2),
first=iaa.Noop(),
name="SimplexNoiseAlphaNoop"),
default_dtypes),
(iaa.Alpha((0.0, 0.1), iaa.Add(10),
name="Alpha"), _not_dts([np.uint32, np.int32, np.float64])),
(iaa.AlphaElementwise((0.0, 0.1), iaa.Add(10),
name="AlphaElementwise"),
_not_dts([np.uint32, np.int32, np.float64])),
(iaa.SimplexNoiseAlpha(iaa.Add(10), name="SimplexNoiseAlpha"),
_not_dts([np.uint32, np.int32, np.float64])),
(iaa.FrequencyNoiseAlpha(exponent=(-2, 2),
first=iaa.Add(10),
name="SimplexNoiseAlpha"),
_not_dts([np.uint32, np.int32, np.float64])),
(iaa.Superpixels(p_replace=0.01, n_segments=64),
_not_dts([np.float16, np.float32, np.float64])),
(iaa.Resize({
"height": 4,
"width": 4
}, name="Resize"),
_not_dts([
np.uint16, np.uint32, np.int16, np.int32, np.float32, np.float16,
np.float64
])),
(iaa.CropAndPad(px=(-10, 10), name="CropAndPad"),
_not_dts([
np.uint16, np.uint32, np.int16, np.int32, np.float32, np.float16,
np.float64
])),
(iaa.Pad(px=(0, 10), name="Pad"),
_not_dts([
np.uint16, np.uint32, np.int16, np.int32, np.float32, np.float16,
np.float64
])),
(iaa.Crop(px=(0, 10), name="Crop"),
_not_dts([
np.uint16, np.uint32, np.int16, np.int32, np.float32, np.float16,
np.float64
]))
]
for (aug, allowed_dtypes) in augs:
# print("aug", aug.name)
# print("allowed_dtypes", allowed_dtypes)
for images_i in images:
if images_i.dtype in allowed_dtypes:
# print("image dt", images_i.dtype)
images_aug = aug.augment_images(images_i)
assert images_aug.dtype == images_i.dtype
else:
# print("image dt", images_i.dtype, "[SKIPPED]")
pass
def __getitem__(self, index):
if self.mode== 'test':
pic_name = self.pic_list[index].split('\n')[0]
image_path = DataDir+'test/' + pic_name
img = jpeg.JPEG(image_path).decode()
image = cv2.imread(image_path, 1)
image = cv2.resize(image, (self.image_size[1], self.image_size[0]))
image = np.transpose(image, (2, 0, 1))
image = image.astype(np.float32)
image = image.reshape([-1, self.image_size[0], self.image_size[1]])
image = image / 255.0
return torch.FloatTensor(image)
elif self.mode == 'train':
if (index >= len(self.pic_list)) & (self.flip_label) :
origin_index = index - len(self.pic_list)
pic_name= self.pic_list[origin_index].split(',')[0]
pic_label = self.pic_list[origin_index].split(',')[1].split('\n')[0]
pic_label = self.image_label_dict[pic_label]
else:
pic_name= self.pic_list[index].split(',')[0]
pic_label = self.pic_list[index].split(',')[1].split('\n')[0]
pic_label = self.image_label_dict[pic_label]
image_path = DataDir+'train/' + pic_name
image = cv2.imread(image_path, 1)
if self.augment:
if random.randint(0,1) == 0:
image = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
image = cv2.cvtColor(image, cv2.COLOR_GRAY2BGR)
if random.randint(0, 1) == 0:
image = Perspective_aug(image)
image = cv2.resize(image, (self.image_size[1], self.image_size[0]))
image = aug_image(image)
if self.flip_label:
if pic_label == 5004: # if is_new_whle
seq = iaa.Sequential([iaa.Fliplr(0.5)])
image = seq.augment_image(image)
elif index >= len(self.pic_list): #
seq = iaa.Sequential([iaa.Fliplr(1.0)])
image = seq.augment_image(image)
pic_label += 5005
image = cv2.resize(image, (self.image_size[1], self.image_size[0]))
image = np.transpose(image, (2, 0, 1))
image = image.astype(np.float32)
image = image.reshape([-1, self.image_size[0], self.image_size[1]])
image = image / 255.0
return torch.FloatTensor(image), pic_label
elif self.mode == 'valid':
pic_name= self.pic_list[index].split(',')[0]
pic_label = self.pic_list[index].split(',')[1].split('\n')[0]
pic_label = self.image_label_dict[pic_label]
image_path = DataDir+'train/' + pic_name
image = cv2.imread(image_path, 1)
if self.flip_label:
seq = iaa.Sequential([iaa.Fliplr(1.0)])
image = seq.augment_image(image)
if pic_label != 5004:
pic_label += 5005
image = cv2.resize(image, (self.image_size[1], self.image_size[0]))
image = np.transpose(image, (2, 0, 1))
image = image.astype(np.float32)
image = image.reshape([-1, self.image_size[0], self.image_size[1]])
image = image / 255.0
return torch.FloatTensor(image), pic_label
else:
raise Exception('mode not available')
def test_determinism():
reseed()
images = [
ia.quokka(size=(128, 128)),
ia.quokka(size=(64, 64)),
ia.imresize_single_image(skimage.data.astronaut(), (128, 256))
]
images.extend([ia.quokka(size=(16, 16))] * 20)
keypoints = [
ia.KeypointsOnImage([
ia.Keypoint(x=20, y=10),
ia.Keypoint(x=5, y=5),
ia.Keypoint(x=10, y=43)
],
shape=(50, 60, 3))
] * 20
augs = [
iaa.Sequential([iaa.Fliplr(0.5), iaa.Flipud(0.5)]),
iaa.SomeOf(1, [iaa.Fliplr(0.5), iaa.Flipud(0.5)]),
iaa.OneOf([iaa.Fliplr(0.5), iaa.Flipud(0.5)]),
iaa.Sometimes(0.5, iaa.Fliplr(1.0)),
iaa.WithColorspace("HSV", children=iaa.Add((-50, 50))),
# iaa.WithChannels([0], iaa.Add((-50, 50))),
# iaa.Noop(name="Noop-nochange"),
# iaa.Lambda(
# func_images=lambda images, random_state, parents, hooks: images,
# func_keypoints=lambda keypoints_on_images, random_state, parents, hooks: keypoints_on_images,
# name="Lambda-nochange"
# ),
# iaa.AssertLambda(
# func_images=lambda images, random_state, parents, hooks: True,
# func_keypoints=lambda keypoints_on_images, random_state, parents, hooks: True,
# name="AssertLambda-nochange"
# ),
# iaa.AssertShape(
# (None, None, None, 3),
# check_keypoints=False,
# name="AssertShape-nochange"
# ),
iaa.Resize((0.5, 0.9)),
iaa.CropAndPad(px=(-50, 50)),
iaa.Pad(px=(1, 50)),
iaa.Crop(px=(1, 50)),
iaa.Fliplr(0.5),
iaa.Flipud(0.5),
iaa.Superpixels(p_replace=(0.25, 1.0), n_segments=(16, 128)),
# iaa.ChangeColorspace(to_colorspace="GRAY"),
iaa.Grayscale(alpha=(0.1, 1.0)),
iaa.GaussianBlur((0.1, 3.0)),
iaa.AverageBlur((3, 11)),
iaa.MedianBlur((3, 11)),
# iaa.Convolve(np.array([[0, 1, 0],
# [1, -4, 1],
# [0, 1, 0]])),
iaa.Sharpen(alpha=(0.1, 1.0), lightness=(0.8, 1.2)),
iaa.Emboss(alpha=(0.1, 1.0), strength=(0.8, 1.2)),
iaa.EdgeDetect(alpha=(0.1, 1.0)),
iaa.DirectedEdgeDetect(alpha=(0.1, 1.0), direction=(0.0, 1.0)),
iaa.Add((-50, 50)),
iaa.AddElementwise((-50, 50)),
iaa.AdditiveGaussianNoise(scale=(0.1, 1.0)),
iaa.Multiply((0.6, 1.4)),
iaa.MultiplyElementwise((0.6, 1.4)),
iaa.Dropout((0.3, 0.5)),
iaa.CoarseDropout((0.3, 0.5), size_percent=(0.05, 0.2)),
iaa.Invert(0.5),
iaa.ContrastNormalization((0.6, 1.4)),
iaa.Affine(scale=(0.7, 1.3),
translate_percent=(-0.1, 0.1),
rotate=(-20, 20),
shear=(-20, 20),
order=ia.ALL,
mode=ia.ALL,
cval=(0, 255)),
iaa.PiecewiseAffine(scale=(0.1, 0.3)),
iaa.ElasticTransformation(alpha=0.5)
]
augs_affect_geometry = [
iaa.Sequential([iaa.Fliplr(0.5), iaa.Flipud(0.5)]),
iaa.SomeOf(1, [iaa.Fliplr(0.5), iaa.Flipud(0.5)]),
iaa.OneOf([iaa.Fliplr(0.5), iaa.Flipud(0.5)]),
iaa.Sometimes(0.5, iaa.Fliplr(1.0)),
iaa.Resize((0.5, 0.9)),
iaa.CropAndPad(px=(-50, 50)),
iaa.Pad(px=(1, 50)),
iaa.Crop(px=(1, 50)),
iaa.Fliplr(0.5),
iaa.Flipud(0.5),
iaa.Affine(scale=(0.7, 1.3),
translate_percent=(-0.1, 0.1),
rotate=(-20, 20),
shear=(-20, 20),
order=ia.ALL,
mode=ia.ALL,
cval=(0, 255)),
iaa.PiecewiseAffine(scale=(0.1, 0.3)),
iaa.ElasticTransformation(alpha=(5, 100), sigma=(3, 5))
]
for aug in augs:
aug_det = aug.to_deterministic()
images_aug1 = aug_det.augment_images(images)
images_aug2 = aug_det.augment_images(images)
aug_det = aug.to_deterministic()
images_aug3 = aug_det.augment_images(images)
images_aug4 = aug_det.augment_images(images)
assert array_equal_lists(images_aug1, images_aug2), \
"Images (1, 2) expected to be identical for %s" % (aug.name,)
assert array_equal_lists(images_aug3, images_aug4), \
"Images (3, 4) expected to be identical for %s" % (aug.name,)
assert not array_equal_lists(images_aug1, images_aug3), \
"Images (1, 3) expected to be different for %s" % (aug.name,)
for aug in augs_affect_geometry:
aug_det = aug.to_deterministic()
kps_aug1 = aug_det.augment_keypoints(keypoints)
kps_aug2 = aug_det.augment_keypoints(keypoints)
aug_det = aug.to_deterministic()
kps_aug3 = aug_det.augment_keypoints(keypoints)
kps_aug4 = aug_det.augment_keypoints(keypoints)
assert keypoints_equal(kps_aug1, kps_aug2), \
"Keypoints (1, 2) expected to be identical for %s" % (aug.name,)
assert keypoints_equal(kps_aug3, kps_aug4), \
"Keypoints (3, 4) expected to be identical for %s" % (aug.name,)
assert not keypoints_equal(kps_aug1, kps_aug3), \
"Keypoints (1, 3) expected to be different for %s" % (aug.name,)
def test_unusual_channel_numbers():
reseed()
images = [(0, create_random_images((4, 16, 16))),
(1, create_random_images((4, 16, 16, 1))),
(2, create_random_images((4, 16, 16, 2))),
(4, create_random_images((4, 16, 16, 4))),
(5, create_random_images((4, 16, 16, 5))),
(10, create_random_images((4, 16, 16, 10))),
(20, create_random_images((4, 16, 16, 20)))]
augs = [
iaa.Add((-5, 5), name="Add"),
iaa.AddElementwise((-5, 5), name="AddElementwise"),
iaa.AdditiveGaussianNoise(0.01 * 255, name="AdditiveGaussianNoise"),
iaa.Multiply((0.95, 1.05), name="Multiply"),
iaa.Dropout(0.01, name="Dropout"),
iaa.CoarseDropout(0.01, size_px=6, name="CoarseDropout"),
iaa.Invert(0.01, per_channel=True, name="Invert"),
iaa.ContrastNormalization((0.95, 1.05), name="ContrastNormalization"),
iaa.GaussianBlur(sigma=(0.95, 1.05), name="GaussianBlur"),
iaa.AverageBlur((3, 5), name="AverageBlur"),
iaa.MedianBlur((3, 5), name="MedianBlur"),
# iaa.BilateralBlur((3, 5), name="BilateralBlur"), # works only with 3/RGB channels
# WithColorspace ?
# iaa.AddToHueAndSaturation((-5, 5), name="AddToHueAndSaturation"), # works only with 3/RGB channels
# ChangeColorspace ?
# iaa.Grayscale((0.0, 0.1), name="Grayscale"), # works only with 3 channels
# Convolve ?
iaa.Sharpen((0.0, 0.1), lightness=(1.0, 1.2), name="Sharpen"),
iaa.Emboss(alpha=(0.0, 0.1), strength=(0.5, 1.5), name="Emboss"),
iaa.EdgeDetect(alpha=(0.0, 0.1), name="EdgeDetect"),
iaa.DirectedEdgeDetect(alpha=(0.0, 0.1),
direction=0,
name="DirectedEdgeDetect"),
iaa.Fliplr(0.5, name="Fliplr"),
iaa.Flipud(0.5, name="Flipud"),
iaa.Affine(translate_px=(-5, 5), name="Affine-translate-px"),
iaa.Affine(translate_percent=(-0.05, 0.05),
name="Affine-translate-percent"),
iaa.Affine(rotate=(-20, 20), name="Affine-rotate"),
iaa.Affine(shear=(-20, 20), name="Affine-shear"),
iaa.Affine(scale=(0.9, 1.1), name="Affine-scale"),
iaa.PiecewiseAffine(scale=(0.001, 0.005), name="PiecewiseAffine"),
iaa.PerspectiveTransform(scale=(0.01, 0.10),
name="PerspectiveTransform"),
iaa.ElasticTransformation(alpha=(0.1, 0.2),
sigma=(0.1, 0.2),
name="ElasticTransformation"),
iaa.Sequential([iaa.Add((-5, 5)),
iaa.AddElementwise((-5, 5))]),
iaa.SomeOf(1, [iaa.Add(
(-5, 5)), iaa.AddElementwise((-5, 5))]),
iaa.OneOf([iaa.Add((-5, 5)),
iaa.AddElementwise((-5, 5))]),
iaa.Sometimes(0.5, iaa.Add((-5, 5)), name="Sometimes"),
# WithChannels
iaa.Noop(name="Noop"),
# Lambda
# AssertLambda
# AssertShape
iaa.Alpha((0.0, 0.1), iaa.Add(10), name="Alpha"),
iaa.AlphaElementwise((0.0, 0.1), iaa.Add(10), name="AlphaElementwise"),
iaa.SimplexNoiseAlpha(iaa.Add(10), name="SimplexNoiseAlpha"),
iaa.FrequencyNoiseAlpha(exponent=(-2, 2),
first=iaa.Add(10),
name="SimplexNoiseAlpha"),
iaa.Superpixels(p_replace=0.01, n_segments=64),
iaa.Resize({
"height": 4,
"width": 4
}, name="Resize"),
iaa.CropAndPad(px=(-10, 10), name="CropAndPad"),
iaa.Pad(px=(0, 10), name="Pad"),
iaa.Crop(px=(0, 10), name="Crop")
]
for aug in augs:
for (nb_channels, images_c) in images:
if aug.name != "Resize":
images_aug = aug.augment_images(images_c)
assert images_aug.shape == images_c.shape
image_aug = aug.augment_image(images_c[0])
assert image_aug.shape == images_c[0].shape
else:
images_aug = aug.augment_images(images_c)
image_aug = aug.augment_image(images_c[0])
if images_c.ndim == 3:
assert images_aug.shape == (4, 4, 4)
assert image_aug.shape == (4, 4)
else:
assert images_aug.shape == (4, 4, 4, images_c.shape[3])
assert image_aug.shape == (4, 4, images_c.shape[3])
def test_keypoint_augmentation():
reseed()
keypoints = []
for y in range(40 // 5):
for x in range(60 // 5):
keypoints.append(ia.Keypoint(y=y * 5, x=x * 5))
keypoints_oi = ia.KeypointsOnImage(keypoints, shape=(40, 60, 3))
keypoints_oi_empty = ia.KeypointsOnImage([], shape=(40, 60, 3))
augs = [
iaa.Add((-5, 5), name="Add"),
iaa.AddElementwise((-5, 5), name="AddElementwise"),
iaa.AdditiveGaussianNoise(0.01 * 255, name="AdditiveGaussianNoise"),
iaa.Multiply((0.95, 1.05), name="Multiply"),
iaa.Dropout(0.01, name="Dropout"),
iaa.CoarseDropout(0.01, size_px=6, name="CoarseDropout"),
iaa.Invert(0.01, per_channel=True, name="Invert"),
iaa.ContrastNormalization((0.95, 1.05), name="ContrastNormalization"),
iaa.GaussianBlur(sigma=(0.95, 1.05), name="GaussianBlur"),
iaa.AverageBlur((3, 5), name="AverageBlur"),
iaa.MedianBlur((3, 5), name="MedianBlur"),
# iaa.BilateralBlur((3, 5), name="BilateralBlur"),
# WithColorspace ?
# iaa.AddToHueAndSaturation((-5, 5), name="AddToHueAndSaturation"),
# ChangeColorspace ?
# Grayscale cannot be tested, input not RGB
# Convolve ?
iaa.Sharpen((0.0, 0.1), lightness=(1.0, 1.2), name="Sharpen"),
iaa.Emboss(alpha=(0.0, 0.1), strength=(0.5, 1.5), name="Emboss"),
iaa.EdgeDetect(alpha=(0.0, 0.1), name="EdgeDetect"),
iaa.DirectedEdgeDetect(alpha=(0.0, 0.1),
direction=0,
name="DirectedEdgeDetect"),
iaa.Fliplr(0.5, name="Fliplr"),
iaa.Flipud(0.5, name="Flipud"),
iaa.Affine(translate_px=(-5, 5), name="Affine-translate-px"),
iaa.Affine(translate_percent=(-0.05, 0.05),
name="Affine-translate-percent"),
iaa.Affine(rotate=(-20, 20), name="Affine-rotate"),
iaa.Affine(shear=(-20, 20), name="Affine-shear"),
iaa.Affine(scale=(0.9, 1.1), name="Affine-scale"),
iaa.PiecewiseAffine(scale=(0.001, 0.005), name="PiecewiseAffine"),
# iaa.PerspectiveTransform(scale=(0.01, 0.10), name="PerspectiveTransform"),
iaa.ElasticTransformation(alpha=(0.1, 0.2),
sigma=(0.1, 0.2),
name="ElasticTransformation"),
# Sequential
# SomeOf
# OneOf
# Sometimes
# WithChannels
# Noop
# Lambda
# AssertLambda
# AssertShape
iaa.Alpha((0.0, 0.1), iaa.Add(10), name="Alpha"),
iaa.AlphaElementwise((0.0, 0.1), iaa.Add(10), name="AlphaElementwise"),
iaa.SimplexNoiseAlpha(iaa.Add(10), name="SimplexNoiseAlpha"),
iaa.FrequencyNoiseAlpha(exponent=(-2, 2),
first=iaa.Add(10),
name="SimplexNoiseAlpha"),
iaa.Superpixels(p_replace=0.01, n_segments=64),
iaa.Resize(0.5, name="Resize"),
iaa.CropAndPad(px=(-10, 10), name="CropAndPad"),
iaa.Pad(px=(0, 10), name="Pad"),
iaa.Crop(px=(0, 10), name="Crop")
]
for aug in augs:
dss = []
for i in range(10):
aug_det = aug.to_deterministic()
kp_fully_empty_aug = aug_det.augment_keypoints([])
assert kp_fully_empty_aug == []
kp_first_empty_aug = aug_det.augment_keypoints(
[keypoints_oi_empty])[0]
assert len(kp_first_empty_aug.keypoints) == 0
kp_image = keypoints_oi.to_keypoint_image(size=5)
kp_image_aug = aug_det.augment_image(kp_image)
kp_image_aug_rev = ia.KeypointsOnImage.from_keypoint_image(
kp_image_aug,
if_not_found_coords={
"x": -9999,
"y": -9999
},
nb_channels=1)
kp_aug = aug_det.augment_keypoints([keypoints_oi])[0]
ds = []
assert len(kp_image_aug_rev.keypoints) == len(kp_aug.keypoints),\
"Lost keypoints for '%s' (%d vs expected %d)" \
% (aug.name, len(kp_aug.keypoints), len(kp_image_aug_rev.keypoints))
for kp_pred, kp_pred_img in zip(kp_aug.keypoints,
kp_image_aug_rev.keypoints):
kp_pred_lost = (kp_pred.x == -9999 and kp_pred.y == -9999)
kp_pred_img_lost = (kp_pred_img.x == -9999
and kp_pred_img.y == -9999)
if not kp_pred_lost and not kp_pred_img_lost:
d = np.sqrt((kp_pred.x - kp_pred_img.x)**2 +
(kp_pred.y - kp_pred_img.y)**2)
ds.append(d)
dss.extend(ds)
if len(ds) == 0:
print("[INFO] No valid keypoints found for '%s' "
"in test_keypoint_augmentation()" % (str(aug), ))
assert np.average(dss) < 5.0, \
"Average distance too high (%.2f, with ds: %s)" \
% (np.average(dss), str(dss))
def _load_augmentation_aug_all():
""" Load image augmentation model """
def sometimes(aug):
return iaa.Sometimes(0.5, aug)
return 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
sometimes(
iaa.CropAndPad(percent=(-0.05, 0.1),
pad_mode='constant',
pad_cval=(0, 255))),
sometimes(
iaa.Affine(
# scale images to 80-120% of their size, individually per axis
scale={
"x": (0.8, 1.2),
"y": (0.8, 1.2)
},
# translate by -20 to +20 percent (per axis)
translate_percent={
"x": (-0.2, 0.2),
"y": (-0.2, 0.2)
},
rotate=(-45, 45), # rotate by -45 to +45 degrees
shear=(-16, 16), # shear by -16 to +16 degrees
# use nearest neighbour or bilinear interpolation (fast)
order=[0, 1],
# if mode is constant, use a cval between 0 and 255
cval=(0, 255),
# use any of scikit-image's warping modes
# (see 2nd image from the top for examples)
mode='constant')),
# 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),
[
# convert images into their superpixel representation
sometimes(
iaa.Superpixels(p_replace=(0, 1.0),
n_segments=(20, 200))),
iaa.OneOf([
# blur images with a sigma between 0 and 3.0
iaa.GaussianBlur((0, 3.0)),
# blur image using local means with kernel sizes
# between 2 and 7
iaa.AverageBlur(k=(2, 7)),
# blur image using local medians with kernel sizes
# between 2 and 7
iaa.MedianBlur(k=(3, 11)),
]),
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)),
])),
# add gaussian noise to images
iaa.AdditiveGaussianNoise(
loc=0, scale=(0.0, 0.05 * 255), per_channel=0.5),
iaa.OneOf([
# randomly remove up to 10% of the pixels
iaa.Dropout((0.01, 0.1), per_channel=0.5),
iaa.CoarseDropout((0.03, 0.15),
size_percent=(0.02, 0.05),
per_channel=0.2),
]),
# invert color channels
iaa.Invert(0.05, per_channel=True),
# change brightness of images (by -10 to 10 of original value)
iaa.Add((-10, 10), per_channel=0.5),
# change hue and saturation
iaa.AddToHueAndSaturation((-20, 20)),
# 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)))
]),
# improve or worsen the contrast
iaa.ContrastNormalization((0.5, 2.0), per_channel=0.5),
iaa.Grayscale(alpha=(0.0, 1.0)),
# move pixels locally around (with random strengths)
sometimes(
iaa.ElasticTransformation(alpha=(0.5, 3.5), sigma=0.25)
),
# sometimes move parts of the image around
sometimes(iaa.PiecewiseAffine(scale=(0.01, 0.05))),
sometimes(iaa.PerspectiveTransform(scale=(0.01, 0.1)))
],
random_order=True)
],
random_order=True)
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 rand_flip(matrix):
random_flip = iaa.Sometimes(0.5, iaa.Fliplr(1.0))
return random_flip(images=matrix)
def generate(data_dir,
batch_size=16,
image_size=640,
min_text_size=8,
shrink_ratio=0.4,
thresh_min=0.3,
thresh_max=0.7,
is_training=True):
#split = 'train' if is_training else 'test'
split = 'train'
with open(osp.join(data_dir, f'{split}_list.txt')) as f:
image_fnames = f.readlines()
image_paths = [
osp.join(data_dir, f'{split}_images', image_fname.strip())
for image_fname in image_fnames
]
#gt_paths = [osp.join(data_dir, f'{split}_gts', image_fname.strip()).replace('.jpg', '.txt') for image_fname in image_fnames]
gt_paths = [
osp.join(
data_dir, f'{split}_gts', '/'.join([
osp.split(image_fname.strip())[0],
'gt_' + osp.split(image_fname.strip())[-1]
]).replace('.jpg', '.txt').lstrip('/'))
for image_fname in image_fnames
]
transform_aug = iaa.Sequential([
iaa.Fliplr(0.5),
iaa.Affine(rotate=(-10, 10)),
iaa.Resize((0.5, 3.0))
])
dataset_size = len(image_paths)
indices = np.arange(dataset_size)
if is_training:
np.random.shuffle(indices)
current_idx = 0
b = 0
while True:
if current_idx >= dataset_size:
if is_training:
np.random.shuffle(indices)
current_idx = 0
if b == 0:
# Init batch arrays
batch_images = np.zeros([batch_size, image_size, image_size, 3],
dtype=np.float32)
batch_gts = np.zeros([batch_size, image_size, image_size],
dtype=np.float32)
batch_masks = np.zeros([batch_size, image_size, image_size],
dtype=np.float32)
batch_thresh_maps = np.zeros([batch_size, image_size, image_size],
dtype=np.float32)
batch_thresh_masks = np.zeros([batch_size, image_size, image_size],
dtype=np.float32)
batch_loss = np.zeros([
batch_size,
], dtype=np.float32)
i = indices[current_idx]
image_path = image_paths[i]
#anns = all_anns[i]
anns = load_anns(gt_paths[i])
image = cv2.imread(image_path)
# show_polys(image.copy(), anns, 'before_aug')
if is_training:
transform_aug = transform_aug.to_deterministic()
image, anns = transform(transform_aug, image, anns)
image, anns = crop(image, anns)
image, anns = resize(image_size, image, anns)
# show_polys(image.copy(), anns, 'after_aug')
# cv2.waitKey(0)
anns = [ann for ann in anns if Polygon(ann['poly']).is_valid]
gt = np.zeros((image_size, image_size), dtype=np.float32)
mask = np.ones((image_size, image_size), dtype=np.float32)
thresh_map = np.zeros((image_size, image_size), dtype=np.float32)
thresh_mask = np.zeros((image_size, image_size), dtype=np.float32)
for ann in anns:
poly = np.array(ann['poly'])
height = max(poly[:, 1]) - min(poly[:, 1])
width = max(poly[:, 0]) - min(poly[:, 0])
polygon = Polygon(poly)
# generate gt and mask
#if polygon.area < 1 or min(height, width) < min_text_size or ann['text'] == '###':
if polygon.area < 1 or min(height, width) < min_text_size:
cv2.fillPoly(mask, poly.astype(np.int32)[np.newaxis, :, :], 0)
continue
else:
distance = polygon.area * (
1 - np.power(shrink_ratio, 2)) / polygon.length
subject = [tuple(l) for l in ann['poly']]
padding = pyclipper.PyclipperOffset()
padding.AddPath(subject, pyclipper.JT_ROUND,
pyclipper.ET_CLOSEDPOLYGON)
shrinked = padding.Execute(-distance)
if len(shrinked) == 0:
cv2.fillPoly(mask,
poly.astype(np.int32)[np.newaxis, :, :], 0)
continue
else:
shrinked = np.array(shrinked[0]).reshape(-1, 2)
if shrinked.shape[0] > 2 and Polygon(shrinked).is_valid:
cv2.fillPoly(gt, [shrinked.astype(np.int32)], 1)
else:
cv2.fillPoly(mask,
poly.astype(np.int32)[np.newaxis, :, :],
0)
continue
# generate thresh map and thresh mask
draw_thresh_map(ann['poly'],
thresh_map,
thresh_mask,
shrink_ratio=shrink_ratio)
thresh_map = thresh_map * (thresh_max - thresh_min) + thresh_min
image = image.astype(np.float32)
image[..., 0] -= mean[0]
image[..., 1] -= mean[1]
image[..., 2] -= mean[2]
batch_images[b] = image
batch_gts[b] = gt
batch_masks[b] = mask
batch_thresh_maps[b] = thresh_map
batch_thresh_masks[b] = thresh_mask
b += 1
current_idx += 1
if b == batch_size:
inputs = [
batch_images, batch_gts, batch_masks, batch_thresh_maps,
batch_thresh_masks
]
outputs = batch_loss
yield inputs, outputs
b = 0
def _create_augment_pipeline():
# augmentors by https://github.com/aleju/imgaug
sometimes = lambda aug: iaa.Sometimes(0.2, aug)
# Define our sequence of augmentation steps that will be applied to every image
# All augmenters with per_channel=0.5 will sample one value _per image_
# in 50% of all cases. In all other cases they will sample new values
# _per channel_.
aug_pipe = 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
# 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, 2),
[
iaa.Affine(scale={
"x": (0.8, 1.2),
"y": (0.8, 1.2)
}, ),
iaa.Affine(translate_percent={
"x": (-0.2, 0.2),
"y": (-0.2, 0.2)
}, ),
iaa.Affine(rotate=(-15, 15), ),
iaa.Affine(shear=(-15, 15)),
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 (kernel sizes between 2 and 7)
iaa.MedianBlur(k=(3, 11)),
# blur image using local medians (kernel sizes between 2 and 7)
]),
iaa.Sharpen(alpha=(0, 1.0),
lightness=(0.75, 1.5)), # sharpen images
iaa.AdditiveGaussianNoise(
loc=0, scale=(0.0, 0.05 * 255), per_channel=0.5),
# add gaussian noise
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.Add((-10, 10),
per_channel=0.5), # change brightness of images
iaa.Multiply(
(0.5, 1.5),
per_channel=0.5), # change brightness of images
iaa.ContrastNormalization(
(0.5, 2.0),
per_channel=0.5), # improve or worsen the contrast
],
random_order=True)
],
random_order=True)
return aug_pipe
def draw_per_augmenter_images(imgName):
print("[draw_per_augmenter_images] Loading image...")
image = misc.imresize(ndimage.imread(imgName), (227, 227))
#keypoints = [ia.Keypoint(x=43, y=43), ia.Keypoint(x=78, y=40), ia.Keypoint(x=64, y=73)] # left eye, right eye, mouth
#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 = [
#("Noop", [("", iaa.Noop()) for _ in sm.xrange(5)]),
#("Crop", [iaa.Crop(px=vals) for vals in [(2, 4), (4, 8), (6, 16), (8, 32), (10, 64)]]),
("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)]]),
("Fliplr", [(str(p), iaa.Fliplr(p)) for p in [0, 0, 1, 1, 1]]),
("Flipud", [(str(p), iaa.Flipud(p)) for p in [0, 0, 1, 1, 1]]),
("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]]),
("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]]),
("Invert", [("p=%d" % (p,), iaa.Invert(p=p)) for p in [0, 0, 1, 1, 1]]),
("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]]),
("Add", [("value=%d" % (val,), iaa.Add(val)) for val in [-45, -25, 0, 25, 45]]),
("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)]]),
("Multiply", [("value=%.2f" % (val,), iaa.Multiply(val)) for val in [0.25, 0.5, 1.0, 1.25, 1.5]]),
("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)]]),
("GaussianBlur", [("sigma=%.2f" % (sigma,), iaa.GaussianBlur(sigma=sigma)) for sigma in [0.25, 0.50, 1.0, 2.0, 4.0]]),
("AverageBlur", [("k=%d" % (k,), iaa.AverageBlur(k=k)) for k in [1, 3, 5, 7, 9]]),
("MedianBlur", [("k=%d" % (k,), iaa.MedianBlur(k=k)) for k in [1, 3, 5, 7, 9]]),
("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]]),
("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]]),
("EdgeDetect", [("alpha=%.2f" % (alpha,), iaa.EdgeDetect(alpha=alpha)) for alpha in [0.0, 0.25, 0.5, 0.75, 1.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]]),
("AdditiveGaussianNoise", [("scale=%.2f*255" % (scale,), iaa.AdditiveGaussianNoise(scale=scale * 255)) for scale in [0.025, 0.05, 0.1, 0.2, 0.3]]),
("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]]),
("Dropout", [("p=%.2f" % (p,), iaa.Dropout(p=p)) for p in [0.025, 0.05, 0.1, 0.2, 0.4]]),
("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]]),
("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]]),
("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]]),
("ContrastNormalization", [("alpha=%.1f" % (alpha,), iaa.ContrastNormalization(alpha=alpha)) for alpha in [0.5, 0.75, 1.0, 1.25, 1.50]]),
("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)]]),
("Grayscale", [("alpha=%.1f" % (alpha,), iaa.Grayscale(alpha=alpha)) for alpha in [0.0, 0.25, 0.5, 0.75, 1.0]]),
("PiecewiseAffine", [("scale=%.3f" % (scale,), iaa.PiecewiseAffine(scale=scale)) for scale in [0.015, 0.03, 0.045, 0.06, 0.075]]),
("Affine: Scale", [("%.1fx" % (scale,), iaa.Affine(scale=scale)) for scale in [0.1, 0.5, 1.0, 1.5, 1.9]]),
("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)]]),
("Affine: Rotate", [("%d deg" % (rotate,), iaa.Affine(rotate=rotate)) for rotate in [-90, -45, 0, 45, 90]]),
("Affine: Shear", [("%d deg" % (shear,), iaa.Affine(shear=shear)) for shear in [-45, -25, 0, 25, 45]]),
("Affine: Modes", [(mode, iaa.Affine(translate_px=-32, mode=mode)) for mode in ["constant", "edge", "symmetric", "reflect", "wrap"]]),
("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]]),
(
"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)
]
),
("ElasticTransformation\n(sigma=0.2)", [("alpha=%.1f" % (alpha,), iaa.ElasticTransformation(alpha=alpha, sigma=0.2)) for alpha in [0.1, 0.5, 1.0, 3.0, 9.0]])
]
print("[draw_per_augmenter_images] Augmenting...")
i = 0
for (row_name, augmenters) in rows_augmenters:
for img_title, augmenter in augmenters:
aug_det = augmenter.to_deterministic()
image_aug = aug_det.augment_image(image)
#print(outputDir + os.path.splitext(os.path.basename(imgName))[0] + "_%04d.jpg"% (i,))
misc.imsave(outputDir + os.path.splitext(os.path.basename(imgName))[0] + "_%04d.jpg" % (i,), image_aug)
i += 1
def processor(self):
return iaa.Fliplr(1)
def __init__(self, images, config, shuffle=True, jitter=True, norm=None):
self.generator = None
self.images = images
self.config = config
self.shuffle = shuffle
self.jitter = jitter
self.norm = norm
self.anchors = [BoundBox(0, 0, config['ANCHORS'][2*i], config['ANCHORS'][2*i+1])\
for i in range(int(len(config['ANCHORS'])//2))]
### augmentors by https://github.com/aleju/imgaug
sometimes = lambda aug: iaa.Sometimes(0.33, aug)
# Define our sequence of augmentation steps that will be applied to every image
# All augmenters with per_channel=0.5 will sample one value _per image_
# in 50% of all cases. In all other cases they will sample new values
# _per channel_.
self.aug_pipe = 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
sometimes(iaa.Crop(percent=(0, 0.1))
), # crop images by 0-10% of their height/width
sometimes(
iaa.Affine(
scale={
"x": (0.85, 1.15),
"y": (0.85, 1.15)
}, # scale images to 80-120% of their size, individually per axis
translate_percent={
"x": (-0.15, 0.15),
"y": (-0.15, 0.15)
}, # translate by -20 to +20 percent (per axis)
rotate=(-5, 5), # rotate by -45 to +45 degrees
#shear=(-5, 5), # 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),
[
#sometimes(iaa.Superpixels(p_replace=(0, 1.0), n_segments=(20, 200))), # convert images into their superpixel representation
iaa.OneOf([
iaa.GaussianBlur(
(0, 2.0)
), # blur images with a sigma between 0 and 3.0
# iaa.AverageBlur(k=(2, 5)), # blur image using local means with kernel sizes between 2 and 7
# iaa.MedianBlur(k=(3, 6)), # 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
#sometimes(iaa.OneOf([
# iaa.EdgeDetect(alpha=(0, 0.7)),
# iaa.DirectedEdgeDetect(alpha=(0, 0.7), direction=(0.0, 1.0)),
#])),
iaa.AdditiveGaussianNoise(
loc=0, scale=(0.0, 0.04 * 255),
per_channel=0.5), # add gaussian noise to images
iaa.OneOf([
iaa.Dropout(
(0.01, 0.05), per_channel=0.5
), # randomly remove up to 5% 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.Multiply(
(0.75, 1.25), per_channel=0.5
), # change brightness of images (50-150% of original value)
iaa.ContrastNormalization(
(0.7, 1.3),
per_channel=0.5), # improve or worsen the contrast
#iaa.Grayscale(alpha=(0.0, 1.0)),
#sometimes(iaa.ElasticTransformation(alpha=(0.5, 3.5), sigma=0.25)), # move pixels locally around (with random strengths)
#sometimes(iaa.PiecewiseAffine(scale=(0.01, 0.05))) # sometimes move parts of the image around
],
random_order=True)
],
random_order=True)
if shuffle: np.random.shuffle(self.images)
def createSequence(self):
seq_affine = []
seq_non_affine = []
seq_noise = []
def sometimes_affine(aug): return iaa.Sometimes(
self.default_param['affine_probability']/100, aug)
def sometimes_non_affine(aug): return iaa.Sometimes(
self.default_param['non_affine_probability']/100, aug)
def sometimes_noise(aug): return iaa.Sometimes(
self.default_param['noise_probability']/100, aug)
affine = {k: self.default_param[k] for k in self.default_param.keys() if (
('affine' in k) and (not 'non' in k) and self.default_param[k])}
if affine != {}:
affine_seq = {}
for a in affine:
if a == 'affine_flip_horizontal':
seq_affine.append(sometimes_affine(
iaa.Flipud(affine[a]/100)))
elif a == 'affine_flip_vertical':
seq_affine.append(sometimes_affine(
iaa.Fliplr(affine[a]/100)))
elif a == 'affine_rotate':
affine_seq['rotate'] = (-affine[a], affine[a])
elif a == 'affine_scale':
affine_seq['scale'] = {
"x": (1, 1+affine[a]/100), "y": (1, 1+affine[a]/100)}
elif a == 'affine_shear':
affine_seq['shear'] = (-affine[a], affine[a])
if affine_seq != {}:
affine_seq['mode'] = 'reflect'
seq_affine.append(sometimes_affine(iaa.Affine(**affine_seq)))
non_affine = {k: self.default_param[k] for k in self.default_param.keys() if (
('non_affine' in k) and self.default_param[k])}
if non_affine != {}:
for a in non_affine:
if a == 'non_affine_brightness':
seq_non_affine.append(sometimes_non_affine(iaa.Multiply(
(1-non_affine[a]/100, 1+non_affine[a]/100), per_channel=True)))
elif a == 'non_affine_contrast':
seq_non_affine.append(sometimes_non_affine(
iaa.ContrastNormalization((1-non_affine[a]/100, 1+non_affine[a]/100))))
elif a == 'non_affine_emboss':
seq_non_affine.append(sometimes_non_affine(iaa.Emboss(
alpha=(non_affine[a]/200, non_affine[a]/100), strength=(0, non_affine[a]/50))))
elif a == 'non_affine_grayscale':
seq_non_affine.append(sometimes_non_affine(
iaa.Grayscale(alpha=(non_affine[a]/200, non_affine[a]/100))))
elif a == 'non_affine_saturation':
seq_non_affine.append(sometimes_non_affine(
iaa.AddToHueAndSaturation((-non_affine[a], non_affine[a]))))
elif a == 'non_affine_shrpen':
seq_non_affine.append(sometimes_non_affine(iaa.Sharpen(alpha=(
non_affine[a]/200, non_affine[a]/100), lightness=(1-non_affine[a]/100, 1+non_affine[a]/100))))
noise = {k: self.default_param[k] for k in self.default_param.keys() if (
('noise' in k) and self.default_param[k])}
if noise != {}:
for a in noise:
if a == 'noise_blur':
seq_noise.append(sometimes_noise(
iaa.GaussianBlur((noise[a]/2, noise[a]))))
elif a == 'noise_dropout':
seq_noise.append(sometimes_noise(
iaa.Dropout((noise[a]/200, noise[a]/100))))
elif a == 'noise_frequency':
seq_noise.append(sometimes_noise(
iaa.FrequencyNoiseAlpha(exponent=(-noise[a], noise[a]))))
elif a == 'noise_noise':
seq_noise.append(sometimes_noise(
iaa.AdditiveGaussianNoise((255*noise[a]/200, 255*noise[a]/100))))
elif a == 'noise_salt_and_pepper':
seq_noise.append(sometimes_noise(
iaa.SaltAndPepper(p=(noise[a]/200, noise[a]/100))))
return {'affine': seq_affine, 'non_affine': seq_non_affine, 'noise': seq_noise}
def tf_softmax(x):
return tf.nn.softmax(x)
def unpickle(file):
import pickle
with open(file, 'rb') as fo:
dict = pickle.load(fo, encoding='bytes')
return dict
# Data Augmentation
seq = iaa.Sequential(
[
iaa.Fliplr(0.5), # horizontal flips
iaa.Crop(percent=(0, 0.1)), # random crops
# 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=(0, 0.5))),
# Strengthen or weaken the contrast in each image.
iaa.ContrastNormalization((0.75, 1.5)),
# Add gaussian noise.
# For 50% of all images, we sample the noise once per pixel.
# For the other 50% of all images, we sample the noise per pixel AND
# channel. This can change the color (not only brightness) of the
# pixels.
iaa.AdditiveGaussianNoise(
loc=0, scale=(0.0, 0.05 * 255), per_channel=0.5),
# Make some images brighter and some darker.
# In 20% of all cases, we sample the multiplier once per channel,
def __init__(self, p=.5, key_source='image', key_target=None):
super(FlipLR, self).__init__(key_source=key_source,
key_target=key_target)
self.sequence = iaa.Fliplr(p=p)
import numpy as np
import imgaug as ia
from imgaug import augmenters as iaa
ia.seed(1)
np.random.seed(1)
augmentations = [{
'common': True,
'seq': iaa.Flipud(1)
}, {
'common': True,
'seq': iaa.Fliplr(1)
}, {
'common': False,
'seq': iaa.GaussianBlur(sigma=(0.0, 3.0))
}, {
'common': False,
'seq': iaa.Sharpen(alpha=(0.0, 1.0), lightness=(0.75, 2.0))
}]
def image_augmentation(img, mask):
"""
Batch wise image augmentation. Randomly augments the images with flip, sharpen and/or gaussian blur
:param img:
:param mask:
:return:
"""
for aug in augmentations:
if not aug['common']:
def check_dir_or_create(dir):
if not os.path.exists(dir):
os.makedirs(dir)
# Sometimes(0.5, ...) applies the given augmenter in 50% of all cases,
# e.g. Sometimes(0.5, GaussianBlur(0.3)) would blur roughly every second image.
sometimes = lambda aug: iaa.Sometimes(0.5, aug)
# Define our sequence of augmentation steps that will be applied to every image
# All augmenters with per_channel=0.5 will sample one value _per image_
# in 50% of all cases. In all other cases they will sample new values
# _per channel_.
augmenters = [
iaa.Fliplr(0.25), # left/right flips
iaa.Flipud(0.25), # up/down flips
iaa.Crop(percent=(0, 0.1)), # random crops
iaa.Affine(
scale={"x": (0.8, 1.2), "y": (0.8, 1.2)},
translate_percent={"x": (-0.2, 0.2), "y": (-0.2, 0.2)},
rotate=(-25, 25),
shear=(-8, 8)
)
]
seq = iaa.Sequential(augmenters, random_order=True)
files = [y for x in os.walk(INPUT)
for y in glob(os.path.join(x[0], '*')) if os.path.isfile(y)]
def __init__(self):
self.imgaug_transform = iaa.Fliplr(p=1)
X_train_aug_accu.append(get_accumEdged(X_aug))
y_train_aug.append(y_aug)
# Save the augmented pictures to the exact folder
name = X_train_names[img_count].replace(".bmp", "")
name = name + "_" + str(img_count) + "_rot_" + str(rotate_angle) + ".bmp"
X_train_aug_names.append(name)
cv2.imwrite(Aug_train_data_folder + name, X_aug)
# Draw Troughs and Save Image
X_aug = draw_troughs(X_aug, y_aug)
cv2.imwrite(Aug_data_with_points_folder + name + "_" + str(img_count) +
"_rot_" + str(rotate_angle) + ".bmp", X_aug)
# Augmentation_2 (Fliplr + Rotation)
images_lr , keypoints_lr = iaa.Fliplr(1.0)(images = image,
keypoints = point)
X_aug , y_aug = iaa.Affine(rotate = rotate_angle)(images = images_lr,
keypoints = keypoints_lr)
# Again Reshaping to before format
X_aug = X_aug.reshape((image.shape[1], image.shape[2], image.shape[3]))
y_aug = np.array(y_aug).reshape((2, 2))
# Append samples after augmentation
X_train_aug_bmp.append(X_aug)
X_train_aug_gray.append(cv2.cvtColor(X_aug, cv2.COLOR_BGR2GRAY))
X_train_aug_accu.append(get_accumEdged(X_aug))
y_train_aug.append(y_aug)
# Save the augmented pictures to the exact folder
name = X_train_names[img_count].replace(".bmp", "")
name = name + "_" + str(img_count) + "_flrot_" + str(rotate_angle) + ".bmp"
X_train_aug_names.append(name)
def make_synthetic_image(self, file_base, added_images):
img_base = cv2.imread(join(self.bg_path, file_base))
# Store mask labels for later training, i.e. stores the corresponding object label for every mask channel
save_name = ''
mask_labels = []
mask_overlayed = np.zeros((img_base.shape[0], img_base.shape[1]),
dtype=np.uint8)[:, :, None]
# Get rid of placeholder channel entry
mask_overlayed = mask_overlayed[:, :, 1:]
if len(mask_overlayed.shape) < 3:
mask_overlayed = mask_overlayed[:, :, np.newaxis]
img_overlayed = copy(img_base)
# Perturb background
scale = np.random.uniform(0.6, 1.1)
img_perturbed = copy(img_overlayed)
img_perturbed = (img_perturbed * scale).astype(np.uint8)
img_perturbed[np.where(img_perturbed > 255)] = 255
img_perturbed[np.where(img_perturbed < 0)] = 0
img_overlayed = img_perturbed
for i, file_added in enumerate(added_images):
# Read image to be added on top
print("Added image: ", file_added)
img_added = cv2.imread(
join(self.mask_root_path,
file_added.split('_')[0], file_added))
if file_base.endswith('.jpg'):
mask_added = np.load(
join(self.mask_root_path,
file_added.split('_')[0],
file_added.split('.jpg')[0] + '.npy'))
else:
mask_added = np.load(
join(self.mask_root_path,
file_added.split('_')[0],
file_added.split('.png')[0] + '.npy'))
mask_labels.append(self.mask_root_path.split('/')[-1])
# Mask image
# img_added_masked = img_added * mask_added[:,:,np.newaxis]
aff = iaa.Sequential([
iaa.Fliplr(0.5), # horizontally flip 50% of all images
iaa.Flipud(0.2), # vertically flip 20% of all images
iaa.Affine(scale={
"x": (0.7, 1.3),
"y": (0.7, 1.3)
},
translate_percent={
"x": (-0.2, 0.2),
"y": (-0.2, 0.2)
},
rotate=(-90, 90),
shear=(-15, 15))
])
# Affine transform
aff_det = aff.to_deterministic()
img_added = aff_det.augment_image(img_added)
mask_added = aff_det.augment_image(mask_added)
# Static Transform
st = iaa.SomeOf(
(0, 3),
[
iaa.AdditiveGaussianNoise(
loc=0, scale=(0.0, 0.02 * 255), per_channel=0.5),
# Change brightness of images (50-150% of original value).
iaa.Multiply((0.8, 1.2), per_channel=0.0),
# Improve or worsen the contrast of images.
iaa.ContrastNormalization((0.8, 1.2), per_channel=0.5),
iaa.OneOf([
iaa.Dropout((0.005, 0.01), per_channel=0.0),
iaa.CoarseDropout((0.01, 0.05),
size_percent=(0.01, 0.05),
per_channel=0.0),
]),
# Add a value of -10 to 10 to each pixel.
iaa.Add((-10, 30), per_channel=0.0),
])
img_added = st.augment_image(img_added)
img_added_masked = img_added * mask_added[:, :, np.newaxis]
# # Augment masks
# img_added_masked, mask_added = self.translate_mask(img_added_masked, mask_added, \
# row_shift=randint(-MAX_SHIFT_ROW, MAX_SHIFT_ROW), \
# col_shift=randint(-MAX_SHIFT_COL, MAX_SHIFT_COL))
# img_added_masked, mask_added = self.rotate_mask(img_added_masked, mask_added, \
# angle=randint(-180,180,1), center=None, \
# scale=np.random.uniform(0.9, 1.1))
# img_added_masked, mask_added = self.perturb_intensity(img_added_masked, mask_added, scale=np.random.uniform(0.9,1.1))
# Apply masks
img_overlayed[np.where(
mask_added == 1)] = img_added_masked[np.where(mask_added == 1)]
for j in range(mask_overlayed.shape[-1]):
mask_overlayed[:, :, j] *= np.logical_not(mask_added)
mask_overlayed = np.concatenate([mask_overlayed, \
mask_added[:, :, np.newaxis]], axis=2)
# Save image and mask
if i > 0: connector = '_'
else: connector = ''
if file_base.endswith('.jpg'):
save_name += connector + file_added.split('.jpg')[0]
else:
save_name += connector + file_added.split('.png')[0]
# if same overlay combo exists, assign unique suffix
save_name += '-0'
while os.path.exists(join(self.save_path, save_name + '.jpg')):
index = int(save_name.split('-')[-1][0])
save_name = save_name.split('-')[0] + '-' + str(index + 1)
return img_overlayed, mask_overlayed, mask_labels, save_name
