def sin2set(x,sets=3):
oper0 = iaa.Invert(0.50, per_channel=False)
oper1 = iaa.Invert(0.25, per_channel=True)
oper2 = iaa.Add((-15,15),per_channel=0.5)
#oper3 = iaa.AddToHueAndSaturation((-10))
oper4 = iaa.Multiply((0.75, 1.25), per_channel=0.5)
oper5 = iaa.GaussianBlur((0, 1.25))
oper6 = iaa.AverageBlur(k=(2, 7))
#oper7 = iaa.MedianBlur(k=(3, 5))
#oper8 = iaa.BilateralBlur(d=7,sigma_color=250,sigma_space=250)
oper9 = iaa.Emboss(alpha=(0,1.0), strength=(0,2.0))
oper10 = iaa.EdgeDetect(alpha=(0, 0.25))
oper11 = iaa.AdditiveGaussianNoise(loc=0, scale=(0.0, 0.25*255), per_channel=True)
oper12 = iaa.Dropout((0.01, 0.1), per_channel=0.5)
l0 = [oper0,oper1,oper2,oper4,oper5,oper6,oper9,oper10,oper11,oper12]
l={}
for si in range(1,sets+1):
tol=len(l0)
t=random.randint(1,tol-1)
l[si]=l0[t]
l0.pop(t)
img_aug1 = l[1].augment_image(x.reshape(32,280,3).cpu().numpy())
img_aug2 = l[2].augment_image(x.reshape(32,280,3).cpu().numpy())
img_aug3 = l[3].augment_image(x.reshape(32,280,3).cpu().numpy())
transform2 = transforms.Compose([transforms.ToTensor(), ])
x=transform2(img_aug1).unsqueeze(0)
x2=transform2(img_aug2).unsqueeze(0)
x3=transform2(img_aug3).unsqueeze(0)
x=torch.cat([x,x2],0)
x=torch.cat([x,x3],0)
#print(x.size()) #(3,3,32,280)
return x
def augment():
with open(CONFIG, "r") as file:
config = json.loads(file.read())
if config[ImageAugmentation.AUGMENT_DATA]:
matrix = np.array([[0, -1, 0], [-1, 4, -1], [0, -1, 0]])
return iaa.Sometimes(ImageAugmentation.AUG_PERCENTAGE, [
iaa.GaussianBlur(sigma=2.0),
iaa.Sequential([iaa.Affine(rotate=45),
iaa.Sharpen(alpha=1.0)]),
iaa.WithColorspace(to_colorspace="HSV",
from_colorspace="RGB",
children=iaa.WithChannels(
0, iaa.Add((10, 50)))),
iaa.AdditiveGaussianNoise(scale=0.2 * 255),
iaa.Add(50, per_channel=True),
iaa.Sharpen(alpha=0.5),
iaa.WithChannels(0, iaa.Add((10, 100))),
iaa.WithChannels(0, iaa.Affine(rotate=(0, 45))),
iaa.Noop(),
iaa.Superpixels(p_replace=0.5, n_segments=64),
iaa.Superpixels(p_replace=(0.1, 1.0), n_segments=(16, 128)),
iaa.ChangeColorspace(from_colorspace="RGB",
to_colorspace="HSV"),
iaa.WithChannels(0, iaa.Add((50, 100))),
iaa.ChangeColorspace(from_colorspace="HSV",
to_colorspace="RGB"),
iaa.Grayscale(alpha=(0.0, 1.0)),
iaa.GaussianBlur(sigma=(0.0, 3.0)),
iaa.AverageBlur(k=(2, 11)),
iaa.AverageBlur(k=((5, 11), (1, 3))),
iaa.MedianBlur(k=(3, 11)),
iaa.Convolve(matrix=matrix),
iaa.Sharpen(alpha=(0.0, 1.0), lightness=(0.75, 2.0)),
iaa.Emboss(alpha=(0.0, 1.0), strength=(0.5, 1.5)),
iaa.EdgeDetect(alpha=(0.0, 1.0)),
iaa.DirectedEdgeDetect(alpha=(0.0, 1.0), direction=(0.0, 1.0)),
iaa.Add((-40, 40)),
iaa.Add((-40, 40), per_channel=0.5),
iaa.AddElementwise((-40, 40)),
iaa.AddElementwise((-40, 40), per_channel=0.5),
iaa.AdditiveGaussianNoise(scale=(0, 0.05 * 255)),
iaa.AdditiveGaussianNoise(scale=0.05 * 255),
iaa.AdditiveGaussianNoise(scale=0.05 * 255, per_channel=0.5),
iaa.Multiply((0.5, 1.5), per_channel=0.5),
iaa.Dropout(p=(0, 0.2)),
iaa.Dropout(p=(0, 0.2), per_channel=0.5),
iaa.CoarseDropout(0.02, size_percent=0.5),
iaa.CoarseDropout((0.0, 0.05), size_percent=(0.02, 0.25)),
iaa.CoarseDropout(0.02, size_percent=0.15, per_channel=0.5),
iaa.Invert(0.25, per_channel=0.5),
iaa.Invert(0.5),
iaa.ContrastNormalization((0.5, 1.5)),
iaa.ContrastNormalization((0.5, 1.5), per_channel=0.5),
iaa.ElasticTransformation(alpha=(0, 5.0), sigma=0.25)
])
else:
return None
def chapter_augmenters_invert():
aug = iaa.Invert(0.5)
run_and_save_augseq("invert.jpg",
aug, [ia.quokka(size=(64, 64)) for _ in range(16)],
cols=8,
rows=2)
aug = iaa.Invert(0.25, per_channel=0.5)
run_and_save_augseq("invert_per_channel.jpg",
aug, [ia.quokka(size=(64, 64)) for _ in range(16)],
cols=8,
rows=2)
def apply_inver(root_dir, dir_name, base_name, img):
# if base_name.startswith("avers_"):
file_path = root_dir + "/" + dir_name + "/invert" + base_name
tf.logging.info("Processing inver ... target ${0}".format(file_path))
invert = iaa.Invert(1, )
updated_image = invert.augment_image(img)
misc.imsave(file_path, updated_image)
def augmentation_sequence_Invert(images, labels):
labels = labels.astype(np.uint8)
seq = iaa.Sequential([iaa.Invert(p=1,
per_channel=0.6)]) #, iaa.Flipud(0.8),\
#iaa.OneOf([iaa.Rotate((270, 270))]) iaa.Fliplr(0.8),
#iaa.Rotate((90, 90)) only invert in order to avoid weight issues and masks
return seq(images=images, segmentation_maps=labels)
def augmentator(images):
"""Apply data augmentation"""
augmenter = iaa.Sequential([
# Invert pixel values on 25% images
iaa.Invert(0.25, per_channel=0.5),
# Blur 30% of images
iaa.Sometimes(
.3,
iaa.OneOf([
iaa.GaussianBlur(sigma=(0.0, 3.0)),
iaa.AverageBlur(k=(2, 2)),
iaa.MedianBlur(k=(1, 3)),
]),
),
# Do embossing or sharpening
iaa.OneOf([
iaa.Sometimes(.2, iaa.Emboss(alpha=(0.0, .3),
strength=(.2, .8))),
iaa.Sometimes(
.2, iaa.Sharpen(alpha=(0.0, 1.0), lightness=(0.75, 2.0))),
]),
# Add one noise (or none)
iaa.OneOf([
iaa.Dropout((0, 0.01)),
iaa.AdditiveGaussianNoise(scale=0.01 * 255),
iaa.SaltAndPepper(0.01),
iaa.Noop(),
]),
# Convert to grayscale
iaa.Sometimes(.2, iaa.Grayscale(alpha=(0.0, 1.0))),
iaa.Sometimes(.4, iaa.LinearContrast((0.5, 1.5), per_channel=0.5)),
# iaa.PiecewiseAffine(scale=(0.005, 0.05)),
])
images = augmenter(images=images)
return images
def augmentData(self, images):
sometimes = lambda aug: iaa.Sometimes(0.5, aug)
augumenters = iaa.Sequential(
[
iaa.SomeOf(
n=(0, 4),
children=[
# iaa.Superpixe-ls(p_replace=(0.1, 1.0), n_segments=(10, 120)),
iaa.Invert(0.2, 0.5),
iaa.Add(value=(-40, 40), per_channel=0.5),
iaa.Multiply(mul=(0.5, 1.5), per_channel=0.5),
iaa.OneOf([
iaa.GaussianBlur(sigma=(0.0, 0.2)),
iaa.AverageBlur(k=(2, 9)),
iaa.MedianBlur(k=(3, 9))
]),
iaa.AdditiveGaussianNoise(scale=0.05 * 255,
per_channel=0.5),
iaa.Dropout(p=(0, 0.2), per_channel=0.5),
iaa.Grayscale(alpha=(0.0, 1.0)),
iaa.ContrastNormalization((0.5, 1.5), per_channel=0.5),
iaa.Sharpen(alpha=(0.0, 1.0), lightness=(0.75, 2.0))
],
random_order=True),
sometimes(
iaa.CropAndPad(percent=(-0.05, 0.1),
pad_mode=["constant", "edge"],
pad_cval=(0, 128)))
],
random_order=False)
augumenters = augumenters.to_deterministic() #
newDatas = augumenters.augment_images(images)
return newDatas # -> dua vao train binh thuong
def customizedImgAug(input_img):
rarely = lambda aug: iaa.Sometimes(0.1, aug)
sometimes = lambda aug: iaa.Sometimes(0.25, aug)
often = lambda aug: iaa.Sometimes(0.5, aug)
seq = iaa.Sequential([
iaa.Fliplr(0.5),
often(
iaa.Affine(
scale={
"x": (0.9, 1.1),
"y": (0.9, 1.1)
},
translate_percent={
"x": (-0.1, 0.1),
"y": (-0.12, 0)
},
rotate=(-10, 10),
shear=(-8, 8),
order=[0, 1],
cval=(0, 255),
)),
iaa.SomeOf((0, 4), [
rarely(iaa.Superpixels(p_replace=(0, 0.3), n_segments=(20, 200))),
iaa.OneOf([
iaa.GaussianBlur((0, 2.0)),
iaa.AverageBlur(k=(2, 4)),
iaa.MedianBlur(k=(3, 5)),
]),
iaa.Sharpen(alpha=(0, 0.3), lightness=(0.75, 1.5)),
iaa.Emboss(alpha=(0, 1.0), strength=(0, 0.5)),
rarely(
iaa.OneOf([
iaa.EdgeDetect(alpha=(0, 0.3)),
iaa.DirectedEdgeDetect(alpha=(0, 0.7),
direction=(0.0, 1.0)),
])),
iaa.AdditiveGaussianNoise(
loc=0, scale=(0.0, 0.05 * 255), per_channel=0.5),
iaa.OneOf([
iaa.Dropout((0.0, 0.05), per_channel=0.5),
iaa.CoarseDropout(
(0.03, 0.05), size_percent=(0.01, 0.05), per_channel=0.2),
]),
rarely(iaa.Invert(0.05, per_channel=True)),
often(iaa.Add((-40, 40), per_channel=0.5)),
iaa.Multiply((0.7, 1.3), per_channel=0.5),
iaa.ContrastNormalization((0.5, 2.0), per_channel=0.5),
iaa.Grayscale(alpha=(0.0, 1.0)),
sometimes(iaa.PiecewiseAffine(scale=(0.01, 0.03))),
sometimes(iaa.ElasticTransformation(alpha=(0.5, 1.5), sigma=0.25)),
],
random_order=True),
iaa.Fliplr(0.5),
iaa.AddToHueAndSaturation(value=(-10, 10), per_channel=True)
],
random_order=True) # apply augmenters in random order
output_img = seq.augment_image(input_img)
return output_img
def imgAug(inputImage, crop=True, flip=True, gaussianBlur=True, channelInvert=True, brightness=True, hueSat=True):
augList = []
if crop:
augList += [iaa.Crop(px=(0, 16))] # crop images from each side by 0 to 16px (randomly chosen)
if flip:
augList += [iaa.Fliplr(0.5)] # horizontally flip 50% of the images
if gaussianBlur:
augList += [iaa.GaussianBlur(sigma=(0, 3.0))] # blur images with a sigma of 0 to 3.0
if channelInvert:
augList += [iaa.Invert(0.05, per_channel=True)] # invert color channels
if brightness:
augList += [iaa.Add((-10, 10), per_channel=0.5)] # change brightness of images (by -10 to 10 of original value)
if hueSat:
augList += [iaa.AddToHueAndSaturation((-20, 20))] # change hue and saturation
seq = iaa.Sequential(augList)
# seq = iaa.Sequential([
# iaa.Crop(px=(0, 16)), # crop images from each side by 0 to 16px (randomly chosen)
# # iaa.Fliplr(0.5), # horizontally flip 50% of the images
# iaa.GaussianBlur(sigma=(0, 3.0)), # blur images with a sigma of 0 to 3.0
# iaa.Invert(0.05, per_channel=True), # invert color channels
# iaa.Add((-10, 10), per_channel=0.5), # change brightness of images (by -10 to 10 of original value)
# iaa.AddToHueAndSaturation((-20, 20)), # change hue and saturation
# ])
image_aug = seq.augment_image(inputImage)
return image_aug
def logic(self, image):
for param in self.augmentation_params:
self.augmentation_data.append([
str(param.augmentation_value),
iaa.Invert(p=param.augmentation_value).to_deterministic().
augment_image(image), param.detection_tag
])
def matsushita_aug():
return iaa.SomeOf((1, 4), [
iaa.Noop(),
iaa.Superpixels(p_replace=0.5, n_segments=64),
iaa.Add((-50, 50), per_channel=True),
iaa.Grayscale(alpha=(0.0, 1.0)),
iaa.GaussianBlur(sigma=(0.1, 1.0)),
iaa.ContrastNormalization((0.5, 2), per_channel=0.5),
iaa.AdditiveGaussianNoise(scale=0.075 * 255, per_channel=0.5),
iaa.CoarseDropout(
(0.1, 0.25), size_percent=(0.02, 0.25), per_channel=0.5),
iaa.OneOf([
iaa.Emboss(alpha=0.25),
iaa.Sharpen(alpha=0.5),
iaa.Invert(1, per_channel=1.0),
]),
iaa.Affine(scale={
'x': (0.84, 1.16),
'y': (0.84, 1.16)
},
mode=['edge', 'wrap']),
iaa.Affine(translate_percent={
'x': (-0.16, 0.16),
'y': (-0.16, 0.16)
},
mode=['edge', 'wrap']),
iaa.Affine(rotate=(-16, 16), mode=['edge', 'wrap']),
iaa.Affine(shear=(-16, 16), mode=['edge', 'wrap']),
iaa.Fliplr(1)
])
def __init__(self):
sometimes = lambda aug: iaa.Sometimes(0.3, aug)
self.aug = iaa.Sequential(iaa.SomeOf((1, 5),
[
# blur
sometimes(iaa.OneOf([iaa.GaussianBlur(sigma=(0, 1.0)),
iaa.MotionBlur(k=3)])),
# color
sometimes(iaa.AddToHueAndSaturation(value=(-10, 10), per_channel=True)),
sometimes(iaa.SigmoidContrast(gain=(3, 10), cutoff=(0.4, 0.6), per_channel=True)),
sometimes(iaa.Invert(0.25, per_channel=0.5)),
sometimes(iaa.Solarize(0.5, threshold=(32, 128))),
sometimes(iaa.Dropout2d(p=0.5)),
sometimes(iaa.Multiply((0.5, 1.5), per_channel=0.5)),
sometimes(iaa.Add((-40, 40), per_channel=0.5)),
sometimes(iaa.JpegCompression(compression=(5, 80))),
# distort
sometimes(iaa.Crop(percent=(0.01, 0.05), sample_independently=True)),
sometimes(iaa.PerspectiveTransform(scale=(0.01, 0.01))),
sometimes(iaa.Affine(scale=(0.7, 1.3), translate_percent=(-0.1, 0.1),
# rotate=(-5, 5), shear=(-5, 5),
order=[0, 1], cval=(0, 255),
mode=ia.ALL)),
sometimes(iaa.PiecewiseAffine(scale=(0.01, 0.01))),
sometimes(iaa.OneOf([iaa.Dropout(p=(0, 0.1)),
iaa.CoarseDropout(p=(0, 0.1), size_percent=(0.02, 0.25))])),
],
random_order=True),
random_order=True)
def augment_image(img_array):
"""Augment images randomly
Parameters
----------
img_array : array-like shape(N, W, H, C)
Returns
----------
img_array : array-like
Augmented images
"""
def st(aug):
return iaa.Sometimes(0.5, aug)
seq = iaa.Sequential(
[
st(iaa.Multiply(mul=(0.25, 1.50))), # Brightness
st(iaa.Crop(percent=(0, 0.1))), # Random Crop
st(iaa.Dropout((0, 0.7))), # Pixel Dropout
st(iaa.Invert(1)),
st(iaa.Affine(translate_percent=(0, 0.3),
shear=(-45, 45))), # Shear
st(iaa.Superpixels(p_replace=(0, 0.25), n_segments=100))
],
random_order=True)
# Visualize Augmentation
# idx = np.random.choice(np.arange(len(img_array)))
# seq.show_grid(img_array[idx], cols=8, rows=8)
# assert 0
return seq.augment_images(img_array)
def randomDataAugument(self, num_trans):
# 以下で定義する変換処理の内ランダムに幾つかの処理を選択
seq = iaa.SomeOf(num_trans, [
iaa.Affine(rotate=(-90, 90), order=1, mode="edge"),
iaa.Fliplr(1.0),
iaa.OneOf([
# 同じ系統の変換はどれか1つが起きるように 1つにまとめる
iaa.Affine(translate_percent={"x": (-0.125, 0.125)}, order=1, mode="edge"),
iaa.Affine(translate_percent={"y": (-0.125, 0.125)}, order=1, mode="edge")
]),
iaa.Affine(scale={"x": (0.8, 1.2), "y": (0.8, 1.2)}, order=1, mode="edge"),
iaa.OneOf([
iaa.AdditiveGaussianNoise(scale=[0.05 * 255, 0.2 * 255]),
iaa.AdditiveLaplaceNoise(scale=[0.05 * 255, 0.2 * 255]),
iaa.AdditivePoissonNoise(lam=(16.0, 48.0), per_channel=True)
]),
iaa.OneOf([
iaa.LogContrast((0.5, 1.5)),
iaa.LinearContrast((0.5, 2.0))
]),
iaa.OneOf([
iaa.GaussianBlur(sigma=(0.5, 1.0)),
iaa.Sharpen(alpha=(0, 1.0), lightness=(0.75, 1.5)),
iaa.Emboss(alpha=(0, 1.0), strength=(0, 2.0))
]),
iaa.Invert(1.0)
], random_order=True)
return seq
def augmentation_sequence(params):
if params is None:
params = dicto.load_("params.yml")
n_augmenters = params.data_augmentation.n_augmenters
return iaa.SomeOf(n_augmenters, [
iaa.Grayscale(alpha=(0.0, 1.0)),
iaa.GaussianBlur(sigma=(0.0, 3.0)),
iaa.AverageBlur(k=(2, 9)),
iaa.MedianBlur(k=(3, 9)),
iaa.Sharpen(alpha=(0.0, 1.0), lightness=(0.75, 2.0)),
iaa.Emboss(alpha=(0.0, 1.0), strength=(0.5, 1.5)),
iaa.Add((-40, 40), per_channel=0.5),
iaa.AddElementwise((-40, 40), per_channel=0.5),
iaa.AdditiveGaussianNoise(scale=0.05 * 255, per_channel=0.5),
iaa.Multiply((0.5, 1.5), per_channel=0.5),
iaa.MultiplyElementwise((0.5, 1.5), per_channel=0.5),
iaa.Dropout(p=(0, 0.2), per_channel=0.5),
iaa.CoarseDropout(0.05, size_percent=0.1),
iaa.Invert(1.0, per_channel=0.5),
iaa.ContrastNormalization((0.5, 1.5), per_channel=0.5),
iaa.ElasticTransformation(alpha=(0, 5.0), sigma=0.25),
iaa.PiecewiseAffine(scale=(0.01, 0.05)),
])
def build_seqlist ():
seq_list = [] # choose aug method here
seq_list.append(iaa.Sequential([iaa.Fliplr(1)]))
seq_list.append(iaa.Sequential([iaa.Flipud(1)]))
seq_list.append(iaa.Sequential([iaa.Crop(percent=(0, 0.1))]))
seq_list.append(iaa.Sequential([iaa.Affine(
scale={"x": (0.8, 1.2), "y": (0.8, 1.2)}, # scale images to 80-120% of their size, individually per axis
translate_percent={"x": (-0.2, 0.2), "y": (-0.2, 0.2)}, # translate by -20 to +20 percent (per axis)
rotate=(-45, 45), # rotate by -45 to +45 degrees
shear=(-16, 16), # shear by -16 to +16 degrees
order=[0, 1], # use nearest neighbour or bilinear interpolation (fast)
cval=(0, 255), # if mode is constant, use a cval between 0 and 255
mode=ia.ALL # use any of scikit-image's warping modes (see 2nd image from the top for examples)
)]))
seq_list.append(iaa.Sequential([iaa.GaussianBlur((0, 3.0))]))
seq_list.append(iaa.Sequential([iaa.Sharpen(alpha=(0, 1.0), lightness=(0.75, 1.5))]))
seq_list.append(iaa.Sequential([iaa.Emboss(alpha=(0, 1.0), strength=(0, 2.0))]))
seq_list.append(iaa.Sequential([iaa.AdditiveGaussianNoise(loc=0, scale=(0.0, 0.05*255), per_channel=0.5)]))
seq_list.append(iaa.Sequential([iaa.Dropout((0.01, 0.1), per_channel=0.5)]))
seq_list.append(iaa.Sequential([iaa.CoarseDropout((0.03, 0.15), size_percent=(0.02, 0.05), per_channel=0.2)]))
seq_list.append(iaa.Sequential([iaa.Invert(0.05, per_channel=True)]))
seq_list.append(iaa.Sequential([iaa.Add((-10, 10), per_channel=0.5)]))
seq_list.append(iaa.Sequential([iaa.Multiply((0.5, 1.5), per_channel=0.5)]))
seq_list.append(iaa.Sequential([iaa.ContrastNormalization((0.5, 2.0), per_channel=0.5)]))
seq_list.append(iaa.Sequential([iaa.Grayscale(alpha=(0.0, 1.0))]))
seq_list.append(iaa.Sequential([iaa.ElasticTransformation(alpha=(0.5, 3.5), sigma=0.25)]))
seq_list.append(iaa.Sequential([iaa.PiecewiseAffine(scale=(0.01, 0.05))]))
return seq_list
def augmentation2(image, mask):
sometimes = lambda aug: iaa.Sometimes(0.5, aug)
seq = iaa.Sequential(
[
sometimes(
iaa.CropAndPad(percent=(-0.05, 0.1),
pad_mode=ia.ALL,
pad_cval=(0, 255))),
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, 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)),
]),
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
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),
iaa.AddToHueAndSaturation(
(-20, 20)), # change hue and saturation
iaa.OneOf([
iaa.Multiply((0.5, 1.5), per_channel=0.5),
]),
iaa.Grayscale(alpha=(0.0, 1.0)),
],
random_order=True)
],
random_order=True)
image_heavy, mask_heavy = seq(images=image, segmentation_maps=mask)
return image_heavy, mask_heavy
def generateAugSeq():
sometimes = lambda aug: iaa.Sometimes(0.5, aug)
return iaa.Sequential([
sometimes(
iaa.CropAndPad(
percent=(-0.05, 0.1), pad_mode=ia.ALL, pad_cval=(0, 255))),
sometimes(
iaa.Affine(scale={
"x": (0.8, 1.2),
"y": (0.8, 1.2)
},
translate_percent={
"x": (-0.2, 0.2),
"y": (-0.2, 0.2)
},
order=[0, 1],
cval=(0, 255),
mode=ia.ALL)),
iaa.SomeOf((0, 5), [
sometimes(iaa.Superpixels(p_replace=(0, 1.0),
n_segments=(20, 200))),
iaa.OneOf([
iaa.GaussianBlur((0, 3.0)),
iaa.AverageBlur(k=(2, 7)),
iaa.MedianBlur(k=(3, 11)),
]),
iaa.Sharpen(alpha=(0, 1.0), lightness=(0.75, 1.5)),
iaa.Emboss(alpha=(0, 1.0), strength=(0, 2.0)),
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),
iaa.OneOf([
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),
]),
iaa.Invert(0.05, per_channel=True),
iaa.Add((-10, 10), per_channel=0.5),
iaa.AddToHueAndSaturation((-20, 20)),
iaa.OneOf([
iaa.Multiply((0.5, 1.5), per_channel=0.5),
iaa.FrequencyNoiseAlpha(exponent=(-4, 0),
first=iaa.Multiply(
(0.5, 1.5), per_channel=True),
second=iaa.ContrastNormalization(
(0.5, 2.0)))
]),
iaa.ContrastNormalization((0.5, 2.0), per_channel=0.5),
iaa.Grayscale(alpha=(0.0, 1.0)),
],
random_order=True)
],
random_order=True)
def augment(self):
image_paths = []
for root, dirs, files in os.walk(self.source_dir):
for name in files:
image_paths.append(os.path.join(root, name))
# loop over the input images
j = 0
for image_path in tqdm(image_paths):
# load the image, pre-process it, and store it in the data list
image = cv2.imread(image_path)
while (True):
if self.STATE == self.ORIGINAL_IMAGE:
cv2.imwrite(image_path, image)
self.increment_state()
continue
seq = iaa.Sequential([
iaa.Affine(shear=self.STATE[self.SHEAR],
cval=(255)), #Good
iaa.Invert(1),
iaa.CoarseDropout(self.STATE[self.DAMAGE],
size_percent=self.coarse_dropout), #Good
iaa.Invert(1),
#iaa.Sometimes(0.5, iaa.GaussianBlur(sigma=2.0)), #Good
#iaa.Resize({"width": (0.5, 0.75), "height": [24, 32, 40]}) #Good
])
images_aug = seq.augment_image(image)
cv2.imwrite(
os.path.split(image_path)[0] + "/Augmented" + str(j) +
"-S" + str(self.STATE[self.SHEAR]) + "-D" +
str(self.STATE[self.DAMAGE]) + ".jpeg", images_aug)
state = numpy.around(self.STATE, decimals=2)
self.STATE = [state[0], state[1]]
if (self.STATE == self.MAX_STATE):
self.STATE = list(self.MIN_STATE)
break
else:
self.increment_state()
j = j + 1
def __init__(self):
self._seq = iaa.Sequential([
iaa.Sharpen(alpha=(0, 1.0), lightness=(0.75, 1.5)),
iaa.Emboss(alpha=(0, 1.0), strength=(0, 2.0)),
iaa.AdditiveGaussianNoise(loc=0, scale=(0.0, 0.05 * 255), per_channel=0.5),
iaa.Invert(0.05, per_channel=True),
iaa.ContrastNormalization((0.5, 2.0), per_channel=0.5),
])
def main():
imgs = []
for f in os.listdir(PATH):
if not f.endswith('png'):
continue
im = cv2.imread(os.path.join(PATH, f))
imgs.append(im)
seq = iaa.Sequential([
iaa.Invert(p=1),
iaa.Affine(rotate=(-5, 5), scale=(0.5, 1.1)),
iaa.ElasticTransformation(alpha=10.0, sigma=5.0),
# iaa.SaltAndPepper(p=0.2),
iaa.Invert(p=1),
])
seq.show_grid(imgs[:1], cols=1, rows=1)
seq.show_grid(imgs[2:], cols=1, rows=1)
def augmenter_1(p=0.99):
"""Create augmenter.
Contains no coordinate transforms.
Parameters
----------
p : float
Number in [0, 1] representing the probability of a random augmentation happening.
Returns
-------
seq : iaa.Augmenter
Augmenter where each augmentation was manually inspected and makes
sense.
"""
subsubseq_1 = iaa.Multiply(mul=(0.8, 1.2))
subsubseq_2 = iaa.Sequential([iaa.Sharpen(alpha=(0, 1))])
subsubseq_3 = iaa.Sequential([iaa.EdgeDetect(alpha=(0, 0.9))])
subsubseq_4 = iaa.OneOf(
[iaa.GaussianBlur((0, 3.0)),
iaa.AverageBlur(k=(2, 7))])
subsubseq_5 = iaa.AdditiveGaussianNoise(loc=(0, 0.5), scale=(0, 0.2))
subsubseq_6 = iaa.Add((-0.3, 0.3))
subsubseq_7 = iaa.Invert(p=1)
subsubseq_8 = iaa.CoarseDropout(p=0.25, size_percent=(0.005, 0.06))
subsubseq_9 = iaa.SigmoidContrast(gain=(0.8, 1.2))
subsubseq_10 = iaa.LinearContrast(alpha=(0.8, 1.2))
subsubseq_11 = iaa.Sequential([iaa.Emboss(alpha=(0, 1))])
seq = iaa.Sometimes(
p,
iaa.OneOf([
subsubseq_1,
subsubseq_2,
subsubseq_3,
subsubseq_4,
subsubseq_5,
subsubseq_6,
subsubseq_7,
subsubseq_8,
subsubseq_9,
subsubseq_10,
subsubseq_11,
]),
)
return seq
def __init__(self):
self.aug_img_seq = iaa.Sequential(
[
# iaa.Fliplr(0.8),
# iaa.Flipud(0.8),
iaa.Invert(1.0),
# iaa.Crop(percent=0.1)
],
random_order=True)
def transform_op(transform):
if transform == 'flip_h':
seq = iaa.Sequential([
iaa.Fliplr(1),
])
elif transform == 'invert':
seq = iaa.Sequential([
iaa.Invert(1, True),
])
elif transform == 'brigth':
seq = iaa.Sequential([
iaa.Multiply(1.5, True),
])
elif transform == 'dark':
seq = iaa.Sequential([
iaa.Multiply(0.5, True),
])
elif transform == 'blur':
seq = iaa.Sequential([
iaa.GaussianBlur(0.5),
])
elif transform == 'sharp':
seq = iaa.Sequential([
iaa.Sharpen(1, 1.25),
])
elif transform == 'dark_sharp':
seq = iaa.Sequential([
iaa.Sharpen(1, 0.25),
])
elif transform == 'gauss_noise':
seq = iaa.Sequential([
iaa.AdditiveGaussianNoise(0.03, 10, True),
])
elif transform == 'dropout':
seq = iaa.Sequential([
iaa.Dropout(0.08, True),
])
elif transform == 'salt':
seq = iaa.Sequential([
iaa.Salt(0.08, True),
])
elif transform == 'salt_pepper':
seq = iaa.Sequential([
iaa.SaltAndPepper(0.08, True),
])
elif transform == 'contrast':
seq = iaa.Sequential([
iaa.ContrastNormalization(1.5, True),
])
else:
# So far it's only implemented horizontal flips
print("Sorry, only those operations listed in help are implemented. \
Check data_augmentation.py -help for further instructions")
return None
return seq
def build_augmentor(self):
self.augmentor = iaa.Sometimes(
0.5,
iaa.OneOf([
iaa.ChannelShuffle(p=1.0),
iaa.Invert(p=1.0, per_channel=True),
iaa.AddToHueAndSaturation((-45, 45), per_channel=True),
iaa.Emboss(alpha=1, strength=(0.5, 1.0))
]))
def process(l):
l = l.strip()
if not l:
return
img_path, formula = l.split(',')
formula = ' '.join(list(formula))
# check img path
if not os.path.isfile(
os.path.join(self._raw_dir_images, img_path)):
return
raw_img = Image.open(
os.path.join(self._raw_dir_images,
img_path)).convert('L')
self.resize_and_save_img(raw_img, img_path)
formulas.append((formula, img_path))
if self._use_aug:
seq = iaa.Sequential([
iaa.Invert(p=1),
sometimes(iaa.Affine(rotate=(-10, 10))),
sometimes(iaa.Affine(shear=(-10, 10))),
sometimes(iaa.Affine(scale=(0.8, 1.3))),
sometimes(
iaa.ElasticTransformation(alpha=10.0,
sigma=5.0)),
sometimes(
iaa.Affine(translate_percent={
"x": (-0.1, 0.1),
"y": (-0.2, 0.0)
})),
sometimesNoise(
iaa.AdditiveGaussianNoise(scale=0.1 * 255)),
iaa.Invert(p=1),
])
img = np.array(raw_img)
# seq.show_grid(img, cols=1, rows=1)
for i in xrange(aug_times):
image_aug = seq.augment_image(img)
image_aug = Image.fromarray(image_aug)
path = 'aug_{}_{}'.format(i, img_path)
self.resize_and_save_img(image_aug, path)
formulas.append((formula, path))
def get_ill_seq(self):
light_change = 50
seq = iaa.Sequential([
# 全局调整，含有颜色空间调整
iaa.Sometimes(
0.5,
iaa.OneOf([
iaa.WithColorspace(
to_colorspace="HSV",
from_colorspace="RGB",
children=iaa.OneOf([
iaa.WithChannels(0, iaa.Add((-5, 5))),
iaa.WithChannels(1, iaa.Add((-20, 20))),
iaa.WithChannels(
2, iaa.Add((-light_change, light_change))),
])),
iaa.Grayscale((0.2, 0.6)),
iaa.ChannelShuffle(1),
iaa.Add((-light_change, light_change)),
iaa.Multiply((0.5, 1.5)),
])),
# # dropout阴影模仿，暂时不使用，转而使用了自定义的阴影模仿
# iaa.Sometimes(0.5, iaa.OneOf([
# iaa.Alpha((0.2, 0.7), iaa.CoarseDropout(p=0.2, size_percent=(0.02, 0.005)))
# ])),
# 椒盐噪声
iaa.Sometimes(
0.5,
iaa.OneOf(
[iaa.Alpha((0.2, 0.6), iaa.SaltAndPepper((0.01, 0.03)))])),
# 图像反转
iaa.Sometimes(0.5, iaa.OneOf([
iaa.Invert(1),
])),
# 对比度调整
iaa.Sometimes(0.5,
iaa.OneOf([
iaa.ContrastNormalization((0.5, 1.5)),
])),
iaa.Sometimes(
0.5,
iaa.OneOf([
iaa.AdditiveGaussianNoise(0, (3, 6)),
iaa.AdditivePoissonNoise((3, 6)),
iaa.JpegCompression((30, 60)),
iaa.GaussianBlur(sigma=1),
iaa.AverageBlur((1, 3)),
iaa.MedianBlur((1, 3)),
])),
])
return seq
def __init__(self):
self._add_augmentation_list = [
iaa.Add((-30, 30), per_channel=True),
iaa.Add((-30, 30), per_channel=False),
iaa.AddElementwise((-30, 30), per_channel=False),
iaa.AddElementwise((-30, 30), per_channel=True),
iaa.Invert(p=0.2, per_channel=True),
iaa.Invert(p=0.2, per_channel=False),
iaa.AddToHueAndSaturation((0, 80), True),
iaa.Multiply((0.8, 1.2), per_channel=True),
iaa.Multiply((0.8, 1.2), per_channel=False),
iaa.MultiplyElementwise((0.8, 1.2), per_channel=True),
iaa.MultiplyElementwise((0.8, 1.2), per_channel=False)
]
self._blur_augmentation_list = [
iaa.GaussianBlur((2, 3)),
iaa.AverageBlur((2, 3)),
iaa.MedianBlur((3, 5)),
iaa.BilateralBlur((2, 3))
]
self._noise_augmentation_list = [
iaa.AdditiveGaussianNoise(0, (5, 20), per_channel=True),
iaa.AdditiveGaussianNoise(0, (5, 20), per_channel=False),
iaa.Dropout((0.05, 0.15), per_channel=False),
iaa.Dropout((0.05, 0.15), per_channel=True),
iaa.CoarseDropout((0.05, 0.15), size_percent=(0.65, 0.85))
]
self._other_augmentation_list = [
iaa.Sharpen((0.9, 0.11), (0.8, 1.2)),
iaa.Emboss((0.9, 0.11), (0.3, 1.6)),
iaa.EdgeDetect((0, 0.4)),
iaa.Grayscale((0, 1))
]
self.noise_list = self._add_augmentation_list +\
self._blur_augmentation_list +\
self._noise_augmentation_list +\
self._other_augmentation_list
def img_aug_seq():
# first we need switch height and width
def sometimes(aug):
return iaa.Sometimes(0.5, aug)
seq = iaa.Sequential([
iaa.AdditiveGaussianNoise(scale=(0, 20)),
iaa.SaltAndPepper(p=0.05),
sometimes(iaa.Invert(p=1)),
])
return seq
def image_augmentor(img, name_img):
seqs = [
iaa.Sequential([
iaa.SaltAndPepper(p=0.03),
]),
iaa.Sequential([
iaa.Invert(0.1, per_channel=True),
iaa.GaussianBlur(sigma=(0, 2.0))
]),
iaa.Sequential([
iaa.Fliplr(0.5),
iaa.Invert(0.05, per_channel=True),
iaa.GaussianBlur(sigma=(0, 3.0))
]),
iaa.Sequential([iaa.MotionBlur(k=5)])
]
step = 0
for seq in seqs:
images_aug = seq.augment_images(img)
imgPath = name_img + '_aug_' + str(step) + '.jpg'
cv2.imwrite(imgPath, images_aug)
step += 1
