def configure_transforms(resize_to):
train_transforms = iaa.Sequential([
iaa.PadToAspectRatio(1.0, position='center'),
iaa.Resize({
"height": resize_to,
"width": resize_to
}),
iaa.Affine(
scale={
"x": (0.95, 1.05),
"y": (0.95, 1.05)
},
translate_percent={
"x": (-0.05, 0.05),
"y": (-0.05, 0.05)
},
rotate=(-10, 10),
shear=(-5, 5),
),
])
valid_transforms = iaa.Sequential([
iaa.PadToAspectRatio(1.0, position='center'),
iaa.Resize({
"height": resize_to,
"width": resize_to
}),
])
return train_transforms, valid_transforms
def __getitem__(self, idx):
img, seg = self.get_data(idx)
img = img[..., ::-1]
h, w, c = img.shape
if self.rect:
scale = min(self.img_size[0] / w, self.img_size[1] / h)
resize = iaa.Sequential([
iaa.Resize({
'width': int(w * scale),
'height': int(h * scale)
}),
iaa.PadToFixedSize(*self.img_size,
pad_cval=[123.675, 116.28, 103.53],
position='center')
])
else:
resize = iaa.Resize({
'width': self.img_size[0],
'height': self.img_size[1]
})
img = resize.augment_image(img)
seg = resize.augment_segmentation_maps(seg)
# augment
if self.augments is not None:
augments = self.augments.to_deterministic()
img = augments.augment_image(img)
seg = augments.augment_segmentation_maps(seg)
img = img.transpose(2, 0, 1)
img = np.ascontiguousarray(img)
seg = seg.get_arr()
return torch.ByteTensor(img), torch.ByteTensor(seg)
def sroie_refine():
aug_list = []
stage_0, stage_1, stage_2, stage_3 = 1536, 2048, 768, 512
# Pad the height to stage_0
aug_list.append(
augmenters.PadToFixedSize(width=1, height=stage_0, pad_cval=255))
# Resize its height to stage_1, note that stage_0 is smaller than stage_1
# so that the font size could be increased for most cases.
aug_list.append(
augmenters.Resize(size={
"height": stage_1,
"width": "keep-aspect-ratio"
}))
# Crop a stage_2 x stage_2 area
aug_list.append(augmenters.CropToFixedSize(width=stage_2, height=stage_2))
# In case the width is not enough, pad it to stage_2 x stage_2
aug_list.append(
augmenters.PadToFixedSize(width=stage_2, height=stage_2, pad_cval=255))
# Resize to stage_3 x stage_3
aug_list.append(
augmenters.Resize(size={
"height": stage_3,
"width": stage_3
}))
# Perform Flip
aug_list.append(augmenters.Fliplr(0.33, name="horizontal_flip"))
aug_list.append(augmenters.Flipud(0.33, name="vertical_flip"))
return aug_list
def generate_cartoon():
ia.seed(1)
image1 = imageio.imread(
os.path.join(INPUT_IMAGES_DIR, "Pahalgam_Valley.jpg"))
image2 = imageio.imread(
os.path.join(INPUT_IMAGES_DIR, "1024px-Salad_platter.jpg"))
image1 = iaa.Resize({
"width": 256,
"height": "keep-aspect-ratio"
})(image=image1)
image2 = iaa.Resize({
"width": 256,
"height": "keep-aspect-ratio"
})(image=image2)
images_aug = [image1]
images_aug.extend(iaa.Cartoon()(images=[image1] * 3))
images_aug.append(image2)
images_aug.extend(iaa.Cartoon()(images=[image2] * 3))
# if we use a single draw_grid() call here, the function will currently
# add an ugly black border at the bottom of the first row, because the
# height of image1 is lower than of image2 and it will ensure that both
# rows have the same height
row1 = ia.draw_grid(images_aug[0:4], cols=4, rows=1)
row2 = ia.draw_grid(images_aug[4:], cols=4, rows=1)
_save("cartoon.jpg", np.vstack([row1, row2]))
def inference(model, img, img_size=(64, 64), rect=False):
img = img[:, :, ::-1]
h, w, c = img.shape
if rect:
scale = min(img_size[0] / w, img_size[1] / h)
resize = ia.Sequential([
ia.Resize({
'width': int(w * scale),
'height': int(h * scale)
}),
ia.PadToFixedSize(*img_size,
position='center')
])
else:
resize = ia.Resize({'width': img_size[0], 'height': img_size[1]})
img = resize.augment_image(img)
img = img.transpose(2, 0, 1)
img = np.ascontiguousarray(img)
imgs = torch.FloatTensor([img]).to(device)
imgs -= torch.FloatTensor([123.675, 116.28,
103.53]).reshape(1, 3, 1, 1).to(imgs.device)
imgs /= torch.FloatTensor([58.395, 57.12,
57.375]).reshape(1, 3, 1, 1).to(imgs.device)
preds = model(imgs)[0].softmax(0).cpu().numpy()
return preds
def YOLO():
"""
Data augmentation model for YOLOv3 training
"""
return iaa.Sequential([
iaa.KeepSizeByResize(
iaa.Affine(
scale=iap.Normal(1, 0.125),
translate_percent=0.1,
cval=128,
)),
iaa.Fliplr(0.5),
iaa.Resize({
"height": iap.Normal(1, 0.1),
"width": iap.Normal(1, 0.1)
}),
iaa.Resize({
"longer-side": 416,
"shorter-side": "keep-aspect-ratio"
}),
iaa.PadToFixedSize(416, 416, pad_cval=128),
iaa.MultiplyHueAndSaturation(mul_hue=iap.Uniform(0, 2),
mul_saturation=iap.Uniform(1 / 1.5, 1.5)),
iaa.AssertShape((None, 416, 416, 3)),
])
def preprocess(self, ims, augment):
def normalize(batch):
return batch.astype(np.float32) / float(255)
if augment:
augmentations = iaa.Sequential([
iaa.Resize(int(1.1 * hp.img_size)),
iaa.Fliplr(0.5),
iaa.Sometimes(0.4, iaa.Rotate((-30, 30))),
iaa.Sometimes(0.4, iaa.Affine(scale=(0.9, 1.2))),
iaa.Sometimes(0.5,
iaa.PerspectiveTransform(scale=(0.01, 0.20))),
# Crop/resize image to proper dimension
iaa.CropToFixedSize(hp.img_size, hp.img_size),
iaa.Resize(hp.img_size),
iaa.Sometimes(0.3, iaa.SaltAndPepper(0.01)),
iaa.CLAHE(to_colorspace='HSV')
])
else:
augmentations = ia.Sequential([iaa.CLAHE(to_colorspace='HSV')])
augmented = augmentations.augment_images(ims)
for i in augmented:
if i.shape != (hp.img_size, hp.img_size, 3):
print(i.shape)
augmented = np.stack(augmented, axis=0)
return normalize(augmented)
def complex_imgaug(x, org_size, scale_size):
"""input single RGB PIL Image instance"""
x = np.array(x)
x = x[np.newaxis, :, :, :]
aug_seq = iaa.Sequential([
iaa.Sometimes(
0.5,
iaa.OneOf([
iaa.GaussianBlur((3, 15)),
iaa.AverageBlur(k=(3, 15)),
iaa.MedianBlur(k=(3, 15)),
iaa.MotionBlur((5, 25))
])),
iaa.Resize(scale_size, interpolation=ia.ALL),
iaa.Sometimes(
0.2,
iaa.AdditiveGaussianNoise(loc=0,
scale=(0.0, 0.1 * 255),
per_channel=0.5)),
iaa.Sometimes(0.7, iaa.JpegCompression(compression=(10, 65))),
iaa.Resize(org_size),
])
aug_img = aug_seq(images=x)
return aug_img[0]
def get_item(self, idx):
img = cv2.imread(self.data[idx][0])
img = img[:, :, ::-1]
h, w, c = img.shape
if self.rect:
scale = min(self.img_size[0] / w, self.img_size[1] / h)
resize = iaa.Sequential([
iaa.Resize({
'width': int(w * scale),
'height': int(h * scale)
}),
iaa.PadToFixedSize(*self.img_size, position='center')
])
else:
resize = iaa.Resize({
'width': self.img_size[0],
'height': self.img_size[1]
})
img = resize.augment_image(img)
# augment
if self.augments is not None:
augments = self.augments.to_deterministic()
img = augments.augment_image(img)
img = img.transpose(2, 0, 1)
img = np.ascontiguousarray(img)
return torch.ByteTensor(img), self.data[idx][1]
def build_augmenter(self):
augmenter = iaa.Sometimes(
0.7,
iaa.Sequential([
iaa.Sequential([
iaa.Resize(
{
'longer-side': (96, 48),
'shorter-side': 'keep-aspect-ratio'
},
interpolation=ia.ALL),
iaa.Resize(
{
'longer-side': self.config.image_size,
'shorter-side': 'keep-aspect-ratio'
},
interpolation=ia.ALL)
]),
iaa.Affine(
scale=(0.8, 1.2),
translate_percent={
"x": (-0.2, 0.2),
"y": (-0.2, 0.2)
},
rotate=(-15, 15),
order=[0, 1],
mode=ia.ALL,
),
iaa.OneOf([
iaa.Noop(),
iaa.Multiply((0.2, 2.0)),
iaa.GammaContrast((0.5, 1.7)),
]),
iaa.OneOf([
iaa.Noop(),
iaa.JpegCompression(compression=(85, 95)),
iaa.GaussianBlur(sigma=(0.75, 2.25)),
iaa.MotionBlur(k=(10, 15))
]),
iaa.OneOf([
iaa.Noop(),
iaa.OneOf([
iaa.Crop(percent=((0.2, 0.5), 0, 0, 0),
keep_size=False),
iaa.Crop(percent=(0, (0.2, 0.5), 0, 0),
keep_size=False),
iaa.Crop(percent=(0, 0, (0.2, 0.5), 0),
keep_size=False),
iaa.Crop(percent=(0, 0, 0, (0.2, 0.5)),
keep_size=False),
iaa.Crop(percent=((0.1, 0.3), 0, (0.1, 0.3), 0),
keep_size=False),
iaa.Crop(percent=(0, (0.1, 0.3), 0, (0.1, 0.3)),
keep_size=False)
]),
iaa.PerspectiveTransform(0.1)
])
]))
return augmenter
def resize(image, target_shape, boxes=None, keep_aspect_ratio=True):
"""Resize images and boxes to the target shape
Arguments
--------
image: an image with shape (H,W,C)
target_shape: a shape of type (H,W,C)
boxes: an array of format (xmin, ymin, xmax, ymax)
keep_aspect_ratio: (default: True)
Returns
-------
image_resized: the image resized
boxes_resized: the boxes resized (optional: if boxes is not None)
"""
if keep_aspect_ratio:
aug = iaa.Sequential([
iaa.Resize({
"longer-side": target_shape[0],
"shorter-side": "keep-aspect-ratio"
}),
])
else:
aug = iaa.Sequential([
iaa.Resize({
"height": target_shape[0],
"width": target_shape[1]
}),
])
return __transform(image, aug, boxes=boxes)
def get_augs(img_size=320):
train_aug = iaa.Sequential([
iaa.Fliplr(0.5),
# iaa.Affine(
# scale={"x": (0.8, 1.2), "y": (0.8, 1.2)}, # scale images to 80-120% of their size, individually per axis
# translate_percent={"x": (-0.2, 0.2), "y": (-0.2, 0.2)}, # translate by -20 to +20 percent (per axis)
# rotate=(-45, 45), # rotate by -45 to +45 degrees
# shear=(-16, 16), # shear by -16 to +16 degrees
# order=[0, 1], # use nearest neighbour or bilinear interpolation (fast)
# cval=(0, 255), # if mode is constant, use a cval between 0 and 255
# mode=ia.ALL),
iaa.AddToHueAndSaturation((-20, 20)), # change hue and saturation
iaa.Crop(percent=(0.05, 0.5)),
iaa.Resize(size=(img_size, img_size))
# iaa.PadToFixedSize(img_size, img_size)
])
valid_aug = iaa.Sequential([
iaa.Fliplr(0.5),
iaa.Resize(size=(img_size, img_size))
# iaa.CropToFixedSize(img_size, img_size),
# iaa.PadToFixedSize(img_size, img_size)
])
return train_aug, valid_aug
def get_transform(image):
seq = []
if image.shape[0] >= image.shape[1]:
seq.append(iaa.Resize({"height": 480, "width": "keep-aspect-ratio"}))
if image.shape[1] / image.shape[1] * 480. > 640.:
seq.append(
iaa.Resize({
"width": 640,
"height": "keep-aspect-ratio"
}))
if image.shape[0] < image.shape[1]:
seq.append(iaa.Resize({"width": 640, "height": "keep-aspect-ratio"}))
if image.shape[0] / image.shape[1] * 640. > 480.:
seq.append(
iaa.Resize({
"height": 480,
"width": "keep-aspect-ratio"
}))
seq.append(iaa.CenterPadToFixedSize(
height=480,
width=640,
))
return iaa.Sequential(seq)
def get_training_augmentation(**kwargs):
seq = iaa.Sequential([
iaa.Resize({
'height': kwargs['crop_sz'],
'width': kwargs['crop_sz']
}),
iaa.flip.Fliplr(p=0.5),
iaa.OneOf(
[iaa.GaussianBlur(sigma=(0.0, 1.0)),
iaa.MotionBlur(k=(3, 5))]),
iaa.OneOf([
iaa.GammaContrast((0.8, 1.0)),
iaa.LinearContrast((0.75, 1.5)),
iaa.LogContrast((0.8, 1.0))
]),
iaa.AdditiveGaussianNoise(loc=0,
scale=(0.0, 0.05 * 255),
per_channel=0.5),
iaa.Crop(px=(0, 2 * (kwargs['crop_sz'] - kwargs['inp_sz']))),
iaa.Resize({
'height': kwargs['inp_sz'],
'width': kwargs['inp_sz']
})
])
return seq
def __init__(self,
image_folder,
annotation_file,
input_size=(512, 512),
target_domain_glob=None,
num_classes=80,
num_keypoints=0,
rotated_boxes=False,
mean=(0.40789654, 0.44719302, 0.47026115),
std=(0.28863828, 0.27408164, 0.27809835),
augmentation=None,
augment_target_domain=False,
max_detections=150,
down_ratio=4):
self.image_folder = Path(image_folder)
self.coco = COCO(annotation_file)
self.images = self.coco.getImgIds()
self.use_rotated_boxes = rotated_boxes
self.max_detections = max_detections
self.down_ratio = down_ratio
self.input_size = input_size
self.mean = np.array(mean, dtype=np.float32).reshape(1, 1, 3)
self.std = np.array(std, dtype=np.float32).reshape(1, 1, 3)
self.augmentation = augmentation
self.num_classes = num_classes
self.num_keypoints = num_keypoints
self.string_id_mapping = {}
self.augment_target_domain = augment_target_domain
self.cat_mapping = {
v: i
for i, v in enumerate(range(1, num_classes + 1))
}
self.classes = {
y: self.coco.cats[x] if x in self.coco.cats else ''
for x, y in self.cat_mapping.items()
}
assert len(input_size) == 2
if isinstance(target_domain_glob, str):
self.target_domain_files = glob(target_domain_glob)
elif isinstance(target_domain_glob, (list, ListConfig)):
self.target_domain_files = []
for pattern in target_domain_glob:
self.target_domain_files.extend(glob(pattern))
else:
self.target_domain_files = []
if self.augmentation:
augmentation_methods = instantiate_augmenters(augmentation)
self.augmentation = iaa.Sequential(augmentation_methods)
self.resize = iaa.Resize((self.input_size[0], self.input_size[1]))
self.resize_out = iaa.Resize((self.input_size[0] // down_ratio,
self.input_size[1] // down_ratio))
log.info(
f"found {len(self.target_domain_files)} samples for target domain")
super().__init__()
def get_down():
return ia.Sequential([
# random downsample between 4x to 8x and get back
ia.Resize((1.0, 1.0), interpolation="cubic"),
ia.Resize({
"height": 512,
"width": 512
}, interpolation="cubic"),
])
def get_down():
return ia.Sequential([
# random downsample between 4x to 8x and get back
ia.Resize((0.125, 0.25)),
ia.Resize({
"height": 512,
"width": 512
}),
])
def __getitem__(self, idx):
img, kps = self.get_data(idx)
img = img[..., ::-1]
h, w, c = img.shape
if self.rect:
scale = min(self.img_size[0] / w, self.img_size[1] / h)
resize = ia.Sequential([
ia.Resize({
'width': int(w * scale),
'height': int(h * scale)
}),
ia.PadToFixedSize(*self.img_size,
pad_cval=[123.675, 116.28, 103.53],
position='center')
])
else:
resize = ia.Resize({
'width': self.img_size[0],
'height': self.img_size[1]
})
img = resize.augment_image(img)
kps = resize.augment_polygons(kps)
# augment
if self.augments is not None:
augments = self.augments.to_deterministic()
img = augments.augment_image(img)
kps = augments.augment_polygons(kps)
heats = [np.zeros(img.shape[:2])] * len(self.classes)
for kp in kps.polygons:
c = kp.label
point = kp.exterior.astype(np.int32)
x = np.arange(img.shape[1], dtype=np.float)
y = np.arange(img.shape[0], dtype=np.float)
xx, yy = np.meshgrid(x, y)
# evaluate kernels at grid points
xxyy = np.c_[xx.ravel(), yy.ravel()]
sigma = 10 # 65.9 # math.sqrt(- math.pow(100, 2) / math.log(0.1))
xxyy -= point
x_term = xxyy[:, 0]**2
y_term = xxyy[:, 1]**2
exp_value = -(x_term + y_term) / 2 / pow(sigma, 2)
zz = np.exp(exp_value)
heat = zz.reshape(img.shape[:2])
heats[c] = heat
# cv2.imshow('c', (heat * 255).astype(np.uint8))
# cv2.waitKey(0)
heats = np.stack(heats, 0)
img = img.transpose(2, 0, 1)
img = np.ascontiguousarray(img)
return torch.ByteTensor(img), torch.FloatTensor(heats)
def prismatize(images, random_state, parents, hooks):
ret_images = list()
for image in images:
val = random_state.uniform(0.0001, 0.9999)
aug1 = iaa.Resize({"width": val})
image1 = aug1(images=image.reshape(1,*image.shape)).reshape(image.shape[0],-1,1)
aug2 = iaa.Resize({"width": 1 - val})
image2 = aug2(images=image.reshape(1,*image.shape)).reshape(image.shape[0],-1,1)
ret_images.append(np.concatenate((image1, image2), axis=1).reshape(image.shape[0],-1,1))
return np.stack(ret_images, axis=0).reshape(len(ret_images), *ret_images[0].shape)
def __call__(self, *args, **kwargs) -> typing.Tuple[np.ndarray, typing.List[Polygon]]:
if self.is_training:
resize = iaa.Resize(size=dict(longer_side=self.long_sizes,
width='keep-aspect-ratio'))
rotate = iaa.Rotate(rotate=self.angles, fit_output=True)
resize_height = iaa.Resize(size=dict(height=self.height_ratios,
width='keep'))
crop = iaa.CropToFixedSize(width=self.cropped_size[0], height=self.cropped_size[1])
fix_resize = iaa.Resize(size=self.output_size)
# blur = iaa.GaussianBlur()
# blur = iaa.Sometimes(p=self.blur_prob,
# then_list=blur)
brightness = iaa.MultiplyBrightness((0.5, 1.5))
brightness = iaa.Sometimes(self.color_jitter_prob, then_list=brightness)
saturation = iaa.MultiplySaturation((0.5, 1.5))
saturation = iaa.Sometimes(self.color_jitter_prob, then_list=saturation)
contrast = iaa.LinearContrast(0.5)
contrast = iaa.Sometimes(self.color_jitter_prob, then_list=contrast)
hue = iaa.MultiplyHue()
hue = iaa.Sometimes(self.color_jitter_prob, then_list=hue)
augs = [resize,
rotate,
resize_height,
crop,
fix_resize,
brightness,
saturation,
contrast,
hue]
ia = iaa.Sequential(augs)
else:
fix_resize = iaa.Resize(size=self.output_size)
ia = iaa.Sequential([fix_resize])
image = args[0]
polygons = args[1]
polygon_list = []
for i in range(polygons.shape[0]):
polygon_list.append(Polygon(polygons[i].tolist()))
polygons_on_image = PolygonsOnImage(polygon_list, shape=image.shape)
image_aug, polygons_aug = ia(image=image, polygons=polygons_on_image)
return image_aug, polygons_aug.polygons
def augmentation_pipeline(level):
if level == 'resize_only':
list_augmentations = [iaa.Resize(512)]
elif level == 'light':
list_augmentations = [
iaa.Resize(512),
iaa.Affine(
scale=1.1,
shear=(2.5, 2.5),
rotate=(-5, 5),
),
]
elif level == 'heavy': #no rotation included
list_augmentations = [
iaa.Resize(512),
iaa.Affine(
scale=1.15,
shear=(4.0, 4.0),
),
iaa.Fliplr(0.2), # horizontally flip 20% of the images
iaa.Sometimes(
0.1,
iaa.CoarseSaltAndPepper(p=(0.01, 0.01),
size_percent=(0.1, 0.2))),
iaa.Sometimes(0.5, iaa.GaussianBlur(sigma=(0.0, 2.0))),
iaa.Sometimes(0.5,
iaa.AdditiveGaussianNoise(scale=(0, 0.04 * 255))),
]
elif level == 'heavy_with_rotations':
list_augmentations = [
iaa.Resize(512),
iaa.Affine(
scale=1.15,
shear=(4.0, 4.0),
rotate=(-6, 6),
),
iaa.Fliplr(0.2), # horizontally flip 20% of the images
iaa.Sometimes(
0.1,
iaa.CoarseSaltAndPepper(p=(0.01, 0.01),
size_percent=(0.1, 0.2))),
iaa.Sometimes(0.5, iaa.GaussianBlur(sigma=(0.0, 2.0))),
iaa.Sometimes(0.5,
iaa.AdditiveGaussianNoise(scale=(0, 0.04 * 255))),
]
return list_augmentations
def __init__(self, width=1020, height=1020):
self.images = np.zeros((0, 3, width, height), dtype=np.uint8)
self.sizes = np.zeros((0, 2), dtype=int)
self.width = width
self.height = height
self.by_height_resizer = iaa.Resize({
'width': 'keep-aspect-ratio',
'height': self.height
})
self.by_width_resizer = iaa.Resize({
'width': self.width,
'height': 'keep-aspect-ratio'
})
self.mutex = Lock()
def get_dataloader(data_dir='',
batch_size=64,
train_set=True,
num_workers=1,
augment=True):
if augment:
seq = iaa.Sequential([
iaa.Resize((64, 64)),
iaa.Affine(rotate=(-5, 5), translate_px=(-10, 10), shear=(-5, 5))
],
random_order=False)
else:
seq = iaa.Resize((64, 64))
dataloader = torch.utils.data.DataLoader(datasets.MNIST(
data_dir,
train=train_set,
download=True,
transform=transforms.Compose([
np.array,
seq.augment_images,
transforms.ToTensor(),
])),
num_workers=num_workers,
batch_size=batch_size,
shuffle=True)
return dataloader
# class CustomDataset(Dataset):
# def __init__(self, n_images, n_classes, transform=None):
# self.images = np.random.randint(0, 255,
# (n_images, 224, 224, 3),
# dtype=np.uint8)
# self.targets = np.random.randn(n_images, n_classes)
# self.transform = transform
#
# def __getitem__(self, item):
# image = self.images[item]
# target = self.targets[item]
#
# if self.transform:
# image = self.transform(image)
#
# return image, target
#
# def __len__(self):
# return len(self.images)
def __init__(self,
list_paths,
labels,
resize_dims=(256, 256),
augment=False):
"""
Dataset for training
:param list_paths: List of image paths
:param labels: List of keypoints
:param resize_dims: What size to make images
:param augment: Whether to augment images or not
:param device: Which device to load tensors to
"""
super().__init__()
self.list_paths = list_paths
self.labels = labels
self.resize_dims = resize_dims
self.keypoint_divisor = np.array([
resize_dims[0], resize_dims[1], resize_dims[0], resize_dims[1],
resize_dims[0], resize_dims[1], resize_dims[0], resize_dims[1],
resize_dims[0], resize_dims[1], resize_dims[0], resize_dims[1],
resize_dims[0], resize_dims[1], resize_dims[0], resize_dims[1]
])
self.augment = augment
self.data_transform = transforms.Compose(
[transforms.Resize(resize_dims),
transforms.ToTensor()])
self.seq_basic = iaa.Sequential([iaa.Resize(resize_dims)])
self.seq1 = iaa.Sequential([
iaa.Affine(scale=(0.7, 1.0), mode='edge'), # 'reflect'
iaa.Fliplr(0.5),
iaa.Flipud(0.5),
iaa.Resize(resize_dims)
])
self.seq2 = iaa.Sequential([
iaa.Affine(rotate=(-60, 60), scale=(0.7, 1.1),
mode='edge'), # 'reflect'
iaa.Crop(px=(
0, 25
)), # crop images from each side by 0 to 16px (randomly chosen)
iaa.Fliplr(0.5), # horizontally flip 50% of the images
iaa.Flipud(0.5),
iaa.Resize(resize_dims)
])
def train_augmentors(self):
shape_augs = [
iaa.Resize((512, 512), interpolation='nearest'),
# iaa.CropToFixedSize(width=800, height=800),
]
#
sometimes = lambda aug: iaa.Sometimes(0.2, aug)
input_augs = [
iaa.OneOf([
iaa.GaussianBlur((0, 3.0)), # gaussian blur with random sigma
iaa.MedianBlur(k=(3, 5)), # median with random kernel sizes
iaa.AdditiveGaussianNoise(loc=0,
scale=(0.0, 0.05 * 255),
per_channel=0.5),
]),
sometimes(iaa.ElasticTransformation(alpha=(0.5, 3.5), sigma=0.25)),
# move pixels locally around (with random strengths)
sometimes(iaa.PiecewiseAffine(scale=(0.01, 0.05))
), # sometimes move parts of the image around
sometimes(iaa.PerspectiveTransform(scale=(0.01, 0.1))),
iaa.Sequential([
iaa.Add((-26, 26)),
iaa.AddToHueAndSaturation((-20, 20)),
iaa.LinearContrast((0.75, 1.25), per_channel=1.0),
],
random_order=True),
sometimes([
iaa.CropAndPad(percent=(-0.05, 0.1),
pad_mode="reflect",
pad_cval=(0, 255)),
]),
]
return shape_augs, input_augs
def _augment(self, images):
'''
We need the augmentation to keep the temporal information of the clip,
so all augmentations in one clip without random
'''
# Get the resize function in the augmentation
if self.params.resize.use:
resize = self.transforms.find_augmenters_by_name('resize')[0]
elif self.params.CropToFixedSize.use:
resize = iaa.Resize(
{
"height": self.params.CropToFixedSize.height,
"width": self.params.CropToFixedSize.width
},
name='resize')
else:
raise Exception('YOU MUST HAVE THE SAME SIZE OF IMAGES')
# Make the some data not augment
oneof_iaa = iaa.OneOf([self.transforms, resize])
oneof_iaa_deterministic = oneof_iaa.to_deterministic()
temp = [
oneof_iaa_deterministic(image=images[i])
for i in range(len(images))
]
temp = np.array(temp)
# import ipdb; ipdb.set_trace()
return temp
def __call__(self, img, anno):
gts = anno[1].numpy()
np_img = np.asarray(img)
scale = self.h / np_img.shape[0]
# get BoundingBoxesOnImage
bbs = []
for gt in gts:
bbs.append(BoundingBox(x1=gt[0], y1=gt[1], x2=gt[2], y2=gt[3]))
bbs_on_img = BoundingBoxesOnImage(bbs, shape=np_img.shape)
# draw_img = bbs_on_img.draw_on_image(np_img, size=2)
self.seq = iaa.Sequential(
[iaa.Resize({
"height": self.h,
"width": self.w
})])
# apply augment
image_aug = self.seq.augment_image(np_img)
bbs_aug = self.seq.augment_bounding_boxes(bbs_on_img).bounding_boxes
gts = []
for bb in bbs_aug:
gts.append([bb.x1, bb.y1, bb.x2, bb.y2])
gts = torch.from_numpy(np.array(gts))
anno[2]["scale"] = scale
return image_aug, (anno[0], gts, anno[2])
def datagen(dataset_path, batch_size, x_mean): # 函数式generator
while 1:
imgs = np.zeros((batch_size, 957, 957, 3), dtype=np.uint8)
labels = np.zeros((batch_size, ))
# 从整个数据集的所有类别中，随机选取batch_size张图片，预处理后yield
for img_idx in range(batch_size):
label = np.random.randint(0, 50) # 随机选取一个类别编号，并作为文件夹索引的一部分
labels[img_idx] = label
if label < 10:
img_path = dataset_path + '0' + str(label)
else:
img_path = dataset_path + str(label)
img_path = img_path + '/' + random.sample(
os.listdir(img_path), 1)[0] # random.sample从指定目录下随机选择文件
img = Image.open(img_path)
imgs[img_idx] = img
ia.seed(np.random.randint(0, 100))
data_preprocessor1 = iaa.Sequential([iaa.Affine(rotate=(-179, 180))])
data_preprocessor2 = iaa.Sequential([
iaa.Resize({
"height": 456,
"width": 456
}),
iaa.Sometimes(0.25, iaa.ContrastNormalization(
(0.8, 1.2))), # 25%的图像对比度随机变为0.8或1.2倍
iaa.Sometimes(0.25, iaa.Multiply(
(0.8, 1.2))) # 25%的图片像素值乘以0.8-1.2中间的数值,用以增加图片明亮度或改变颜色
])
imgs_aug0 = data_preprocessor1.augment_images(imgs)
imgs_aug1 = imgs_aug0[:, 140:-140, 140:-140, :]
imgs_aug2 = data_preprocessor2.augment_images(imgs_aug1)
plt.imshow(np.squeeze(imgs_aug2, 0))
plt.show()
yield imgs_aug2.astype(np.float32) - x_mean, np_utils.to_categorical(
labels, num_classes=50)
def __init__(self, data_config, transform=False, mode="train", visualize=False):
# Set the mode (train/val)
self.mode = mode
self.visualize = visualize
# Read in necessary configs
file_data_path = data_config[mode]
self.image_directory = data_config["image_directory"]
self.annotation_directory = data_config["annotation_directory"]
self.classes = tuple(data_config['classes'])
self.file_list = self.create_file_list(file_data_path)
self.transform = transform
self.transformations = iaa.Noop()
self.height = data_config["figure_size"]
self.width = data_config["figure_size"]
self.resize_transformation = iaa.Resize({
"height": self.height,
"width": self.width
})
self.data_encoder = DataEncoder(data_config)
self.default_boxes = self.data_encoder.default_boxes
def _get_default_augment(self):
augment_seq = iaa.Sequential([
iaa.Fliplr(0.5),
iaa.Affine(rotate=(-10, 10)),
iaa.Resize((0.5, 3.0))
])
return augment_seq
