def get_train_transform(mu, sigma):
"""
Args:
tensor (Tensor): Tensor image of size (C, H, W) to be normalized.
Returns:
Tensor: Normalized image.
"""
train_transform = A.Compose([
A.HorizontalFlip(p=0.4),
A.ShiftScaleRotate(),
A.Normalize(mean=(mu),
std=(sigma)),
A.CoarseDropout(max_holes=1,
max_height=16,
max_width=16,
min_holes=1,
min_height=16,
min_width=16,
fill_value=(mu)),
A.ToGray(),
ToTensorV2(),
])
return(train_transform)
def get_train_transforms():
return A.Compose([
A.HueSaturationValue(hue_shift_limit=0.4,
sat_shift_limit=0.4,
val_shift_limit=0.4,
p=0.5),
A.OneOf([
A.RandomGamma(p=0.5),
A.RandomBrightnessContrast(
brightness_limit=0.4, contrast_limit=0.85, p=0.5)
],
p=0.5),
A.Blur(p=0.5),
A.ToGray(p=0.1),
A.RandomRotate90(p=0.5),
A.Resize(height=1024, width=1024, p=1),
A.Cutout(
num_holes=10, 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 get_train_transforms():
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.1, sat_shift_limit= 0.3,
val_shift_limit=0.3, p=0.9),
A.RandomBrightnessContrast(brightness_limit=0.4,
contrast_limit=0.3, 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 get_train_transforms():
return A.Compose(
[
A.RandomSizedCrop(
min_max_height=(650, 1024), height=1024, width=1024, p=0.5),
A.OneOf([
A.HueSaturationValue(hue_shift_limit=0.68,
sat_shift_limit=0.68,
val_shift_limit=0.1,
p=0.9),
A.RandomGamma(p=0.9),
A.RandomBrightnessContrast(
brightness_limit=0.1, contrast_limit=0.1, p=0.9),
],
p=0.9),
# A.CLAHE(p=1.0),
A.ToGray(p=0.01),
A.HorizontalFlip(p=0.5),
A.VerticalFlip(p=0.5),
A.RandomRotate90(p=0.5),
A.Resize(height=512, width=512, p=1),
A.CoarseDropout(max_holes=20,
max_height=32,
max_width=32,
fill_value=0,
p=0.25),
ToTensorV2(p=1.0),
],
p=1.0,
bbox_params=A.BboxParams(format='pascal_voc',
min_area=0,
min_visibility=0,
label_fields=['labels']))
def apply_transforms(mean, std):
train_transforms = A.Compose([
A.HorizontalFlip(p=0.2),
A.ShiftScaleRotate(shift_limit=0.1,
scale_limit=0.1,
rotate_limit=10,
p=0.2),
A.CoarseDropout(
max_holes=1,
max_height=16,
max_width=16,
min_holes=1,
min_height=16,
min_width=16,
fill_value=tuple((x * 255.0 for x in mean)),
p=0.2,
),
A.ToGray(p=0.15),
A.Normalize(mean=mean, std=std, always_apply=True),
ToTensorV2(),
])
test_transforms = A.Compose([
A.Normalize(mean=mean, std=std, always_apply=True),
ToTensorV2(),
])
return lambda img: train_transforms(image=np.array(img))[
"image"], lambda img: test_transforms(image=np.array(img))["image"]
# if __name__ == "__main__":
# pass
def __init__(self, images_path, labels_path, input_size, transform=None, multiscale=False, normalized_bboxes=True,
balance_classes=False, class_names=None, single_channel=True):
self.img_files = []
self.label_files = []
self.input_size = input_size
self.transform = transform
self.normalized_bboxes = normalized_bboxes
self.multiscale = multiscale
self.min_input_size = self.input_size - 3 * 32 # Network stride
self.max_input_size = self.input_size + 3 * 32
self.balance_classes = balance_classes
self.class_counter = np.zeros(len(class_names))
self.ignored, self.total = 0, 0
self.single_channel = single_channel
self.batch_count = 0
# Data format
self.data_format = A.Compose([
A.ToGray(p=1.0),
A.LongestMaxSize(max_size=self.input_size, interpolation=cv2.INTER_AREA),
A.PadIfNeeded(min_height=self.input_size, min_width=self.input_size, border_mode=cv2.BORDER_CONSTANT,
value=(128, 128, 128)),
], p=1)
# Get files
self.img_files = []
self.label_files = []
for filename in os.listdir(images_path):
img_path = os.path.join(images_path, filename)
label_path = os.path.join(labels_path, filename.replace(".jpg", ".txt").replace(".png", ".txt"))
# Check if label file exists
if os.path.exists(label_path):
self.img_files.append(img_path)
self.label_files.append(label_path)
def get_preprocess(input_size,
use_crop=False,
use_center_crop=False,
center_crop_ratio=0.9,
use_gray=False):
if isinstance(input_size, int):
input_size = (input_size, input_size)
if use_crop:
resize = [
al.Resize(int(input_size[0] * 1.1), int(input_size[1] * 1.1)),
al.RandomSizedCrop(min_max_height=(int(input_size[0] * 0.7),
int(input_size[0] * 1.1)),
height=input_size[0],
width=input_size[1])
]
elif use_center_crop:
resize = [
al.Resize(int(input_size[0] * (2. - center_crop_ratio)),
int(input_size[1] * (2. - center_crop_ratio))),
al.CenterCrop(input_size[0], input_size[1])
]
else:
resize = [al.Resize(input_size[0], input_size[1])]
return al.Compose(
resize +
[al.ToGray(p=1. if use_gray else 0.),
al.Normalize(),
ToTensorV2()])
def get_training_augmentation(type='basic'):
if type == 'basic':
train_transform = [
album.RandomCrop(height=1024, width=1024, always_apply=True),
album.HorizontalFlip(p=0.5),
album.VerticalFlip(p=0.5),
]
elif type == 'advance':
train_transform = [
album.RandomCrop(height=1024, width=1024, always_apply=True),
album.HorizontalFlip(p=0.5),
album.VerticalFlip(p=0.5),
album.RandomBrightnessContrast(brightness_limit=0.25, contrast_limit=0.25),
album.HueSaturationValue(p=0.5),
album.Blur(blur_limit=7, p=0.5),
album.ToGray(p=0.5),
album.IAASharpen(p=0.5),
]
elif type == 'intermediate':
train_transform = [
album.RandomCrop(height=1024, width=1024, always_apply=True),
album.HorizontalFlip(p=0.5),
album.VerticalFlip(p=0.5),
album.Rotate(limit=90, p=0.5),
album.RandomBrightnessContrast(brightness_limit=0.25, contrast_limit=0.25),
album.HueSaturationValue(p=0.5),
]
else:
raise ValueError(f'type {type} is not supported')
return album.Compose(train_transform)
def aug_train():
''' augmentation for training a FR-system '''
aug = alt.Compose([
alt.Resize(height=112, width=112),
alt.HorizontalFlip(p=0.5),
alt.HueSaturationValue(hue_shift_limit=10,
sat_shift_limit=20,
val_shift_limit=10,
p=0.2),
alt.RGBShift(r_shift_limit=20,
g_shift_limit=20,
b_shift_limit=20,
p=0.2),
alt.RandomBrightnessContrast(brightness_limit=0.2,
contrast_limit=0.2,
p=0.3),
alt.ToGray(p=0.01),
alt.MotionBlur(blur_limit=7, p=0.2), # default=11
alt.GaussianBlur(blur_limit=7, p=0.2), # default=11
alt.GaussNoise(var_limit=(5.0, 20.0), mean=0,
p=0.1), # defalt var_limit=(10.0, 30.0)
alt.ISONoise(p=0.2),
alt.Normalize(),
ToTensor()
])
return aug
def get_train_transforms(cfg):
image_size = cfg["image_size"]
return A.Compose([
A.RandomSizedCrop(min_max_height=(image_size - 200, image_size - 200),
height=image_size,
width=image_size,
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),
A.GaussNoise(
var_limit=(0.01, .005), mean=0, always_apply=False, p=0.6),
],
p=0.9),
A.ToGray(p=0.01),
A.HorizontalFlip(p=0.5),
A.VerticalFlip(p=0.5),
A.Resize(height=image_size, width=image_size, p=1),
A.CoarseDropout(
max_holes=8, max_height=32, max_width=128, fill_value=0, p=0.3),
A.CoarseDropout(
max_holes=8, max_height=128, max_width=32, fill_value=0, p=0.3),
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, root_dir, is_train):
super(FaceDataset, self).__init__()
#self.local_rank = local_rank
self.is_train = is_train
self.input_size = 256
self.num_kps = 68
transform_list = []
if is_train:
transform_list += \
[
A.ColorJitter(brightness=0.8, contrast=0.5, p=0.5),
A.ToGray(p=0.1),
A.ISONoise(p=0.1),
A.MedianBlur(blur_limit=(1,7), p=0.1),
A.GaussianBlur(blur_limit=(1,7), p=0.1),
A.MotionBlur(blur_limit=(5,12), p=0.1),
A.ImageCompression(quality_lower=50, quality_upper=90, p=0.05),
A.ShiftScaleRotate(shift_limit=0.1, scale_limit=0.2, rotate_limit=40, interpolation=cv2.INTER_LINEAR,
border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0, p=0.8),
A.HorizontalFlip(p=0.5),
RectangleBorderAugmentation(limit=0.33, fill_value=0, p=0.2),
]
transform_list += \
[
A.geometric.resize.Resize(self.input_size, self.input_size, interpolation=cv2.INTER_LINEAR, always_apply=True),
A.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]),
ToTensorV2(),
]
self.transform = A.ReplayCompose(transform_list,
keypoint_params=A.KeypointParams(
format='xy',
remove_invisible=False))
self.root_dir = root_dir
with open(osp.join(root_dir, 'annot.pkl'), 'rb') as f:
annot = pickle.load(f)
self.X, self.Y = annot
train_size = int(len(self.X) * 0.99)
if is_train:
self.X = self.X[:train_size]
self.Y = self.Y[:train_size]
else:
self.X = self.X[train_size:]
self.Y = self.Y[train_size:]
#if local_rank==0:
# logging.info('data_transform_list:%s'%transform_list)
flip_parts = ([1, 17], [2, 16], [3, 15], [4, 14], [5, 13], [6, 12],
[7, 11], [8, 10], [18, 27], [19, 26], [20, 25], [21, 24],
[22, 23], [32, 36], [33, 35], [37, 46], [38, 45],
[39, 44], [40, 43], [41, 48], [42, 47], [49,
55], [50, 54],
[51, 53], [62, 64], [61, 65], [68, 66], [59,
57], [60, 56])
self.flip_order = np.arange(self.num_kps)
for pair in flip_parts:
self.flip_order[pair[1] - 1] = pair[0] - 1
self.flip_order[pair[0] - 1] = pair[1] - 1
logging.info('len:%d' % len(self.X))
print('!!!len:%d' % len(self.X))
def get_transform(stage, gb_prob=1.0, solarize_prob=0.):
t_list = []
normalize = A.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
if stage in ('train', 'val'):
t_list = [
A.RandomResizedCrop(224, 224),
A.HorizontalFlip(p=0.5),
A.RandomBrightnessContrast(brightness_limit=0.4, contrast_limit=0.4, p=0.8),
A.HueSaturationValue(hue_shift_limit=int(0.1 * 255),
sat_shift_limit=int(0.2 * 255),
val_shift_limit=0, p=0.8),
A.ToGray(p=0.2),
A.GaussianBlur(blur_limit=[23, 23], sigma_limit=[0.1, 0.2], p=gb_prob),
A.Solarize(p=solarize_prob),
normalize,
ToTensorV2()
]
elif stage == 'ft':
t_list = [
A.RandomResizedCrop(224, 224),
A.HorizontalFlip(p=0.5),
normalize,
ToTensorV2()
]
elif stage == 'test':
t_list = [
A.Resize(256, 256),
A.CenterCrop(224, 224),
normalize,
ToTensorV2()
]
transform = A.Compose(t_list)
return transform
def get_train_transform():
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=our_image_size, width=our_image_size, p=1),
A.Cutout(num_holes=8,
max_h_size=our_image_size // 8,
max_w_size=our_image_size // 8,
fill_value=0,
p=0.5)
],
bbox_params={
'format': 'pascal_voc',
'label_fields': ['labels']
})
def __init__(self):
self.transform = None
try:
import albumentations as A
check_version(A.__version__, '1.0.3',
hard=True) # version requirement
self.transform = A.Compose([
A.Blur(p=0.01),
A.MedianBlur(p=0.01),
A.ToGray(p=0.01),
A.CLAHE(p=0.01),
A.RandomBrightnessContrast(p=0.0),
A.RandomGamma(p=0.0),
A.ImageCompression(quality_lower=75, p=0.0)
],
bbox_params=A.BboxParams(
format='yolo',
label_fields=['class_labels']))
LOGGER.info(
colorstr('albumentations: ') +
', '.join(f'{x}' for x in self.transform.transforms if x.p))
except ImportError: # package not installed, skip
pass
except Exception as e:
LOGGER.info(colorstr('albumentations: ') + f'{e}')
def __init__(self,
scale_range: float = (0.35, 0.65),
input_size: int = (416, 416),
augmentation: bool = False) -> None:
if augmentation:
self.crop_func = RandomCropAndResize(scale_range, input_size)
self.aug_func = alb.Compose([
alb.OneOf([
alb.RGBShift(),
alb.ToGray(),
alb.NoOp(),
]),
alb.RandomBrightnessContrast(),
alb.OneOf([
alb.GaussNoise(),
alb.IAAAdditiveGaussianNoise(),
alb.CoarseDropout(fill_value=100),
])
])
else:
scale = (scale_range[0] + scale_range[1]) / 2.
self.crop_func = CenterCropAndResize(scale, input_size)
self.aug_func = None
self.heatmap_stride = 4
self.heatmap_size = (input_size[0] // self.heatmap_stride,
input_size[1] // self.heatmap_stride)
def get_train_transforms():
return A.Compose(
[
# A.RandomSizedCrop(min_max_height=(380, 676), height=1024, width=1024, p=0.5),
A.RandomSizedBBoxSafeCrop(512, 512, erosion_rate=0.0, interpolation=1, 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=4, max_h_size=64, max_w_size=64, fill_value=0, p=0.5),
A.Normalize(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 get_train_transforms(cfg):
return A.Compose(
[
A.RandomSizedCrop(min_max_height=cfg.INPUT.RSC_MIN_MAX_HEIGHT,
height=cfg.INPUT.RSC_HEIGHT,
width=cfg.INPUT.RSC_WIDTH,
p=cfg.INPUT.RSC_PROB),
A.OneOf([
A.HueSaturationValue(hue_shift_limit=cfg.INPUT.HSV_H,
sat_shift_limit=cfg.INPUT.HSV_S,
val_shift_limit=cfg.INPUT.HSV_V,
p=cfg.INPUT.HSV_PROB),
A.RandomBrightnessContrast(brightness_limit=cfg.INPUT.BC_B,
contrast_limit=cfg.INPUT.BC_C,
p=cfg.INPUT.BC_PROB),
],
p=cfg.INPUT.COLOR_PROB),
A.ToGray(p=cfg.INPUT.TOFGRAY_PROB),
A.HorizontalFlip(p=cfg.INPUT.HFLIP_PROB),
A.VerticalFlip(p=cfg.INPUT.VFLIP_PROB),
# A.Resize(height=512, width=512, p=1),
A.Cutout(num_holes=cfg.INPUT.COTOUT_NUM_HOLES,
max_h_size=cfg.INPUT.COTOUT_MAX_H_SIZE,
max_w_size=cfg.INPUT.COTOUT_MAX_W_SIZE,
fill_value=cfg.INPUT.COTOUT_FILL_VALUE,
p=cfg.INPUT.COTOUT_PROB),
ToTensorV2(p=1.0),
],
p=1.0,
bbox_params=A.BboxParams(format='pascal_voc',
min_area=0,
min_visibility=0,
label_fields=['labels']))
def get_train_transforms():
return A.Compose(
[
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="coco", min_area=0, min_visibility=0, label_fields=["labels"]
),
)
def get_train_transforms():
return A.Compose([
A.RandomSizedCrop(
min_max_height=(800, 1024), 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.RandomRotate90(p=0.5),
A.Transpose(p=0.5),
A.JpegCompression(quality_lower=85, quality_upper=95, p=0.2),
A.OneOf(
[A.Blur(blur_limit=3, p=1.0),
A.MedianBlur(blur_limit=3, p=1.0)],
p=0.1),
A.Resize(height=1024, width=1024, 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 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))
class Apollo(object):
data_format = 'VOC'
voc_root = 'datasets/apollo'
train_split = 'train.txt'
val_split = 'val.txt'
class_names = [
'bicycle', 'bicycle_group', 'bus', 'car', 'car_groups', 'motorbicycle',
'motorbicycle_group', 'person', 'person_group', 'rider', 'rider_group',
'tricycle', 'truck'
]
class_names = [
'bus', 'car', 'motorbicycle_group', 'person', 'tricycle', 'truck'
]
img_format = 'jpg'
width = 512
height = 416
train_transform = A.Compose(
[
A.RandomSizedCrop(min_max_height=(640, 640),
height=800,
width=1000,
w2h_ratio=1.25,
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=height, width=width, p=1),
# A.Cutout(num_holes=5, 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']),
)
val_transform = A.Compose([
A.Resize(height=height, width=width, p=1.0),
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_albu_augs(img_size: int, crop_size: Optional[int], mode: str):
assert mode in ["train", "val", "test"]
if crop_size is None:
crop_size = img_size
if mode == "train":
return A.Compose([
A.RandomResizedCrop(
crop_size,
crop_size,
scale=(0.9, 1),
p=1,
),
A.HorizontalFlip(p=0.5),
A.ShiftScaleRotate(p=0.7),
A.HueSaturationValue(hue_shift_limit=10,
sat_shift_limit=10,
val_shift_limit=10,
p=0.7),
A.RandomBrightnessContrast(brightness_limit=(-0.2, 0.2),
contrast_limit=(-0.2, 0.2),
p=0.7),
A.CLAHE(clip_limit=(1, 4), p=0.5),
A.OneOf(
[
A.OpticalDistortion(distort_limit=1.0),
A.GridDistortion(num_steps=5, distort_limit=1.0),
A.ElasticTransform(alpha=3),
],
p=0.4,
),
A.OneOf(
[
A.GaussNoise(var_limit=[10, 50]),
A.GaussianBlur(),
A.MotionBlur(),
A.MedianBlur(),
],
p=0.4,
),
A.ToGray(p=0.5),
A.ToSepia(p=0.5),
A.Cutout(
max_h_size=int(crop_size * 0.075),
max_w_size=int(crop_size * 0.075),
num_holes=10,
p=0.5,
),
A.Normalize(mean=IMAGENET_DEFAULT_MEAN, std=IMAGENET_DEFAULT_STD),
ToTensorV2(),
], )
if mode in ["val", "test"]:
return A.Compose([
A.Resize(img_size, img_size),
A.CenterCrop(
crop_size, crop_size, p=1 if crop_size != img_size else 0),
A.Normalize(mean=IMAGENET_DEFAULT_MEAN, std=IMAGENET_DEFAULT_STD),
ToTensorV2(),
], )
def train_aug(height=224, width=224):
return alb.Compose(
[
alb.RandomResizedCrop(height=height, width=width, always_apply=True, interpolation=cv2.INTER_LANCZOS4),
alb.CLAHE(p=0.1),
alb.ToGray(p=0.2),
alb.RandomBrightnessContrast(p=0.6),
]
)
def get_hard_augmentations(image_size):
return A.Compose([
A.OneOf([
A.ShiftScaleRotate(shift_limit=0.05, scale_limit=0.1,
rotate_limit=45,
border_mode=cv2.BORDER_CONSTANT, value=0),
A.ElasticTransform(alpha_affine=0,
alpha=35,
sigma=5,
border_mode=cv2.BORDER_CONSTANT,
value=0),
A.OpticalDistortion(distort_limit=0.11, shift_limit=0.15,
border_mode=cv2.BORDER_CONSTANT,
value=0),
A.GridDistortion(border_mode=cv2.BORDER_CONSTANT,
value=0),
A.NoOp()
]),
A.OneOf([
A.RandomSizedCrop(min_max_height=(int(image_size[0] * 0.75), image_size[0]),
height=image_size[0],
width=image_size[1], p=0.3),
A.NoOp()
]),
A.ISONoise(p=0.5),
# Brightness/contrast augmentations
A.OneOf([
A.RandomBrightnessContrast(brightness_limit=0.5,
contrast_limit=0.4),
IndependentRandomBrightnessContrast(brightness_limit=0.25,
contrast_limit=0.24),
A.RandomGamma(gamma_limit=(50, 150)),
A.NoOp()
]),
A.OneOf([
A.RGBShift(r_shift_limit=40, b_shift_limit=30, g_shift_limit=30),
A.HueSaturationValue(hue_shift_limit=10,
sat_shift_limit=10),
A.ToGray(p=0.2),
A.NoOp()
]),
A.ChannelDropout(),
A.RandomGridShuffle(p=0.3),
# D4
A.Compose([
A.RandomRotate90(),
A.Transpose()
])
])
def pet_augmentation():
transform_list = [
albu.Resize(100, 100),
albu.HorizontalFlip(p=0.5),
albu.ToSepia(p=0.2),
albu.ToGray(p=0.3),
albu.RandomRotate90(p=0.5),
albu.VerticalFlip(p=0.2)
]
return albu.Compose(transform_list)
class Rtts(object):
data_format = 'VOC'
voc_root = 'datasets/RTTS'
train_split = 'train.txt'
val_split = 'all.txt'
class_names = [
"aeroplane", "bicycle", "bird", "boat", "bottle", "bus", "car", "cat",
"chair", "cow", "diningtable", "dog", "horse", "motorbike", "person",
"pottedplant", "sheep", "sofa", "train", "tvmonitor"
]
img_format = 'png'
width = 480
height = 480
train_transform = A.Compose(
[
A.Resize(height=1024, width=1024, p=1), # 896
A.RandomSizedCrop(
min_max_height=(600, 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=height, width=width, p=1),
# A.Cutout(num_holes=5, 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']),
)
val_transform = A.Compose(
[
A.Resize(height=height, width=width, p=1.0),
# A.LongestMaxSize(416, p=1.0),
# A.PadIfNeeded(min_height=416, min_width=416, border_mode=0, value=(0.5,0.5,0.5), p=1.0),
ToTensorV2(p=1.0),
],
p=1.0,
bbox_params=A.BboxParams(format='pascal_voc',
min_area=0,
min_visibility=0,
label_fields=['labels']))
def get_train_transforms():
return A.Compose([
# A.Resize(height=384, width=384, p=1),
# A.RandomSizedCrop(min_max_height=(350, 350), height=384, width=384, p=0.5),
# A.RandomRotate90(p=0.5),
# A.HorizontalFlip(p=0.5),
# A.VerticalFlip(p=0.5),
A.ToGray()
#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)
def base_line_transform():
result = [
albu.HorizontalFlip(),
albu.RandomGamma(),
albu.RandomBrightnessContrast(),
albu.OneOf([
albu.ToGray(),
albu.CLAHE()]),
albu.RandomScale(),
]
return result
def pet_augmentation():
transform_list = [
albu.Resize(100, 100),
albu.HorizontalFlip(p=0.5),
albu.ToSepia(p=0.2),
albu.ToGray(p=0.3),
albu.RandomRotate90(p=0.5),
albu.VerticalFlip(p=0.2),
albu.GaussianBlur(blur_limit=10,p=0.5,always_apply=False)
]
return albu.Compose(transform_list)
def get_training_augmentation(grayscale=False,
height=320,
width=640,
crop_mode=0):
mea = mean
st = std
if grayscale:
mea = (mean[0] + mean[1] + mean[2]) / 3
st = (std[0] + std[1] + std[2]) / 3
if crop_mode == 0:
train_transform = [
albu.PadIfNeeded(height * 3 // 2, width * 3 // 2),
albu.RandomCrop(height * 3 // 2, width * 3 // 2),
albu.HorizontalFlip(p=0.5),
albu.VerticalFlip(p=0.5),
albu.CoarseDropout(p=0.1),
albu.ShiftScaleRotate(scale_limit=0.4,
rotate_limit=45,
shift_limit=0.1,
p=0.5,
border_mode=0),
albu.GridDistortion(p=0.3),
albu.OpticalDistortion(p=0.3, distort_limit=2, shift_limit=0.5),
albu.RGBShift(p=0.3),
albu.Blur(p=0.3),
albu.MotionBlur(p=0.3),
albu.PadIfNeeded(height, width),
albu.RandomCrop(height, width)
]
else:
train_transform = [
albu.HorizontalFlip(p=0.5),
albu.VerticalFlip(p=0.5),
albu.ShiftScaleRotate(scale_limit=0.4,
rotate_limit=45,
shift_limit=0.1,
p=0.5,
border_mode=0),
albu.GridDistortion(p=0.5),
albu.OpticalDistortion(p=0.5, distort_limit=2, shift_limit=0.5),
albu.RGBShift(p=0.5),
albu.ToGray(p=0.5),
albu.Resize(height, width)
]
train_transform.extend([
#Equalize(p=1.0, by_channels=False),
albu.Normalize(mean=mea, std=st, p=1),
ToTensor(),
])
return albu.Compose(train_transform)
