def someAug():
bg = iap.Uniform(16, 18)
#Creating a series of augmentations
shearXY = iaa.Sequential([
iaa.ShearY(iap.Uniform(-10, 10), cval=bg),
iaa.ShearX(iap.Uniform(-10, 10), cval=bg)
])
rotate = iaa.Rotate(rotate=iap.Choice([-30, -15, 15, 30],
p=[0.25, 0.25, 0.25, 0.25]),
cval=bg)
pwAff = iaa.PiecewiseAffine(scale=(0.01, 0.06), cval=bg)
affine = iaa.Affine(scale={
"x": iap.Uniform(1.1, 1.2),
"y": iap.Uniform(1.1, 1.2)
},
cval=bg)
noise = iaa.AdditiveGaussianNoise(loc=0, scale=(0, 0.025 * 255))
#Using SomeOf to randomly select some augmentations
someAug = iaa.SomeOf(iap.Choice([2, 3, 4], p=[1 / 3, 1 / 3, 1 / 3]),
[affine, shearXY, pwAff, rotate, noise],
random_order=True)
return someAug
def augmentation(X, y, masks, itterations):
ys = np.concatenate(
(y[:, :, np.newaxis], y[:, :, np.newaxis], y[:, :, np.newaxis]),
axis=2)
masks = np.concatenate(
(masks[:, :, np.newaxis], masks[:, :, np.newaxis], masks[:, :,
np.newaxis]),
axis=2)
B = np.concatenate((ys, X, masks), axis=2).astype(np.uint8)
A = np.zeros((itterations, np.shape(B)[0], np.shape(B)[1], np.shape(B)[2]))
for num in range(itterations):
aug1 = iaa.Affine(scale={"x": (1, 1.5), "y": (1, 1.5)})
aug2 = iaa.Fliplr(1)
aug3 = iaa.Flipud(1)
aug4 = iaa.ShearX((-20, 20), mode='reflect')
aug5 = iaa.ShearY((-20, 20), mode='reflect')
aug6 = iaa.Rotate((-45, 45), mode='reflect')
aug7 = iaa.WithChannels((3, 4, 5), iaa.Multiply((0.5, 1.5)))
aug_list = [aug1, aug2, aug3, aug4, aug5, aug6, aug7]
ID = np.random.randint(0, len(aug_list))
A[num, :, :, :] = aug_list[ID](image=B)
aug_y = A[:, :, :, 0]
aug_X = A[:, :, :, 3:6]
aug_masks = A[:, :, :, 8]
return aug_X, aug_y, aug_masks
def initialise_augmenter():
# Horizontal and Vertical Flips (set to 1 as the SomeOf function will choose when to apply these itself)
horizontal_flip = iaa.Fliplr(1) #0.5)
vertical_flip = iaa.Flipud(1) #0.5)
# 90, 180 and 270 degree rotations
rotate_90 = iaa.Affine(rotate=90)
rotate_180 = iaa.Affine(rotate=180)
rotate_270 = iaa.Affine(rotate=270)
# Translations of -10% to 10% of the image's pixels
translate_x = iaa.TranslateX(percent=(-0.1, 0.1))
translate_y = iaa.TranslateY(percent=(-0.1, 0.1))
# Scale the image between 0.75 and 1.1 of the original size
scale_x = iaa.ScaleX((0.75, 1.1))
scale_y = iaa.ScaleY((0.75, 1.1))
# Shear the image between -20 and 20 degrees
shear_x = iaa.ShearX((-20, 20))
shear_y = iaa.ShearY((-20, 20))
augmentation = iaa.SomeOf((0, None), [
horizontal_flip, vertical_flip,
iaa.OneOf([rotate_90, rotate_180, rotate_270]), translate_x,
translate_y, scale_x, scale_y, shear_x, shear_y
],
random_order=True)
return augmentation
def shear(image):
# shear image randomly between -25 and 25 degree
aug_x = iaa.ShearX((-25, 25))
aug_y = iaa.ShearY((-25, 25))
image_aug = aug_x(image=image)
image_aug = aug_y(image=image_aug)
return image_aug
def shearY(shear_amount, input_path, output_path, image_count):
images = []
labels = []
ia.seed(1)
for img_path in range(image_count):
img = imageio.imread(input_path + '/images/' + str(img_path) + '.png')
images.append(img)
lbl = imageio.imread(input_path + '/labels/' + str(img_path) + '.png')
labels.append(lbl)
seq = iaa.Sequential(
[
iaa.ShearY((shear_amount)),
]
)
images_aug = seq(images=images)
labels_aug = seq(images=labels)
path = os.path.join(output_path, 'images')
os.mkdir(path)
path = os.path.join(output_path, 'labels')
os.mkdir(path)
for indx, i in enumerate(images_aug):
imageio.imwrite(output_path + '/images/' + 'shear'+ '_' + str(indx) + '.png', i)
for indx, i in enumerate(labels_aug):
imageio.imwrite(output_path + '/labels/' + 'shear'+ '_' + str(indx) + '.png', i)
print("Shear results were saved given directory.")
def augment_geometric(
d_scale=0.05,
d_translate=0.02,
d_rotate=3,
d_shear_x=5,
d_shear_y=1,
):
return iaa.Sequential(
[
iaa.Sometimes(
0.5,
iaa.Affine(
scale=(1 / (1 + d_scale), (1 + d_scale)),
translate_percent=dict(
x=(-d_translate, d_translate),
y=(-d_translate, d_translate),
),
rotate=(-d_rotate, d_rotate),
),
),
iaa.Sometimes(0.5, iaa.ShearX(shear=(-d_shear_x, d_shear_x))),
iaa.Sometimes(0.5, iaa.ShearY(shear=(-d_shear_y, d_shear_y))),
],
random_order=True,
)
def chapter_augmenters_sheary():
fn_start = "geometric/sheary"
image = ia.quokka(size=(128, 128))
aug = iaa.ShearY((0.5, 1.5))
run_and_save_augseq(
fn_start + ".jpg", aug,
[image for _ in range(4*2)], cols=4, rows=2)
def __init__(self,num_of_augms=0):
self.num_of_augms=num_of_augms
self.aug=iaa.OneOf([
iaa.Sequential([
iaa.LinearContrast(alpha=(0.75, 1.5)),
iaa.Fliplr(0.5)
]),
iaa.Sequential([
iaa.Grayscale(alpha=(0.1, 0.9)),
iaa.Affine(
translate_percent={"y": (-0.15, 0.15)}
)
]),
iaa.Sequential([
iaa.LinearContrast((0.6, 1.4)),
iaa.ShearX((-10, 10))
]),
iaa.Sequential([
iaa.GaussianBlur(sigma=(0, 1)),
iaa.ShearY((-10, 10))
]),
iaa.Sequential([
iaa.Cutout(nb_iterations=(1, 2), size=0.1, squared=False),
iaa.Multiply((0.8, 1.2), per_channel=0.25),
iaa.Fliplr(0.5),
]),
iaa.Sequential([
iaa.LinearContrast((0.6, 1.4)),
iaa.Affine(
translate_percent={"x": (-0.25, 0.25)}
)
]),
iaa.Sequential([
iaa.Cutout(nb_iterations=(1, 5), size=0.1, squared=False),
iaa.AdditiveGaussianNoise(loc=0, scale=(0.0, 15), per_channel=0.5),
iaa.Affine(
scale={"x": (0.9, 1.1), "y": (0.9, 1.1)},
)
]),
iaa.Sequential([
iaa.CoarseDropout((0.0, 0.05), size_percent=(0.02, 0.25)),
iaa.GaussianBlur(sigma=(0, 2)),
iaa.Affine(
scale={"x": (0.8, 1.2), "y": (0.8, 1.2)}
)])
# iaa.Sequential([
# iaa.Cutout(nb_iterations=(1, 5), size=0.05, squared=False),
# iaa.Grayscale(alpha=(0.0, 0.50)),
# iaa.ScaleX((0.75, 1.25))
# ]),
# iaa.Sequential([
# iaa.LinearContrast((0.8, 1.2), per_channel=True),
# iaa.PerspectiveTransform(scale=(0.01, 0.15))
# ])
])
def dictShearY(baseImageListFunc, baseMaskListFunc, fullImageListFunc, segmapListFunc):
print('ShearY, starting number of images:', len(segmapListFunc))
shearY_x00percent = 2
shearY = iaa.ShearY((-3, 3), mode="reflect")
shearY._mode_segmentation_maps = "reflect"
alteredImageListFunc, alteredMaskListFunc = expandList(baseImageListFunc, baseMaskListFunc, shearY_x00percent)
(alteredImageListFunc, alteredMaskListFunc) = shearY(images=alteredImageListFunc,
segmentation_maps=alteredMaskListFunc)
fullImageListFunc.extend(alteredImageListFunc)
segmapListFunc.extend(alteredMaskListFunc)
return fullImageListFunc, segmapListFunc
def shear_y(magnitude: int) -> iaa.ShearY:
"""
Apply y shear image and boxes
Tensorflow Policy Equivalent: shear_y
:type magnitude: int
:param magnitude: magnitude of y shear
:rtype: iaa.ShearY
:return: Method to y shear bounding boxes
"""
level = _shear_mag_to_arg(magnitude)
return iaa.ShearY(level)
def shear_y_bbox(magnitude: int) -> iaa.BlendAlphaBoundingBoxes:
"""
Apply y shear only to bboxes
Tensorflow Policy Equivalent: shear_y_only_bboxes
:type magnitude: int
:param magnitude: magnitude of y shear
:rtype: iaa.BlendAlphaBoundingBoxes
:return: Method to y shear bounding boxes
"""
level = _shear_mag_to_arg(magnitude)
return iaa.BlendAlphaBoundingBoxes(
None,
foreground=iaa.ShearY(level),
)
def __init__(self,num_of_augms=0):
self.num_of_augms=num_of_augms
self.aug=iaa.OneOf([
iaa.Sequential([
iaa.LinearContrast(alpha=(0.75, 1.5)),
iaa.Fliplr(0.5)
]),
iaa.Sequential([
iaa.Grayscale(alpha=(0.1, 0.9)),
iaa.Affine(
translate_percent={"y": (-0.15, 0.15)}
)
]),
iaa.Sequential([
iaa.Solarize(0.5, threshold=(0, 256)),
iaa.ShearX((-10, 10))
]),
iaa.Sequential([
iaa.GaussianBlur(sigma=(0, 1)),
iaa.ShearY((-10, 10))
]),
iaa.Sequential([
iaa.Multiply((0.5, 1.5), per_channel=0.25),
iaa.Fliplr(0.5),
]),
iaa.Sequential([
iaa.HistogramEqualization(),
iaa.Affine(
translate_percent={"x": (-0.25, 0.25)},
shear=(-8, 8)
)
]),
iaa.Sequential([
iaa.Crop(percent=(0.01, 0.1)),
iaa.AdditiveGaussianNoise(loc=0, scale=(0.0, 0.05*255), per_channel=0.5),
iaa.Affine(
scale={"x": (0.9, 1.1), "y": (0.9, 1.1)},
)
]),
iaa.Sequential([
iaa.GaussianBlur(sigma=(0, 0.9)),
iaa.Affine(
scale={"x": (0.8, 1.2), "y": (0.8, 1.2)}
)
])
])
def __call__(self, sample):
img, annot = sample.image, sample.annotation
unique_labels = np.unique(
annot[:, 4].astype('int').astype('str')).tolist()
bbs = BoundingBoxesOnImage([
BoundingBox(x1=ann[0],
y1=ann[1],
x2=ann[2],
y2=ann[3],
label=str(int(ann[4]))) for ann in annot
],
shape=img.shape)
aug = iaa.BlendAlphaBoundingBoxes(labels=unique_labels,
foreground=iaa.ShearY(self.v))
img_aug, bbs_aug = aug(image=img, bounding_boxes=bbs)
annot_aug = np.array(
[[bb.x1, bb.y1, bb.x2, bb.y2,
np.float32(bb.label)] for bb in bbs_aug])
masks = []
if sample.masks_and_category is not None:
for index in sample.masks_and_category:
masks.append(index[0])
mask_aug = []
if masks is not None:
for mask in masks:
mask = SegmentationMapsOnImage(mask, shape=img.shape).arr
segmap, _ = aug(image=mask, bounding_boxes=bbs)
mask_aug.append(segmap)
# back to 2D array
mask_result = []
for mask in mask_aug:
mask_result.append(mask[:, :, 0])
for i, index in enumerate(sample.masks_and_category):
index[0] = mask_result[i]
# the shape has to be at least (0,5)
if len(annot_aug) == 0:
annot_aug = np.zeros((0, 5))
sample.image = img_aug
sample.annotation = annot_aug
def np_func(img, ann):
# convert to imgaug keypoints
keypoints = annotation_to_keypoints(img, ann)
img = img.astype(np.uint8)
p = 0.1
seq = iaa.Sequential([
iaa.Sometimes(p, iaa.Sequential([iaa.ShearY((-20, 20))])),
iaa.Sometimes(p, iaa.ChangeColorTemperature((3500, 8000))),
iaa.Sometimes(p, iaa.AddToBrightness((-15, 15))),
iaa.Sometimes(p, iaa.AdditiveGaussianNoise(scale=(0, 0.03 * 255), per_channel=True))
])
img, keypoints = seq(image=img, keypoints=keypoints)
# convert from imgaug keypoints
ann = keypoints_to_annotation(img, ann, keypoints)
return img.astype(np.float32), ann
def __call__(self, sample):
img, annot = sample['img'], sample['annot']
bbs = BoundingBoxesOnImage([
BoundingBox(x1=ann[0],
y1=ann[1],
x2=ann[2],
y2=ann[3],
label=str(int(ann[4]))) for ann in annot
],
shape=img.shape)
aug = iaa.ShearY(self.v)
img_aug, bbs_aug = aug(image=img, bounding_boxes=bbs)
annot_aug = np.array(
[[bb.x1, bb.y1, bb.x2, bb.y2,
np.float32(bb.label)] for bb in bbs_aug])
# the shape has to be at least (0,5)
if len(annot_aug) == 0:
annot_aug = np.zeros((0, 5))
return {'img': img_aug, 'annot': annot_aug}
def get_aug(aug_cfg):
seq = iaa.Sequential(
[
iaa.Sometimes(
aug_cfg["Shear"]["p"],
iaa.OneOf([
iaa.ShearX(aug_cfg["Shear"]["X"]),
iaa.ShearY(aug_cfg["Shear"]["Y"]),
]),
),
iaa.Sometimes(
aug_cfg["GaussianBlur"]["p"],
iaa.GaussianBlur(sigma=aug_cfg["GaussianBlur"]["sigma"]),
),
iaa.OneOf([
iaa.LinearContrast(aug_cfg["LinearContrast"]["alpha"]),
iaa.AdditiveGaussianNoise(
loc=aug_cfg["AdditiveGaussianNoise"]["loc"],
scale=aug_cfg["AdditiveGaussianNoise"]["scale"],
per_channel=aug_cfg["AdditiveGaussianNoise"]
["per_channel"],
),
iaa.Multiply(
aug_cfg["Multiply"]["mul"],
per_channel=aug_cfg["Multiply"]["per_channel"],
),
]),
iaa.Sometimes(
aug_cfg["Affine"]["p"],
iaa.Affine(
translate_percent=iap.Normal(
*aug_cfg["Affine"]["translate_percent"]),
rotate=iap.Normal(*aug_cfg["Affine"]["rotate"]),
scale=None,
),
),
],
random_order=True,
)
return seq
def gen_steps():
STEPS=[
iaa.Rotate((-50,-20)),
iaa.Rotate((20,50)),
iaa.Affine(shear=(-30,-10)),
iaa.Affine(shear=(10,30)),
iaa.ShearX(((-10, 10))),
iaa.ShearY(((-10, 10))),
iaa.Affine(scale=(0.5, 1.5)),
iaa.Affine(scale=(1, 2)),
iaa.Affine(translate_px={"x": (1, random.randint(300,800)), "y": (1, random.randint(300,800))}),
[
iaa.Affine(translate_px={"x": (1, random.randint(300,800)), "y": (1, random.randint(300,800))}),
iaa.Affine(shear=(-15,15)),
],
[
iaa.Affine(translate_px={"x": (1, random.randint(300,800)), "y": (1, random.randint(300,800))}),
iaa.Affine(shear=(-15,15)),
],
]
return STEPS
def __call__(self, sample):
img, annot = sample['img'], sample['annot']
unique_labels = np.unique(
annot[:, 4].astype('int').astype('str')).tolist()
bbs = BoundingBoxesOnImage([
BoundingBox(x1=ann[0],
y1=ann[1],
x2=ann[2],
y2=ann[3],
label=str(int(ann[4]))) for ann in annot
],
shape=img.shape)
aug = iaa.BlendAlphaBoundingBoxes(labels=unique_labels,
foreground=iaa.ShearY(self.v))
img_aug, bbs_aug = aug(image=img, bounding_boxes=bbs)
annot_aug = np.array(
[[bb.x1, bb.y1, bb.x2, bb.y2,
np.float32(bb.label)] for bb in bbs_aug])
# the shape has to be at least (0,5)
if len(annot_aug) == 0:
annot_aug = np.zeros((0, 5))
return {'img': img_aug, 'annot': annot_aug}
# ),
# iaa.Add((-15, 15), per_channel=0.5),
# iaa.Multiply((0.8, 1.2), per_channel=0.5),
# iaa.imgcorruptlike.Contrast(severity=1),
# iaa.imgcorruptlike.Brightness(severity=2),
iaa.ContrastNormalization((0.1, 1.5), per_channel=0.5),
iaa.WithHueAndSaturation([
iaa.WithChannels(0, iaa.Add((-15, 15))),
iaa.WithChannels(1, iaa.Add((-20, 20))),
]),
iaa.GammaContrast((0.3, 1.5)),
iaa.WithBrightnessChannels(iaa.Add((-30, 70))),
iaa.ScaleX((0.5, 1.5)),
iaa.ScaleY((0.5, 1.5)),
iaa.ShearX((-10, 10)),
iaa.ShearY((-10, 10)),
],
random_order=True)
],
random_order=True)
def augment_pair(fg, label):
# print('Augment start')
label_i, segmaps_aug_i = seq(images=fg, segmentation_maps=label)
# print('Augment ok')
return label_i, segmaps_aug_i
#res = [1080, 960]
res = [int(1080 / 5), int(960 / 5)]
iaa.LinearContrast((0.80, 1.1)),
iaa.Multiply((0.9, 1.5)),
# iaa.pillike.Autocontrast((10, 20), per_channel=True),
iaa.Sometimes(0.50,
iaa.OneOf([
iaa.AdditiveGaussianNoise(loc=0, scale=(0.0, 0.03*255)),
iaa.PiecewiseAffine(scale=(0.01, 0.05))
]),
),
]),
iaa.Sometimes(0.8,
iaa.OneOf([
iaa.OneOf([
iaa.ShearX((-5,5)),
iaa.ShearY((-5,5))
]),
iaa.OneOf([
iaa.Affine(
scale={"x": (0.8, 1), "y": (0.8, 1)}
),
iaa.Affine(
translate_percent={"x": (-0.05, 0.05), "y": (-0.05, 0.05)}
),
iaa.Affine(
rotate=(-4, 4)
)
]),
]),
),
], random_order=True) # apply augmenters in random order
critical_1 = [
iaa.SaltAndPepper(0.05),
iaa.Sharpen(alpha=0.2, lightness=0.9),
iaa.ScaleX(0.7)
]
critical_2 = [
iaa.SaltAndPepper(0.05),
iaa.Sharpen(alpha=0.2, lightness=0.9),
iaa.Flipud(1)
]
critical_3 =[
iaa.SaltAndPepper(0.05),
iaa.Sharpen(alpha=0.2, lightness=0.9),
iaa.ShearY(10)
]
critical_4 =[
iaa.SaltAndPepper(0.05),
iaa.Sharpen(alpha=0.2, lightness=0.9),
iaa.Add(20)
]
critical_5 =[
iaa.SaltAndPepper(0.05),
iaa.Sharpen(alpha=0.2, lightness=0.9),
iaa.Multiply(1.3)
]
critical_6 =[
def da_policy(image, label):
img_size = 224
#image = sample[0]
policy = np.random.randint(4)
#policy = 2
if policy == 0:
p = np.random.random()
if p <= 0.6:
aug = iaa.TranslateX(px=(-60, 60), cval=128)
image = aug(image=image)
p = np.random.random()
if p <= 0.8:
aug = iaa.HistogramEqualization()
image = aug(image=image)
elif policy == 1:
p = np.random.random()
if p <= 0.2:
aug = iaa.TranslateY(px=(int(-0.18 * img_size),
int(0.18 * img_size)),
cval=128)
image = aug(image=image)
p = np.random.random()
if p <= 0.8:
square_size = np.random.randint(48)
aug = iaa.Cutout(nb_iterations=1,
size=square_size / img_size,
squared=True)
image = aug(image=image)
elif policy == 2:
p = np.random.random()
if p <= 1:
aug = iaa.ShearY(shear=(int(-0.06 * img_size),
int(0.06 * img_size)),
order=1,
cval=128)
image = aug(image=image)
p = np.random.random()
if p <= 0.6:
aug = iaa.TranslateX(px=(-60, 60), cval=128)
image = aug(image=image)
elif policy == 3:
p = np.random.random()
if p <= 0.6:
aug = iaa.Rotate(rotate=(-30, 30), order=1, cval=128)
image = aug(image=image)
p = np.random.random()
if p <= 1:
aug = iaa.MultiplySaturation((0.54, 1.54))
image = aug(image=image)
#Para EFFICIENTNET NO es necesario NORMALIZAR
return (tf.cast(image, tf.float32), tf.cast(label, tf.int64))
class Dataset(object):
# Dataset preprocess implementation
def __init__(self, dataset_type, TEST_INPUT_SIZE=TEST_INPUT_SIZE):
self.annot_path = TRAIN_ANNOT_PATH if dataset_type == 'train' else TEST_ANNOT_PATH
self.input_sizes = TRAIN_INPUT_SIZE if dataset_type == 'train' else TEST_INPUT_SIZE
self.batch_size = TRAIN_BATCH_SIZE if dataset_type == 'train' else TEST_BATCH_SIZE
self.data_aug = TRAIN_DATA_AUG if dataset_type == 'train' else TEST_DATA_AUG
self.train_input_sizes = TRAIN_INPUT_SIZE
self.strides = np.array(YOLO_STRIDES)
self.classes = read_class_names(TRAIN_CLASSES)
self.num_classes = len(self.classes)
self.anchors = (np.array(YOLO_ANCHORS).T/self.strides).T
self.anchor_per_scale = YOLO_ANCHOR_PER_SCALE
self.max_bbox_per_scale = YOLO_MAX_BBOX_PER_SCALE
self.annotations = self.load_annotations(dataset_type)
self.num_samples = len(self.annotations)
self.num_batchs = int(np.ceil(self.num_samples / self.batch_size))
self.batch_count = 0
def load_annotations(self, dataset_type):
final_annotations = []
with open(self.annot_path, 'r') as f:
txt = f.readlines()
annotations = [line.strip() for line in txt if len(line.strip().split()[1:]) != 0]
np.random.shuffle(annotations)
for annotation in annotations:
# fully parse annotations
line = annotation.split()
image_path, index = "", 1
for i, one_line in enumerate(line):
if not one_line.replace(",","").isnumeric():
if image_path != "": image_path += " "
image_path += one_line
else:
index = i
break
if not os.path.exists(image_path):
raise KeyError("%s does not exist ... " %image_path)
if TRAIN_LOAD_IMAGES_TO_RAM:
image = cv2.imread(image_path)
else:
image = ''
final_annotations.append([image_path, line[index:], image])
return final_annotations
def __iter__(self):
return self
def Delete_bad_annotation(self, bad_annotation):
print(f'Deleting {bad_annotation} annotation line')
bad_image_path = bad_annotation[0]
bad_image_name = bad_annotation[0].split('/')[-1] # can be used to delete bad image
bad_xml_path = bad_annotation[0][:-3]+'xml' # can be used to delete bad xml file
# remove bad annotation line from annotation file
with open(self.annot_path, "r+") as f:
d = f.readlines()
f.seek(0)
for i in d:
if bad_image_name not in i:
f.write(i)
f.truncate()
def __next__(self):
with tf.device('/cpu:0'):
self.train_input_size = random.choice([self.train_input_sizes])
self.train_output_sizes = self.train_input_size // self.strides
batch_image = np.zeros((self.batch_size, self.train_input_size, self.train_input_size, 3), dtype=np.float32)
batch_label_sbbox = np.zeros((self.batch_size, self.train_output_sizes[0], self.train_output_sizes[0],
self.anchor_per_scale, 5 + self.num_classes), dtype=np.float32)
batch_label_mbbox = np.zeros((self.batch_size, self.train_output_sizes[1], self.train_output_sizes[1],
self.anchor_per_scale, 5 + self.num_classes), dtype=np.float32)
batch_label_lbbox = np.zeros((self.batch_size, self.train_output_sizes[2], self.train_output_sizes[2],
self.anchor_per_scale, 5 + self.num_classes), dtype=np.float32)
batch_sbboxes = np.zeros((self.batch_size, self.max_bbox_per_scale, 4), dtype=np.float32)
batch_mbboxes = np.zeros((self.batch_size, self.max_bbox_per_scale, 4), dtype=np.float32)
batch_lbboxes = np.zeros((self.batch_size, self.max_bbox_per_scale, 4), dtype=np.float32)
exceptions = False
num = 0
#annotation more than 1
#random <0.5
#ambil gambar pertama
#ambil gambar kedua
#implement fungsi mix up
#
def mixup(image1, bboxes1, image2, bboxes2, alpha=MIX_UP_THRESHOLD):
'''
Mixup 2 image
image_info_1, image_info_2: Info dict 2 image with keys = {"image", "label", "box", "difficult"}
lambd: Mixup ratio
Out: mix_image (Temsor), mix_boxes, mix_labels, mix_difficulties
'''
l = np.random.beta(alpha,alpha)
mixup_width = max(image1.shape[1], image2.shape[1])
mix_up_height = max(image1.shape[0], image2.shape[0])
mix_img = np.zeros((mix_up_height, mixup_width,3),dtype=float)
mix_img[:, :image1.shape[0], :image1.shape[1]] = image1 * l
mix_img[:, :image2.shape[0], :image2.shape[1]] += image2 * (1. - l)
mix_boxes = np.concatenate((bboxes1,bboxes2), axis= 0)
return mix_img, mix_boxes
# curr_dict = {"image" : annotation[2], "box" : annotation[2]}
if self.batch_count < self.num_batchs:
while num < self.batch_size:
index = self.batch_count * self.batch_size + num
if index >= self.num_samples: index -= self.num_samples
annotation = self.annotations[index]
image, bboxes = self.parse_annotation(annotation)
if MIX_UP:
if num > 0:
#apply mixup function here with 50% chance
if random.random()<0.5:
#annotation = [image_path,bboxes,image]
select_index_prev = int(random.randint(0,index))
select_index_prev = select_index_prev if select_index_prev != index else index-1
prev_annotation = self.annotations[select_index_prev]
prev_image, prev_bboxes = self.parse_annotation(prev_annotation, only_parse=True)
image, bboxes = mixup(image, bboxes, prev_image, prev_bboxes)
# image = cv2.cvtColor(image.astype('float32'),cv2.COLOR_BGR2RGB)
try:
label_sbbox, label_mbbox, label_lbbox, sbboxes, mbboxes, lbboxes = self.preprocess_true_boxes(bboxes)
except IndexError:
exceptions = True
self.Delete_bad_annotation(annotation)
print("IndexError, something wrong with", annotation[0], "removed this line from annotation file")
batch_image[num, :, :, :] = image
batch_label_sbbox[num, :, :, :, :] = label_sbbox
batch_label_mbbox[num, :, :, :, :] = label_mbbox
batch_label_lbbox[num, :, :, :, :] = label_lbbox
batch_sbboxes[num, :, :] = sbboxes
batch_mbboxes[num, :, :] = mbboxes
batch_lbboxes[num, :, :] = lbboxes
num += 1
if exceptions:
print('\n')
raise Exception("There were problems with dataset, I fixed them, now restart the training process.")
self.batch_count += 1
batch_smaller_target = batch_label_sbbox, batch_sbboxes
batch_medium_target = batch_label_mbbox, batch_mbboxes
batch_larger_target = batch_label_lbbox, batch_lbboxes
return batch_image, (batch_smaller_target, batch_medium_target, batch_larger_target)
else:
self.batch_count = 0
np.random.shuffle(self.annotations)
raise StopIteration
# https://www.ecva.net/papers/eccv_2020/papers_ECCV/papers/123720562.pdf
##Augmentor with imgaug
aug = iaa.SomeOf(2, [
#top 3 augment technique from paper
iaa.pillike.Equalize(),
iaa.Affine(translate_percent={"y":(-1, 1)}),
iaa.Rotate(),
# iaa.Affine(scale=(0.5, 1.5)),
iaa.Sharpen(alpha=(0,1.0)),
iaa.Posterize(),
iaa.Solarize(0.5),
iaa.pillike.Autocontrast(0.5),
iaa.Affine(translate_percent={"x":(-1, 1),"y":(-1, 1)}),
iaa.Affine(translate_percent={"x":(-1, 1)}),
iaa.imgcorruptlike.Contrast(),
iaa.imgcorruptlike.Brightness(),
iaa.ShearY()
])
def aug_with_imgaug(self,image, bboxes,aug = aug):
if random.random() < 0.5:
bbs = BoundingBoxesOnImage.from_xyxy_array(bboxes[:,:-1], shape= image.shape)
image, bbs = aug(image=image, bounding_boxes=bbs)
#disregard bounding boxes which have fallen out of image pane
bbs = bbs.remove_out_of_image()
#clip bounding boxes which are partially outside of image pane
bbs = bbs.clip_out_of_image()
bboxes = np.column_stack((bbs.to_xyxy_array(),bboxes[:,-1][:bbs.to_xyxy_array().shape[0],np.newaxis])).astype(int)
return image, bboxes
def parse_annotation(self, annotation, mAP = 'False', only_parse= False):
if TRAIN_LOAD_IMAGES_TO_RAM:
image_path = annotation[0]
image = annotation[2]
else:
image_path = annotation[0]
image = cv2.imread(image_path)
bboxes = np.array([list(map(int, box.split(','))) for box in annotation[1]])
if not only_parse:
if self.data_aug:
image, bboxes = self.aug_with_imgaug(np.copy(image), np.copy(bboxes))
# image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
if mAP == True:
return image, bboxes
image, bboxes = image_preprocess(np.copy(image), [self.input_sizes, self.input_sizes], np.copy(bboxes))
return image, bboxes
def preprocess_true_boxes(self, bboxes):
label = [np.zeros((self.train_output_sizes[i], self.train_output_sizes[i], self.anchor_per_scale,
5 + self.num_classes)) for i in range(3)]
bboxes_xywh = [np.zeros((self.max_bbox_per_scale, 4)) for _ in range(3)]
bbox_count = np.zeros((3,))
for bbox in bboxes:
bbox_coor = bbox[:4]
bbox_class_ind = bbox[4]
onehot = np.zeros(self.num_classes, dtype=np.float)
onehot[bbox_class_ind] = 1.0
uniform_distribution = np.full(self.num_classes, 1.0 / self.num_classes)
deta = 0.01
smooth_onehot = onehot * (1 - deta) + deta * uniform_distribution
bbox_xywh = np.concatenate([(bbox_coor[2:] + bbox_coor[:2]) * 0.5, bbox_coor[2:] - bbox_coor[:2]], axis=-1)
bbox_xywh_scaled = 1.0 * bbox_xywh[np.newaxis, :] / self.strides[:, np.newaxis]
iou = []
exist_positive = False
for i in range(3):
anchors_xywh = np.zeros((self.anchor_per_scale, 4))
anchors_xywh[:, 0:2] = np.floor(bbox_xywh_scaled[i, 0:2]).astype(np.int32) + 0.5
anchors_xywh[:, 2:4] = self.anchors[i]
iou_scale = bbox_iou(bbox_xywh_scaled[i][np.newaxis, :], anchors_xywh)
iou.append(iou_scale)
iou_mask = iou_scale > 0.3
if np.any(iou_mask):
xind, yind = np.floor(bbox_xywh_scaled[i, 0:2]).astype(np.int32)
label[i][yind, xind, iou_mask, :] = 0
label[i][yind, xind, iou_mask, 0:4] = bbox_xywh
label[i][yind, xind, iou_mask, 4:5] = 1.0
label[i][yind, xind, iou_mask, 5:] = smooth_onehot
bbox_ind = int(bbox_count[i] % self.max_bbox_per_scale)
bboxes_xywh[i][bbox_ind, :4] = bbox_xywh
bbox_count[i] += 1
exist_positive = True
if not exist_positive:
best_anchor_ind = np.argmax(np.array(iou).reshape(-1), axis=-1)
best_detect = int(best_anchor_ind / self.anchor_per_scale)
best_anchor = int(best_anchor_ind % self.anchor_per_scale)
xind, yind = np.floor(bbox_xywh_scaled[best_detect, 0:2]).astype(np.int32)
label[best_detect][yind, xind, best_anchor, :] = 0
label[best_detect][yind, xind, best_anchor, 0:4] = bbox_xywh
label[best_detect][yind, xind, best_anchor, 4:5] = 1.0
label[best_detect][yind, xind, best_anchor, 5:] = smooth_onehot
bbox_ind = int(bbox_count[best_detect] % self.max_bbox_per_scale)
bboxes_xywh[best_detect][bbox_ind, :4] = bbox_xywh
bbox_count[best_detect] += 1
label_sbbox, label_mbbox, label_lbbox = label
sbboxes, mbboxes, lbboxes = bboxes_xywh
return label_sbbox, label_mbbox, label_lbbox, sbboxes, mbboxes, lbboxes
def __len__(self):
return self.num_batchs
iaa.GaussianBlur(1.5),
iaa.MotionBlur(k=15, angle=60, direction=1),
iaa.MotionBlur(k=5, angle=60, direction=-1),
iaa.Grayscale(0.5),
iaa.SigmoidContrast(gain=10, cutoff=0.3),
iaa.LogContrast(0.7),
iaa.LogContrast(1.3),
iaa.Sharpen(alpha=0.2, lightness=0.9),
iaa.Sharpen(alpha=0.2, lightness=1.2),
iaa.Fliplr(1),
iaa.Flipud(1),
iaa.Rotate(15),
iaa.Rotate(-15),
iaa.ShearX(-10),
iaa.ShearX(10),
iaa.ShearY(-10),
iaa.ShearY(10),
iaa.ScaleX(0.7),
iaa.ScaleX(1.3),
iaa.ScaleY(0.7),
iaa.ScaleY(1.3),
]
def custom_imshow(imgList, labels):
fig = plt.figure()
rows = 2
cols = 5
for i in range(10):
#These three are from contrast module, the above five from blur module.
sometimes2(iaa.HistogramEqualization()),
sometimes2(iaa.SigmoidContrast(gain=(3, 10), cutoff=(0.4, 0.6))),
sometimes2(iaa.LinearContrast(alpha=(0.6, 1.4)))
])
sometimes3 = lambda aug: iaa.Sometimes(0.93, aug)
seq3 = iaa.SomeOf(
(1, 2),
[
#sometimes3(iaa.Affine(scale=1.5)), # cuts out part of the objects, resulting in negative coordinates..
sometimes3(iaa.ElasticTransformation(alpha=(20, 30.0), sigma=5.0)),
sometimes3(iaa.Rot90((1, 3), keep_size=False)
), # On 90,270 transformation, the width and height change.
sometimes3(iaa.Rotate((-30, 30))),
sometimes3(iaa.WithPolarWarping(iaa.AveragePooling((2, 7)))),
sometimes3(iaa.ShearY((30, 50))),
sometimes3(iaa.ShearX((30, 70))),
])
img_path = "C:\\Users\\gishy\\Dropbox\\My PC (LAPTOP-SQRN8N46)\\Desktop\\sample_images"
txt_path = "C:\\Users\\gishy\\Dropbox\\My PC (LAPTOP-SQRN8N46)\\Desktop\\sample_annotations"
#img_path="C:\\Users\\gishy\\Dropbox\\My PC (LAPTOP-SQRN8N46)\\Desktop\\final-dataset\\main\\Not Augmented\\train_images"
#txt_path="C:\\Users\\gishy\\Dropbox\\My PC (LAPTOP-SQRN8N46)\\Desktop\\final-dataset\\main\\Not Augmented\\train_annotations_yolo"
if __name__ == "__main__":
conversion(txt_path, img_path, seq3)
def GenerateRandomImgaugAugmentation(
pNbAugmentations=5, # number of augmentations
pEnableResizing=True, # enable scaling
pScaleFactor=0.5, # maximum scale factor
pEnableCropping=True, # enable cropping
pCropFactor=0.25, # maximum crop out size (minimum new size is 1.0-pCropFactor)
pEnableFlipping1=True, # enable x flipping
pEnableFlipping2=True, # enable y flipping
pEnableRotation90=True, # enable rotation
pEnableRotation=True, # enable rotation
pMaxRotationDegree=15, # maximum shear degree
pEnableShearX=True, # enable x shear
pEnableShearY=True, # enable y shear
pMaxShearDegree=15, # maximum shear degree
pEnableDropOut=True, # enable pixel dropout
pMaxDropoutPercentage=.1, # maximum dropout percentage
pEnableBlur=True, # enable gaussian blur
pBlurSigma=.25, # maximum sigma for gaussian blur
pEnableSharpness=True, # enable sharpness
pSharpnessFactor=.1, # maximum additional sharpness
pEnableEmboss=True, # enable emboss
pEmbossFactor=.1, # maximum emboss
pEnableBrightness=True, # enable brightness
pBrightnessFactor=.1, # maximum +- brightness
pEnableRandomNoise=True, # enable random noise
pMaxRandomNoise=.1, # maximum random noise strength
pEnableInvert=False, # enables color invert
pEnableContrast=True, # enable contrast change
pContrastFactor=.1, # maximum +- contrast
):
augmentationMap = []
augmentationMapOutput = []
if pEnableResizing:
if random.Random().randint(0, 1) == 1:
randomResizeX = 1 - random.Random().random() * pScaleFactor
else:
randomResizeX = 1 + random.Random().random() * pScaleFactor
if random.Random().randint(0, 1) == 1:
randomResizeY = 1 - random.Random().random() * pScaleFactor
else:
randomResizeY = 1 + random.Random().random() * pScaleFactor
aug = iaa.Resize({"height": randomResizeY, "width": randomResizeX})
augmentationMap.append(aug)
if pEnableCropping:
randomCrop2 = random.Random().random() * pCropFactor
randomCrop4 = random.Random().random() * pCropFactor
randomCrop1 = random.Random().random() * pCropFactor
randomCrop3 = random.Random().random() * pCropFactor
aug = iaa.Crop(percent=(randomCrop1, randomCrop2, randomCrop3,
randomCrop4))
augmentationMap.append(aug)
if pEnableFlipping1:
aug = iaa.Fliplr()
augmentationMap.append(aug)
if pEnableFlipping2:
aug = iaa.Flipud()
augmentationMap.append(aug)
if pEnableRotation90:
randomNumber = random.Random().randint(1, 3)
aug = iaa.Rot90(randomNumber)
augmentationMap.append(aug)
if pEnableRotation:
if random.Random().randint(0, 1) == 1:
randomRotation = random.Random().random() * pMaxRotationDegree
else:
randomRotation = -random.Random().random() * pMaxRotationDegree
aug = iaa.Rotate(randomRotation)
augmentationMap.append(aug)
if pEnableShearX:
if random.Random().randint(0, 1) == 1:
randomShearingX = random.Random().random() * pMaxShearDegree
else:
randomShearingX = -random.Random().random() * pMaxShearDegree
aug = iaa.ShearX(randomShearingX)
augmentationMap.append(aug)
if pEnableShearY:
if random.Random().randint(0, 1) == 1:
randomShearingY = random.Random().random() * pMaxShearDegree
else:
randomShearingY = -random.Random().random() * pMaxShearDegree
aug = iaa.ShearY(randomShearingY)
augmentationMap.append(aug)
if pEnableDropOut:
randomDropOut = random.Random().random() * pMaxDropoutPercentage
aug = iaa.Dropout(p=randomDropOut, per_channel=False)
augmentationMap.append(aug)
if pEnableBlur:
randomBlur = random.Random().random() * pBlurSigma
aug = iaa.GaussianBlur(randomBlur)
augmentationMap.append(aug)
if pEnableSharpness:
randomSharpness = random.Random().random() * pSharpnessFactor
aug = iaa.Sharpen(randomSharpness)
augmentationMap.append(aug)
if pEnableEmboss:
randomEmboss = random.Random().random() * pEmbossFactor
aug = iaa.Emboss(randomEmboss)
augmentationMap.append(aug)
if pEnableBrightness:
if random.Random().randint(0, 1) == 1:
randomBrightness = 1 - random.Random().random() * pBrightnessFactor
else:
randomBrightness = 1 + random.Random().random() * pBrightnessFactor
aug = iaa.Add(randomBrightness)
augmentationMap.append(aug)
if pEnableRandomNoise:
if random.Random().randint(0, 1) == 1:
randomNoise = 1 - random.Random().random() * pMaxRandomNoise
else:
randomNoise = 1 + random.Random().random() * pMaxRandomNoise
aug = iaa.MultiplyElementwise(randomNoise, per_channel=True)
augmentationMap.append(aug)
if pEnableInvert:
aug = iaa.Invert(1)
augmentationMap.append(aug)
if pEnableContrast:
if random.Random().randint(0, 1) == 1:
randomContrast = 1 - random.Random().random() * pContrastFactor
else:
randomContrast = 1 + random.Random().random() * pContrastFactor
aug = iaa.contrast.LinearContrast(randomContrast)
augmentationMap.append(aug)
widthFactor = 1
heightFactor = 1
arr = numpy.arange(0, len(augmentationMap))
numpy.random.shuffle(arr)
switchWidthHeight = False
for i in range(pNbAugmentations):
augmentationMapOutput.append(augmentationMap[arr[i]])
if arr[i] == 0:
widthFactor *= randomResizeX
heightFactor *= randomResizeY
if arr[i] == 1:
widthFactor *= (1.0 - (randomCrop2 + randomCrop4))
heightFactor *= (1.0 - (randomCrop1 + randomCrop3))
if arr[i] == 4:
if randomNumber == 1 or randomNumber == 3:
switchWidhtHeight = True
return iaa.Sequential(
augmentationMapOutput), widthFactor, heightFactor, switchWidthHeight
seq_blur = iaa.Sequential([
iaa.Crop(px=(1, 16), keep_size=False),
iaa.Fliplr(0.5),
iaa.GaussianBlur(sigma=(0, 3.0))
])
seq_rot = iaa.Sequential([
iaa.PerspectiveTransform(scale=(0.01, 0.15)),
iaa.Rot90((1, 3))
])
seq_shear = iaa.Sequential([
iaa.Crop(px=(1, 16), keep_size=False),
iaa.ShearX((-20, 20)),
iaa.ShearY((-20,20))
])
seq_scale = iaa.Sequential([
iaa.Affine(scale={"x": (0.5, 1.5), "y": (0.5, 1.5)})
])
seq_offset = iaa.Sequential([
iaa.Affine(translate_px={"x": (-100, 100), "y": (-100, 100)}),
iaa.Crop(px=(1, 16), keep_size=False)
])
def create_aug_img(folder_path):
contents = folder_path.split('/')
)
img_batch = []
os.chdir("..")
aug = iaa.SomeOf(3, [
iaa.OneOf([
iaa.Affine(scale=(0.5, 1.5)),
iaa.ScaleX((0.5, 1.5)),
iaa.ScaleY((0.5, 1.5)),
]),
iaa.OneOf([
iaa.Rotate((-180, 180)),
iaa.ShearX((-60, 60)),
iaa.ShearY((-60, 60)),
]),
iaa.OneOf([
iaa.Fliplr(0.5),
iaa.Flipud(0.5),
]),
iaa.OneOf([
iaa.AverageBlur(k=(2, 6)),
iaa.GaussianBlur(sigma=(0.0, 2.0)),
iaa.Sharpen(alpha=(0.0, 0.8), lightness=(0.8, 1.2)),
]),
iaa.OneOf([
iaa.imgcorruptlike.GaussianNoise(severity=random.randint(1, 3)),
iaa.imgcorruptlike.ImpulseNoise(severity=random.randint(1, 3)),
iaa.imgcorruptlike.ElasticTransform(severity=random.randint(1, 3)),
]),
