def get_train_transforms():
# noinspection PyTypeChecker
return A.Compose([
A.RandomSizedCrop(
min_max_height=(850, 850), height=1024, width=1024, p=0.3),
A.OneOf([
A.HueSaturationValue(hue_shift_limit=0.2,
sat_shift_limit=0.2,
val_shift_limit=0.2,
p=0.8),
A.RandomBrightnessContrast(
brightness_limit=0.2, contrast_limit=0.2, p=0.9)
],
p=0.5),
A.OneOf([
A.RandomRain(rain_type='drizzle', p=0.2),
A.GaussianBlur(blur_limit=7, p=0.5),
A.GaussNoise((0.2, 0.25), p=0.3),
A.RandomShadow(p=0.2)
],
p=0.4),
A.ToGray(p=0.01),
A.Flip(p=0.5),
A.CoarseDropout(max_height=64,
max_width=64,
min_holes=3,
min_height=32,
min_width=32,
p=0.5),
A.Resize(Config.Train.img_size, Config.Train.img_size, p=1.0),
ToTensorV2(p=1.0),
],
bbox_params=BboxParams('pascal_voc',
label_fields=['labels'],
min_visibility=0.0))
def model_predict(img_path):
#input_image= io.imread(img_path)
# Declare an augmentation pipeline
transform = 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=1)
#Read an image with OpenCV and convert it to the RGB colorspace
image = cv2.imread(img_path)
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
# Augment an image
transformed = transform(image=image)
transformed_image = transformed["image"]
cv2.imwrite('image.jpg', transformed_image)
return cv2.imwrite('image.jpg', transformed_image)
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 elastic_tranform_r_brightness(p=1.0):
return albumentations.Compose([
albumentations.ElasticTransform(p=p),
albumentations.RandomBrightnessContrast(p=p),
albumentations.RandomRain(p=p)
],
p=p)
def get_tfms_albu(p=0.6): return A.Compose([
A.HorizontalFlip(),
A.ShiftScaleRotate(rotate_limit=15),
A.ChannelDropout(p=0.1),
A.RandomRain(p=0.1),
A.GridDistortion(p=0.2)
], p=p)
def augmentation(image_size, train=True):
max_crop = image_size // 5
if train:
data_transform = A.Compose([
A.Resize(image_size, image_size),
A.Compose([
A.OneOf([
A.RandomRain(p=0.1),
A.GaussNoise(mean=15),
A.GaussianBlur(blur_limit=10, p=0.4),
A.MotionBlur(p=0.2)
]),
A.OneOf([
A.RGBShift(p=1.0,
r_shift_limit=(-10, 10),
g_shift_limit=(-10, 10),
b_shift_limit=(-10, 10)),
A.RandomBrightnessContrast(
brightness_limit=0.3, contrast_limit=0.1, p=1),
A.HueSaturationValue(hue_shift_limit=20, p=1),
],
p=0.6),
A.OneOf([
A.CLAHE(clip_limit=2),
A.IAASharpen(),
A.IAAEmboss(),
]),
A.OneOf([A.IAAPerspective(p=0.3),
A.ElasticTransform(p=0.1)]),
A.OneOf([
A.Rotate(limit=25, p=0.6),
A.IAAAffine(
scale=0.9,
translate_px=15,
rotate=25,
shear=0.2,
)
],
p=1),
A.Cutout(num_holes=1,
max_h_size=max_crop,
max_w_size=max_crop,
p=0.2)
],
p=1),
A.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
AT.ToTensor()
])
else:
data_transform = transforms.Compose([
transforms.ToPILImage(),
transforms.Resize((image_size, image_size)),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
])
return data_transform
def __init__(self):
self.augmentor = A.Compose(
[
A.MotionBlur(p=0.25),
A.ColorJitter(p=0.5),
A.RandomRain(p=0.1), # random occlusion
A.RandomSunFlare(p=0.1),
A.JpegCompression(p=0.25),
A.ISONoise(p=0.25)
],
p=1.0)
def get_training_augmentation(min_area=0., min_visibility=0.):
train_transform = [
albu.OneOf([
albu.MotionBlur(p=.2),
albu.MedianBlur(blur_limit=3, p=0.1),
albu.Blur(blur_limit=3, p=0.1),
],
p=0.2),
albu.ShiftScaleRotate(shift_limit=0,
scale_limit=0,
rotate_limit=15,
p=0.5),
albu.OneOf([
albu.CLAHE(clip_limit=2),
albu.IAASharpen(),
albu.IAAEmboss(),
],
p=0.3),
albu.OneOf([
albu.RandomFog(fog_coef_lower=0.1, fog_coef_upper=0.15, p=0.1),
albu.RandomShadow(p=0.1),
albu.RandomBrightness(limit=0.3, p=0.2),
albu.RandomRain(slant_lower=0,
slant_upper=8,
drop_length=0,
blur_value=4,
brightness_coefficient=0.8,
rain_type='heavy',
p=0.1),
albu.RandomSunFlare(p=0.2),
]),
albu.OneOf([
albu.RGBShift(p=0.1),
albu.HueSaturationValue(p=0.3),
]),
albu.OneOf([
albu.HorizontalFlip(p=0.5),
albu.RandomSizedCrop(min_max_height=(720, 1380),
height=1380,
width=720,
interpolation=cv2.INTER_AREA)
],
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 setup_pipeline(self, dict_transform):
tranform_list = []
if 'shadow' in dict_transform:
tranform_list.append(
A.RandomShadow(shadow_roi=(0, 0.5, 1, 1),
num_shadows_upper=1,
p=0.2))
if 'scale' in dict_transform:
tranform_list.append(
A.RandomScale(scale_limit=float(dict_transform['scale'])))
if 'rotate' in dict_transform:
tranform_list.append(
A.Rotate(limit=float(dict_transform['rotate']), p=0.8))
if 'shift' in dict_transform:
tranform_list.append(
A.ShiftScaleRotate(shift_limit=float(dict_transform['shift']),
scale_limit=0.0,
rotate_limit=0,
interpolation=1,
border_mode=4,
p=0.8))
if 'brightness' in dict_transform:
tranform_list.append(
A.RandomBrightness(limit=float(dict_transform['brightness']),
p=0.8))
if 'contrast' in dict_transform:
tranform_list.append(
A.RandomContrast(limit=float(dict_transform['contrast']),
p=0.8))
if 'motion_blur' in dict_transform:
tranform_list.append(A.MotionBlur(p=0.5, blur_limit=7))
if 'fog' in dict_transform:
tranform_list.append(
A.RandomFog(fog_coef_lower=0.0,
fog_coef_upper=float(dict_transform['fog']),
alpha_coef=0.05,
p=0.7))
if 'rain' in dict_transform:
tranform_list.append(
A.RandomRain(brightness_coefficient=0.95,
drop_width=1,
blur_value=1,
p=0.7))
if 'occlusion' in dict_transform:
tranform_list.append(
A.CoarseDropout(max_holes=5, max_height=8, max_width=8, p=0.5))
self.transform = A.Compose(tranform_list)
def train_transform(width=512, height=512, min_area=0.0, min_visibility=0.0, lamda_norm=False):
list_transforms = []
augment = albu.Compose([
albu.OneOf(
[
albu.RandomSizedBBoxSafeCrop(p=1.0, height=height, width=width),
albu.HorizontalFlip(p=1.0),
albu.VerticalFlip(p=1.0),
albu.RandomRotate90(p=1.0),
albu.NoOp(p=1.0)
]
),
albu.OneOf(
[
albu.RandomBrightnessContrast(p=1.0),
albu.RandomGamma(p=1.0),
albu.NoOp(p=1.0)
]
),
albu.OneOf(
[
albu.MotionBlur(p=1.0),
albu.RandomFog(p=1.0),
albu.RandomRain(p=1.0),
albu.CLAHE(p=1.0),
albu.ToGray(p=1.0),
albu.NoOp(p=1.0)
]
)
])
list_transforms.extend([augment])
if lamda_norm:
list_transforms.extend([albu.Lambda(image=lamda_norm_tran)])
else:
list_transforms.extend([albu.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), max_pixel_value=255., p=1.0)])
list_transforms.extend([albu.Resize(height=height, width=width, p=1.0)])
return albu.Compose(list_transforms, bbox_params=albu.BboxParams(format='pascal_voc', min_area=min_area,
min_visibility=min_visibility,
label_fields=['label']))
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 __getitem__(self, idx):
net_h, net_w = self._update_net_size(idx)
# base_grid_h, base_grid_w = net_h // self.downsample, net_w // self.downsample
# determine the first and the last indices of the batch
l_bound, r_bound = self.get_inst_bounds(idx)
if r_bound > len(self.instances):
r_bound = len(self.instances)
l_bound = r_bound - self.batch_size
x_batch = np.zeros(
(r_bound - l_bound, net_h, net_w, 3)) # input images
# list of groundtruth boxes
t_batch = np.zeros(
(r_bound - l_bound, 1, 1, 1, self.max_box_per_image, 4))
# [print(net_h // self.downsample[i], net_w // self.downsample[i]) for i in reversed(range(self.output_layers_count))]
# According to reversed outputs - because of anchors
yolos = [
np.zeros((r_bound - l_bound, net_h // self.downsample[i],
net_w // self.downsample[i], self.anchors_per_output,
4 + 1 + len(self.labels)))
for i in reversed(range(self.output_layers_count))
]
instance_count = 0
true_box_index = 0
fill_value = [127] * 3
if self.infer_sz is None:
augmentations = [
albu.OneOf([
albu.IAAAdditiveGaussianNoise(),
albu.GaussNoise(),
],
p=0.2),
albu.OneOf([
albu.MotionBlur(p=0.2),
albu.MedianBlur(blur_limit=3, p=0.1),
albu.Blur(blur_limit=3, p=0.1),
],
p=0.2),
albu.OneOf([
albu.CLAHE(clip_limit=2),
albu.IAASharpen(),
albu.IAAEmboss(),
albu.RandomBrightnessContrast(),
],
p=0.3),
albu.HueSaturationValue(p=0.3),
albu.JpegCompression(quality_lower=50, quality_upper=100,
p=.5),
albu.MultiplicativeNoise(multiplier=[.5, 1.5],
per_channel=True,
p=.5),
albu.OneOf([
albu.RandomRain(),
albu.RandomFog(),
albu.RandomSunFlare(),
albu.RandomShadow(),
],
p=0.1),
ResizeKeepingRatio(target_wh=(net_w, net_h),
always_apply=True),
albu.PadIfNeeded(min_height=net_h,
min_width=net_w,
border_mode=0,
value=fill_value,
always_apply=True),
albu.ShiftScaleRotate(shift_limit=.25,
scale_limit=.25,
rotate_limit=15,
interpolation=3,
border_mode=0,
value=fill_value,
p=.7),
]
else:
augmentations = [
ResizeKeepingRatio(target_wh=(net_w, net_h),
always_apply=True),
albu.PadIfNeeded(min_height=net_h,
min_width=net_w,
border_mode=0,
value=fill_value,
always_apply=True),
]
transform = albu.Compose(augmentations,
bbox_params=albu.BboxParams(
format='pascal_voc',
min_visibility=0.1,
label_fields=['cat_name']))
# do the logic to fill in the inputs and the output
for inst_idx in range(l_bound, r_bound):
# augment input image and fix object's position and size
img, all_objs = self._aug_image(inst_idx, net_h, net_w, transform)
for objbox in all_objs:
# find the best anchor box for this object
max_anchor = None
max_index = -1
max_iou = -1
# print(objbox)
shifted_box = BoundBox(0, 0, objbox.xmax - objbox.xmin,
objbox.ymax - objbox.ymin)
# Get best matching anchor
for i in range(len(self.anchors)):
anchor = self.anchors[i]
iou = bbox_iou(shifted_box, anchor)
if max_iou < iou:
max_anchor = anchor
max_index = i
max_iou = iou
output_idx = max_index // self.anchors_per_output
output_anchor_idx = max_index % self.anchors_per_output
# determine the yolo to be responsible for this bounding box
yolo = yolos[output_idx]
# [52, 26, 13]
grid_h, grid_w = yolo.shape[1:3]
# determine the position of the bounding box on the grid
center_x = .5 * (objbox.xmin + objbox.xmax)
center_x = center_x / float(net_w) * grid_w # sigma(t_x) + c_x
center_y = .5 * (objbox.ymin + objbox.ymax)
center_y = center_y / float(net_h) * grid_h # sigma(t_y) + c_y
# if max_anchor.xmax == 0 or max_anchor.ymax == 0:
# print('>>>>> {}'.format(max_anchor))
# determine the sizes of the bounding box
w = np.log((objbox.xmax - objbox.xmin) /
float(max_anchor.xmax)) # t_w
h = np.log((objbox.ymax - objbox.ymin) /
float(max_anchor.ymax)) # t_h
box = [center_x, center_y, w, h]
if any(np.isinf(box)):
print(objbox, box, np.isinf(box))
# determine the index of the label
obj_indx = self.labels.index(objbox.class_name)
# print(self.labels, objbox.class_name, obj_indx)
# determine the location of the cell responsible for this object
grid_x = int(np.floor(center_x))
grid_y = int(np.floor(center_y))
# assign ground truth x, y, w, h, confidence and class probs to y_batch
yolo[instance_count, grid_y, grid_x, output_anchor_idx] = 0
yolo[instance_count, grid_y, grid_x, output_anchor_idx,
0:4] = box
yolo[instance_count, grid_y, grid_x, output_anchor_idx, 4] = 1.
yolo[instance_count, grid_y, grid_x, output_anchor_idx,
5 + obj_indx] = 1
# assign the true box to t_batch
true_box = [
center_x, center_y, objbox.xmax - objbox.xmin,
objbox.ymax - objbox.ymin
]
# print(true_box)
t_batch[instance_count, 0, 0, 0, true_box_index] = true_box
true_box_index += 1
true_box_index = true_box_index % self.max_box_per_image
# assign input image to x_batch
if self.norm:
# print(net_h, net_w, x_batch.shape, img.shape)
x_batch[instance_count] = self.norm(img)
# assert np.amax(x_batch) <= 1
# assert np.amin(x_batch) >= 0
else:
# plot image and bounding boxes for sanity check
for objbox in all_objs:
cv2.rectangle(img, (objbox.xmin, objbox.ymin),
(objbox.xmax, objbox.ymax), (255, 255, 0), 2)
cv2.putText(img, objbox.class_name,
(objbox.xmin + 2, objbox.ymin + 2), 0,
2e-3 * img.shape[0], (255, 0, 0), 2)
# print(train_instance['filename'])
# print(obj['name'])
x_batch[instance_count] = img
# increase instance counter in the current batch
instance_count += 1
dummies = [
np.zeros((r_bound - l_bound, 1))
for i in range(self.output_layers_count)
]
if self.norm:
return [x_batch, t_batch] + [yolo
for yolo in reversed(yolos)], dummies
else:
return x_batch
import albumentations as A
transform_fn = A.Compose([
A.OneOf([
A.IAAAdditiveGaussianNoise(),
A.GaussNoise(),
], p=.2),
A.OneOf([
A.MotionBlur(p=.2),
A.MedianBlur(blur_limit=3, p=.2),
A.Blur(blur_limit=3, p=.2),
], p=.2),
A.OneOf([
A.CLAHE(clip_limit=2),
A.IAASharpen(),
A.IAAEmboss(),
A.RandomBrightnessContrast(),
], p=0.2),
A.OneOf([
A.ChannelShuffle(),
A.HueSaturationValue(),
A.RGBShift(),
A.ToSepia(),
], p=0.2),
A.OneOf([
A.RandomSunFlare(flare_roi=(0, 0, 1., 1.), src_radius=100, p=.1),
A.RandomFog(fog_coef_lower=0.2, fog_coef_upper=0.3, p=.1),
A.RandomShadow(p=.1),
A.RandomRain(p=.1, blur_value=1),
], p=0.1)
])
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 getdata(img, count, disp=False):
#randomly transform the template image to generate sample data
#need to add a new function that generates data by registering real -
#input images with template and thus generating transform matrix
xtrain = []
ytrain = []
d = 20
pts1 = np.float32([[0, 0], [width, 0], [width, height]])
'''
cv2.circle(img, tuple(pts1[0]), 5, (0, 0, 255), -1)
cv2.circle(img, tuple(pts1[1]), 5, (0, 0, 255), -1)
cv2.circle(img, tuple(pts1[2]), 5, (0, 0, 255), -1)
cv2.imshow("Image", img)
'''
aug = A.Compose(
[
A.RandomBrightnessContrast(p=.5),
A.RandomGamma(p=.5),
A.RandomRain(
brightness_coefficient=0.9, drop_width=1, blur_value=5, p=.5),
A.RandomShadow(num_shadows_lower=1,
num_shadows_upper=1,
shadow_dimension=5,
shadow_roi=(0, 0.5, 1, 1),
p=.5),
A.RandomFog(
fog_coef_lower=0.1, fog_coef_upper=0.5, alpha_coef=0.1, p=.5),
#A.RandomSunFlare(flare_roi=(0, 0, 0.2, 0.2), angle_lower=0.2, p=.5),
#A.CLAHE(p=1),
A.HueSaturationValue(hue_shift_limit=3,
sat_shift_limit=50,
val_shift_limit=50,
p=.5),
],
p=.8)
for i in range(count):
d0 = random.sample(range(-d, d), 2)
d1 = random.sample(range(-d, d), 2)
d2 = random.sample(range(-d, d), 2)
#import pdb;pdb.set_trace()
pts2 = np.float32([pts1[0] + d0, pts1[1] + d1, pts1[2] + d2])
matrix = cv2.getAffineTransform(pts1, pts2)
result = cv2.warpAffine(img, matrix, (width, height))
#augmentations
result = aug(image=result)['image']
#import pdb;pdb.set_trace()
matrix = cv2.invertAffineTransform(matrix)
matrix = matrix.flatten()
xtrain.append(result)
ytrain.append(matrix)
if disp == True:
cv2.imshow("Affine transformation", result)
cv2.waitKey(30)
cv2.destroyAllWindows()
xtrain = np.array(xtrain, dtype=np.float32)
ytrain = np.array(ytrain, dtype=np.float32)
return (xtrain / 255.0, ytrain)
def rain(img, msk):
aug = A.Compose([A.RandomRain(always_apply=True, blur_value=2)])
data = aug(image=img)
return data['image'], msk
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)
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
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_transform(size, transform_type="weak", min_visibility=0):
"""Creates transformation for COCO dataset
Args:
size (int): image size to return
transform_type (str):
'weak': resizes and normalizes image and bbox
'strong': performs different image effects, resizes and normalizes image and bbox
min_visibility (int): minimum fraction of area for a bounding box
Returns:
albu.core.transforms_interface.BasicTransform: image and bbox transformation
"""
bbox_params = {
'format': 'coco',
'min_visibility': min_visibility,
'label_fields': ['category_id']
}
augs = {
'strong':
albu.Compose(
[
albu.Resize(size, size),
albu.HorizontalFlip(),
# albu.VerticalFlip(p=0.1),
albu.ShiftScaleRotate(shift_limit=0.05,
scale_limit=0.15,
rotate_limit=20,
p=.4,
border_mode=cv2.BORDER_CONSTANT),
albu.OneOf([
albu.Blur(),
albu.MotionBlur(),
albu.MedianBlur(),
albu.GaussianBlur(),
],
p=0.2),
albu.OneOf([
albu.GaussNoise(var_limit=(10, 35)),
albu.IAAAdditiveGaussianNoise(),
albu.JpegCompression(quality_lower=50),
],
p=0.2),
albu.OneOf(
[
albu.RandomRain(),
# albu.RandomSunFlare(),
albu.RandomShadow()
],
p=0.15),
albu.OneOf([
albu.CLAHE(clip_limit=2),
albu.IAASharpen(alpha=(0.1, 0.3)),
albu.IAAEmboss(alpha=(0.1, 0.4)),
albu.RandomGamma(),
albu.RandomBrightnessContrast(),
],
p=0.2),
# albu.HueSaturationValue(p=0.25),
],
bbox_params=bbox_params),
'weak':
albu.Compose(
[
albu.Resize(size, size),
# albu.HorizontalFlip(),
],
bbox_params=bbox_params),
}
aug_fn = augs[transform_type]
normalize = albu.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
pipeline = albu.Compose([
aug_fn,
# ])
normalize
])
return pipeline
alb.OneOf([alb.CLAHE(clip_limit=2),
alb.IAASharpen(),
alb.IAAEmboss()],
p=0.3),
alb.OneOf([
alb.HueSaturationValue(p=0.3),
alb.RGBShift(),
alb.RandomBrightnessContrast(),
alb.Equalize(mode='cv', p=1)
],
p=0.3),
alb.HorizontalFlip(),
alb.RandomGamma(p=0.2),
alb.OneOf([
alb.CoarseDropout(2, 10, 10, p=0.5),
alb.RandomRain(blur_value=3, p=1)
],
p=0.5)
]))
class MyDataset(Dataset):
def __init__(self,
data_dir,
data_anno,
phase='train',
transform=alb_transforms,
max_size=None):
self.data_dir = data_dir
self.data_anno = data_anno
self.phase = phase
def set_augmentations(img_size: int = 512):
hard_augs = [
A.RandomResizedCrop(height=img_size,
width=img_size,
scale=(0.5, 1.5),
ratio=(0.75, 1.25),
p=1),
#A.RandomSizedCrop(min_max_height=(512, 1024), height=img_size, width=img_size, p=0.5),
A.Resize(height=img_size, width=img_size, p=1.0),
# Add occasion blur
A.OneOf([A.GaussianBlur(), A.MotionBlur()], p=0.5),
A.ShiftScaleRotate(shift_limit=0.0625,
scale_limit=0.2,
rotate_limit=0,
p=0.5),
# noise
A.OneOf([
A.GaussNoise(p=0.5),
A.RandomGamma(p=0.4),
], p=0.5),
# D4 Augmentations
A.HorizontalFlip(p=0.5),
A.VerticalFlip(p=0.5),
A.RandomRotate90(p=0.5),
A.Transpose(p=0.2),
# Spatial-preserving augmentations
A.RandomBrightnessContrast(brightness_by_max=True, p=0.8),
A.HueSaturationValue(p=0.7),
# cutout
#A.Cutout(50, 26, 26, p=0.5),
]
medium_augs = [
A.RandomSizedCrop(min_max_height=(512, 1024),
height=img_size,
width=img_size,
p=0.5),
A.Resize(height=img_size, width=img_size, p=1.0),
A.OneOf([
A.HueSaturationValue(p=0.9),
A.RandomBrightnessContrast(p=0.9),
],
p=0.5),
# noise
A.OneOf([
A.GaussNoise(p=0.5),
A.RandomGamma(p=0.4),
], p=0.5),
# D4 transforms
A.HorizontalFlip(p=0.5),
A.VerticalFlip(p=0.5),
A.RandomRotate90(p=0.5),
A.Transpose(p=0.2),
]
light_augs = [
A.RandomSizedCrop(min_max_height=(800, 1024),
height=img_size,
width=img_size,
p=0.5),
A.Resize(height=img_size, width=img_size, p=1),
A.OneOf([
A.HueSaturationValue(hue_shift_limit=0.2,
sat_shift_limit=0.2,
val_shift_limit=0.2,
p=0.9),
A.RandomBrightnessContrast(
brightness_limit=0.2, contrast_limit=0.2, p=0.9),
],
p=0.9),
A.ToGray(p=0.01),
# D4 transforms
A.HorizontalFlip(p=0.5),
A.VerticalFlip(p=0.5),
A.RandomRotate90(p=0.5),
]
d4_augs = [
# D4 augmentations
A.HorizontalFlip(p=0.5),
A.VerticalFlip(p=0.5),
A.RandomRotate90(p=0.5),
A.Transpose(p=0.5),
]
resize = [A.Resize(height=img_size, width=img_size, p=1.0)]
# Cutout,p=0.5
cutout = [
A.Cutout(num_holes=16,
max_h_size=img_size // 16,
max_w_size=img_size // 16,
fill_value=0,
p=0.5)
]
# Weather effects
weather = [
A.OneOf([
A.RandomFog(fog_coef_lower=0.01, fog_coef_upper=0.3, p=0.2),
A.RandomRain(p=0.2),
],
p=0.5),
]
hard_cutout = hard_augs.append(cutout)
# dictionary of transforms
transforms_dict = {
"d4": d4_augs,
"hard": hard_augs,
"medium": medium_augs,
"light": light_augs,
"resize": resize,
"cutout": cutout,
"weather": weather,
"hard_cutout": hard_augs,
}
return transforms_dict
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 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()
])
随机选择策略列表中的一种策略增强图像
建议把所有加噪声的方法加入此类
"""
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]
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()
])
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"]:
outfile.write(
str(elems[4]) + ' ' + str(elems[0]) + ' ' +
A.RandomRotate90(p=0.5),
A.Transpose(p=0.2),
# Cutout,p=0.5
A.Cutout(num_holes=8, max_h_size=IMG_SIZE // 8, max_w_size=IMG_SIZE // 8, fill_value=0, p=0.5),
# Spatial-preserving augmentations:
A.OneOf(
[ A.RandomBrightnessContrast(brightness_by_max=True),
A.HueSaturationValue(),
A.RGBShift(),
A.RandomGamma(),
], p=0.9
),
# Weather effects
A.OneOf(
[ A.RandomFog(fog_coef_lower=0.01, fog_coef_upper=0.3, p=0.2),
A.RandomRain( p=0.2),
]
),
]
medium_augs = [
A.RandomSizedCrop(min_max_height=(800, 800), height=IMG_SIZE, width=IMG_SIZE, p=0.5),
A.Resize(height=IMG_SIZE, width=IMG_SIZE, p=1.0),
A.OneOf([
A.HueSaturationValue(hue_shift_limit=0.2, sat_shift_limit= 0.2,
val_shift_limit=0.2, p=0.9),
A.RandomBrightnessContrast(brightness_limit=0.2,
contrast_limit=0.2, p=0.9),
],p=0.9),
