def train_transforms():
return A.Compose(
[
A.RandomSizedCrop(
min_max_height=(512, 540), height=600, width=600, p=0.1),
A.OneOf([
A.HueSaturationValue(hue_shift_limit=0.3,
sat_shift_limit=0.3,
val_shift_limit=0.3,
p=0.5),
A.RandomBrightnessContrast(
brightness_limit=0.3, contrast_limit=0.3, p=0.5),
],
p=0.9),
A.ShiftScaleRotate(
shift_limit=0.0625, scale_limit=0.1, rotate_limit=10, p=0.5),
# A.Cutout(num_holes=8, max_h_size=32, max_w_size=32, fill_value=0, p=0.5),
# A.Cutout(num_holes=4, max_h_size=100, max_w_size=2, fill_value=0, p=0.5)
],
p=1.0,
bbox_params=A.BboxParams(format='pascal_voc',
label_fields=['class_labels']))
def get_train_transforms(config, force_light=False):
aug_list=[
CropLemon(p=1),
A.Transpose(p=0.5),
A.HorizontalFlip(p=0.5),
A.VerticalFlip(p=0.5),
A.Rotate(p=0.5),
A.OneOf([
A.GaussNoise(p=1),
A.GaussianBlur(p=1),
], p=0.3),
A.RandomBrightnessContrast(brightness_limit=(-0.2, 0.2), contrast_limit=(-0.2, 0.2), p=0.3),
A.HueSaturationValue(hue_shift_limit=5, val_shift_limit=5, p=0.3),
A.Resize(config.img_size, config.img_size),
A.Normalize(
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225],
max_pixel_value=255.0,
p=1.0),
ToTensorV2(p=1.0),
]
return A.Compose(aug_list, p=1.0)
def __init__(self, img, data, img_size):
"""
arguments
---------
img : list
list of images, in the original size (height, width, 3)
data : list of dict
Each dict has :
'image' : index of the image. The index should match with img
'mask' : [rr, cc]
'box' : [[xmin, ymin], [xmax,ymax]]
'size' : the size of the image that the data was created with
IMPORTANT : (WIDTH, HEIGHT)
img_size : tuple
Desired output image size
The axes will be swapped to match pygame.
IMPORTANT : (WIDTH, HEIGHT)
"""
self.img = img
self.data = data
self.n = len(data)
self.output_size = img_size
self.aug = A.Compose(
[
A.OneOf([
A.RandomGamma((40, 200), p=1),
A.RandomBrightness(limit=0.5, p=1),
A.RandomContrast(limit=0.5, p=1),
A.RGBShift(p=1),
],
p=0.8),
A.VerticalFlip(p=0.5),
A.RandomRotate90(p=1),
A.Resize(img_size[1], img_size[0]),
],
bbox_params=A.BboxParams(format='albumentations',
label_fields=['bbox_classes']),
keypoint_params=A.KeypointParams(format='xy'),
)
def stong_aug():
# strong aug for train
train_transform = [
albu.Resize(height=configs.input_size, width=configs.input_size),
albu.HorizontalFlip(p=0.5),
albu.VerticalFlip(p=0.5),
albu.RandomRotate90(p=0.5),
albu.OneOf([
albu.CenterCrop(
p=0.5, height=configs.input_size, width=configs.input_size),
albu.ElasticTransform(
p=0.5, alpha=120, sigma=120 * 0.05, alpha_affine=120 * 0.03),
albu.GridDistortion(p=0.5),
albu.OpticalDistortion(p=1, distort_limit=1, shift_limit=0.5),
],
p=0.8),
albu.Normalize(mean=(0.485, 0.456, 0.406),
std=(0.229, 0.224, 0.225),
p=1),
AT.ToTensor(),
]
return albu.Compose(train_transform)
def main():
image = cv2.imread("cuiyan.png")
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
def visualize(image):
plt.figure(figsize=(6, 6))
plt.axis("off")
plt.imshow(image)
# plt.show()
transform = A.Compose([
A.RandomCrop(111, 222),
A.OneOf([A.RGBShift(), A.HueSaturationValue()]),
])
random.seed(42)
transformed = transform(image=image)
visualize(transformed["image"])
A.save(transform, "./transform.json")
A.save(transform, "./transform.yml", data_format="yaml")
pprint.pprint(A.to_dict(transform))
def get_train_transforms():
return A.Compose(
[
# A.RandomSizedCrop(min_max_height=(512, 512), height=1024, width=1024, p=0.5),
#### THESE ARE THE SAFE ONES ####
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),
# A.HorizontalFlip(p=0.5),
# A.VerticalFlip(p=0.5),
# #################################
# A.RandomScale (scale_limit=(0.1, 2.0), interpolation=1, p=0.5),
# A.OneOf([
# A.RandomSizedBBoxSafeCrop (256, 256, p=1.0),
# A.RandomSizedBBoxSafeCrop (1024, 1024, p=1.0),
# ], p=0.9),
# A.IAAPerspective (scale=(0.05, 0.1), keep_size=True, always_apply=False, p=0.5),
A.Resize(height=512, width=512, p=1.0),
# A.Cutout(num_holes=8, max_h_size=64, max_w_size=64, fill_value=0, p=0.5),
ToTensorV2(p=1.0),
],
# p=1.0,
# bbox_params=A.BboxParams(
# format='pascal_voc',
# min_area=0,
# min_visibility=0,
# label_fields=['labels'],
# )
)
def __init__(self, size=512, mode='train'):
assert mode in ['train', 'val', 'test']
if mode == 'train':
self.transform = A.Compose([
A.HorizontalFlip(p=0.5),
A.ShiftScaleRotate(
p=0.5,
shift_limit=0.0625,
scale_limit=0.1,
rotate_limit=10,
interpolation=1,
border_mode=4,
),
A.OneOf([
A.Cutout(
p=1.0,
num_holes=6,
max_h_size=32,
max_w_size=32,
),
A.GridDropout(p=1.0,
ratio=0.5,
unit_size_min=64,
unit_size_max=128,
random_offset=True),
],
p=0.5),
A.Resize(size, size, p=1.0),
])
elif mode == 'val':
self.transform = A.Compose([
A.Resize(size, size, p=1.0),
])
elif mode == 'test':
self.transform = A.Compose([
A.Resize(size, size, p=1.0),
])
def test_data_augmentation(data_dir, save_dir, filename):
"""画像の変換のテスト。目視したいので結果を`../___check/image/`に保存しちゃう。"""
base_size = 32 if filename == "cifar.png" else 256
bboxes = [(0.41, 0.39, 0.70, 0.75)]
keypoints = [(0.52 * base_size, 0.52 * base_size)]
aug = A.Compose(
[
A.OneOf(
[
tk.image.Standardize(),
tk.image.ToGrayScale(p=0.125),
tk.image.RandomBinarize(p=0.125),
],
p=0.25,
),
# tk.image.RandomRotate(), # TODO
tk.image.RandomTransform(size=(256, 256), base_scale=2.0),
tk.image.RandomColorAugmentors(noisy=True),
tk.image.SpeckleNoise(),
tk.image.GridMask(),
],
bbox_params=A.BboxParams(format="albumentations", label_fields=["classes"]),
keypoint_params=A.KeypointParams(format="xy"),
)
img_path = data_dir / filename
original_img = tk.ndimage.load(img_path)
for i in range(32):
augmented = aug(
image=original_img, bboxes=bboxes, classes=[0], keypoints=keypoints
)
img = augmented["image"]
img = tk.od.plot_objects(img, None, None, augmented["bboxes"])
for x, y in augmented["keypoints"]:
x = np.clip(int(x), 1, img.shape[1] - 2)
y = np.clip(int(y), 1, img.shape[1] - 2)
img[range(y - 1, y + 2), x, :] = [[[255, 255, 0]]]
img[y, range(x - 1, x + 2), :] = [[[255, 255, 0]]]
tk.ndimage.save(save_dir / f"{img_path.stem}.DA.{i}.png", img)
def get_augumentation(phase,
width=512,
height=512,
min_area=0.,
min_visibility=0.):
list_transforms = []
if phase == 'train':
list_transforms.extend([
albu.HorizontalFlip(p=0.5),
albu.OneOf([
albu.RandomGamma(),
albu.RandomBrightnessContrast(),
albu.VerticalFlip(p=0.5),
],
p=0.3),
albu.ShiftScaleRotate(),
])
list_transforms.extend([
albu.Resize(width, height),
])
if phase == 'train':
list_transforms.extend(
[albu.CenterCrop(p=0.2, height=height, width=width)])
if (phase == 'show'):
return albu.Compose(list_transforms)
list_transforms.extend([ToTensor()])
if (phase == 'test'):
return albu.Compose(list_transforms)
return albu.Compose(list_transforms,
bbox_params=albu.BboxParams(
format='pascal_voc',
min_area=min_area,
min_visibility=min_visibility,
label_fields=['category_id']))
def create_data_transforms(args, split='train'):
"""Create data transofrms
Args:
args: data transforms configs
split (str, optional): split for train, val or test. Defaults to 'train'.
Returns:
albumentation: pytorch data augmentations
"""
base_transform = create_base_transforms(args, split=split)
if split == 'train':
aug_transform = alb.Compose([
alb.Rotate(limit=30),
alb.Cutout(1, 25, 25, p=0.1),
alb.RandomResizedCrop(256, 256, scale=(0.5, 1.0), p=0.5),
alb.Resize(args.image_size, args.image_size),
alb.HorizontalFlip(),
alb.ToGray(p=0.1),
alb.GaussNoise(p=0.1),
alb.OneOf([
alb.RandomBrightnessContrast(),
alb.FancyPCA(),
alb.HueSaturationValue(),
],
p=0.7),
alb.GaussianBlur(blur_limit=3, p=0.05),
])
data_transform = alb.Compose([*aug_transform, *base_transform])
elif split == 'val':
data_transform = base_transform
elif split == 'test':
data_transform = base_transform
return data_transform
class Resize(object):
width = height = opt.scale if opt.scale else 256
train_transform = A.Compose(
[
A.RandomResizedCrop(
height=height, width=width, scale=(0.8, 1.0), p=1.0),
A.OneOf([
A.HueSaturationValue(hue_shift_limit=0.4,
sat_shift_limit=0.4,
val_shift_limit=0.4,
p=0.9),
A.RandomBrightnessContrast(
brightness_limit=0.3, contrast_limit=0.3, p=0.9),
],
p=0.9), # 色相饱和度对比度增强
A.GaussianBlur(p=0.5),
A.HorizontalFlip(p=0.5),
A.VerticalFlip(p=0.5),
A.Transpose(p=0.5), # TTA×8
A.Normalize(max_pixel_value=1.0, p=1.0),
A.CoarseDropout(p=0.5, max_width=32, max_height=32),
# A.Cutout(p=0.5),
ToTensorV2(p=1.0),
],
p=1.0,
)
divisor = 8 # padding成8的倍数
val_transform = A.Compose(
[
# A.PadIfNeeded(min_height=None, min_width=None, pad_height_divisor=divisor, pad_width_divisor=divisor, p=1.0),
A.Resize(height=height, width=width, p=1.0),
A.Normalize(max_pixel_value=1.0, p=1.0),
ToTensorV2(p=1.0),
],
p=1.0,
)
def __init__(
self,
transforms=None,
mean=(0, 0, 0),
std=(1, 1, 1),
width=3,
depth=-1,
alpha=1.,
p=1.,
):
self.transforms = transforms
self.mean = mean
self.std = std
self.width = width
self.depth = depth
self.alpha = alpha
self.p = p
if self.transforms is None:
self.transforms = [
AutoContrast(cutoff=0, p=1),
albu.Equalize(mode='pil', p=1),
albu.Posterize(num_bits=(3, 4), p=1),
albu.ShiftScaleRotate(shift_limit=0, scale_limit=0, rotate_limit=5, border_mode=cv2.BORDER_CONSTANT, value=(0, 0, 0), p=1), # rotate
albu.Solarize(threshold=77, p=1),
RandomShear(shear_x=0.09, shear_y=0, border_mode=cv2.BORDER_CONSTANT, value=(0, 0, 0), p=1),
RandomShear(shear_x=0, shear_y=0.09, border_mode=cv2.BORDER_CONSTANT, value=(0, 0, 0), p=1),
VerticalShift(shift_limit=0.09, border_mode=cv2.BORDER_CONSTANT, value=(0, 0, 0), p=1),
HorizontalShift(shift_limit=0.09, border_mode=cv2.BORDER_CONSTANT, value=(0, 0, 0), p=1),
# ImageNet-C
albu.HueSaturationValue(hue_shift_limit=0, sat_shift_limit=(-36, 0), val_shift_limit=0, p=1), # saturation
albu.RandomContrast(limit=(-0.36, 0), p=1),
albu.RandomBrightness(limit=(-0.36, 0), p=1),
albu.OneOf([ # sharpness
albu.IAASharpen(alpha=(0.1, 0.5), lightness=0, p=1),
albu.Blur(blur_limit=7, p=1),
], p=0.5),
]
def build_transforms(args, n_classes):
train_transforms = A.Compose([
A.HorizontalFlip(),
A.RandomResizedCrop(width=args.image_size, height=args.image_size, scale=(0.5, 2.)),
A.CoarseDropout(max_height=int(args.image_size / 5), max_width=int(args.image_size / 5), max_holes=5),
A.Rotate(limit=(-30, 30)),
A.ColorJitter(),
A.OneOf([
A.RandomGamma(),
A.RandomBrightnessContrast(),
A.Blur(blur_limit=5),
]),
ToTensorV2(),
])
train_transforms = AlbumentationsSegmentationWrapperTransform(train_transforms, class_num=n_classes,
ignore_indices=[255, ])
test_transforms = A.Compose([
A.Resize(width=args.image_size, height=args.image_size),
ToTensorV2(),
])
test_transforms = AlbumentationsSegmentationWrapperTransform(test_transforms, class_num=n_classes,
ignore_indices=[255, ])
return train_transforms, test_transforms
def __init__(self, data_dir,is_train=True):
self.paths=sorted(glob.glob(data_dir+'/*/*'))
self.transform_train = A.Compose([
A.RandomResizedCrop(height=500, width=900), # change ratio and scale 500 / 900
A.RandomBrightnessContrast(brightness_limit=0.1, contrast_limit=0.1, p=0.5),
A.RandomGamma(p=0.5),
A.HorizontalFlip(p=0.5),
A.Rotate(limit=10,p=0.5),
A.OneOf([A.MotionBlur(blur_limit=3), A.GlassBlur(max_delta=3), A.GaussianBlur(blur_limit=3)], p=0.5),
A.GaussNoise(p=0.5),
A.Normalize(mean=(0.446, 0.469, 0.472), std=(0.326, 0.330, 0.338), max_pixel_value=255.0, p=1.0),
ToTensorV2(p=1.0),
])
self.transform_valid = A.Compose([
A.Resize(height=500, width=900),
A.Normalize(mean=(0.446, 0.469, 0.472), std=(0.326, 0.330, 0.338), max_pixel_value=255.0, p=1.0),
ToTensorV2(p=1.0),
])
if is_train:
self.data_transforms=self.transform_train
else:
self.data_transforms = self.transform_valid
def get_train_transforms_distortion(cfg):
return A.Compose([
A.CenterCrop(cfg["img_size"], cfg["img_size"], p=1.0),
A.HueSaturationValue(),
A.OneOf(
[
A.OpticalDistortion(p=0.4),
A.GridDistortion(p=0.2),
A.IAAPiecewiseAffine(p=0.4),
],
p=0.5,
),
A.RandomBrightnessContrast(brightness_limit=(-0.3, 0.3),
contrast_limit=(-0.1, 0.1),
p=0.5),
A.Normalize(
mean=[0.56019358, 0.52410121, 0.501457],
std=[0.23318603, 0.24300033, 0.24567522],
max_pixel_value=255.0,
p=1.0,
),
ToTensorV2(p=1.0),
])
def dataAugumentation2(phase,
mean=(0.485, 0.456, 0.406),
std=(0.229, 0.224, 0.225)):
trans = []
if phase == "train":
trans.extend([
albu.HorizontalFlip(p=0.5), # only horizontal flip as of now
albu.VerticalFlip(p=0.5),
albu.RandomCrop(256, 256, always_apply=True),
albu.IAAAdditiveGaussianNoise(p=0.2),
albu.OneOf(
[
albu.RandomContrast(p=1),
albu.HueSaturationValue(p=1),
],
p=0.5,
)
])
trans.extend([
albu.Normalize(mean=mean, std=std, p=1),
])
all_trans = albu.Compose(trans)
return all_trans
def choco_transform(p):
return albu.Compose([
# Flips
albu.HorizontalFlip(p=0.5),
albu.VerticalFlip(p=0.5),
# Shift, scale, rotate
albu.ShiftScaleRotate(rotate_limit=0,
scale_limit=0.15,
border_mode=cv2.BORDER_CONSTANT,
value=[255, 255, 255],
p=0.5),
# Noise
albu.IAAAdditiveGaussianNoise(p=0.2),
# Color
albu.Solarize(p=0.2),
albu.ToGray(p=0.2),
# Contrast, brightness
albu.OneOf([
albu.RandomGamma(p=1),
albu.RandomContrast(p=1),
albu.RandomBrightness(p=1)
], p=0.5)
], p=p, additional_targets={'image{}'.format(_) : 'image' for _ in range(1, 101)})
def get_hard_train_transforms(mean, std):
transforms = [
albu.OneOf([
albu.RandomSizedCrop(min_max_height=(200, 256),
height=256,
width=1600,
w2h_ratio=1600 / 256,
p=0.5),
ShiftScaleRotate(shift_limit=0.25,
scale_limit=0.25,
rotate_limit=90,
border_mode=cv.BORDER_CONSTANT,
value=0,
mask_value=0),
]),
albu.RandomBrightnessContrast(),
albu.RandomGamma(),
Flip(),
Normalize(mean=mean, std=std),
ToTensor()
]
return Compose(transforms)
def get_train_transforms(input_size=256):
return A.Compose(
[
A.RandomCrop(input_size, input_size),
A.HorizontalFlip(),
A.VerticalFlip(),
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.15, p=0.9),
],
p=0.9,
),
A.ToFloat(255),
ToTensorV2(),
],
additional_targets={"image1": "image"},
)
def get_light_augmentations(image_size):
return A.Compose([
A.ShiftScaleRotate(shift_limit=0.05,
scale_limit=0.1,
rotate_limit=15,
border_mode=cv2.BORDER_CONSTANT,
value=0),
A.RandomSizedCrop(min_max_height=(int(image_size[0] * 0.85),
image_size[0]),
height=image_size[0],
width=image_size[1],
p=0.3),
# Brightness/contrast augmentations
A.OneOf([
A.RandomBrightnessContrast(brightness_limit=0.25,
contrast_limit=0.2),
IndependentRandomBrightnessContrast(brightness_limit=0.1,
contrast_limit=0.1),
A.RandomGamma(gamma_limit=(75, 125)),
A.NoOp()
]),
A.HorizontalFlip(p=0.5),
])
def get_train_transforms() -> A.Compose:
return A.Compose(
[
A.RandomSizedCrop(
min_max_height=(800, 800), height=1024, width=1024, p=0.5
),
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),
A.HorizontalFlip(p=0.5),
A.VerticalFlip(p=0.5),
A.Resize(height=512, width=512, p=1),
A.Cutout(
num_holes=8, max_h_size=64, max_w_size=64, fill_value=0, p=0.5
),
ToTensorV2(p=1.0),
],
p=1.0,
bbox_params=A.BboxParams(
format="pascal_voc",
min_area=0,
min_visibility=0,
label_fields=["labels"],
),
)
def make_augmentation(output_size, is_validation):
aug = None
if is_validation:
aug = get_aug([
A.Resize(width=output_size[0],
height=output_size[1],
always_apply=True),
A.Normalize(),
],
min_visibility=0.1)
else:
aug = get_aug([
A.RGBShift(p=0.1),
A.OneOf([
A.RandomBrightnessContrast(p=0.5),
A.HueSaturationValue(),
A.RandomGamma(p=0.25),
A.RandomBrightness(p=0.25),
A.Blur(blur_limit=2, p=0.25),
],
p=0.01),
A.HorizontalFlip(p=0.5),
A.VerticalFlip(p=0.05),
A.ShiftScaleRotate(shift_limit=0.1,
scale_limit=0.05,
rotate_limit=15,
border_mode=0,
p=0.2,
value=(144.75479165, 137.70713403, 129.666091),
mask_value=0.0),
A.Resize(width=output_size[0],
height=output_size[1],
always_apply=True),
A.Normalize(),
],
min_visibility=0.1)
return aug
def light_post_image_transform():
return A.OneOf([
A.NoOp(),
A.Compose(
[
A.PadIfNeeded(1024 + 10,
1024 + 10,
border_mode=cv2.BORDER_CONSTANT,
value=0,
mask_value=0),
A.RandomSizedCrop((1024 - 5, 1024 + 5), 1024, 1024),
],
p=0.2,
),
A.ShiftScaleRotate(
shift_limit=0.02,
rotate_limit=3,
scale_limit=0.02,
border_mode=cv2.BORDER_CONSTANT,
mask_value=0,
value=0,
p=0.2,
),
])
def get_transforms(image_size):
normMean_160 = [0.59610313, 0.45660403, 0.39085752]
normStd_160 = [0.25930294, 0.23150486, 0.22701606]
normMean_224 = [0.59610313, 0.45660552, 0.3908535]
normStd_224 = [0.25930434, 0.23150496, 0.22701606]
transforms_train = albumentations.Compose([
albumentations.HorizontalFlip(p=0.5),
albumentations.RandomBrightnessContrast(0.2, p=0.2),
albumentations.OneOf([
albumentations.MotionBlur(blur_limit=5),
albumentations.MedianBlur(blur_limit=5),
albumentations.GaussianBlur(blur_limit=5),
albumentations.GaussNoise(var_limit=(5.0, 15.0)),
],
p=0.5),
albumentations.ShiftScaleRotate(shift_limit=0.1,
scale_limit=0.1,
rotate_limit=10,
border_mode=0,
p=0.5),
albumentations.Resize(image_size, image_size),
albumentations.CoarseDropout(max_height=int(image_size * 0.15),
max_width=int(image_size * 0.15),
max_holes=6,
p=0.7),
albumentations.Normalize(std=normStd_160, mean=normMean_160)
])
transforms_test = albumentations.Compose([
albumentations.Resize(image_size, image_size),
albumentations.Normalize(std=normStd_160, mean=normStd_160)
])
return transforms_train, transforms_test
def get_transform(train):
if train:
transform = A.Compose([
A.RandomSizedBBoxSafeCrop(width=525, height=600),
A.HorizontalFlip(p=0.5),
A.OneOf([
A.HueSaturationValue(hue_shift_limit=10,
sat_shift_limit=30,
val_shift_limit=20,
p=1),
A.RandomBrightnessContrast(
brightness_limit=0.2, contrast_limit=0.2, p=1),
],
p=1),
A.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)),
A.Resize(height=512, width=512, p=1.0),
ToTensorV2()
],
bbox_params=A.BboxParams(
format='pascal_voc',
min_area=0,
min_visibility=0,
label_fields=['class_labels']))
return transform
else:
transform = A.Compose([
A.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)),
A.Resize(height=512, width=512, p=1.0),
ToTensorV2()
],
bbox_params=A.BboxParams(
format='pascal_voc',
min_area=0,
min_visibility=0,
label_fields=['class_labels']))
return transform
def get_train_transforms():
return A.Compose([
A.RandomSizedCrop(
min_max_height=(500, 500), height=1024, width=1024, p=0.35),
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),
A.HorizontalFlip(p=0.5),
A.VerticalFlip(p=0.5),
A.Resize(height=512, width=512, p=1),
ToTensorV2(p=1.0),
],
p=1.0,
bbox_params=A.BboxParams(format='pascal_voc',
min_area=0,
min_visibility=0,
label_fields=['labels']))
def __random_transform(self, img):
composition = albu.Compose([
albu.OneOf([
albu.ShiftScaleRotate(rotate_limit=8,
scale_limit=0.16,
shift_limit=0,
border_mode=0,
value=0,
p=0.5),
albu.CoarseDropout(max_holes=16,
max_height=DIM // 10,
max_width=DIM // 10,
fill_value=0,
p=0.5)
],
p=0.5),
albu.ShiftScaleRotate(rotate_limit=0,
scale_limit=0.,
shift_limit=0.12,
border_mode=0,
value=0,
p=0.5)
])
return composition(image=img)['image']
def get_augmentation_transforms(add_non_spatial=True):
transforms = [
A.VerticalFlip(p=0.5),
A.HorizontalFlip(p=0.5),
A.RandomRotate90(p=0.5),
A.OneOf([
A.ElasticTransform(
alpha=120, sigma=120 * 0.05, alpha_affine=120 * 0.03, p=0.5),
A.GridDistortion(p=0.5),
A.OpticalDistortion(distort_limit=2, shift_limit=0.5, p=1)
],
p=0.8),
]
if add_non_spatial:
transforms.extend([
A.CLAHE(p=0.8),
A.RandomBrightnessContrast(p=0.8),
A.RandomGamma(p=0.8)
])
aug_transform = A.Compose(transforms)
return aug_transform
def resize_transforms(image_size=224):
BORDER_CONSTANT = 0
pre_size = int(image_size * 1.5)
random_crop = albu.Compose(
[
albu.SmallestMaxSize(pre_size, p=1),
albu.RandomCrop(image_size, image_size, p=1),
]
)
rescale = albu.Compose([albu.Resize(image_size, image_size, p=1)])
random_crop_big = albu.Compose(
[
albu.LongestMaxSize(pre_size, p=1),
albu.RandomCrop(image_size, image_size, p=1),
]
)
# Converts the image to a square of size image_size x image_size
result = [albu.OneOf([random_crop, rescale, random_crop_big], p=1)]
return result
def __init__(self, img_root_path='', ann_file=None, training_flag=True, shuffle=True):
self.color_augmentor = ColorDistort()
self.training_flag = training_flag
self.lst = self.parse_file(img_root_path, ann_file)
self.shuffle = shuffle
self.train_trans = A.Compose([
A.RandomBrightnessContrast(p=0.75, brightness_limit=0.1, contrast_limit=0.2),
A.CLAHE(clip_limit=4.0, p=0.7),
A.HueSaturationValue(hue_shift_limit=10, sat_shift_limit=20,
val_shift_limit=10, p=0.5),
A.OneOf([
A.MotionBlur(blur_limit=5),
A.MedianBlur(blur_limit=5),
A.GaussianBlur(blur_limit=5),
A.GaussNoise(var_limit=(5.0, 30.0)),
], p=0.7)
])
