def alpha(image , xmin1 , ymin1 , xmax1 , ymax1 , classy , img_name): global xml_list ctt = 0 if classy == 'open': for i in range(10): rotate=iaa.Affine(rotate=(-12, 12)) image_aug = rotate(image=image) for j in range(10): aug = iaa.AddToBrightness((-30, 30)) image_color= aug(image=image_aug) aug = iaa.AddToHue((-15, 15)) image_color= aug(image=image_color) ctt = ctt+1 name_changed = str(ctt)+img_name cv2.imwrite(os.path.join(fin_folder, "training" , name_changed),image_color) # ia.imshow(draw_on_image(image_aug, size=2)) value = (name_changed , 624 , 832 , 'open' , 0 , 0 , 0 , 0) xml_list.append(value) else: bbs = BoundingBoxesOnImage([ BoundingBox(x1=xmin1, x2=xmax1, y1=ymin1, y2=ymax1) ], shape=image.shape) for i in range(10): rotate=iaa.Affine(rotate=(-12, 12)) image_aug, bbs_aug = rotate(image=image, bounding_boxes=bbs) for j in range(10): r="AddToHue" aug = iaa.AddToBrightness((-30, 30)) image_color, bbs_aug = aug(image=image_aug, bounding_boxes=bbs_aug) aug = iaa.AddToHue((-15, 15)) image_color, bbs_aug = aug(image=image_color, bounding_boxes=bbs_aug) ctt = ctt+1 name_changed = str(ctt)+img_name cv2.imwrite(os.path.join(fin_folder, "training" , name_changed),image_color) # ia.imshow(bbs_aug.draw_on_image(image_color, size=2)) value = (name_changed , 624 , 832 , 'closed' , bbs_aug[0].x1 , bbs_aug[0].y1 , bbs_aug[0].x2 , bbs_aug[0].y2) xml_list.append(value)
def chapter_augmenters_blendalphahorizontallineargradient():
fn_start = "blend/blendalphahorizontallineargradient"
aug = iaa.BlendAlphaHorizontalLinearGradient(iaa.AddToHue((-100, 100)))
run_and_save_augseq(fn_start + "_hue.jpg",
aug,
[ia.quokka(size=(128, 128)) for _ in range(4 * 2)],
cols=4,
rows=2)
aug = iaa.BlendAlphaHorizontalLinearGradient(iaa.TotalDropout(1.0),
min_value=0.2,
max_value=0.8)
run_and_save_augseq(fn_start + "_total_dropout.jpg",
aug,
[ia.quokka(size=(128, 128)) for _ in range(4 * 2)],
cols=4,
rows=2)
aug = iaa.BlendAlphaHorizontalLinearGradient(iaa.AveragePooling(11),
start_at=(0.0, 1.0),
end_at=(0.0, 1.0))
run_and_save_augseq(fn_start + "_pooling.jpg",
aug,
[ia.quokka(size=(128, 128)) for _ in range(4 * 2)],
cols=4,
rows=2)
def main():
image = data.astronaut()
cv2.namedWindow("aug", cv2.WINDOW_NORMAL)
cv2.imshow("aug", image)
cv2.waitKey(TIME_PER_STEP)
# for value in cycle(np.arange(-255, 255, VAL_PER_STEP)):
for value in np.arange(-255, 255, VAL_PER_STEP):
aug = iaa.AddToHueAndSaturation(value=value)
img_aug = aug.augment_image(image)
img_aug = iaa.pad(img_aug, bottom=40)
img_aug = ia.draw_text(img_aug,
x=0,
y=img_aug.shape[0] - 38,
text="value=%d" % (value, ),
size=30)
cv2.imshow("aug", img_aug)
cv2.waitKey(TIME_PER_STEP)
images_aug = iaa.AddToHueAndSaturation(
value=(-255, 255), per_channel=True).augment_images([image] * 64)
ia.imshow(ia.draw_grid(images_aug))
image = ia.quokka_square((128, 128))
images_aug = []
images_aug.extend(iaa.AddToHue().augment_images([image] * 10))
images_aug.extend(iaa.AddToSaturation().augment_images([image] * 10))
ia.imshow(ia.draw_grid(images_aug, rows=2))
def train(model, dataset_dir, annotations_file, epochs):
from imgaug import augmenters as iaa
"""Train the mask rcnn model.
Inputs:
model: Model to train.
dataset_dir: Root directory of dataset.
epochs: Epochs to train for. If given two values, the network
heads are first trained for epochs[0] before training
the full model to epochs[1].
"""
# Training dataset
dataset_train = FoodDataset()
dataset_train.load_food(dataset_dir, 'train', annotations_file)
dataset_train.prepare()
print('[*] Training dataset:')
print(' ', 'Image Count: {}'.format(len(dataset_train.image_ids)))
print(' ', 'Class Count: {}'.format(dataset_train.num_classes))
print(' ', 'Classes:', dataset_train.class_names)
#Validation dataset
dataset_val = FoodDataset()
dataset_val.load_food(dataset_dir, 'val', annotations_file)
dataset_val.prepare()
print('[*] Validation dataset:')
print(' ', 'Image Count: {}'.format(len(dataset_val.image_ids)))
print(' ', 'Class Count: {}'.format(dataset_val.num_classes))
print(' ', 'Classes:', dataset_val.class_names)
# Input augmentations
augmentation = iaa.SomeOf(
(0, None),
[
iaa.Fliplr(0.5), # Left-right flip with probability 0.5
iaa.Flipud(0.5), # Up-down flip with probability 0.5
iaa.Add((-40, 40)), # Add delta value to brightness
iaa.LinearContrast((0.8, 1.2)), # Transform contrast
iaa.AddToSaturation((-40, 40)), # Add delta value to saturation
iaa.AddToHue((-20, 20)) # Add delta value to hue
])
# Train network heads first if two epoch values are given
if len(epochs) > 1:
print('[*] Training network heads.')
model.train(dataset_train,
dataset_val,
learning_rate=config.LEARNING_RATE,
augmentation=augmentation,
epochs=epochs[0],
layers='heads')
else:
epochs.append(epochs[0])
print('[*] Training network.')
model.train(dataset_train,
dataset_val,
learning_rate=config.LEARNING_RATE,
augmentation=augmentation,
epochs=epochs[1],
layers='all')
def __init__(self, data_root, image_shape, plus1, mode, \
use_subset=False, no_flow=False, precomputed_val=None, \
sample_length=5):
self.no_flow = no_flow
self.mode = mode
self.precomputed_val = precomputed_val
self.sample_length = sample_length
assert self.mode in ['train', 'val']
if self.precomputed_val is not None:
assert self.mode == 'val'
self.data_root = data_root
if plus1:
self.image_shape = [image_shape[0] + 1, image_shape[1] + 1]
else:
self.image_shape = list(image_shape)
setname = '{}_videos_subset.txt' if use_subset else '{}_videos.txt'
setname = setname.format(self.mode)
with open(os.path.join(self.data_root, 'frame_corr.json'), 'r') as f:
self.frame_corr = json.load(f)
with open(os.path.join(self.data_root, setname), 'r') as f:
self.samples = self.parse(f)
#self.samples = self.samples[:240]
self.dataset_length = len(self.samples)
# apply to fg, bg
self.pixel_aug = iaa.Sequential([
iaa.MultiplyHueAndSaturation(mul=iap.TruncatedNormal(
1.0, 0.2, 0.5, 1.5)), # mean, std, low, high
iaa.GammaContrast(gamma=iap.TruncatedNormal(1.0, 0.2, 0.5, 1.5)),
iaa.AddToHue(value=iap.TruncatedNormal(0.0, 0.1 * 100, -0.2 *
255, 0.2 * 255)),
])
self.jpeg_aug = iaa.Sometimes(
0.6, iaa.JpegCompression(compression=(70, 99)))
def check():
image = imageio.imread("img1.jpg")
bbs = BoundingBoxesOnImage([
BoundingBox(x1=0, x2=0, y1=0, y2=0)
], shape=image.shape)
for i in range(1):
rotate=iaa.Affine(rotate=(-12, 12))
image_aug, bbs_aug = rotate(image=image, bounding_boxes=bbs)
for j in range(1):
r="AddToHue"
aug = iaa.AddToBrightness((-30, 30))
image_aug, bbs_aug = aug(image=image_aug, bounding_boxes=bbs_aug)
aug = iaa.AddToHue((-15, 15))
image_aug, bbs_aug = aug(image=image_aug, bounding_boxes=bbs_aug)
# cv2.imwrite("a.jpg",image_aug)
print(bbs_aug[0].x1)
ia.imshow(bbs_aug.draw_on_image(image_aug, size=2))
def train(model):
"""Train the model."""
# Training dataset.
dataset_train = CustomDataset()
dataset_train.load_custom(args.dataset, "train")
dataset_train.prepare()
# Validation dataset
dataset_val = CustomDataset()
dataset_val.load_custom(args.dataset, "val")
dataset_val.prepare()
# *** This training schedule is an example. Update to your needs ***
# Since we're using a very small dataset, and starting from
# COCO trained weights, we don't need to train too long. Also,
# no need to train all layers, just the heads should do it.
augmentation = iaa.Sometimes(0.6, [
iaa.Fliplr(0.5),
iaa.Flipud(0.5),
iaa.GaussianBlur(sigma=(0.0, 5.0)),
iaa.AddToHue((-50, 50))
])
# Training - Stage 1
print("Training network heads")
model.train(
dataset_train,
dataset_val,
learning_rate=0.00001,
epochs=50,
layers='heads',
augmentation=augmentation,
)
def chapter_augmenters_addtohue():
fn_start = "color/addtohue"
aug = iaa.AddToHue((-50, 50))
run_and_save_augseq(fn_start + ".jpg",
aug, [ia.quokka(size=(128, 128)) for _ in range(8)],
cols=4,
rows=2)
def __init__(self, ):
self.augmentations = iaa.Sequential([
iaa.Dropout([0.0, 0.01]),
iaa.Sharpen((0.0, 0.1)),
iaa.Affine(rotate=(-10, 10), translate_percent=(-0.1,0.1)), # rotate by -45 to 45 degrees (affects segmaps)
iaa.AddToBrightness((-10, 10)),
iaa.AddToHue((-5, 5)),
iaa.Fliplr(0.5),
])
def __init__(self, ):
self.augmentations = iaa.Sequential([
iaa.Dropout([0.0, 0.01]), # 随机去掉一些像素点, 即把这些像素点变成0。
iaa.Sharpen((0.0, 0.2)), # 锐化
iaa.Affine(rotate=(-20, 20), translate_percent=(-0.2,0.2)), # rotate by -45 to 45 degrees (affects segmaps)
iaa.AddToBrightness((-30, 30)), # change brightness of images
iaa.AddToHue((-20, 20)), # 为图像的色调添加随机值。
iaa.Fliplr(0.5), # 水平镜面翻转。
], random_order=True)
def train(model):
"""Train the model."""
# Training dataset.
dataset_train = CustomDataset()
dataset_train.load_custom(args.dataset, "train")
dataset_train.prepare()
# Validation dataset
dataset_val = CustomDataset()
dataset_val.load_custom(args.dataset, "val")
dataset_val.prepare()
# augmentation settings
augmentation = iaa.Sometimes(0.6, [
iaa.Fliplr(0.5),
iaa.Flipud(0.5),
iaa.GaussianBlur(sigma=(0.0, 5.0)),
iaa.AddToHue((-50, 50))
])
# Training - Stage 1
# print("Training network heads")
# model.train(dataset_train, dataset_val,
# learning_rate=0.0001,
# epochs=20,
# layers='heads',
# augmentation=augmentation,
# custom_callbacks=[keras.callbacks.EarlyStopping(
# monitor='val_loss', mode='min', verbose=1, patience=6)]
# )
# # # # Training - Stage 2
# # # # Finetune layers from ResNet stage 4 and up
# print("Fine tune Resnet stage 4 and up")
# model.train(dataset_train, dataset_val,
# learning_rate=0.0001,
# epochs=30,
# layers='4+',
# custom_callbacks=[keras.callbacks.EarlyStopping(monitor='val_loss', mode='min',
# verbose=1, patience=6)]
# )
# # # # Training - Stage 3
# # # # Fine tune all layers
# print("Fine tune all layers")
# model.train(dataset_train, dataset_val,
# learning_rate=0.0001 / 10,
# epochs=40,
# layers='all',
# custom_callbacks=[keras.callbacks.EarlyStopping(monitor='val_loss', mode='min',
# verbose=1, patience=6)]
# )
model.train(dataset_train, dataset_val,
learning_rate=config.LEARNING_RATE,
epochs=100,
augmentation=augmentation,
layers='heads')
def __init__(self, ):
self.augmentations = iaa.Sequential([
iaa.Sharpen((0.0, 0.1)),
iaa.Affine(rotate=(-0, 0),
translate_percent=(-0.1, 0.1),
scale=(0.8, 1.5)),
iaa.AddToBrightness((-60, 40)),
iaa.AddToHue((-10, 10)),
iaa.Fliplr(0.5),
])
def chapter_augmenters_blendalphacheckerboard():
fn_start = "blend/blendalphacheckerboard"
aug = iaa.BlendAlphaCheckerboard(nb_rows=2,
nb_cols=(1, 4),
foreground=iaa.AddToHue((-100, 100)))
run_and_save_augseq(fn_start + "_hue.jpg",
aug,
[ia.quokka(size=(200, 200)) for _ in range(3 * 4)],
cols=3,
rows=4)
def __init__(self, ):
self.augmentations = iaa.Sequential(
[
iaa.Dropout([0.0, 0.01]),
iaa.Sharpen((0.0, 0.2)),
iaa.Affine(rotate=(-20, 20), translate_percent=(
-0.2,
0.2)), # rotate by -45 to 45 degrees (affects segmaps)
iaa.AddToBrightness((-30, 30)),
iaa.AddToHue((-20, 20)),
iaa.Fliplr(0.5),
],
random_order=True)
def chapter_augmenters_blendalphasegmapclassids():
fn_start = "blend/blendalphasegmapclassids"
aug = iaa.BlendAlphaSegMapClassIds([1, 3],
foreground=iaa.AddToHue((-100, 100)))
batch = ia.Batch(
images=[ia.quokka(size=(128, 128))] * (4 * 2),
segmentation_maps=[ia.quokka_segmentation_map(size=(128, 128))] *
(4 * 2))
run_and_save_augseq_batch(fn_start + "_hue.jpg",
aug,
batch,
cols=4,
rows=2)
def apply_augmentation(img):
'''
apply augmentation for TFRecords
Parameters
----------
img : numpy array N dimensional
an MxNxD array that contains the image
Returns
-------
img : numpy array
an MxNxD array that contains the augmented image
'''
sometimes = lambda aug: iaa.Sometimes(0.5, aug)
# channel invariant augmentations
seq = iaa.Sequential([
iaa.Fliplr(0.5), # horizontally flip 50% of the images
iaa.Flipud(0.5),
sometimes(iaa.Rot90((1, 3)))
], random_order=True)
# RGB dependent augmentations
seq2 = sometimes(
iaa.SomeOf((1,4),[
iaa.AddToHue((-8,8)),
iaa.AddToSaturation((-10,10)),
iaa.Multiply((0.90, 1.25)),
iaa.LinearContrast((0.90, 1.3))
], random_order=True)
)
img = seq(image=img)
img2 = np.array(img[:,:,0:3] * 255, dtype=np.uint8)
img2 = seq2(image=img2)
img2 = np.array(img2/255, dtype=np.float32)
img[:,:,0:3] = img2
#print(img)
return img
def chapter_augmenters_blendalphaelementwise():
fn_start = "blend/blendalphaelementwise"
aug_cls = iaa.AlphaElementwise
aug = aug_cls(0.5, iaa.Grayscale(1.0))
run_and_save_augseq(fn_start + "_050_grayscale.jpg",
aug, [ia.quokka(size=(128, 128)) for _ in range(4)],
cols=4,
rows=1)
aug = aug_cls((0.0, 1.0), iaa.AddToHue(100))
run_and_save_augseq(fn_start + "_uniform_factor.jpg",
aug, [ia.quokka(size=(512, 512)) for _ in range(1)],
cols=1,
rows=1)
aug = aug_cls((0.0, 1.0), iaa.Affine(rotate=(-20, 20)), per_channel=0.5)
run_and_save_augseq(fn_start + "_affine_per_channel.jpg",
aug,
[ia.quokka(size=(128, 128)) for _ in range(4 * 2)],
cols=4,
rows=2)
aug = aug_cls((0.0, 1.0), first=iaa.Add(100), second=iaa.Multiply(0.2))
run_and_save_augseq(fn_start + "_two_branches.jpg",
aug,
[ia.quokka(size=(128, 128)) for _ in range(4 * 2)],
cols=4,
rows=2)
aug = aug_cls([0.25, 0.75], iaa.MedianBlur(13))
run_and_save_augseq(fn_start + "_with_choice.jpg",
aug,
[ia.quokka(size=(128, 128)) for _ in range(4 * 2)],
cols=4,
rows=2)
def __init__(self,
data_root,
image_shape=(256, 256),
isTrain=True,
silence=False):
self.silence = silence
self.data_root = data_root
self.is_train = isTrain
self.image_shape = (image_shape[0], image_shape[1])
if isTrain:
fg_set_file_path = os.path.join(data_root, 'fg_train_set.txt')
bg_set_file_path = os.path.join(data_root, 'bg_train_set.txt')
else:
fg_set_file_path = os.path.join(data_root, 'fg_val_set.txt')
bg_set_file_path = os.path.join(data_root, 'bg_val_set.txt')
fg_file = open(fg_set_file_path, 'r')
bg_file = open(bg_set_file_path, 'r')
self.fg_list = []
self.bg_list = []
self.alpha_list = []
for line in fg_file:
line = line.strip()
fg_path, alpha_path = line.split(' ')
self.fg_list.append(fg_path)
self.alpha_list.append(alpha_path)
for line in bg_file:
bg_path = line.strip()
self.bg_list.append(bg_path)
self.num_fg = len(self.fg_list)
self.num_bg = len(self.bg_list)
if not isTrain:
assert self.num_fg == self.num_bg, "len(fg_list) must equal to len(bg_list) in eval mode. {}!={}".format(
len(self.fg_list), len(self.bg_list))
sometimes = lambda aug: iaa.Sometimes(0.3, aug)
# apply to fg, bg
self.color_aug = iaa.Sequential([
iaa.MultiplyHueAndSaturation(mul=iap.TruncatedNormal(
1.0, 0.2, 0.5, 1.5)), # mean, std, low, high
iaa.GammaContrast(gamma=iap.TruncatedNormal(1.0, 0.2, 0.5, 1.5)),
iaa.AddToHue(value=iap.TruncatedNormal(0.0, 0.1 * 100, -0.2 *
255, 0.2 * 255))
])
# apply to compose
self.compose_shape_aug = iaa.Sequential([
iaa.Fliplr(0.5),
# iaa.OneOf([
# iaa.Resize({"height":480, "width": "keep-aspect-ratio"}),
# iaa.Resize({"height":640, "width": "keep-aspect-ratio"}),
# # iaa.Resize({"height": 800, "width": "keep-aspect-ratio"})
# ]),
# iaa.Resize(size=(512, 512)),
iaa.OneOf([
# iaa.CropToFixedSize(width=256, height=256),
iaa.CropToFixedSize(width=384, height=384),
iaa.CropToFixedSize(width=480, height=480),
iaa.CropToFixedSize(width=512, height=512),
iaa.CropToFixedSize(width=640, height=640),
iaa.CropToFixedSize(width=800, height=800)
]),
sometimes(
iaa.PadToFixedSize(width=512,
height=512,
pad_mode="constant",
pad_cval=0)), # TODO:
iaa.Resize({
"height": self.image_shape[0],
"width": self.image_shape[1]
})
])
self.fg_simple_aug = iaa.Sequential([iaa.Fliplr(0.5)])
self.bg_aug = iaa.Sequential([
iaa.CropToFixedSize(width=self.image_shape[1],
height=self.image_shape[0]),
# iaa.OneOf([
# # iaa.CropToFixedSize(width=256, height=256),
# iaa.CropToFixedSize(width=384, height=384),
# iaa.CropToFixedSize(width=self.image_shape[1], height=self.image_shape[0]),
# iaa.CropToFixedSize(width=480, height=480),
# iaa.CropToFixedSize(width=512, height=512),
# # iaa.CropToFixedSize(width=640, height=640),
# ]),
iaa.Resize({
"height": self.image_shape[0],
"width": self.image_shape[1]
}),
iaa.GammaContrast(gamma=iap.TruncatedNormal(1.0, 0.3, 0.5, 1.5)),
iaa.MultiplySaturation(
mul=iap.TruncatedNormal(1.0, 0.3, 0.5, 1.5)),
# iaa.GaussianBlur(sigma=(0.0, 1.5)),
iaa.Fliplr(0.5),
])
self.scale_down = iaa.Sequential([
iaa.Resize(0.8),
iaa.PadToFixedSize(width=self.image_shape[1],
height=self.image_shape[0],
pad_mode='constant',
pad_cval=0)
])
def __init__(self):
imgaug_hue_param = int(0.5 * 255)
self.imgaug_transform = iaa.AddToHue(
(imgaug_hue_param, imgaug_hue_param))
# start_at=(0.0, 0.4), end_at=(0.0, 0.4))
# aug36 = iaa.BlendAlpha(
# (0.0, 0.3),
# iaa.Affine(rotate=(0, 0)),
# per_channel=0.3)
aug38 = iaa.WithColorspace(
to_colorspace="HSV",
from_colorspace="RGB",
children=iaa.WithChannels(0,iaa.Add((0, 50))))
aug40 = iaa.WithHueAndSaturation(
iaa.WithChannels(0, iaa.Add((0, 50))))
aug41 = iaa.MultiplyHueAndSaturation((0.5, 1.9), per_channel=True)
aug42 = iaa.AddToHueAndSaturation((-50, 50), per_channel=True)
aug43 = iaa.AddToHue((-50, 50))
aug44 = iaa.AddToSaturation((-50, 50))
aug45 = iaa.Sequential([
iaa.ChangeColorspace(from_colorspace="RGB", to_colorspace="HSV"),
iaa.WithChannels(0, iaa.Add((50, 100))),
iaa.ChangeColorspace(from_colorspace="HSV", to_colorspace="RGB")])
aug46 = iaa.Grayscale(alpha=(0.0, 1.0))
aug47 = iaa.ChangeColorTemperature((1100, 10000))
aug49 = iaa.UniformColorQuantization()
aug50 = iaa.UniformColorQuantizationToNBits()
aug51 = iaa.GammaContrast((0.5, 2.0), per_channel=True)
aug52 = iaa.SigmoidContrast(gain=(3, 10), cutoff=(0.4, 0.6), per_channel=True)
aug53 = iaa.LogContrast(gain=(0.6, 1.4), per_channel=True)
aug54 = iaa.LinearContrast((0.4, 1.6), per_channel=True)
# aug55 = iaa.AllChannelsCLAHE(clip_limit=(1, 10), per_channel=True)
def test_returns_correct_class(self):
aug = iaa.AddToHue((-20, 20))
assert isinstance(aug, iaa.AddToHueAndSaturation)
assert isinstance(aug.value_hue, iap.DiscreteUniform)
assert aug.value_hue.a.value == -20
assert aug.value_hue.b.value == 20
foreground=iaa.Multiply(0.0))
transformed_image = transform(image=image)
elif augmentation == 'blend_alpha_mask':
transform = iaa.BlendAlphaMask(iaa.InvertMaskGen(0.5,
iaa.VerticalLinearGradientMaskGen()),
iaa.Clouds())
transformed_image = transform(image=image)
elif augmentation == 'blend_alpha_elementwise':
transform = iaa.BlendAlphaElementwise(0.5, iaa.Grayscale(1.0))
transformed_image = transform(image=image)
elif augmentation == 'blend_alpha_vlg':
transform = iaa.BlendAlphaVerticalLinearGradient(
iaa.AddToHue((-100, 100)))
transformed_image = transform(image=image)
elif augmentation == 'blend_alpha_hlg':
transform = iaa.BlendAlphaHorizontalLinearGradient(
iaa.AddToHue((-100, 100)))
transformed_image = transform(image=image)
## Blur
elif augmentation == 'blur':
transform = Blur(always_apply=True)
transformed_image = transform(image=image)['image']
elif augmentation == 'gaussian_blur':
transform = GaussianBlur(always_apply=True)
def __init__(self):
self.seq = iaa.Sequential(
[
iaa.Fliplr(0.5),
iaa.Sometimes(0.5, iaa.Crop(percent=(0, 0.1))),
iaa.Sometimes(0.5, iaa.Affine(
rotate=(-20, 20), # 旋转±20度
# shear=(-16, 16), # 剪切变换±16度，矩形变平行四边形
# order=[0, 1], # 使用最近邻插值 或 双线性插值
cval=0, # 填充值
mode=ia.ALL # 定义填充图像外区域的方法
)),
# 使用0~3个方法进行图像增强
iaa.SomeOf((0, 3),
[
iaa.Sometimes(0.8, iaa.OneOf([
iaa.GaussianBlur((0, 2.0)), # 高斯模糊
iaa.AverageBlur(k=(1, 5)), # 平均模糊，磨砂
])),
# 要么运动，要么美颜
iaa.Sometimes(0.8, iaa.OneOf([
iaa.MotionBlur(k=(3, 11)), # 运动模糊
iaa.BilateralBlur(d=(1, 5),
sigma_color=(10, 250),
sigma_space=(10, 250)), # 双边滤波，美颜
])),
# 模仿雪花
iaa.Sometimes(0.8, iaa.OneOf([
iaa.SaltAndPepper(p=(0., 0.03)),
iaa.AdditiveGaussianNoise(loc=0, scale=(0., 0.05 * 255), per_channel=False)
])),
# 对比度
iaa.Sometimes(0.8, iaa.LinearContrast((0.6, 1.4), per_channel=0.5)),
# 锐化
iaa.Sometimes(0.8, iaa.Sharpen(alpha=(0, 1.0), lightness=(0.75, 1.5))),
# 整体亮度
iaa.Sometimes(0.8, iaa.OneOf([
# 加性调整
iaa.AddToBrightness((-30, 30)),
# 线性调整
iaa.MultiplyBrightness((0.5, 1.5)),
# 加性 & 线性
iaa.MultiplyAndAddToBrightness(mul=(0.5, 1.5), add=(-30, 30)),
])),
# 饱和度
iaa.Sometimes(0.8, iaa.OneOf([
iaa.AddToSaturation((-75, 75)),
iaa.MultiplySaturation((0., 3.)),
])),
# 色相
iaa.Sometimes(0.8, iaa.OneOf([
iaa.AddToHue((-255, 255)),
iaa.MultiplyHue((-3.0, 3.0)),
])),
# 云雾
# iaa.Sometimes(0.3, iaa.Clouds()),
# 卡通化
# iaa.Sometimes(0.01, iaa.Cartoon()),
],
random_order=True
)
],
random_order=True
)
image, image, image, image, image, image, image, image, image, image,
image, image, image, image, image, image, image, image, image, image,
image, image, image, image, image, image, image, image, image, image,
image, image, image, image, image, image, image, image, image, image,
image, image, image, image, image, image, image, image, image
]
sometimes = lambda aug: iaa.Sometimes(0.5, aug)
seq = iaa.Sequential([
iaa.SomeOf((3, 4), [
iaa.Add((-40, 40), per_channel=0.5),
iaa.Multiply((0.5, 1.5), per_channel=0.5),
iaa.Multiply((0.5, 1)),
iaa.JpegCompression(compression=(70, 99)),
iaa.BlendAlphaHorizontalLinearGradient(iaa.AddToHue((-100, 100))),
iaa.BlendAlphaCheckerboard(nb_rows=2,
nb_cols=(1, 4),
foreground=iaa.AddToHue((-100, 100))),
iaa.GaussianBlur(sigma=(0.0, 1.0)),
iaa.AddToHueAndSaturation((-50, 50), per_channel=True),
iaa.GammaContrast((0.5, 2.0), per_channel=True),
iaa.Affine(rotate=(-15, 15)),
iaa.Affine(
translate_percent={"x": -0.20}, mode=ia.ALL, cval=(0, 255)),
iaa.Affine(
translate_percent={"y": -0.20}, mode=ia.ALL, cval=(0, 255)),
iaa.Affine(
translate_percent={"x": +0.20}, mode=ia.ALL, cval=(0, 255)),
iaa.Affine(
translate_percent={"y": +0.20}, mode=ia.ALL, cval=(0, 255)),
def __init__(self,
data_root,
image_shape=None,
min_shape=None,
val_mode=None,
plus1=True,
isTrain=True):
'''
We assume that image_shape is always an even number.
With plus1 = True, we'll modify image_shape to odd.
'''
self.data_root = data_root
if isTrain:
assert image_shape is not None
self.image_shape = image_shape
else:
assert min_shape is not None
self.image_shape = (min_shape, min_shape)
self.isTrain = isTrain
self.val_mode = val_mode
if plus1:
self.image_shape = (image_shape[0] + 1, image_shape[1] + 1)
if isTrain:
bg_set_fn = [
i.strip()
for i in open(os.path.join(data_root, 'bg_train_set.txt'), 'r')
]
fg_set = [
i.strip() for i in open(
os.path.join(data_root, 'fg_train_set_old.txt'), 'r')
]
fg_set_fn = [None] * len(bg_set_fn)
for i in range(len(bg_set_fn)):
fg_set_fn[i] = fg_set[i // 100]
else:
bg_set_fn = [
i.strip()
for i in open(os.path.join(data_root, 'bg_val_set.txt'), 'r')
] #[60:]
fg_set_fn = [
i.strip()
for i in open(os.path.join(data_root, 'fg_val_set.txt'), 'r')
] #[60:]
self.dataset_length = len(bg_set_fn)
assert len(fg_set_fn) == self.dataset_length
#ratio = self.dataset_length // len(fg_set_fn)
self.sample_fn = [None] * self.dataset_length
for i in range(self.dataset_length):
_fn = fg_set_fn[i].split(' ')
self.sample_fn[i] = (_fn[0], _fn[1], bg_set_fn[i])
# apply to fg, bg
self.flip_and_color_aug = iaa.Sequential([
iaa.MultiplyHueAndSaturation(mul=iap.TruncatedNormal(
1.0, 0.2, 0.5, 1.5)), # mean, std, low, high
iaa.GammaContrast(gamma=iap.TruncatedNormal(1.0, 0.2, 0.5, 1.5)),
iaa.AddToHue(value=iap.TruncatedNormal(0.0, 0.1 * 100, -0.2 *
255, 0.2 * 255))
])
if isTrain:
self.min_shape = min_shape
self.preshape_aug = iaa.Sequential([
iaa.CropToFixedSize(width=self.min_shape, height=self.min_shape, \
position='uniform' if isTrain else 'center'),
])
else:
assert self.val_mode in ['gca', 'dim', 'origin', 'resize']
if self.val_mode == 'resize':
assert min_shape is not None
self.min_shape = min_shape
elif self.val_mode == 'origin':
print('Warning: val_mode == origin, change min_shape to 2112')
self.min_shape = 2112
self.image_shape = (2112, 2112)
self.shape_aug = iaa.Sequential([
iaa.Fliplr(0.5),
iaa.OneOf([
# iaa.CropToFixedSize(width=384, height=384),
# iaa.CropToFixedSize(width=448, height=448),
iaa.CropToFixedSize(width=512, height=512),
iaa.CropToFixedSize(width=576, height=576),
iaa.CropToFixedSize(width=640, height=640),
iaa.CropToFixedSize(width=704, height=704),
iaa.CropToFixedSize(width=768, height=768)
]),
]) if isTrain else \
iaa.Sequential([
iaa.CropToFixedSize(width=self.image_shape[1], \
height=self.image_shape[0], \
position='uniform' if isTrain else 'center'),
])
], random_order=True)
''' Noisy Data Aug'''
seq_2 = iaa.Sequential(
[
iaa.OneOf(
[
# Blur each image using a median over neihbourhoods that have a random size between 3x3 and 7x7
sometimes(iaa.MedianBlur(k=(3, 7))),
# blur images using gaussian kernels with random value (sigma) from the interval [a, b]
sometimes(iaa.GaussianBlur(sigma=(0.0, 1.0))),
sometimes(iaa.AdditiveGaussianNoise(loc=0, scale=(0.0, 0.05 * 255), per_channel=0.5))
]
),
iaa.Sequential(
[
sometimes(iaa.AddToHue((-8, 8))),
sometimes(iaa.AddToSaturation((-20, 20))),
sometimes(iaa.AddToBrightness((-26, 26))),
sometimes(iaa.Lambda(func_images = add_to_contrast))
], random_order=True)
], random_order=True)
#%%
for p in range(iterations): # how many times to apply random augmentations
for idx in trange(len(img_path), desc='Augumenting Dataset (iteration {}of{})'.format(p+1, iterations)):
img = cv2.imread(img_path[idx])
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
filepath = xml_path[idx]
full_dict = xmltodict.parse(open( filepath , 'rb' ))
'''
aug_colorTemperature = iaa.ChangeColorTemperature((1100, 10000))
'''
Convert each image to a colorspace with a brightness-related channel, extract
that channel, multiply it by a factor between 0.5 and 1.5, add a value between
-30 and 30 and convert back to the original colorspace
'''
aug_brightness = iaa.MultiplyAndAddToBrightness(mul=(0.5, 1.5), add=(-30, 30))
'''
Multiply the hue and saturation of images by random values;
Sample random values from the discrete uniform range [-50..50],and add them
'''
aug_hueSaturation = [
iaa.MultiplyHue((0.5, 1.5)),
iaa.MultiplySaturation((0.5, 1.5)),
iaa.AddToHue((-50, 50)),
iaa.AddToSaturation((-50, 50))
]
'''
Increase each pixel’s R-value (redness) by 10 to 100
'''
aug_redChannels = iaa.WithChannels(0, iaa.Add((10, 100)))
### add the augmenters ###
seq = iaa.Sequential([
## 0.5 is the probability, horizontally flip 50% of the images
iaa.Fliplr(0.5),
#iaa.Flipud(0.5),
## crop images from each side by 0 to 16px(randomly chosen)
#iaa.Crop(percent=(0, 0.1)),
#iaa.LinearContrast((0.75, 1.5)),
def __init__(self, rgb_mean, randomImg, insize):
sometimes = lambda aug: iaa.Sometimes(0.7, aug)
self.rand_img_dir = randomImg
self.rgb_mean = rgb_mean
self.inp_dim = insize
#
self.randomImgList = glob.glob( randomImg + '*.jpg')
self.aug = iaa.Sequential([
sometimes(iaa.Affine(
scale={"x": (0.8, 1.2), "y": (0.8, 1.2)}, # scale images to 80-120% of their size, individually per axis
translate_percent={"x": (-0.1, 0.1), "y": (-0.1, 0.1)}, # translate by -20 to +20 percent (per axis)
rotate=(-25, 25), # rotate by -45 to +45 degrees
shear=(-6, 6), # 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)
)),
iaa.OneOf([
iaa.Fliplr(0.5),
iaa.GaussianBlur(
sigma=iap.Uniform(0.0, 1.0)
),
iaa.BlendAlphaSimplexNoise(
foreground=iaa.BlendAlphaSimplexNoise(
foreground=iaa.EdgeDetect(1.0),
background=iaa.LinearContrast((0.1, .8)),
per_channel=True
),
background=iaa.BlendAlphaFrequencyNoise(
exponent=(-.5, -.1),
foreground=iaa.Affine(
rotate=(-10, 10),
translate_px={"x": (-1, 1), "y": (-1, 1)}
),
# background=iaa.AddToHueAndSaturation((-4, 4)),
# per_channel=True
),
per_channel=True,
aggregation_method="max",
sigmoid=False
),
iaa.BlendAlpha(
factor=(0.2, 0.8),
foreground=iaa.Sharpen(1.0, lightness=2),
background=iaa.CoarseDropout(p=0.1, size_px=8)
),
iaa.BlendAlpha(
factor=(0.2, 0.8),
foreground=iaa.Affine(rotate=(-5, 5)),
per_channel=True
),
iaa.MotionBlur(k=15, angle=[-5, 5]),
iaa.BlendAlphaCheckerboard(nb_rows=2, nb_cols=(1, 4),
foreground=iaa.AddToHue((-10, 10))),
iaa.BlendAlphaElementwise((0, 1.0), iaa.AddToHue(10)),
iaa.BilateralBlur(
d=(3, 10), sigma_color=(1, 5), sigma_space=(1, 5)),
iaa.AdditiveGaussianNoise(scale=0.02 * 255),
iaa.AddElementwise((-5, 5), per_channel=0.5),
iaa.AdditiveLaplaceNoise(scale=0.01 * 255),
iaa.AdditivePoissonNoise(20),
iaa.Cutout(fill_mode="gaussian", fill_per_channel=True),
iaa.CoarseDropout(0.02, size_percent=0.1),
iaa.SaltAndPepper(0.1, per_channel=True),
iaa.JpegCompression(compression=(70, 99)),
iaa.ImpulseNoise(0.02),
iaa.Dropout(p=(0, 0.04)),
iaa.Sharpen(alpha=0.1),
]) # oneof
])
def create_augmenters(height, width, height_augmentable, width_augmentable,
only_augmenters):
def lambda_func_images(images, random_state, parents, hooks):
return images
def lambda_func_heatmaps(heatmaps, random_state, parents, hooks):
return heatmaps
def lambda_func_keypoints(keypoints, random_state, parents, hooks):
return keypoints
def assertlambda_func_images(images, random_state, parents, hooks):
return True
def assertlambda_func_heatmaps(heatmaps, random_state, parents, hooks):
return True
def assertlambda_func_keypoints(keypoints, random_state, parents, hooks):
return True
augmenters_meta = [
iaa.Sequential([iaa.Noop(), iaa.Noop()],
random_order=False,
name="Sequential_2xNoop"),
iaa.Sequential([iaa.Noop(), iaa.Noop()],
random_order=True,
name="Sequential_2xNoop_random_order"),
iaa.SomeOf((1, 3),
[iaa.Noop(), iaa.Noop(), iaa.Noop()],
random_order=False,
name="SomeOf_3xNoop"),
iaa.SomeOf((1, 3),
[iaa.Noop(), iaa.Noop(), iaa.Noop()],
random_order=True,
name="SomeOf_3xNoop_random_order"),
iaa.OneOf([iaa.Noop(), iaa.Noop(), iaa.Noop()], name="OneOf_3xNoop"),
iaa.Sometimes(0.5, iaa.Noop(), name="Sometimes_Noop"),
iaa.WithChannels([1, 2], iaa.Noop(), name="WithChannels_1_and_2_Noop"),
iaa.Noop(name="Noop"),
iaa.Lambda(func_images=lambda_func_images,
func_heatmaps=lambda_func_heatmaps,
func_keypoints=lambda_func_keypoints,
name="Lambda"),
iaa.AssertLambda(func_images=assertlambda_func_images,
func_heatmaps=assertlambda_func_heatmaps,
func_keypoints=assertlambda_func_keypoints,
name="AssertLambda"),
iaa.AssertShape((None, height_augmentable, width_augmentable, None),
name="AssertShape"),
iaa.ChannelShuffle(0.5, name="ChannelShuffle")
]
augmenters_arithmetic = [
iaa.Add((-10, 10), name="Add"),
iaa.AddElementwise((-10, 10), name="AddElementwise"),
#iaa.AddElementwise((-500, 500), name="AddElementwise"),
iaa.AdditiveGaussianNoise(scale=(5, 10), name="AdditiveGaussianNoise"),
iaa.AdditiveLaplaceNoise(scale=(5, 10), name="AdditiveLaplaceNoise"),
iaa.AdditivePoissonNoise(lam=(1, 5), name="AdditivePoissonNoise"),
iaa.Multiply((0.5, 1.5), name="Multiply"),
iaa.MultiplyElementwise((0.5, 1.5), name="MultiplyElementwise"),
iaa.Dropout((0.01, 0.05), name="Dropout"),
iaa.CoarseDropout((0.01, 0.05),
size_percent=(0.01, 0.1),
name="CoarseDropout"),
iaa.ReplaceElementwise((0.01, 0.05), (0, 255),
name="ReplaceElementwise"),
#iaa.ReplaceElementwise((0.95, 0.99), (0, 255), name="ReplaceElementwise"),
iaa.SaltAndPepper((0.01, 0.05), name="SaltAndPepper"),
iaa.ImpulseNoise((0.01, 0.05), name="ImpulseNoise"),
iaa.CoarseSaltAndPepper((0.01, 0.05),
size_percent=(0.01, 0.1),
name="CoarseSaltAndPepper"),
iaa.Salt((0.01, 0.05), name="Salt"),
iaa.CoarseSalt((0.01, 0.05),
size_percent=(0.01, 0.1),
name="CoarseSalt"),
iaa.Pepper((0.01, 0.05), name="Pepper"),
iaa.CoarsePepper((0.01, 0.05),
size_percent=(0.01, 0.1),
name="CoarsePepper"),
iaa.Invert(0.1, name="Invert"),
# ContrastNormalization
iaa.JpegCompression((50, 99), name="JpegCompression")
]
augmenters_blend = [
iaa.Alpha((0.01, 0.99), iaa.Noop(), name="Alpha"),
iaa.AlphaElementwise((0.01, 0.99), iaa.Noop(),
name="AlphaElementwise"),
iaa.SimplexNoiseAlpha(iaa.Noop(), name="SimplexNoiseAlpha"),
iaa.FrequencyNoiseAlpha((-2.0, 2.0),
iaa.Noop(),
name="FrequencyNoiseAlpha")
]
augmenters_blur = [
iaa.GaussianBlur(sigma=(1.0, 5.0), name="GaussianBlur"),
iaa.AverageBlur(k=(3, 11), name="AverageBlur"),
iaa.MedianBlur(k=(3, 11), name="MedianBlur"),
iaa.BilateralBlur(d=(3, 11), name="BilateralBlur"),
iaa.MotionBlur(k=(3, 11), name="MotionBlur")
]
augmenters_color = [
# InColorspace (deprecated)
iaa.WithColorspace(to_colorspace="HSV",
children=iaa.Noop(),
name="WithColorspace"),
iaa.WithHueAndSaturation(children=iaa.Noop(),
name="WithHueAndSaturation"),
iaa.MultiplyHueAndSaturation((0.8, 1.2),
name="MultiplyHueAndSaturation"),
iaa.MultiplyHue((-1.0, 1.0), name="MultiplyHue"),
iaa.MultiplySaturation((0.8, 1.2), name="MultiplySaturation"),
iaa.AddToHueAndSaturation((-10, 10), name="AddToHueAndSaturation"),
iaa.AddToHue((-10, 10), name="AddToHue"),
iaa.AddToSaturation((-10, 10), name="AddToSaturation"),
iaa.ChangeColorspace(to_colorspace="HSV", name="ChangeColorspace"),
iaa.Grayscale((0.01, 0.99), name="Grayscale"),
iaa.KMeansColorQuantization((2, 16), name="KMeansColorQuantization"),
iaa.UniformColorQuantization((2, 16), name="UniformColorQuantization")
]
augmenters_contrast = [
iaa.GammaContrast(gamma=(0.5, 2.0), name="GammaContrast"),
iaa.SigmoidContrast(gain=(5, 20),
cutoff=(0.25, 0.75),
name="SigmoidContrast"),
iaa.LogContrast(gain=(0.7, 1.0), name="LogContrast"),
iaa.LinearContrast((0.5, 1.5), name="LinearContrast"),
iaa.AllChannelsCLAHE(clip_limit=(2, 10),
tile_grid_size_px=(3, 11),
name="AllChannelsCLAHE"),
iaa.CLAHE(clip_limit=(2, 10),
tile_grid_size_px=(3, 11),
to_colorspace="HSV",
name="CLAHE"),
iaa.AllChannelsHistogramEqualization(
name="AllChannelsHistogramEqualization"),
iaa.HistogramEqualization(to_colorspace="HSV",
name="HistogramEqualization"),
]
augmenters_convolutional = [
iaa.Convolve(np.float32([[0, 0, 0], [0, 1, 0], [0, 0, 0]]),
name="Convolve_3x3"),
iaa.Sharpen(alpha=(0.01, 0.99), lightness=(0.5, 2), name="Sharpen"),
iaa.Emboss(alpha=(0.01, 0.99), strength=(0, 2), name="Emboss"),
iaa.EdgeDetect(alpha=(0.01, 0.99), name="EdgeDetect"),
iaa.DirectedEdgeDetect(alpha=(0.01, 0.99), name="DirectedEdgeDetect")
]
augmenters_edges = [iaa.Canny(alpha=(0.01, 0.99), name="Canny")]
augmenters_flip = [
iaa.Fliplr(1.0, name="Fliplr"),
iaa.Flipud(1.0, name="Flipud")
]
augmenters_geometric = [
iaa.Affine(scale=(0.9, 1.1),
translate_percent={
"x": (-0.05, 0.05),
"y": (-0.05, 0.05)
},
rotate=(-10, 10),
shear=(-10, 10),
order=0,
mode="constant",
cval=(0, 255),
name="Affine_order_0_constant"),
iaa.Affine(scale=(0.9, 1.1),
translate_percent={
"x": (-0.05, 0.05),
"y": (-0.05, 0.05)
},
rotate=(-10, 10),
shear=(-10, 10),
order=1,
mode="constant",
cval=(0, 255),
name="Affine_order_1_constant"),
iaa.Affine(scale=(0.9, 1.1),
translate_percent={
"x": (-0.05, 0.05),
"y": (-0.05, 0.05)
},
rotate=(-10, 10),
shear=(-10, 10),
order=3,
mode="constant",
cval=(0, 255),
name="Affine_order_3_constant"),
iaa.Affine(scale=(0.9, 1.1),
translate_percent={
"x": (-0.05, 0.05),
"y": (-0.05, 0.05)
},
rotate=(-10, 10),
shear=(-10, 10),
order=1,
mode="edge",
cval=(0, 255),
name="Affine_order_1_edge"),
iaa.Affine(scale=(0.9, 1.1),
translate_percent={
"x": (-0.05, 0.05),
"y": (-0.05, 0.05)
},
rotate=(-10, 10),
shear=(-10, 10),
order=1,
mode="constant",
cval=(0, 255),
backend="skimage",
name="Affine_order_1_constant_skimage"),
# TODO AffineCv2
iaa.PiecewiseAffine(scale=(0.01, 0.05),
nb_rows=4,
nb_cols=4,
order=1,
mode="constant",
name="PiecewiseAffine_4x4_order_1_constant"),
iaa.PiecewiseAffine(scale=(0.01, 0.05),
nb_rows=4,
nb_cols=4,
order=0,
mode="constant",
name="PiecewiseAffine_4x4_order_0_constant"),
iaa.PiecewiseAffine(scale=(0.01, 0.05),
nb_rows=4,
nb_cols=4,
order=1,
mode="edge",
name="PiecewiseAffine_4x4_order_1_edge"),
iaa.PiecewiseAffine(scale=(0.01, 0.05),
nb_rows=8,
nb_cols=8,
order=1,
mode="constant",
name="PiecewiseAffine_8x8_order_1_constant"),
iaa.PerspectiveTransform(scale=(0.01, 0.05),
keep_size=False,
name="PerspectiveTransform"),
iaa.PerspectiveTransform(scale=(0.01, 0.05),
keep_size=True,
name="PerspectiveTransform_keep_size"),
iaa.ElasticTransformation(
alpha=(1, 10),
sigma=(0.5, 1.5),
order=0,
mode="constant",
cval=0,
name="ElasticTransformation_order_0_constant"),
iaa.ElasticTransformation(
alpha=(1, 10),
sigma=(0.5, 1.5),
order=1,
mode="constant",
cval=0,
name="ElasticTransformation_order_1_constant"),
iaa.ElasticTransformation(
alpha=(1, 10),
sigma=(0.5, 1.5),
order=1,
mode="nearest",
cval=0,
name="ElasticTransformation_order_1_nearest"),
iaa.ElasticTransformation(
alpha=(1, 10),
sigma=(0.5, 1.5),
order=1,
mode="reflect",
cval=0,
name="ElasticTransformation_order_1_reflect"),
iaa.Rot90((1, 3), keep_size=False, name="Rot90"),
iaa.Rot90((1, 3), keep_size=True, name="Rot90_keep_size")
]
augmenters_pooling = [
iaa.AveragePooling(kernel_size=(1, 16),
keep_size=False,
name="AveragePooling"),
iaa.AveragePooling(kernel_size=(1, 16),
keep_size=True,
name="AveragePooling_keep_size"),
iaa.MaxPooling(kernel_size=(1, 16), keep_size=False,
name="MaxPooling"),
iaa.MaxPooling(kernel_size=(1, 16),
keep_size=True,
name="MaxPooling_keep_size"),
iaa.MinPooling(kernel_size=(1, 16), keep_size=False,
name="MinPooling"),
iaa.MinPooling(kernel_size=(1, 16),
keep_size=True,
name="MinPooling_keep_size"),
iaa.MedianPooling(kernel_size=(1, 16),
keep_size=False,
name="MedianPooling"),
iaa.MedianPooling(kernel_size=(1, 16),
keep_size=True,
name="MedianPooling_keep_size")
]
augmenters_segmentation = [
iaa.Superpixels(p_replace=(0.05, 1.0),
n_segments=(10, 100),
max_size=64,
interpolation="cubic",
name="Superpixels_max_size_64_cubic"),
iaa.Superpixels(p_replace=(0.05, 1.0),
n_segments=(10, 100),
max_size=64,
interpolation="linear",
name="Superpixels_max_size_64_linear"),
iaa.Superpixels(p_replace=(0.05, 1.0),
n_segments=(10, 100),
max_size=128,
interpolation="linear",
name="Superpixels_max_size_128_linear"),
iaa.Superpixels(p_replace=(0.05, 1.0),
n_segments=(10, 100),
max_size=224,
interpolation="linear",
name="Superpixels_max_size_224_linear"),
iaa.UniformVoronoi(n_points=(250, 1000), name="UniformVoronoi"),
iaa.RegularGridVoronoi(n_rows=(16, 31),
n_cols=(16, 31),
name="RegularGridVoronoi"),
iaa.RelativeRegularGridVoronoi(n_rows_frac=(0.07, 0.14),
n_cols_frac=(0.07, 0.14),
name="RelativeRegularGridVoronoi"),
]
augmenters_size = [
iaa.Resize((0.8, 1.2), interpolation="nearest", name="Resize_nearest"),
iaa.Resize((0.8, 1.2), interpolation="linear", name="Resize_linear"),
iaa.Resize((0.8, 1.2), interpolation="cubic", name="Resize_cubic"),
iaa.CropAndPad(percent=(-0.2, 0.2),
pad_mode="constant",
pad_cval=(0, 255),
keep_size=False,
name="CropAndPad"),
iaa.CropAndPad(percent=(-0.2, 0.2),
pad_mode="edge",
pad_cval=(0, 255),
keep_size=False,
name="CropAndPad_edge"),
iaa.CropAndPad(percent=(-0.2, 0.2),
pad_mode="constant",
pad_cval=(0, 255),
name="CropAndPad_keep_size"),
iaa.Pad(percent=(0.05, 0.2),
pad_mode="constant",
pad_cval=(0, 255),
keep_size=False,
name="Pad"),
iaa.Pad(percent=(0.05, 0.2),
pad_mode="edge",
pad_cval=(0, 255),
keep_size=False,
name="Pad_edge"),
iaa.Pad(percent=(0.05, 0.2),
pad_mode="constant",
pad_cval=(0, 255),
name="Pad_keep_size"),
iaa.Crop(percent=(0.05, 0.2), keep_size=False, name="Crop"),
iaa.Crop(percent=(0.05, 0.2), name="Crop_keep_size"),
iaa.PadToFixedSize(width=width + 10,
height=height + 10,
pad_mode="constant",
pad_cval=(0, 255),
name="PadToFixedSize"),
iaa.CropToFixedSize(width=width - 10,
height=height - 10,
name="CropToFixedSize"),
iaa.KeepSizeByResize(iaa.CropToFixedSize(height=height - 10,
width=width - 10),
interpolation="nearest",
name="KeepSizeByResize_CropToFixedSize_nearest"),
iaa.KeepSizeByResize(iaa.CropToFixedSize(height=height - 10,
width=width - 10),
interpolation="linear",
name="KeepSizeByResize_CropToFixedSize_linear"),
iaa.KeepSizeByResize(iaa.CropToFixedSize(height=height - 10,
width=width - 10),
interpolation="cubic",
name="KeepSizeByResize_CropToFixedSize_cubic"),
]
augmenters_weather = [
iaa.FastSnowyLandscape(lightness_threshold=(100, 255),
lightness_multiplier=(1.0, 4.0),
name="FastSnowyLandscape"),
iaa.Clouds(name="Clouds"),
iaa.Fog(name="Fog"),
iaa.CloudLayer(intensity_mean=(196, 255),
intensity_freq_exponent=(-2.5, -2.0),
intensity_coarse_scale=10,
alpha_min=0,
alpha_multiplier=(0.25, 0.75),
alpha_size_px_max=(2, 8),
alpha_freq_exponent=(-2.5, -2.0),
sparsity=(0.8, 1.0),
density_multiplier=(0.5, 1.0),
name="CloudLayer"),
iaa.Snowflakes(name="Snowflakes"),
iaa.SnowflakesLayer(density=(0.005, 0.075),
density_uniformity=(0.3, 0.9),
flake_size=(0.2, 0.7),
flake_size_uniformity=(0.4, 0.8),
angle=(-30, 30),
speed=(0.007, 0.03),
blur_sigma_fraction=(0.0001, 0.001),
name="SnowflakesLayer")
]
augmenters = (augmenters_meta + augmenters_arithmetic + augmenters_blend +
augmenters_blur + augmenters_color + augmenters_contrast +
augmenters_convolutional + augmenters_edges +
augmenters_flip + augmenters_geometric + augmenters_pooling +
augmenters_segmentation + augmenters_size +
augmenters_weather)
if only_augmenters is not None:
augmenters_reduced = []
for augmenter in augmenters:
if any([
re.search(pattern, augmenter.name)
for pattern in only_augmenters
]):
augmenters_reduced.append(augmenter)
augmenters = augmenters_reduced
return augmenters
sometimes = lambda aug: iaa.Sometimes(0.9, aug)
seq = iaa.SomeOf(
(1, 2),
[
sometimes(
iaa.BlendAlphaFrequencyNoise(foreground=iaa.EdgeDetect(0.75),
upscale_method="nearest")),
sometimes(
iaa.BlendAlphaMask(
iaa.InvertMaskGen(0.5, iaa.VerticalLinearGradientMaskGen()),
iaa.Sequential([iaa.Clouds(),
iaa.WithChannels([1, 2])]))),
sometimes(
iaa.BlendAlphaCheckerboard(
nb_rows=2, nb_cols=(1, 4), foreground=iaa.AddToHue(
(-80, 80)))),
#important augmenter
sometimes(
iaa.BlendAlphaVerticalLinearGradient(iaa.AveragePooling(10),
start_at=(0.0, 1.0),
end_at=(0.0, 1.0))),
sometimes(
iaa.BlendAlphaSimplexNoise(iaa.EdgeDetect(1.0),
upscale_method="linear"))
])
sometimes2 = lambda aug: iaa.Sometimes(0.95, aug) # probability is increased
seq2 = iaa.SomeOf(
(1, 2),
