def get_training_augmentation():
train_transform = [
A.RandomSizedCrop(min_max_height=(300, 360), height=320, width=320,
always_apply=True),
A.HorizontalFlip(p=0.5),
A.OneOf([
A.CLAHE(),
A.RandomBrightnessContrast(),
A.RandomGamma(),
A.HueSaturationValue(),
A.NoOp()
]),
A.OneOf([
A.IAAAdditiveGaussianNoise(p=0.2),
A.IAASharpen(),
A.Blur(blur_limit=3),
A.MotionBlur(blur_limit=3),
A.NoOp()
]),
A.OneOf([
A.RandomFog(),
A.RandomSunFlare(),
A.RandomRain(),
A.RandomSnow(),
A.NoOp()
]),
A.Normalize(),
]
return A.Compose(train_transform)
def augment(self, img0, img1):
transform = A.Compose([
A.IAAAdditiveGaussianNoise(p=0.05),
A.OneOf([
A.IAASharpen(p=1.0),
A.Blur(blur_limit=3, p=1.0),
],
p=0.5),
A.OneOf([
A.RandomBrightnessContrast(p=1.0),
A.HueSaturationValue(p=1.0),
A.RandomGamma(p=1.0),
],
p=0.5),
A.OneOf([
A.RandomFog(p=1.0),
A.RandomRain(p=1.0),
A.RandomShadow(p=1.0),
A.RandomSnow(p=1.0),
A.RandomSunFlare(p=1.0)
],
p=0.05),
],
additional_targets={'img1': 'image'})
transformed = transform(image=img0, img1=img1)
img0 = transformed["image"]
img1 = transformed["img1"]
return img0, img1
def get_training_augmentation(min_area=0., min_visibility=0.):
train_transform = [
albu.OneOf([
albu.ISONoise(p=.5),
albu.GaussNoise(p=0.4),
albu.Blur(blur_limit=3, p=0.1),
]),
albu.OneOf([
albu.CLAHE(clip_limit=2),
], p=0.2),
albu.OneOf([
albu.RandomSnow(snow_point_lower=0.,
snow_point_upper=0.2,
brightness_coeff=2.,
p=0.5),
albu.RandomSunFlare(p=0.5),
]),
albu.OneOf([
albu.RGBShift(p=0.1),
albu.ChannelShuffle(p=0.2),
])
]
return albu.Compose(train_transform,
bbox_params={
'format': 'coco',
'min_area': min_area,
'min_visibility': min_visibility,
'label_fields': ['category_id']
})
def snow(img, msk):
aug = A.Compose([
A.RandomSnow(snow_point_lower=0.6,
snow_point_upper=0.8,
brightness_coeff=1.2,
always_apply=True)
])
data = aug(image=img)
return data['image'], msk
def augment_and_save(path_to_get_data,
path_to_save_data,
number_of_tranformation=10):
"""
Function defined to apply an image / rounding boxes transformation pipeline
and save the corresponding files.
Args:
-----
- path_to_get_data: str, the folder path where untouched data is
- path_to_save_data: str, the folder path where to save augmented data
- number_of_tranformation: int, number of transformation to perform
Returns:
--------
- None
"""
images_names, yolo_names = get_images_and_box_files_names(path_to_get_data)
augmentation_pipeline = A.Compose([
A.Resize(416, 416),
A.Equalize(by_channels=True),
A.RGBShift(r_shift_limit=(-30, 30),
g_shift_limit=(-30, 30),
b_shift_limit=(-30, 30),
p=0.25),
A.HorizontalFlip(p=0.35),
A.VerticalFlip(p=0.35),
A.ShiftScaleRotate(border_mode=cv2.BORDER_REPLICATE, p=0.35),
A.RandomSnow(brightness_coeff=2.0, p=0.2)
], A.BboxParams('yolo', ['class_labels']))
# Iterate through each image
for idx, name in enumerate(images_names):
image_path = path_to_get_data + '/' + name
image = cv2.imread(image_path)
yolo_file_path = path_to_get_data + '/' + yolo_names[idx]
labels, coordinates = get_labels_and_coordinates(yolo_file_path)
# Generate x tranformation of the images
for i in tqdm(range(number_of_tranformation)):
new_image_name, new_yolos_name = set_new_files_names(
name, i, "jpg", "txt")
# Catch error due to unproper labelling
try:
new_image, new_coordinates, labels = get_data_from_pipeline(
augmentation_pipeline, image, coordinates, labels)
except ValueError as e:
print("**** Error Message ****\n")
print(f"{e}\n")
print(f"""Invalid transformation of box:
{str(new_coordinates)}\n""")
print(f"Image: {new_image_name}\n")
continue
# Same each image to jpg with its corresponding coordinates
save_image_bbox_data(path_to_save_data, new_image, new_image_name,
new_coordinates, labels, new_yolos_name)
def generate_transforms2(img_size):
train_transform = Compose([
# A.RandomCrop(p=1, height=img_size, width=img_size),
A.Resize(height=img_size, width=img_size),
A.RandomSunFlare(p=1),
A.RandomFog(p=1),
A.RandomBrightness(p=1),
A.Rotate(p=1, limit=90),
A.RGBShift(p=1),
A.RandomSnow(p=1),
A.HorizontalFlip(p=1),
A.VerticalFlip(p=1),
A.RandomContrast(limit=0.5, p=1),
A.HueSaturationValue(p=1,
hue_shift_limit=20,
sat_shift_limit=30,
val_shift_limit=50),
# A.Cutout(p=1),
# A.Transpose(p=1),
A.JpegCompression(p=1),
A.CoarseDropout(p=1),
A.IAAAdditiveGaussianNoise(loc=0,
scale=(2.5500000000000003, 12.75),
per_channel=False,
p=1),
A.IAAAffine(scale=1.0,
translate_percent=None,
translate_px=None,
rotate=0.0,
shear=0.0,
order=1,
cval=0,
mode='reflect',
p=1),
A.IAAAffine(rotate=90., p=1),
A.IAAAffine(rotate=180., p=1),
Normalize(mean=(0.485, 0.456, 0.406),
std=(0.229, 0.224, 0.225),
max_pixel_value=255.0,
p=1.0),
ToTensorV2()
])
val_transform = Compose([
Resize(height=img_size, width=img_size),
Normalize(mean=(0.485, 0.456, 0.406),
std=(0.229, 0.224, 0.225),
max_pixel_value=255.0,
p=1.0),
ToTensorV2(),
])
return {"train": train_transform, "val": val_transform}
def get_training_augmentation():
train_transform = [
# albu.Resize(height=1248, width=1248, p=1),
# albu.HorizontalFlip(p=0.5),
albu.Flip(p=0.5),
albu.Transpose(p=0.5),
# albu.ShiftScaleRotate(scale_limit=0.5, rotate_limit=0, shift_limit=0.1, p=1, border_mode=0),
albu.RandomCrop(height=512, width=512, always_apply=True),
# albu.RandomGridShuffle(p=0.5),
albu.RandomSnow(brightness_coeff=1.0, p=0.5),
# albu.RandomSunFlare(p=0.5),
]
return albu.Compose(train_transform)
def augmentation_function(n_augment: int) -> A.core.composition.Compose:
"""Performs data augmentation on images with realistic parameters
Returns a Albumentation composition function"""
proba_transfo = 1 / n_augment
def random_proba(proba_transfo: float) -> float:
return max(0.4, min(1, proba_transfo + (2 * np.random.random() - 1) / 3))
return A.Compose(
[
A.HorizontalFlip(p=1),
A.Rotate(limit=25, p=random_proba(proba_transfo)),
A.RandomBrightness(limit=0.1, p=random_proba(proba_transfo)),
A.RandomSnow(brightness_coeff=0.95, snow_point_lower=0.1,
snow_point_upper=0.3, p=random_proba(proba_transfo)),
A.RandomFog(fog_coef_lower=0.1, fog_coef_upper=0.4,
alpha_coef=0.1, p=random_proba(proba_transfo)),
],
p=1.0,
bbox_params=A.BboxParams(format='yolo', label_fields=['category_ids'])
)
def augment(self, img, mask, do_affine_transform = True):
if do_affine_transform:
afine_transform = A.Compose([
A.HorizontalFlip(p=0.4),
A.OneOf([
A.GridDistortion(interpolation=cv2.INTER_NEAREST, border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0, p=1.0),
A.ElasticTransform(interpolation=cv2.INTER_NEAREST, alpha_affine=10, border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0, p=1.0),
A.ShiftScaleRotate(interpolation=cv2.INTER_NEAREST, shift_limit=0.03, rotate_limit=4, border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0, p=1.0),
A.OpticalDistortion(interpolation=cv2.INTER_NEAREST, border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0, p=1.0)
], p=0.6),
], additional_targets={'mask': 'image'})
afine_transformed = afine_transform(image=img, mask=mask)
img = afine_transformed["image"]
mask = afine_transformed["mask"]
transform = A.Compose([
A.IAAAdditiveGaussianNoise(p=0.05),
A.OneOf([
A.IAASharpen(p=1.0),
A.Blur(blur_limit=3, p=1.0),
] , p=0.5),
A.OneOf([
A.RandomBrightnessContrast(p=1.0),
A.HueSaturationValue(p=1.0),
A.RandomGamma(p=1.0),
], p=0.5),
A.OneOf([
A.RandomFog(p=1.0),
A.RandomRain(p=1.0),
A.RandomShadow(p=1.0),
A.RandomSnow(p=1.0),
A.RandomSunFlare(p=1.0)
], p=0.05),
])
transformed = transform(image=img)
img = transformed["image"]
return img, mask
def get_transform_imagenet(use_albu_aug):
if use_albu_aug:
train_transform = al.Compose([
# al.Flip(p=0.5),
al.Resize(256, 256, interpolation=2),
al.RandomResizedCrop(224,
224,
scale=(0.08, 1.0),
ratio=(3. / 4., 4. / 3.),
interpolation=2),
al.HorizontalFlip(),
al.OneOf(
[
al.OneOf(
[
al.ShiftScaleRotate(
border_mode=cv2.BORDER_CONSTANT,
rotate_limit=30), # , p=0.05),
al.OpticalDistortion(
border_mode=cv2.BORDER_CONSTANT,
distort_limit=5.0,
shift_limit=0.1),
# , p=0.05),
al.GridDistortion(border_mode=cv2.BORDER_CONSTANT
), # , p=0.05),
al.ElasticTransform(
border_mode=cv2.BORDER_CONSTANT,
alpha_affine=15), # , p=0.05),
],
p=0.1),
al.OneOf(
[
al.RandomGamma(), # p=0.05),
al.HueSaturationValue(), # p=0.05),
al.RGBShift(), # p=0.05),
al.CLAHE(), # p=0.05),
al.ChannelShuffle(), # p=0.05),
al.InvertImg(), # p=0.05),
],
p=0.1),
al.OneOf(
[
al.RandomSnow(), # p=0.05),
al.RandomRain(), # p=0.05),
al.RandomFog(), # p=0.05),
al.RandomSunFlare(num_flare_circles_lower=1,
num_flare_circles_upper=2,
src_radius=110),
# p=0.05, ),
al.RandomShadow(), # p=0.05),
],
p=0.1),
al.RandomBrightnessContrast(p=0.1),
al.OneOf(
[
al.GaussNoise(), # p=0.05),
al.ISONoise(), # p=0.05),
al.MultiplicativeNoise(), # p=0.05),
],
p=0.1),
al.OneOf(
[
al.ToGray(), # p=0.05),
al.ToSepia(), # p=0.05),
al.Solarize(), # p=0.05),
al.Equalize(), # p=0.05),
al.Posterize(), # p=0.05),
al.FancyPCA(), # p=0.05),
],
p=0.1),
al.OneOf(
[
# al.MotionBlur(blur_limit=1),
al.Blur(blur_limit=[3, 5]),
al.MedianBlur(blur_limit=[3, 5]),
al.GaussianBlur(blur_limit=[3, 5]),
],
p=0.1),
al.OneOf(
[
al.CoarseDropout(), # p=0.05),
al.Cutout(), # p=0.05),
al.GridDropout(), # p=0.05),
al.ChannelDropout(), # p=0.05),
al.RandomGridShuffle(), # p=0.05),
],
p=0.1),
al.OneOf(
[
al.Downscale(), # p=0.1),
al.ImageCompression(quality_lower=60), # , p=0.1),
],
p=0.1),
],
p=0.5),
al.Normalize(),
ToTensorV2()
])
else:
train_transform = transforms.Compose([
transforms.Resize(256),
transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
])
test_transform = transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
])
if use_albu_aug:
train_transform = MultiDataTransformAlbu(train_transform)
else:
train_transform = MultiDataTransform(train_transform)
return train_transform, test_transform
def augment(self,
img1, bbox1 = [], keypoints1 = [], filtered_objs1 = [],
img0 = None, bbox0 = [], keypoints0 = [], filtered_objs0 = [],
do_img_aug = True, do_affine_aug = False, img1_to_img0 = False
):
if img0 is None:
img0 = img1.copy()
replay_img_aug = []
keypoints = keypoints1 + keypoints0
bboxes = bbox1 + bbox0
# Afine augmentations
# --------------------------------------
if do_affine_aug:
afine_transform = A.ReplayCompose(
[
A.HorizontalFlip(p=0.4),
A.OneOf([
# A.GridDistortion(interpolation=cv2.INTER_NEAREST, border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0, p=1.0),
# A.ElasticTransform(interpolation=cv2.INTER_NEAREST, alpha_affine=10, border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0, p=1.0),
A.ShiftScaleRotate(interpolation=cv2.INTER_NEAREST, shift_limit=0.035, rotate_limit=5, border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0, p=1.0),
# A.OpticalDistortion(interpolation=cv2.INTER_NEAREST, border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0, p=1.0),
], p=0.65),
],
additional_targets={"img0": "image"},
keypoint_params=A.KeypointParams(format="xy", remove_invisible=False),
bbox_params=A.BboxParams(format='coco', label_fields=["bbox_ids"]), # coco format: [x-min, y-min, width, height]
)
transformed = afine_transform(image=img1, img0=img0, keypoints=keypoints, bboxes=bboxes, bbox_ids=np.arange(len(bboxes)))
replay_img_aug.append(transformed["replay"])
img1 = transformed["image"]
img0 = transformed["img0"]
transformed_keypoints = transformed['keypoints']
transformed_bboxes = transformed['bboxes']
bbox_ids = transformed["bbox_ids"]
# it can happend that bounding boxes are removed, we have to account for that
# and also remove the objects and keypoints in question
idx_offset = len(bbox1)
keypoints1 = []
keypoints0 = []
bbox1 = []
bbox0 = []
tmp_filtered_objs1 = []
tmp_filtered_objs0 = []
for i, bbox_id in enumerate(bbox_ids):
kp_idx_start = bbox_id * 8
kp_idx_end = bbox_id * 8 + 8
if bbox_id < idx_offset:
tmp_filtered_objs1.append(filtered_objs1[i])
bbox1.append(transformed_bboxes[i])
keypoints1 += transformed_keypoints[kp_idx_start:kp_idx_end]
else:
tmp_filtered_objs0.append(filtered_objs0[i])
bbox0.append(transformed_bboxes[i])
keypoints0 += transformed_keypoints[kp_idx_start:kp_idx_end]
filtered_objs1 = tmp_filtered_objs1
filtered_objs0 = tmp_filtered_objs0
# Translate img0 + bbox0/keypoints0 for single track centernet
# --------------------------------------
if img1_to_img0:
transform = A.Compose(
[A.ShiftScaleRotate(shift_limit=0.1, scale_limit=0.15, rotate_limit=0, always_apply=True, border_mode=cv2.BORDER_CONSTANT)],
keypoint_params=A.KeypointParams(format="xy", remove_invisible=False),
bbox_params=A.BboxParams(format='coco', label_fields=[])
)
keypoints = list(np.array(piped_params["gt_2d_info"])[:,:2] * self.params.R)
transformed = transform(image=img1, keypoints=keypoints1, bboxes=bboxes1)
img0 = transformed["image"]
bboxes0 = transformed['bboxes']
keypoints0 = transformed['keypoints']
# Augmentation for images
# --------------------------------------
if do_img_aug:
transform = A.ReplayCompose([
A.IAAAdditiveGaussianNoise(p=0.02),
A.OneOf([
A.IAASharpen(p=1.0),
A.Blur(blur_limit=3, p=1.0),
] , p=0.5),
A.OneOf([
A.RandomBrightnessContrast(p=1.0),
A.HueSaturationValue(p=1.0),
A.RandomGamma(p=1.0),
], p=0.6),
A.OneOf([
A.RandomFog(p=1.0),
A.RandomRain(p=1.0),
A.RandomShadow(p=1.0),
A.RandomSnow(p=1.0)
], p=0.02),
], additional_targets={"img0": "image"})
transformed = transform(image=img1, img0=img0)
img1 = transformed["image"]
img0 = transformed["img0"]
return img1, bbox1, keypoints1, filtered_objs1, img0, bbox0, keypoints0, filtered_objs0, replay_img_aug
def __call__(self, data):
rgb, thermal, depth, audio, label, id = data
rgb = rgb.astype(np.float32)
height, width, _ = rgb.shape
albumentations_transform_pixel = {
'Blur': albumentations.Blur(),
#'CLAHE':albumentations.CLAHE(),
'ChannelDropout': albumentations.ChannelDropout(),
'ChannelShuffle': albumentations.ChannelShuffle(),
'CoarseDropout': albumentations.CoarseDropout(),
#'Equalize':albumentations.Equalize(),
#'FancyPCA':albumentations.FancyPCA(),
'GaussNoise': albumentations.GaussNoise(),
'GaussianBlur': albumentations.GaussianBlur(),
#'GlassBlur':albumentations.GlassBlur(),
'HueSaturationValue': albumentations.HueSaturationValue(),
'IAAAdditiveGaussianNoise':
albumentations.IAAAdditiveGaussianNoise(),
#'ISONoise':albumentations.ISONoise(),
'RGBShift': albumentations.RGBShift(),
'RandomBrightnessContrast':
albumentations.RandomBrightnessContrast(),
'RandomFog': albumentations.RandomFog(),
#'RandomGamma':albumentations.RandomGamma(),
'RandomRain': albumentations.RandomRain(),
'RandomShadow': albumentations.RandomShadow(),
'RandomSnow': albumentations.RandomSnow(),
'RandomSunFlare': albumentations.RandomSunFlare(),
'Solarize': albumentations.Solarize(),
}
albumentations_transform_bbox = {
#'HorizontalFlip':albumentations.HorizontalFlip(),
#'VerticalFlip':albumentations.VerticalFlip(),
#'CenterCrop':albumentations.CenterCrop(height=height-10, width=width-10, p=0.5),
#'RandomCropNearBBox':albumentations.RandomCropNearBBox(p=0.5),
#'Crop':albumentations.Crop(x_min=10, y_min =10, y_max=height-10, x_max=width-10, p=0.5),
#'ElasticTransform':albumentations.ElasticTransform(),
#'ShiftScaleRotate':albumentations.ShiftScaleRotate(),
}
transform = np.random.choice(
['None'] + list(albumentations_transform_pixel.keys()) +
list(albumentations_transform_bbox.keys()))
if transform in albumentations_transform_pixel:
aug = albumentations.Compose(
[albumentations_transform_pixel[transform]],
bbox_params={
'format': 'pascal_voc',
'label_fields': ['labels']
})
try:
annots = np.array(annots).astype(np.float32)
aug_result = aug(image=rgb,
bboxes=annots[:, :4],
labels=annots[:, 4])
rgb = aug_result['image']
annots = np.hstack([
aug_result['bboxes'],
np.array(aug_result['labels']).reshape(-1, 1)
])
except Exception as e:
print(
f"transform={transform} aug_result['bboxes']={aug_result['bboxes']} aug_result['labels']={aug_result['labels']}"
)
raise Exception(e)
elif transform in albumentations_transform_bbox:
aug = albumentations.Compose(
[albumentations_transform_bbox[transform]],
bbox_params={
'format': 'pascal_voc',
'label_fields': ['labels']
})
try:
annots = np.array(annots).astype(np.float32)
aug_result = aug(image=rgb,
bboxes=annots[:, :4],
labels=annots[:, 4])
rgb = aug_result['image']
label = np.hstack([
aug_result['bboxes'],
np.array(aug_result['labels']).reshape(-1, 1)
])
except Exception as e:
print(
f"transform={transform} aug_result['bboxes']={aug_result['bboxes']} aug_result['labels']={aug_result['labels']}"
)
raise Exception(e)
return rgb, thermal, depth, audio, label, id
def data_snow():
return A.Compose([
A.Resize(size, size),
A.RandomSnow(),
ToTensorV2(transpose_mask=True)
])
def get_train_transforms(height: int = 437,
width: int = 582,
level: str = 'hard'):
if level == 'light':
return A.Compose([
A.HorizontalFlip(p=0.5),
A.IAAAdditiveGaussianNoise(p=0.2),
A.OneOf([
A.CLAHE(p=1.0),
A.RandomBrightness(p=1.0),
A.RandomGamma(p=1.0),
],
p=0.5),
A.OneOf([
A.IAASharpen(p=1.0),
A.Blur(blur_limit=3, p=1.0),
A.MotionBlur(blur_limit=3, p=1.0),
],
p=0.5),
A.OneOf([
A.RandomContrast(p=1.0),
A.HueSaturationValue(p=1.0),
],
p=0.5),
A.Resize(height=height, width=width, p=1.0),
A.PadIfNeeded(pad_to_multiple(height),
pad_to_multiple(width),
border_mode=cv2.BORDER_CONSTANT,
value=0,
mask_value=0)
],
p=1.0)
elif level == 'hard':
return A.Compose([
A.HorizontalFlip(p=0.5),
A.IAAAdditiveGaussianNoise(p=0.2),
A.OneOf([
A.GridDistortion(border_mode=cv2.BORDER_CONSTANT,
value=0,
mask_value=0,
p=1.0),
A.ElasticTransform(alpha_affine=10,
border_mode=cv2.BORDER_CONSTANT,
value=0,
mask_value=0,
p=1.0),
A.ShiftScaleRotate(shift_limit=0,
scale_limit=0,
rotate_limit=10,
border_mode=cv2.BORDER_CONSTANT,
value=0,
mask_value=0,
p=1.0),
A.OpticalDistortion(border_mode=cv2.BORDER_CONSTANT,
value=0,
mask_value=0,
p=1.0),
],
p=0.5),
A.OneOf([
A.CLAHE(p=1.0),
A.RandomBrightness(p=1.0),
A.RandomGamma(p=1.0),
A.ISONoise(p=1.0)
],
p=0.5),
A.OneOf([
A.IAASharpen(p=1.0),
A.Blur(blur_limit=3, p=1.0),
A.MotionBlur(blur_limit=3, p=1.0),
],
p=0.5),
A.OneOf([
A.RandomContrast(p=1.0),
A.HueSaturationValue(p=1.0),
],
p=0.5),
A.Resize(height=height, width=width, p=1.0),
A.Cutout(p=0.3),
A.PadIfNeeded(pad_to_multiple(height),
pad_to_multiple(width),
border_mode=cv2.BORDER_CONSTANT,
value=0,
mask_value=0)
],
p=1.0)
elif level == 'hard_weather':
return A.Compose([
A.HorizontalFlip(p=0.5),
A.IAAAdditiveGaussianNoise(p=0.2),
A.OneOf([
A.GridDistortion(border_mode=cv2.BORDER_CONSTANT,
value=0,
mask_value=0,
p=1.0),
A.ElasticTransform(alpha_affine=10,
border_mode=cv2.BORDER_CONSTANT,
value=0,
mask_value=0,
p=1.0),
A.ShiftScaleRotate(shift_limit=0,
scale_limit=0,
rotate_limit=10,
border_mode=cv2.BORDER_CONSTANT,
value=0,
mask_value=0,
p=1.0),
A.OpticalDistortion(border_mode=cv2.BORDER_CONSTANT,
value=0,
mask_value=0,
p=1.0),
],
p=0.5),
A.OneOf([
A.CLAHE(p=1.0),
A.RandomBrightness(p=1.0),
A.RandomGamma(p=1.0),
A.ISONoise(p=1.0)
],
p=0.5),
A.OneOf([
A.IAASharpen(p=1.0),
A.Blur(blur_limit=3, p=1.0),
A.MotionBlur(blur_limit=3, p=1.0),
],
p=0.5),
A.OneOf([
A.RandomContrast(p=1.0),
A.HueSaturationValue(p=1.0),
],
p=0.5),
A.OneOf([
A.RandomFog(fog_coef_upper=0.8, p=1.0),
A.RandomRain(p=1.0),
A.RandomSnow(p=1.0),
A.RandomSunFlare(src_radius=100, p=1.0)
],
p=0.4),
A.Resize(height=height, width=width, p=1.0),
A.Cutout(p=0.3),
A.PadIfNeeded(pad_to_multiple(height),
pad_to_multiple(width),
border_mode=cv2.BORDER_CONSTANT,
value=0,
mask_value=0)
],
p=1.0)
def get_transforms(aug_type: str):
"""
Data augmentation 객체 생성
Args:
aug_type(str) : augmentation타입 지정
Returns :
list :: train, validation, test데이터 셋에 대한 transform
"""
# TODO: Normalize
if False:
pass
else:
norm_mean = (0, 0, 0)
norm_std = (1, 1, 1)
if aug_type == 'no':
train_transform = A.Compose(
[A.Normalize(mean=norm_mean, std=norm_std),
ToTensorV2()])
val_transform = A.Compose(
[A.Normalize(mean=norm_mean, std=norm_std),
ToTensorV2()])
test_transform = A.Compose(
[A.Normalize(mean=norm_mean, std=norm_std),
ToTensorV2()])
elif aug_type == 'dev':
pass
elif aug_type == 'final':
train_transform = A.Compose([
A.HorizontalFlip(p=0.5),
A.RandomResizedCrop(512,
512,
p=0.8,
scale=(0.7, 1.0),
ratio=(0.5, 1.5)),
A.Rotate(limit=30, p=0.8),
A.Cutout(num_holes=4, max_h_size=16, max_w_size=16, p=0.8),
A.ElasticTransform(alpha=40, p=0.8),
A.CLAHE(clip_limit=3.0, p=0.8),
A.Normalize(mean=norm_mean, std=norm_std),
ToTensorV2()
])
val_transform = A.Compose(
[A.Normalize(mean=norm_mean, std=norm_std),
ToTensorV2()])
test_transform = A.Compose(
[A.Normalize(mean=norm_mean, std=norm_std),
ToTensorV2()])
# TODO: 아래 코드 정리 중
elif aug_type == 'basic':
train_transform = A.Compose([
A.Normalize(mean=(0.46009655, 0.43957878, 0.41827092),
std=(0.2108204, 0.20766491, 0.21656131),
max_pixel_value=255.0,
p=1.0),
ToTensorV2()
])
val_transform = A.Compose([
A.Normalize(mean=(0.46009655, 0.43957878, 0.41827092),
std=(0.2108204, 0.20766491, 0.21656131),
max_pixel_value=255.0,
p=1.0),
ToTensorV2()
])
test_transform = A.Compose([ToTensorV2()])
elif aug_type == "aug1":
train_transform = A.Compose([
A.OneOf([
A.ElasticTransform(alpha=120,
sigma=120 * 0.05,
alpha_affine=120 * 0.03,
p=0.5),
A.GridDistortion(p=1.0),
A.OpticalDistortion(distort_limit=2, shift_limit=0.5, p=1)
],
p=0.8),
A.VerticalFlip(p=0.5),
A.RandomBrightnessContrast(p=0.8),
A.RandomGamma(p=0.8),
A.RandomRotate90(p=0.5),
ToTensorV2()
])
val_transform = A.Compose([ToTensorV2()])
test_transform = A.Compose([ToTensorV2()])
elif aug_type == "aug2":
train_transform = A.Compose([
A.OneOf([
A.RandomShadow(p=1),
A.RandomSunFlare(num_flare_circles_lower=1,
num_flare_circles_upper=5,
src_radius=250,
p=1),
A.RandomRain(p=1),
A.RandomSnow(brightness_coeff=1.5, p=1),
A.RandomFog(
fog_coef_lower=0.8, fog_coef_upper=1, alpha_coef=0.08, p=1)
],
p=0.8),
ToTensorV2()
])
val_transform = A.Compose([ToTensorV2()])
test_transform = A.Compose([ToTensorV2()])
elif aug_type == "aug3":
train_transform = A.Compose([
A.OneOf([
A.HueSaturationValue(hue_shift_limit=0.2,
sat_shift_limit=0.2,
val_shift_limit=0.2,
p=1),
A.MultiplicativeNoise(
multiplier=(0.9, 1.1), per_channel=True, p=1),
A.RGBShift(r_shift_limit=0.1,
g_shift_limit=0.1,
b_shift_limit=0.1,
p=1),
A.ChannelShuffle(0.05)
],
p=0.8),
ToTensorV2()
])
val_transform = A.Compose([ToTensorV2()])
test_transform = A.Compose([ToTensorV2()])
elif aug_type == "aug4":
train_transform = A.Compose([
A.HorizontalFlip(p=0.5),
A.VerticalFlip(p=0.5),
A.RandomRotate90(p=0.5),
ToTensorV2()
])
val_transform = A.Compose([ToTensorV2()])
test_transform = A.Compose([ToTensorV2()])
elif aug_type == "aug5":
train_transform = A.Compose([
A.VerticalFlip(p=0.5),
A.RandomRotate90(p=0.5),
#A.ElasticTransform(p=1, alpha=120, sigma=120 * 0.05, alpha_affine=120 * 0.03),
#A.GridDistortion(p=1.0),
#A.OpticalDistortion(distort_limit=2, shift_limit=0.5, p=1)
#A.VerticalFlip(p=0.5),
#A.RandomBrightnessContrast(p=0.8),
#A.RandomGamma(p=0.8),
#A.RandomRotate90(p=0.5),
#A.MultiplicativeNoise(multiplier=(0.9, 1.1), per_channel=True, p=0.8),
ToTensorV2()
])
val_transform = A.Compose([ToTensorV2()])
test_transform = A.Compose([ToTensorV2()])
return train_transform, val_transform, test_transform
float(elems[2]),
float(elems[3]),
float(elems[4]),
int(elems[0])
])
lines.close()
image = cv2.imread(imgpath)
for i in range(n): #A.ShiftScaleRotate(p=0.2)
print(".", end="", flush=True)
transform_list = list()
#A.Resize()
seed_weather = random.randint(0, 2)
seed_contrast = random.randint(0, 2)
seed_rotate = random.randint(0, 2)
if seed_weather == 0:
transform_list.append(A.RandomSnow(p=0.5))
else:
transform_list.append(A.RandomRain(p=0.5))
if seed_contrast == 1:
transform_list.append(A.RandomBrightnessContrast(p=0.5))
if seed_rotate == 1:
transform_list.append(
A.ShiftScaleRotate(p=0.5, rotate_limit=15))
transform = A.Compose(transforms=transform_list,
bbox_params=A.BboxParams(format="yolo"))
res = transform(image=image, bboxes=bboxes)
outputimgpath = outputImgs + originname + '-' + str(i) + '.jpg'
outputannpath = outputAnns + originname + '-' + str(i) + '.txt'
cv2.imwrite(outputimgpath, res["image"])
outfile = open(outputannpath, "wt")
for elems in res["bboxes"]:
chosen_image = cv2.imread(image_path)
plt.imshow(chosen_image)
#%%
# ref)
# Albumentations part adapted from my good friend Hongnan's notebbok in the Global Wheat Detection competition (https://www.kaggle.com/reighns/augmentations-data-cleaning-and-bounding-boxes#Bounding-Boxes-with-Albumentations)
#%%
albumentation_list = [
A.RandomSunFlare(p=1),
A.RandomFog(p=1),
A.RandomBrightness(p=1),
A.RandomCrop(p=1, height=512, width=512),
A.Rotate(p=1, limit=90),
A.RGBShift(p=1),
A.RandomSnow(p=1),
A.HorizontalFlip(p=1),
A.VerticalFlip(p=1),
A.RandomContrast(limit=0.5, p=1),
A.HueSaturationValue(p=1,
hue_shift_limit=20,
sat_shift_limit=30,
val_shift_limit=50),
A.Cutout(p=1),
A.Transpose(p=1),
A.JpegCompression(p=1),
A.CoarseDropout(p=1),
A.IAAAdditiveGaussianNoise(loc=0,
scale=(2.5500000000000003, 12.75),
per_channel=False,
p=1),
"""
def __init__(self, transforms):
self.transforms = transforms
def __call__(self, img):
n = len(self.transforms)
idx = np.random.randint(0, n - 1)
t = self.transforms[idx]
return t(image=img)
rand_weather = OneOf([
am.RandomRain(),
am.RandomFog(),
am.RandomSnow(),
]) # 策略2，随机天气，自然界可能随机发生一些天气现象，增强模型对天气现象的抗干扰能力，参考链接https://github.com/UjjwalSaxena/Automold--Road-Augmentation-Library
sharpOrBlur = OneOf([
am.GaussianBlur(), # 高斯模糊在mnist中我已经提供了一个自己实现的版本，这里选择调库
am.IAASharpen(),
])
noiser = OneOf([
GaussNoise(),
SaltAndPepper(),
])
strategy = [eraser, rand_weather, sharpOrBlur, noiser]
# res_images = np.zeros(shape=(100000, 32, 32, 3))
def get_train_transforms_mmdetection(input_size,
use_crop=False,
use_no_color_aug=False,
use_center_crop=False,
center_crop_ratio=0.9,
use_gray=False):
if isinstance(input_size, int):
input_size = (input_size[0], input_size[1])
return al.Compose([
al.RandomResizedCrop(height=input_size[0],
width=input_size[1],
scale=(0.4, 1.0),
interpolation=0,
p=0.5),
al.Resize(input_size[0], input_size[1], p=1.0),
al.HorizontalFlip(p=0.5),
al.OneOf([
al.ShiftScaleRotate(border_mode=0,
shift_limit=(-0.2, 0.2),
scale_limit=(-0.2, 0.2),
rotate_limit=(-20, 20)),
al.OpticalDistortion(border_mode=0,
distort_limit=[-0.5, 0.5],
shift_limit=[-0.5, 0.5]),
al.GridDistortion(
num_steps=5, distort_limit=[-0., 0.3], border_mode=0),
al.ElasticTransform(border_mode=0),
al.IAAPerspective(),
al.RandomGridShuffle()
],
p=0.1),
al.Rotate(limit=(-25, 25), border_mode=0, p=0.1),
al.OneOf([
al.RandomBrightnessContrast(brightness_limit=(-0.2, 0.2),
contrast_limit=(-0.2, 0.2)),
al.HueSaturationValue(hue_shift_limit=(-20, 20),
sat_shift_limit=(-30, 30),
val_shift_limit=(-20, 20)),
al.RandomGamma(gamma_limit=(30, 150)),
al.RGBShift(),
al.CLAHE(clip_limit=(1, 15)),
al.ChannelShuffle(),
al.InvertImg(),
],
p=0.1),
al.RandomSnow(p=0.05),
al.RandomRain(p=0.05),
al.RandomFog(p=0.05),
al.RandomSunFlare(num_flare_circles_lower=1,
num_flare_circles_upper=2,
src_radius=110,
p=0.05),
al.RandomShadow(p=0.05),
al.GaussNoise(var_limit=(10, 20), p=0.05),
al.ISONoise(color_shift=(0, 15), p=0.05),
al.MultiplicativeNoise(p=0.05),
al.OneOf([
al.ToGray(p=1. if use_gray else 0.05),
al.ToSepia(p=0.05),
al.Solarize(p=0.05),
al.Equalize(p=0.05),
al.Posterize(p=0.05),
al.FancyPCA(p=0.05),
],
p=0.05),
al.OneOf([
al.MotionBlur(blur_limit=(3, 7)),
al.Blur(blur_limit=(3, 7)),
al.MedianBlur(blur_limit=3),
al.GaussianBlur(blur_limit=3),
],
p=0.05),
al.CoarseDropout(p=0.05),
al.Cutout(num_holes=30,
max_h_size=37,
max_w_size=37,
fill_value=0,
p=0.05),
al.GridDropout(p=0.05),
al.ChannelDropout(p=0.05),
al.Downscale(scale_min=0.5, scale_max=0.9, p=0.1),
al.ImageCompression(quality_lower=60, p=0.2),
al.Normalize(),
ToTensorV2()
])
def get_train_transforms_atopy(input_size,
use_crop=False,
use_no_color_aug=False):
if use_crop:
resize = [
al.Resize(int(input_size * 1.2), int(input_size * 1.2)),
al.RandomSizedCrop(min_max_height=(int(input_size * 0.6),
int(input_size * 1.2)),
height=input_size,
width=input_size)
]
else:
resize = [al.Resize(input_size, input_size)]
return al.Compose(resize + [
al.Flip(p=0.5),
al.OneOf([
al.RandomRotate90(),
al.Rotate(limit=180),
], p=0.5),
al.OneOf([
al.ShiftScaleRotate(),
al.OpticalDistortion(),
al.GridDistortion(),
al.ElasticTransform(),
],
p=0.3),
al.RandomGridShuffle(p=0.05),
al.OneOf([
al.RandomGamma(),
al.HueSaturationValue(),
al.RGBShift(),
al.CLAHE(),
al.ChannelShuffle(),
al.InvertImg(),
],
p=0.1),
al.RandomSnow(p=0.05),
al.RandomRain(p=0.05),
al.RandomFog(p=0.05),
al.RandomSunFlare(p=0.05),
al.RandomShadow(p=0.05),
al.RandomBrightnessContrast(p=0.05),
al.GaussNoise(p=0.2),
al.ISONoise(p=0.2),
al.MultiplicativeNoise(p=0.2),
al.ToGray(p=0.05),
al.ToSepia(p=0.05),
al.Solarize(p=0.05),
al.Equalize(p=0.05),
al.Posterize(p=0.05),
al.FancyPCA(p=0.05),
al.OneOf([
al.MotionBlur(blur_limit=3),
al.Blur(blur_limit=3),
al.MedianBlur(blur_limit=3),
al.GaussianBlur(blur_limit=3),
],
p=0.05),
al.CoarseDropout(p=0.05),
al.Cutout(p=0.05),
al.GridDropout(p=0.05),
al.ChannelDropout(p=0.05),
al.Downscale(p=0.1),
al.ImageCompression(quality_lower=60, p=0.2),
al.Normalize(),
ToTensorV2()
])
A.OneOf([
A.CLAHE(clip_limit=2),
A.IAASharpen(),
A.IAAEmboss(),
], p=0.2),
A.OneOf([
A.OpticalDistortion(p=0.3),
A.GridDistortion(p=.1),
A.IAAPiecewiseAffine(p=0.3),
], p=0.2),
A.OneOf([
A.RandomFog(p=0.05),
A.RandomShadow(p=0.05),
A.RandomSnow(p=0.05),
A.HueSaturationValue(p=0.05),
], p=0.1),
A.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)),
albumentations.pytorch.transforms.ToTensor()
])
def UpDown_Resize(image, upsize, downsize, p=0.1):
num = random.random()
if num<p:
image = cv2.resize(image, (upsize,upsize))
image = cv2.resize(image, (downsize,downsize))
return image
def __call__(self, image, boxes=None, labels=None):
#initialize the format for lib albumentations
if boxes.shape[0] == 0:
return image, boxes, labels
bbox = []
for i in boxes:
bbox.append(list(i))
#create annotations
annotations = {
'image': image,
'bboxes': boxes,
'category_id': list(labels)
}
#create translation
#Color_Level Change
if self.cfg.DATA_LOADER.AUGMENTATION_WEATHER:
trans_color_level = A.Compose([
A.Cutout(num_holes=20,
max_h_size=64,
max_w_size=64,
fill_value=255,
always_apply=False,
p=0.8),
A.Equalize(p=1),
A.HueSaturationValue(hue_shift_limit=50,
sat_shift_limit=50,
val_shift_limit=50,
always_apply=False,
p=0.8),
A.OneOf([
A.RandomFog(fog_coef_lower=0.3,
fog_coef_upper=0.7,
alpha_coef=0.08,
always_apply=False,
p=0.5),
A.RandomSnow(snow_point_lower=0.1,
snow_point_upper=0.3,
brightness_coeff=2.5,
always_apply=False,
p=0.5),
A.RandomSunFlare(flare_roi=(0, 0, 1, 0.5),
angle_lower=0,
angle_upper=1,
num_flare_circles_lower=6,
num_flare_circles_upper=10,
src_radius=400,
src_color=(255, 255, 255),
always_apply=False,
p=0.5),
A.RandomRain(slant_lower=-10,
slant_upper=10,
drop_length=20,
drop_width=1,
drop_color=(200, 200, 200),
blur_value=7,
brightness_coefficient=0.7,
rain_type=None,
always_apply=False,
p=0.5)
]),
A.OneOf([
A.RandomSizedBBoxSafeCrop(720,
960,
erosion_rate=0.0,
interpolation=1,
always_apply=False,
p=0.5),
A.RandomSizedBBoxSafeCrop(480,
640,
erosion_rate=0.0,
interpolation=1,
always_apply=False,
p=0.5),
A.RandomSizedBBoxSafeCrop(240,
320,
erosion_rate=0.0,
interpolation=1,
always_apply=False,
p=0.5),
]),
])
else:
trans_color_level = A.Compose([
A.Cutout(num_holes=20,
max_h_size=64,
max_w_size=64,
fill_value=255,
always_apply=False,
p=0.5),
A.Equalize(p=1),
A.HueSaturationValue(hue_shift_limit=50,
sat_shift_limit=50,
val_shift_limit=50,
always_apply=False,
p=0.5),
A.OneOf([
A.RandomSizedBBoxSafeCrop(720,
960,
erosion_rate=0.0,
interpolation=1,
always_apply=False,
p=0.5),
A.RandomSizedBBoxSafeCrop(480,
640,
erosion_rate=0.0,
interpolation=1,
always_apply=False,
p=0.5),
A.RandomSizedBBoxSafeCrop(240,
320,
erosion_rate=0.0,
interpolation=1,
always_apply=False,
p=0.5),
]),
])
#Spatial_Level
if self.cfg.DATA_LOADER.AUGMENTATION_SPATIAL_LEVEL:
trans_rotate_level = A.Compose([
A.OneOf([
A.Rotate(limit=90,
interpolation=1,
border_mode=4,
value=None,
mask_value=None,
always_apply=False,
p=0.5),
A.RandomRotate90(always_apply=False, p=0.5),
A.VerticalFlip(always_apply=False, p=0.5),
A.HorizontalFlip(always_apply=False, p=0.5)
]),
])
#Apply the trans
aug = get_aug(trans_color_level)
augmented = aug(**annotations)
img = augmented['image']
bbox = augmented['bboxes']
bbox = np.array(bbox)
label = augmented['category_id']
#try rotate
if self.cfg.DATA_LOADER.AUGMENTATION_SPATIAL_LEVEL:
aug1 = get_aug(trans_rotate_level)
augmented1 = aug1(**augmented)
img1 = augmented1['image']
bbox1 = augmented1['bboxes']
bbox1 = np.array(bbox1)
label1 = augmented1['category_id']
#if rotate fail
if bbox1.shape[0] == 0:
return img, bbox.astype(np.float32), np.array(label)
else:
return img1, bbox1.astype(np.float32), np.array(label1)
else:
return img, bbox.astype(np.float32), np.array(label)
