def brightness(image_np, save_dir, input_filename, is_groud_true, out_count=1):
"""
Change the brightness of images: MultiplyAndAddToBrightness
:param image_np: 'images' should be either a 4D numpy array of shape (N, height, width, channels)
:param save_dir: the directory for saving images
:param input_filename: File base name (e.g basename.tif)
:param is_groud_true: if ground truth, just copy the image
:return:
"""
file_basename = os.path.basename(input_filename)
basename = os.path.splitext(file_basename)[0]
ext = os.path.splitext(file_basename)[1]
for idx in range(out_count):
save_path = os.path.join(save_dir,
basename + '_bright' + str(idx) + ext)
if is_groud_true is True:
# just copy the groud true
images_b = image_np
else:
brightness = iaa.MultiplyAndAddToBrightness(
mul=(0.5, 1.5),
add=(-30, 30)) # a random value between the range
images_b = brightness.augment_image(image_np)
io.imsave(save_path, images_b)
return True
def __init__(self):
self.aug = iaa.Sequential([
# iaa.Sometimes(0.25, iaa.GammaContrast(gamma=(0, 1.75))),
# iaa.Sometimes(0.25, iaa.GaussianBlur(sigma=(0, 1.3))),
# iaa.Sometimes(0.25, iaa.pillike.Autocontrast(cutoff=(0, 15.0))),
# iaa.Grayscale(alpha=(0.0, 1.0)),
# iaa.Sometimes(0.15, iaa.MotionBlur(k=5, angle=[-45, 45])),
iaa.Sometimes(
0.35,
iaa.OneOf([
iaa.MultiplyAndAddToBrightness(mul=(0.5, 1.5),
add=(-30, 30)),
iaa.GammaContrast(gamma=(0, 1.75)),
iaa.pillike.Autocontrast(cutoff=(0, 15.0)),
iaa.Sometimes(0.25, iaa.GaussianBlur(sigma=(0, 1.3)))
])),
# iaa.Fliplr(0.5),
# iaa.Sometimes(0.35,
# iaa.OneOf([iaa.Dropout(p=(0, 0.1)),
# iaa.Dropout2d(p=0.5),
# iaa.CoarseDropout(0.1, size_percent=0.5),
# iaa.SaltAndPepper(0.1),
# ])),
# iaa.Sometimes(0.15,
# iaa.OneOf([
# iaa.Clouds(),
# iaa.Fog(),
# iaa.Snowflakes(flake_size=(0.1, 0.4), speed=(0.01, 0.05)),
# iaa.Rain(speed=(0.1, 0.3))
# ])),
# iaa.Sometimes(0.5, iaa.MultiplyAndAddToBrightness(mul=(0.5, 1.5), add=(-30, 30)))
])
def __init__(self):
self.aug = iaa.Sequential([
iaa.Sometimes(
0.15,
iaa.OneOf([
iaa.GammaContrast(gamma=(0, 1.75)),
iaa.pillike.Autocontrast(cutoff=(0, 15.0))
])),
iaa.Sometimes(
0.15,
iaa.OneOf([
iaa.HistogramEqualization(),
iaa.pillike.Equalize(),
])),
iaa.Sometimes(0.1, iaa.Grayscale(alpha=(0.05, 1.0))),
iaa.Sometimes(0.2, iaa.JpegCompression(compression=(70, 99))),
iaa.Sometimes(0.1,
iaa.UniformColorQuantizationToNBits(nb_bits=(2, 8))),
iaa.Sometimes(
0.3,
iaa.MultiplyAndAddToBrightness(mul=(0.5, 1.5), add=(-30, 30))),
iaa.Sometimes(
0.2,
iaa.Cutout(
fill_mode="constant", cval=(0, 255), fill_per_channel=0.5))
],
random_order=True)
def __init__(self):
sometimes = lambda aug: iaa.Sometimes(0.3, aug)
self.seq = iaa.Sequential([
sometimes(iaa.CropToFixedSize(width=640, height=640)),
iaa.Fliplr(0.5),
iaa.Flipud(0.5),
iaa.MultiplyAndAddToBrightness(mul=(0.9, 1.1), add=(-5, 5)),
iaa.Affine(
rotate=(-380, 380),
scale=(0.7, 1.3),
translate_percent={
'x': (-0.2, 0.2),
'y': (-0.2, 0.2)
},
#mode=['symmetric', 'reflect'], # bbox는 reflect 되지 않음
cval=(0, 0)),
sometimes(
iaa.SomeOf(1, [
iaa.GaussianBlur(sigma=(0.6, 1.4)),
iaa.AverageBlur(k=(1, 3)),
iaa.MedianBlur(k=(1, 3)),
iaa.BilateralBlur(d=(5, 7), sigma_space=(10, 250))
])),
sometimes(iaa.PerspectiveTransform(scale=(0.01, 0.11))),
sometimes(iaa.Grayscale(alpha=(0.0, 0.3))),
])
def chapter_augmenters_multiplyandaddtobrightness():
fn_start = "color/multiplyandaddtobrightness"
aug = iaa.MultiplyAndAddToBrightness(mul=(0.5, 1.5), add=(-30, 30))
run_and_save_augseq(fn_start + ".jpg",
aug, [ia.quokka(size=(128, 128)) for _ in range(8)],
cols=4,
rows=2)
def dataAug(imgPath, txtPath):
images, bbs= loadData(imgPath, txtPath)
seq = iaa.Sequential([
iaa.Sometimes(0.25, iaa.AdditiveGaussianNoise(scale=0.05*255)),
iaa.Affine(translate_px={"x": (1, 5)}),
iaa.MultiplyAndAddToBrightness(mul=(0.5, 1.5), add=(-30, 30)),
iaa.Sometimes(0.25,iaa.imgcorruptlike.MotionBlur(severity=(1,2))),
iaa.Resize({"height": (0.75, 1.25), "width": (0.75, 1.25)}),
iaa.CropAndPad(percent=(-0.25, 0.25)),
iaa.JpegCompression(compression=(0, 66))
])
image_aug, bbs_aug = seq(images=images, bounding_boxes=bbs)
return image_aug[0], bbs_aug[0]
def __init__(self):
self.aug = iaa.Sequential([
iaa.Sometimes(0.15, iaa.MotionBlur(k=5, angle=[-45, 45])),
iaa.Sometimes(
0.35,
iaa.OneOf([
iaa.MultiplyAndAddToBrightness(mul=(0.5, 1.5),
add=(-30, 30)),
iaa.GammaContrast(gamma=(0.7, 1.75)),
iaa.pillike.Autocontrast(cutoff=(0, 15.0)),
iaa.Sometimes(0.25, iaa.GaussianBlur(sigma=(0, 1.3)))
])),
iaa.Fliplr(0.5),
iaa.Sometimes(
0.35,
iaa.OneOf([
iaa.SaltAndPepper(0.05),
iaa.Affine(rotate=(-20, 20), mode='symmetric')
]))
])
def load_augmentation_aug_non_geometric():
return iaa.Sequential([
iaa.Sometimes(
0.5,
iaa.AdditiveGaussianNoise(loc=0,
scale=(0.0, 0.05 * 255),
per_channel=0.5)),
iaa.Sometimes(
0.5,
iaa.OneOf([
iaa.GaussianBlur(sigma=(0.0, 3.0)),
iaa.GaussianBlur(sigma=(0.0, 5.0))
])),
iaa.Sometimes(0.5, iaa.MultiplyAndAddToBrightness(mul=(0.4, 1.7))),
iaa.Sometimes(0.5, iaa.GammaContrast((0.4, 1.7))),
iaa.Sometimes(0.5, iaa.Multiply((0.4, 1.7), per_channel=0.5)),
iaa.Sometimes(0.5, iaa.MultiplyHue((0.4, 1.7))),
iaa.Sometimes(
0.5, iaa.MultiplyHueAndSaturation((0.4, 1.7),
per_channel=True)),
iaa.Sometimes(0.5, iaa.LinearContrast((0.4, 1.7), per_channel=0.5))
])
def train_augs(self,):
return iaa.Sequential([
iaa.HorizontalFlip(0.5),
iaa.VerticalFlip(0.5),
iaa.OneOf([
iaa.MultiplyAndAddToBrightness(mul=(0.5, 1.5), add=(-30, 30)),
iaa.Noop()
]),
iaa.OneOf([
iaa.Grayscale(alpha=(0.0, 1.0)),
iaa.Noop()
]),
iaa.OneOf([
iaa.Noop(),
iaa.GammaContrast((0.5, 1.0))
]),
iaa.Affine(
scale={"x": (0.9, 1.1), "y": (0.9, 1.1)},
translate_percent={"x": (-0.05, 0.05), "y": (-0.05, 0.05)},
rotate=(-5, 5),
cval=255,
),
])
def __init__(self,
root_path,
annotation_path,
subset,
n_samples_for_each_video=1,
spatial_transform=None,
temporal_transform=None,
target_transform=None,
sample_duration=16,
modality='rgb',
get_loader=get_default_video_loader):
if subset == 'training':
self.data, self.class_names = make_dataset(
root_path, annotation_path, subset, n_samples_for_each_video,
sample_duration)
# self.val_data, _ = make_dataset(
# root_path, annotation_path, 'validation', n_samples_for_each_video,
# sample_duration)
# self.data += self.val_data
else:
self.data, self.class_names = make_dataset(
root_path, annotation_path, 'testing',
n_samples_for_each_video, sample_duration)
print('loaded', len(self.data))
self.spatial_transform = spatial_transform
self.temporal_transform = temporal_transform
self.target_transform = target_transform
self.subset = subset
self.modality = modality
if self.modality == 'flow':
self.loader = get_default_video_loader_flow()
elif self.modality == 'depth':
self.loader = get_default_video_loader_depth()
else:
self.loader = get_loader()
sometimes = lambda aug: iaa.Sometimes(0.3, aug)
self.aug_seq = iaa.Sequential([
# iaa.Fliplr(0.5),
# sometimes(iaa.MotionBlur(k=2)),
# sometimes(iaa.ChangeColorTemperature((1100, 10000))),
sometimes(
iaa.MultiplyAndAddToBrightness(mul=(0.8, 1.2), add=(-30, 30))),
# 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)},
# rotate=(-20, 20),
# shear=(-10, 10),
# cval=(0, 255),
# mode=ia.ALL, )),
# sometimes(iaa.PerspectiveTransform(scale=(0.01, 0.15))),
# sometimes(iaa.AdditiveGaussianNoise(scale=0.05 * 255)),
])
self.aug_seq.to_deterministic()
# added by alexhu
self.root_path = root_path
if self.modality != 'pose':
self.to_tensor = Compose(self.spatial_transform.transforms[-2:])
self.spatial_transform.transforms = self.spatial_transform.transforms[:
-2]
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
)
transformed_image = transform(image=image)
elif augmentation == 'hue_saturation':
transform = HueSaturationValue(always_apply=True)
transformed_image = transform(image=image)['image']
elif augmentation == 'multiply_brightness':
transform = iaa.MultiplyBrightness((0.1, 1.9))
transformed_image = transform(image=image)
elif augmentation == 'addto_brightness':
transform = iaa.AddToBrightness((-50, 50))
transformed_image = transform(image=image)
elif augmentation == 'multiply_and_addtobrightness':
transform = iaa.MultiplyAndAddToBrightness(mul=(0.5, 1.5),
add=(-30, 30))
transformed_image = transform(image=image)
elif augmentation == 'to_gray':
transform = ToGray(always_apply=True)
transformed_image = transform(image=image)['image']
elif augmentation == 'posterize':
transform = Posterize(always_apply=True, num_bits=2)
transformed_image = transform(image=image)['image']
elif augmentation == 'to_sepia':
transform = ToSepia(always_apply=True)
transformed_image = transform(image=image)['image']
elif augmentation == 'fancy_pca':
save_path = os.path.join(
vis_dir,
self.images_name[i] + '_polygon' + '.' + self.images_format[i])
cv2.imwrite(save_path, image_with_polygon)
'''
changes the color temperature of images to a random value between 1100 and 10000 Kelvin
'''
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)))
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.Identity(name="Identity"),
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.Cutout(nb_iterations=1, name="Cutout-fill_constant"),
iaa.Dropout((0.01, 0.05), name="Dropout"),
iaa.CoarseDropout((0.01, 0.05), size_percent=(0.01, 0.1), name="CoarseDropout"),
iaa.Dropout2d(0.1, name="Dropout2d"),
iaa.TotalDropout(0.1, name="TotalDropout"),
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_artistic = [
iaa.Cartoon(name="Cartoon")
]
augmenters_blend = [
iaa.BlendAlpha((0.01, 0.99), iaa.Identity(), name="Alpha"),
iaa.BlendAlphaElementwise((0.01, 0.99), iaa.Identity(), name="AlphaElementwise"),
iaa.BlendAlphaSimplexNoise(iaa.Identity(), name="SimplexNoiseAlpha"),
iaa.BlendAlphaFrequencyNoise((-2.0, 2.0), iaa.Identity(), name="FrequencyNoiseAlpha"),
iaa.BlendAlphaSomeColors(iaa.Identity(), name="BlendAlphaSomeColors"),
iaa.BlendAlphaHorizontalLinearGradient(iaa.Identity(), name="BlendAlphaHorizontalLinearGradient"),
iaa.BlendAlphaVerticalLinearGradient(iaa.Identity(), name="BlendAlphaVerticalLinearGradient"),
iaa.BlendAlphaRegularGrid(nb_rows=(2, 8), nb_cols=(2, 8), foreground=iaa.Identity(), name="BlendAlphaRegularGrid"),
iaa.BlendAlphaCheckerboard(nb_rows=(2, 8), nb_cols=(2, 8), foreground=iaa.Identity(), name="BlendAlphaCheckerboard"),
# TODO BlendAlphaSegMapClassId
# TODO BlendAlphaBoundingBoxes
]
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"),
iaa.MeanShiftBlur(spatial_radius=(5.0, 40.0), color_radius=(5.0, 40.0),
name="MeanShiftBlur")
]
augmenters_collections = [
iaa.RandAugment(n=2, m=(6, 12), name="RandAugment")
]
augmenters_color = [
# InColorspace (deprecated)
iaa.WithColorspace(to_colorspace="HSV", children=iaa.Noop(), name="WithColorspace"),
iaa.WithBrightnessChannels(iaa.Identity(), name="WithBrightnessChannels"),
iaa.MultiplyAndAddToBrightness(mul=(0.7, 1.3), add=(-30, 30), name="MultiplyAndAddToBrightness"),
iaa.MultiplyBrightness((0.7, 1.3), name="MultiplyBrightness"),
iaa.AddToBrightness((-30, 30), name="AddToBrightness"),
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.RemoveSaturation((0.01, 0.99), name="RemoveSaturation"),
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"),
iaa.UniformColorQuantizationToNBits((1, 7), name="UniformQuantizationToNBits"),
iaa.Posterize((1, 7), name="Posterize")
]
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"),
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"),
iaa.WithPolarWarping(iaa.Identity(), name="WithPolarWarping"),
iaa.Jigsaw(nb_rows=(3, 8), nb_cols=(3, 8), max_steps=1, name="Jigsaw")
]
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_imgcorruptlike = [
iaa.imgcorruptlike.GaussianNoise(severity=(1, 5), name="imgcorruptlike.GaussianNoise"),
iaa.imgcorruptlike.ShotNoise(severity=(1, 5), name="imgcorruptlike.ShotNoise"),
iaa.imgcorruptlike.ImpulseNoise(severity=(1, 5), name="imgcorruptlike.ImpulseNoise"),
iaa.imgcorruptlike.SpeckleNoise(severity=(1, 5), name="imgcorruptlike.SpeckleNoise"),
iaa.imgcorruptlike.GaussianBlur(severity=(1, 5), name="imgcorruptlike.GaussianBlur"),
iaa.imgcorruptlike.GlassBlur(severity=(1, 5), name="imgcorruptlike.GlassBlur"),
iaa.imgcorruptlike.DefocusBlur(severity=(1, 5), name="imgcorruptlike.DefocusBlur"),
iaa.imgcorruptlike.MotionBlur(severity=(1, 5), name="imgcorruptlike.MotionBlur"),
iaa.imgcorruptlike.ZoomBlur(severity=(1, 5), name="imgcorruptlike.ZoomBlur"),
iaa.imgcorruptlike.Fog(severity=(1, 5), name="imgcorruptlike.Fog"),
iaa.imgcorruptlike.Frost(severity=(1, 5), name="imgcorruptlike.Frost"),
iaa.imgcorruptlike.Snow(severity=(1, 5), name="imgcorruptlike.Snow"),
iaa.imgcorruptlike.Spatter(severity=(1, 5), name="imgcorruptlike.Spatter"),
iaa.imgcorruptlike.Contrast(severity=(1, 5), name="imgcorruptlike.Contrast"),
iaa.imgcorruptlike.Brightness(severity=(1, 5), name="imgcorruptlike.Brightness"),
iaa.imgcorruptlike.Saturate(severity=(1, 5), name="imgcorruptlike.Saturate"),
iaa.imgcorruptlike.JpegCompression(severity=(1, 5), name="imgcorruptlike.JpegCompression"),
iaa.imgcorruptlike.Pixelate(severity=(1, 5), name="imgcorruptlike.Pixelate"),
iaa.imgcorruptlike.ElasticTransform(severity=(1, 5), name="imgcorruptlike.ElasticTransform")
]
augmenters_pillike = [
iaa.pillike.Solarize(p=1.0, threshold=(32, 128), name="pillike.Solarize"),
iaa.pillike.Posterize((1, 7), name="pillike.Posterize"),
iaa.pillike.Equalize(name="pillike.Equalize"),
iaa.pillike.Autocontrast(name="pillike.Autocontrast"),
iaa.pillike.EnhanceColor((0.0, 3.0), name="pillike.EnhanceColor"),
iaa.pillike.EnhanceContrast((0.0, 3.0), name="pillike.EnhanceContrast"),
iaa.pillike.EnhanceBrightness((0.0, 3.0), name="pillike.EnhanceBrightness"),
iaa.pillike.EnhanceSharpness((0.0, 3.0), name="pillike.EnhanceSharpness"),
iaa.pillike.FilterBlur(name="pillike.FilterBlur"),
iaa.pillike.FilterSmooth(name="pillike.FilterSmooth"),
iaa.pillike.FilterSmoothMore(name="pillike.FilterSmoothMore"),
iaa.pillike.FilterEdgeEnhance(name="pillike.FilterEdgeEnhance"),
iaa.pillike.FilterEdgeEnhanceMore(name="pillike.FilterEdgeEnhanceMore"),
iaa.pillike.FilterFindEdges(name="pillike.FilterFindEdges"),
iaa.pillike.FilterContour(name="pillike.FilterContour"),
iaa.pillike.FilterEmboss(name="pillike.FilterEmboss"),
iaa.pillike.FilterSharpen(name="pillike.FilterSharpen"),
iaa.pillike.FilterDetail(name="pillike.FilterDetail"),
iaa.pillike.Affine(scale=(0.9, 1.1),
translate_percent={"x": (-0.05, 0.05), "y": (-0.05, 0.05)},
rotate=(-10, 10),
shear=(-10, 10),
fillcolor=(0, 255),
name="pillike.Affine"),
]
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"),
iaa.Rain(name="Rain"),
iaa.RainLayer(density=(0.03, 0.14),
density_uniformity=(0.8, 1.0),
drop_size=(0.01, 0.02),
drop_size_uniformity=(0.2, 0.5),
angle=(-15, 15),
speed=(0.04, 0.20),
blur_sigma_fraction=(0.001, 0.001),
name="RainLayer")
]
augmenters = (
augmenters_meta
+ augmenters_arithmetic
+ augmenters_artistic
+ augmenters_blend
+ augmenters_blur
+ augmenters_collections
+ augmenters_color
+ augmenters_contrast
+ augmenters_convolutional
+ augmenters_edges
+ augmenters_flip
+ augmenters_geometric
+ augmenters_pooling
+ augmenters_imgcorruptlike
+ augmenters_pillike
+ 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
foreground=iaa.Add((-15, 15)),
background=iaa.Multiply((0.8, 1.2))),
iaa.ReplaceElementwise(0.05,
iap.Normal(128, 0.4 * 128),
per_channel=0.5),
iaa.Dropout(p=(0, 0.05), per_channel=0.5),
])),
# Brightness + Color + Contrast
iaa.Sometimes(
0.5,
iaa.OneOf([
iaa.Add(iap.Normal(iap.Choice([-30, 30]), 10)),
iaa.Multiply((0.75, 1.25)),
iaa.AddToBrightness((-35, 35)),
iaa.MultiplyBrightness((0.85, 1.15)),
iaa.MultiplyAndAddToBrightness(mul=(0.85, 1.15), add=(-10, 10)),
iaa.BlendAlphaHorizontalLinearGradient(iaa.Add(
iap.Normal(iap.Choice([-40, 40]), 10)),
start_at=(0, 0.2),
end_at=(0.8, 1)),
iaa.BlendAlphaHorizontalLinearGradient(iaa.Add(
iap.Normal(iap.Choice([-40, 40]), 10)),
start_at=(0.8, 1),
end_at=(0, 0.2)),
iaa.BlendAlphaVerticalLinearGradient(iaa.Add(
iap.Normal(iap.Choice([-40, 40]), 10)),
start_at=(0.8, 1),
end_at=(0, 0.2)),
iaa.BlendAlphaVerticalLinearGradient(iaa.Add(
iap.Normal(iap.Choice([-40, 40]), 10)),
start_at=(0, 0.2),
import imgaug.augmenters as iaa
import random
import numpy as np
import cv2
from PIL import Image
aug_transform = iaa.SomeOf((0, None), [
iaa.OneOf([
iaa.MultiplyAndAddToBrightness(mul=(0.3, 1.6), add=(-50, 50)),
iaa.MultiplyHueAndSaturation((0.5, 1.5), per_channel=True),
iaa.ChannelShuffle(0.5),
iaa.RemoveSaturation(),
iaa.Grayscale(alpha=(0.0, 1.0)),
iaa.ChangeColorTemperature((1100, 35000)),
]),
iaa.OneOf([
iaa.MedianBlur(k=(3, 7)),
iaa.BilateralBlur(
d=(3, 10), sigma_color=(10, 250), sigma_space=(10, 250)),
iaa.MotionBlur(k=(3, 9), angle=[-45, 45]),
iaa.MeanShiftBlur(spatial_radius=(5.0, 10.0),
color_radius=(5.0, 10.0)),
iaa.AllChannelsCLAHE(clip_limit=(1, 10)),
iaa.AllChannelsHistogramEqualization(),
iaa.GammaContrast((0.5, 1.5), per_channel=True),
iaa.GammaContrast((0.5, 1.5)),
iaa.SigmoidContrast(gain=(3, 10), cutoff=(0.4, 0.6), per_channel=True),
iaa.SigmoidContrast(gain=(3, 10), cutoff=(0.4, 0.6)),
iaa.HistogramEqualization(),
iaa.Sharpen(alpha=0.5)
def train(name, df, resume=False):
now = datetime.now()
dt_string = now.strftime("%d|%m_%H|%M|%S")
print("Starting -->", dt_string)
os.makedirs(OUTPUT_DIR, exist_ok=True)
wandb.init(
project="imanip", config=config_defaults, name=f"{name},{dt_string}",
)
config = wandb.config
model = SRM_Classifer(num_classes=312)
print("Parameters : ", sum(p.numel() for p in model.parameters() if p.requires_grad))
wandb.save('segmentation/merged_net.py')
wandb.save('pretrain_dataset.py')
#####################################################################################################################
train_imgaug = iaa.Sequential(
[
iaa.SomeOf((0, 5),
[
iaa.OneOf([
iaa.JpegCompression(compression=(10, 60)),
iaa.GaussianBlur((0, 1.75)), # 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, 7)), # 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.AdditiveGaussianNoise(loc=0, scale=(0.0, 0.05*255), per_channel=0.5), # add gaussian noise to images
# iaa.Sometimes(0.3, 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
iaa.LinearContrast((0.5, 2.0), per_channel=0.5), # improve or worsen the contrast
# # either change the brightness of the whole image (sometimes
# # per channel) or change the brightness of subareas
iaa.Sometimes(0.5,
iaa.OneOf([
iaa.Multiply((0.5, 1.5), per_channel=0.5),
iaa.MultiplyAndAddToBrightness(mul=(0.5, 2.5), add=(-10,10)),
iaa.MultiplyHueAndSaturation(),
# iaa.BlendAlphaFrequencyNoise(
# exponent=(-4, 0),
# foreground=iaa.Multiply((0.5, 1.5), per_channel=True),
# background=iaa.LinearContrast((0.5, 2.0))
# )
])
),
], random_order=True
)
], random_order=True
)
train_geo_aug = albumentations.Compose(
[
albumentations.HorizontalFlip(p=0.5),
albumentations.VerticalFlip(p=0.5),
albumentations.RandomRotate90(p=0.1),
albumentations.ShiftScaleRotate(shift_limit=0.01, scale_limit=0.04, rotate_limit=35, p=0.25),
# albumentations.OneOf([
# albumentations.ElasticTransform(p=0.5, alpha=120, sigma=120 * 0.05, alpha_affine=120 * 0.03),
# albumentations.GridDistortion(p=0.5),
# albumentations.OpticalDistortion(p=0.5, distort_limit=2, shift_limit=0.5)
# ], p=0.7),
],
additional_targets={'ela':'image'}
)
####################################################################################################################
normalize = {
"mean": [0.4535408213875562, 0.42862278450748387, 0.41780105499276865],
"std": [0.2672804038612597, 0.2550410416463668, 0.29475415579144293],
}
transforms_normalize = albumentations.Compose(
[
albumentations.Normalize(mean=normalize['mean'], std=normalize['std'], always_apply=True, p=1),
albumentations.pytorch.transforms.ToTensorV2()
],
additional_targets={'ela':'image'}
)
# -------------------------------- CREATE DATASET and DATALOADER --------------------------
df_train, df_val, df_test = stratified_train_val_test_split(df, stratify_colname='class_idx',
frac_train=0.96, frac_val=0.02, frac_test=0.02)
train_dataset = DATASET(
dataframe=df_train,
mode="train",
transforms_normalize=transforms_normalize,
imgaug_augment=None,
geo_augment=train_geo_aug
)
train_loader = DataLoader(train_dataset, batch_size=config.train_batch_size, shuffle=True, num_workers=12, pin_memory=True, drop_last=False)
valid_dataset = DATASET(
dataframe=df_val,
mode="val",
transforms_normalize=transforms_normalize,
)
valid_loader = DataLoader(valid_dataset, batch_size=config.valid_batch_size, shuffle=True, num_workers=12, pin_memory=True, drop_last=False)
test_dataset = DATASET(
dataframe=df_test,
mode="test",
transforms_normalize=transforms_normalize,
)
test_loader = DataLoader(test_dataset, batch_size=config.valid_batch_size, shuffle=True, num_workers=12, pin_memory=True, drop_last=False)
optimizer = get_optimizer(model, config.optimizer, config.learning_rate, config.weight_decay)
scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(
optimizer,
patience=config.schedule_patience,
mode="min",
factor=config.schedule_factor,
)
model = nn.DataParallel(model).to(device)
criterion = nn.CrossEntropyLoss()
es = EarlyStopping(patience=15, mode="min")
start_epoch = 0
if resume:
checkpoint = torch.load('checkpoint/pretrain_[28|03_21|47|58].pt')
scheduler.load_state_dict(checkpoint['scheduler_state_dict'])
model.load_state_dict(checkpoint['model_state_dict'])
optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
start_epoch = checkpoint['epoch'] + 1
print("-----------> Resuming <------------")
for epoch in range(start_epoch, config.epochs):
print(f"Epoch = {epoch}/{config.epochs-1}")
print("------------------")
train_metrics = train_epoch(model, train_loader, optimizer, criterion, epoch)
valid_metrics = valid_epoch(model, valid_loader, criterion, epoch)
scheduler.step(valid_metrics['valid_loss'])
print(
"TRAIN_ACC = %.5f, TRAIN_LOSS = %.5f" % (train_metrics['train_acc5_manual'], train_metrics['train_loss'])
)
print(
"VALID_ACC = %.5f, VALID_LOSS = %.5f" % (valid_metrics['valid_acc5_manual'], valid_metrics['valid_loss'])
)
print("New LR", optimizer.param_groups[0]['lr'])
checkpoint = {
'epoch': epoch,
'model_state_dict': model.state_dict(),
'optimizer_state_dict' : optimizer.state_dict(),
'scheduler_state_dict': scheduler.state_dict(),
}
os.makedirs('checkpoint', exist_ok=True)
torch.save(checkpoint, os.path.join('checkpoint', f"{name}_[{dt_string}].pt"))
os.makedirs(OUTPUT_DIR, exist_ok=True)
es(
valid_metrics['valid_loss'],
model,
model_path=os.path.join(OUTPUT_DIR, f"{name}_[{dt_string}].h5"),
)
if es.early_stop:
print("Early stopping")
break
if os.path.exists(os.path.join(OUTPUT_DIR, f"{name}_[{dt_string}].h5")):
print(model.load_state_dict(torch.load(os.path.join(OUTPUT_DIR, f"{name}_[{dt_string}].h5"))))
print("LOADED FOR TEST")
wandb.save(os.path.join(OUTPUT_DIR, f"{name}_[{dt_string}].h5"))
test_metrics = test(model, test_loader, criterion)
return test_metrics
def compute_cluster(image_path):
"""each cluster can be computed independently"""
image_path_data = Path(image_path)
stem = image_path_data.stem
basename = image_path_data.name
image_annotation_path = get_image_annotation_path(stem)
image_annotation_path_data = Path(image_annotation_path)
print("Processing {}...".format(stem))
if image_annotation_path:
labels_df = decode_image_annotation(image_annotation_path)
shutil.copy(image_path, "{}/{}".format(DATASET_AUGM_IMAGES_DIR,
basename))
shutil.copy(
image_annotation_path,
"{}/{}".format(DATASET_AUGM_ANNOTS_DIR,
image_annotation_path_data.name))
for i in range(0, AUG_NB_AUGMENTATION_PER_IMAGE):
# This setup of augmentation parameters will pick 1 to 4
# of the given augmenters and apply them in random order.
sometimes = lambda aug: augmenters.Sometimes(0.5, aug)
aug_config = augmenters.SomeOf(
(1, 4),
[
augmenters.Affine(scale=(0.1, 1.5)),
augmenters.Affine(rotate=(-45, 45)),
augmenters.Affine(translate_percent={
"x": (-0.3, 0.3),
"y": (-0.3, 0.3)
}),
# augmenters.Affine(shear=(-16, 16)),
augmenters.OneOf([
augmenters.Fliplr(1),
augmenters.Flipud(1),
]),
augmenters.Rot90(1),
# sometimes(
# augmenters.Superpixels(
# p_replace=(0, 1.0),
# n_segments=(20, 200)
# )
# ),
augmenters.OneOf([
augmenters.GaussianBlur((0, 3.0)),
augmenters.AverageBlur(k=(2, 7)),
augmenters.MedianBlur(k=(3, 11)),
augmenters.MotionBlur(k=3),
]),
augmenters.Sharpen(alpha=(0, 1.0), lightness=(0.75, 1.5)),
# sometimes(augmenters.OneOf([
# augmenters.EdgeDetect(alpha=(0, 0.7)),
# augmenters.DirectedEdgeDetect(
# alpha=(0, 0.7), direction=(0.0, 1.0)
# ),
# ])),
augmenters.AdditiveGaussianNoise(
loc=0, scale=(0.0, 0.05 * 255), per_channel=0.5),
augmenters.OneOf([
augmenters.Dropout((0.05, 0.3), per_channel=0.5),
augmenters.CoarseDropout((0.02, 0.05),
size_percent=(0.01, 0.02),
per_channel=0.2),
]),
augmenters.OneOf([
augmenters.pillike.EnhanceColor(),
augmenters.Add((-10, 10)),
augmenters.Multiply((0.5, 1.5)),
augmenters.LinearContrast((0.5, 2.0), per_channel=0.5),
augmenters.MultiplyAndAddToBrightness(mul=(0.5, 1.5),
add=(-30, 30)),
# augmenters.Grayscale(alpha=(0.0, 1.0)),
]),
sometimes(
augmenters.ElasticTransformation(alpha=(0.2, 1.5),
sigma=0.25)),
sometimes(augmenters.PiecewiseAffine(scale=(0.01, 0.05)))
],
random_order=True)
aug_file_suffix = '_aug_{}'.format(i)
try:
augmented_image_df = augment_image(labels_df,
DATASET_IMAGES_DIR,
DATASET_AUGM_IMAGES_DIR,
aug_file_suffix, aug_config)
image_annotation_dest_path = "{}/{}{}{}".format(
DATASET_AUGM_ANNOTS_DIR, stem, aug_file_suffix,
image_annotation_path_data.suffix)
if (len(augmented_image_df.index)):
xml_annotations_et = get_xml_from_dataframe(
image_annotation_path, augmented_image_df)
xml_annotations_et.write(image_annotation_dest_path)
except:
print("Failed to augment {}".format(aug_file_suffix))
os.remove(image_annotation_path)
os.remove(image_path)
print("Removed: {}".format(image_path.split('/')[-1]))
import json
import webcolors
import imgaug.augmenters as iaa
classes=os.getcwd()+'/yolov3_tf2/'+'data/voc2012.names'
weights=os.getcwd()+'/yolov3_tf2/'+'/checkpoints/yolov3_train_e2_8.tf'
tiny=False,
size= 416
image= './data/girl.png'
tfrecord= None
output='./output.jpg'
num_classes= 9
class_names=[]
yolo=None
first_run_flag=True
aug = iaa.HistogramEqualization()
brightless = iaa.MultiplyAndAddToBrightness(mul=(0.9, 1.0), add=(-40, -50))
brightmore = iaa.MultiplyAndAddToBrightness(mul=(1.6, 1.8), add=(10, 20))
from numpy.linalg import norm
class_mappings={
'rayban01':'Rayban Wayfarer',
'Oo9343':'Oakley Men\'s Oo9343 M2 Frame Xl Shield Sunglasses',
'ck01': 'CK One Eau De Toilette',
'oakleySun2':'Oakley Sunglasses 2',
'dhl_envelope' : 'DHL Envelope as per the demo kits',
'poloshirt': 'Polo Shirt x 3',
'hoodie': 'Hoodie x 2',
'listerine': 'Listerine',
'Everydrop': 'Filter cartridge'}
# flags = tf.compat.v1.flags
# plt.figure(figsize=(6.66,10))
# plt.imshow( (20*np.log10( 0.1 + F2)).astype(int), cmap=plt.cm.gray)
# plt.show()
# im1 = fftpack.ifft2(fftpack.ifftshift(F2)).real
# plt.figure(figsize=(10,10))
# plt.imshow(im1, cmap='gray')
# plt.axis('off')
# plt.show()
# exit()
aug_seq = iaa.Sequential([
iaa.Resize({
"height": 72 * 5,
"width": 128 * 5
}),
iaa.MultiplyAndAddToBrightness(mul=(0.9, 1.1), add=0),
# 가우시안 필터는 scale 0이 정상 0~15사이인데 정상이 중간값으로 진행되지 않습니다.
iaa.SigmoidContrast(gain=5, cutoff=0.35),
iaa.GammaContrast((0.9, 1.1), per_channel=True),
iaa.ChangeColorTemperature(kelvin=(8000, 12000)),
iaa.MultiplyHueAndSaturation((0.8, 1.1), per_channel=True),
iaa.Resize({
"height": 720,
"width": 1280
}),
iaa.Sometimes(
0.5,
iaa.Sequential([
iaa.MotionBlur(k=15, angle=[-90, 90]),
iaa.AdditiveGaussianNoise(scale=(0, 15)),
]))