def get_training_augmentation():
train_transform = [
albu.HorizontalFlip(p=0.5),
albu.VerticalFlip(p=0.2),
albu.ShiftScaleRotate(scale_limit=0.5,
rotate_limit=50,
shift_limit=0.1,
p=1,
border_mode=0),
#320 384 448 512 640
# albu.GridDistortion(num_steps=2, distort_limit=0.2, interpolation=1, border_mode=0, value=None, always_apply=False, p=0.5),
albu.PadIfNeeded(min_height=padheight,
min_width=padwidth,
always_apply=True,
border_mode=0),
albu.Resize(height=padheight, width=padwidth),
albu.RandomCrop(height=inputheight,
width=inputwidth,
always_apply=True), #the last size
albu.ChannelShuffle(p=0.1),
albu.IAAAdditiveGaussianNoise(p=0.2),
albu.IAAPerspective(p=0.5),
albu.OneOf(
[
albu.CLAHE(p=1),
albu.RandomBrightness(p=1),
albu.RandomGamma(p=1),
],
p=0.9,
),
albu.OneOf(
[
albu.IAASharpen(p=1),
albu.Blur(blur_limit=3, p=1),
albu.MotionBlur(blur_limit=3, p=1),
],
p=0.9,
),
albu.OneOf(
[
albu.RandomContrast(p=1),
albu.HueSaturationValue(p=1),
],
p=0.9,
),
]
return albu.Compose(train_transform)
def build_transforms(cfg, is_train, debug=False):
to_compose = [albu.Resize(*cfg.inputs.size)]
if is_train and cfg.augmentation.enable:
to_compose.extend([
albu.HorizontalFlip(p=0.5),
albu.VerticalFlip(p=0.5),
albu.RandomRotate90(p=0.5),
albu.Transpose(p=0.5),
albu.ShiftScaleRotate(scale_limit=0.2,
rotate_limit=0,
shift_limit=0.2,
p=0.2,
border_mode=0),
albu.IAAAdditiveGaussianNoise(p=0.2),
albu.IAAPerspective(p=0.5),
albu.OneOf(
[
albu.CLAHE(p=1),
albu.RandomBrightness(p=1),
albu.RandomGamma(p=1),
],
p=0.9,
),
albu.OneOf(
[
albu.IAASharpen(p=1),
albu.Blur(blur_limit=3, p=1),
albu.MotionBlur(blur_limit=3, p=1),
],
p=0.9,
),
albu.OneOf(
[
albu.RandomContrast(p=1),
albu.HueSaturationValue(p=1),
],
p=0.9,
),
albu.Compose(
[albu.VerticalFlip(p=0.5),
albu.RandomRotate90(p=0.5)])
])
if debug:
return albu.Compose(to_compose)
to_compose.append(albu.Normalize(**cfg.inputs.normalize))
to_compose.append(ToTensorV2(transpose_mask=True))
return albu.Compose(to_compose)
def create_train_transform(flip, noise, cutout, resize, size=112, bright=True):
translist = []
if resize:
if size == 112:
translist += [albumentations.Resize(128, 128)]
elif size == 224:
translist += [albumentations.Resize(256, 256)]
translist += [albumentations.RandomCrop(size, size, always_apply=True)]
if flip:
translist += [
albumentations.OneOf([albumentations.HorizontalFlip()], p=0.5)
]
if noise:
translist += [
albumentations.OneOf([
albumentations.MotionBlur(blur_limit=5),
albumentations.MedianBlur(blur_limit=5),
albumentations.OpticalDistortion(),
albumentations.GaussNoise(var_limit=(5.0, 30.0))
],
p=0.65)
]
if bright:
translist += [
albumentations.RandomBrightness(limit=0.2, always_apply=False)
]
if cutout:
translist += [
albumentations.Cutout(max_h_size=int(size * 0.2),
max_w_size=int(size * 0.2),
num_holes=1,
p=0.5)
]
#translist+=[albumentations.Normalize(mean=(0.2481, 0.2292, 0.2131), std = (0.2167,0.2071,0.2014))]
#trainlist+=[albumentations.Normalize(mean=(0.2539, 0.2348, 0.2189), std = (0.2195,0.2110,0.2061))]
#translist+=[albumentations.Normalize(mean=(0.2580, 0.2360, 0.2215), std = (0.2235, 0.2132, 0.2100))]
translist += [
albumentations.Normalize(mean=(0.2527, 0.2343, 0.2177),
std=(0.2171, 0.2082, 0.2026))
]
transform = albumentations.Compose(translist)
return transform
def bboxes_augmentation(cfg):
'''
'''
transforms = []
if cfg['smallest'] > 0:
transforms += [
albumentations.SmallestMaxSize(max_size=cfg['smallest'], p=1.0)
]
if cfg.get('random_crop', 0):
# transforms += [OneOf([albumentations.RandomCrop(height=1024, width=1024, p=0.8),
# albumentations.RandomCrop(height=720, width=720, p=0.8),], p=1.),]
if cfg.get('safe_crop', 0):
transforms += [
albumentations.RandomSizedBBoxSafeCrop(height=cfg['height'],
width=cfg['width'],
p=1.)
]
else:
transforms += [
albumentations.RandomSizedCrop(cfg['min_max_height'],
height=cfg['height'],
width=cfg['width'],
p=1.0)
]
if cfg.get('flip', 0):
transforms += [albumentations.HorizontalFlip(p=0.5)]
transforms += [
albumentations.RandomBrightness(limit=0.2, p=0.3),
albumentations.RandomContrast(limit=0.2, p=0.3),
albumentations.Blur(blur_limit=5, p=0.2),
albumentations.GaussNoise(var_limit=(5, 20), p=0.2),
albumentations.ChannelShuffle(p=0.2),
]
bbox_params = {
'format': 'pascal_voc',
'min_visibility': cfg['min_visibility'],
'label_fields': ['labels'],
'min_area': cfg['min_area']
} if cfg['bbox'] else {}
return Compose(transforms, bbox_params=bbox_params, p=1.)
def aug_train(p=1):
return aug.Compose([
aug.HorizontalFlip(p=0.5),
aug.OneOf([
aug.Compose([
aug.ShiftScaleRotate(rotate_limit=0, p=1),
aug.RandomSizedCrop((88, 128), 128, 128)
]),
aug.GridDistortion(num_steps=10, distort_limit=np.random.uniform(0, 0.1), p=1),
aug.ShiftScaleRotate(scale_limit=0, rotate_limit=10, p=1)
], p=0.5),
aug.OneOf([
aug.RandomBrightness(limit=0.08, p=1),
aug.RandomContrast(limit=0.08, p=1),
aug.RandomGamma(gamma_limit=(92, 108), p=1)
], p=0.5)
], p=p)
def ISIC2020_get_transforms(image_size, is_training):
# https://github.com/haqishen/SIIM-ISIC-Melanoma-Classification-1st-Place-Solution/blob/master/dataset.py
if is_training:
return albumentations.Compose([
albumentations.Transpose(p=0.5),
albumentations.VerticalFlip(p=0.5),
albumentations.HorizontalFlip(p=0.5),
albumentations.RandomBrightness(limit=0.2, p=0.75),
albumentations.RandomContrast(limit=0.2, p=0.75),
albumentations.OneOf([
albumentations.MotionBlur(blur_limit=5),
albumentations.MedianBlur(blur_limit=5),
albumentations.GaussianBlur(blur_limit=5),
albumentations.GaussNoise(var_limit=(5.0, 30.0)),
],
p=0.7),
albumentations.OneOf([
albumentations.OpticalDistortion(distort_limit=1.0),
albumentations.GridDistortion(num_steps=5, distort_limit=1.),
albumentations.ElasticTransform(alpha=3),
],
p=0.7),
albumentations.CLAHE(clip_limit=4.0, p=0.7),
albumentations.HueSaturationValue(hue_shift_limit=10,
sat_shift_limit=20,
val_shift_limit=10,
p=0.5),
albumentations.ShiftScaleRotate(shift_limit=0.1,
scale_limit=0.1,
rotate_limit=15,
border_mode=0,
p=0.85),
albumentations.Resize(image_size, image_size),
albumentations.Cutout(max_h_size=int(image_size * 0.375),
max_w_size=int(image_size * 0.375),
num_holes=1,
p=0.7),
albumentations.Normalize()
])
else:
return albumentations.Compose([
albumentations.Resize(image_size, image_size),
albumentations.Normalize()
])
def __init__(self, data, phase_coeff):
self.root = data
self.folder = os.listdir(self.root)
self.folder.sort()
self.aug = A.Compose([
A.ShiftScaleRotate(shift_limit=0.15, scale_limit=0.15, rotate_limit=45, interpolation=1, border_mode=4, always_apply=False, p=0.3),
A.RandomCrop(220, 220, always_apply=False, p=1.0),
A.HorizontalFlip(always_apply=False, p=0.2),
A.VerticalFlip(always_apply=False, p=0.2),
A.ElasticTransform(alpha=1, sigma=50, alpha_affine=50, interpolation=1, border_mode=4, always_apply=False, p=0.5),
A.RandomBrightness(limit=0.2, always_apply=False, p=0.2),
A.RandomContrast(limit=0.2, always_apply=False, p=0.2),
A.MedianBlur(blur_limit=5, always_apply=False, p=0.2),
A.GaussNoise(var_limit=(10, 50), always_apply=False, p=0.2),
A.Resize(256, 256),
])
self.phase_coeff = phase_coeff
def strong(img_size):
return A.Compose([
A.Resize(img_size, img_size),
A.CLAHE(p=1),
A.ShiftScaleRotate(p=1),
A.RandomBrightness(p=1),
A.Blur(blur_limit=11, p=1),
A.GaussNoise(var_limit=(100, 150), p=1),
A.HorizontalFlip(p=1),
A.Cutout(p=1),
A.RandomRotate90(p=1),
A.Normalize(
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225],
),
ToTensorV2()
])
def __init__(self, mode=None, resize=224):
# assert type(resize) == list, f'resize type is not list '
if mode == 'train_tfms_mask':
self.transform = A.Compose([
A.OneOf([
A.Perspective(p=1.0),
A.Rotate(limit=20, p=1.0, border_mode=1),
],
p=0.5),
A.OneOf([
A.RandomBrightness(p=1.0),
A.HueSaturationValue(p=1.0),
A.RandomContrast(p=1.0),
],
p=0.5),
A.Compose([
A.Resize(resize, resize),
A.Normalize(),
])
])
elif mode == 'train_age_gender':
self.transform = A.Compose([
A.Rotate(limit=20, p=0.5, border_mode=1),
A.OneOf(
[
A.RandomGridShuffle(grid=(2, 2),
p=1.0), # not using for gender
# A.RandomGridShuffle(grid=(4, 2), p=1.0),
A.Perspective(p=1.0)
],
p=0.5),
A.GaussNoise(p=0.5),
A.Compose([
A.Resize(resize, resize),
A.Normalize(),
])
])
# elif mode =
elif mode == 'valid_tfms':
self.transform = A.Compose([
A.Resize(resize, resize),
A.Normalize(),
])
def __init__(self, cfg):
self.cfg = cfg
self.data = self.prepare()
self.mean = self.cfg.mean
self.std = self.cfg.std
self.normal_transform = A.Compose([
A.Resize(384, 288, p=1.0),
A.HorizontalFlip(p=0.5),
A.Normalize(p=1.0, mean=self.mean, std=self.std)
])
self.augment_transform = A.Compose([
A.Resize(384, 288, p=1.0),
A.HorizontalFlip(p=0.7),
A.GaussNoise(p=0.5),
A.ShiftScaleRotate(shift_limit=0.1,
scale_limit=0.25,
rotate_limit=20,
p=0.6,
border_mode=0),
A.OneOf([
A.CLAHE(p=0.5),
A.Compose([
A.RandomBrightness(limit=0.5, p=0.6),
A.RandomContrast(limit=0.4, p=0.6),
A.RandomGamma(p=0.6),
])
],
p=0.65),
A.OneOf([
A.HueSaturationValue(10, 20, 10, p=1.0),
A.RGBShift(p=1.0),
A.Emboss(p=1.0),
],
p=0.5),
A.RandomFog(fog_coef_lower=0.3, fog_coef_upper=0.3, p=0.3),
A.OneOf([
A.Perspective(p=1.0, scale=(0.05, 0.1)),
A.GridDistortion(p=1.0, distort_limit=0.25, border_mode=0),
A.OpticalDistortion(
p=1.0, shift_limit=0.1, distort_limit=0.1, border_mode=0)
],
p=0.65),
A.Normalize(p=1.0, mean=self.mean, std=self.std),
])
def get_training_augmentation(min_area=0., min_visibility=0.):
train_transform = [
albu.OneOf([
albu.MotionBlur(p=.2),
albu.MedianBlur(blur_limit=3, p=0.1),
albu.Blur(blur_limit=3, p=0.1),
],
p=0.2),
albu.OneOf([
albu.CLAHE(clip_limit=2),
albu.IAASharpen(),
albu.IAAEmboss(),
],
p=0.3),
albu.OneOf([
albu.RandomFog(fog_coef_lower=0.1, fog_coef_upper=0.15, p=0.1),
albu.RandomShadow(p=0.1),
albu.RandomBrightness(limit=0.3, p=0.2),
albu.RandomRain(slant_lower=0,
slant_upper=8,
drop_length=0,
blur_value=4,
brightness_coefficient=0.8,
rain_type='heavy',
p=0.1),
albu.RandomSunFlare(p=0.2),
]),
albu.OneOf([
albu.RGBShift(p=0.1),
albu.HueSaturationValue(p=0.3),
]),
albu.OneOf(
[
albu.HorizontalFlip(p=0.5),
#albu.RandomSizedCrop(min_max_height=(720, 1380), height=1380, width=720, interpolation=cv2.INTER_AREA)
],
p=0.2)
]
return albu.Compose(train_transform,
bbox_params={
'format': 'coco',
'min_area': min_area,
'min_visibility': min_visibility,
'label_fields': ['category_id']
})
def get_dataset(dataset, args):
width = height = args.data_shape
train_aug = [
A.HorizontalFlip(),
A.RandomSizedBBoxSafeCrop(width, height),
A.RGBShift(),
A.Blur(blur_limit=11),
A.RandomBrightness(),
A.CLAHE(),
A.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5]),
ToTensor(),
]
val_aug = [
A.Resize(width, height),
A.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5]),
ToTensor(),
]
if dataset.lower() == 'voc':
train_dataset = dlcv.data.VOCDetection(
root='/home/vismarty/.datasets/VOCdevkit',
splits=[(2007, 'trainval'), (2012, 'trainval')],
transform=get_transform(train_aug))
val_dataset = dlcv.data.VOCDetection(
root='/home/vismarty/.datasets/VOCdevkit',
splits=[(2007, 'test')],
transform=get_transform(val_aug))
# val_metric = dlcv.utils.metrics.voc_detection.VOC07MApMetric(iou_thresh=0.5, class_names=val_dataset.classes)
val_metric = None
# elif dataset.lower() == 'coco':
# train_dataset = gdata.COCODetection(root=args.dataset_root + "/coco", splits='instances_train2017')
# val_dataset = gdata.COCODetection(root=args.dataset_root + "/coco", splits='instances_val2017', skip_empty=False)
# val_metric = COCODetectionMetric(
# val_dataset, args.save_prefix + '_eval', cleanup=True,
# data_shape=(args.data_shape, args.data_shape), post_affine=get_post_transform)
# # coco validation is slow, consider increase the validation interval
# if args.val_interval == 1:
# args.val_interval = 10
else:
raise NotImplementedError(
'Dataset: {} not implemented.'.format(dataset))
if args.num_samples < 0:
args.num_samples = len(train_dataset)
return train_dataset, val_dataset, val_metric
def get_transforms(image_size):
transforms_train = albumentations.Compose([
albumentations.Transpose(p=0.5),
albumentations.VerticalFlip(p=0.5),
albumentations.HorizontalFlip(p=0.5),
albumentations.RandomBrightness(limit=0.2, p=0.75),
albumentations.RandomContrast(limit=0.2, p=0.75),
albumentations.OneOf([
albumentations.MotionBlur(blur_limit=5),
albumentations.MedianBlur(blur_limit=5),
albumentations.GaussianBlur(blur_limit=5),
albumentations.GaussNoise(var_limit=(5.0, 30.0)),
],
p=0.7),
albumentations.OneOf([
albumentations.OpticalDistortion(distort_limit=1.0),
albumentations.GridDistortion(num_steps=5, distort_limit=1.),
albumentations.ElasticTransform(alpha=3),
],
p=0.7),
albumentations.CLAHE(clip_limit=4.0, p=0.7),
albumentations.HueSaturationValue(hue_shift_limit=10,
sat_shift_limit=20,
val_shift_limit=10,
p=0.5),
albumentations.ShiftScaleRotate(shift_limit=0.1,
scale_limit=0.1,
rotate_limit=15,
border_mode=0,
p=0.85),
albumentations.Resize(image_size, image_size),
albumentations.Cutout(max_h_size=int(image_size * 0.375),
max_w_size=int(image_size * 0.375),
num_holes=1,
p=0.7),
albumentations.Normalize()
])
transforms_val = albumentations.Compose([
albumentations.Resize(image_size, image_size),
albumentations.Normalize()
])
return transforms_train, transforms_val
def make_transforms(phase,
mean=(0.485, 0.456, 0.406),
std=(0.229, 0.224, 0.225)):
list_transforms = []
if phase == "train":
list_transforms.extend([
albu.HorizontalFlip(p=0.5),
albu.Rotate(limit=15),
albu.RandomContrast(limit=0.2),
albu.RandomBrightness(limit=0.2)
])
list_transforms.extend([
albu.Resize(512, 512),
Normalize(mean=mean, std=std, p=1),
ToTensor(),
])
list_trfms = Compose(list_transforms)
return list_trfms
def aug_train(p=1, shift_limit=0.0625, scale_limit=0.1):
aug_list = [
aug.HorizontalFlip(p=0.5),
aug.VerticalFlip(p=0.5),
ShiftScaleRotate(shift_limit=shift_limit,
scale_limit=scale_limit,
rotate_limit=8,
p=0.7),
aug.OneOf([
aug.RandomBrightness(limit=0.1, p=1),
aug.RandomContrast(limit=0.1, p=1),
aug.RandomGamma(gamma_limit=(90, 110), p=1)
],
p=0.5),
aug.CLAHE(clip_limit=2.0, tile_grid_size=(8, 8), p=0.5)
]
return aug.Compose(aug_list, p=p)
def __initialize_image_augmentation(image_shape):
pipeline = augmentator.Compose([
augmentator.VerticalFlip(p=0.5),
augmentator.HorizontalFlip(p=0.5),
augmentator.RandomBrightness(limit=1.2, p=0.5),
augmentator.RandomGamma(gamma_limit=37, p=0.5),
augmentator.ElasticTransform(
alpha=203, sigma=166, alpha_affine=106, p=0.5),
augmentator.JpegCompression(
quality_lower=25, quality_upper=100, p=0.5),
augmentator.RandomContrast(limit=1, p=0.5),
augmentator.Resize(image_shape[0], image_shape[1], p=1)
],
bbox_params={
'format': 'coco',
'label_fields': ["category_id"]
})
return pipeline
def parse_annotation(annotation, train_input_size, annotation_type):
line = annotation.split()
image_path = line[0]
image = np.array(cv2.imread(image_path))
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
exist_boxes = True
augmentation = al.Compose([
# al.VerticalFlip(p=0.5),
# al.HorizontalFlip(p=0.5),
# al.RandomRotate90(p=0.5),
al.OneOf([
al.GaussNoise(0.002, p=0.5),
al.IAAAffine(p=0.5),
], p=0.2),
al.OneOf([
al.Blur(blur_limit=(3, 10), p=0.4),
al.MedianBlur(blur_limit=3, p=0.3),
al.MotionBlur(p=0.3)
],
p=0.3),
al.OneOf([
al.RandomBrightness(p=0.3),
al.RandomContrast(p=0.4),
al.RandomGamma(p=0.3)
],
p=0.5),
al.Cutout(num_holes=20, max_h_size=20, max_w_size=20, p=0.5),
])
bboxes = np.array([
list(map(lambda x: int(float(x)), box.split(','))) for box in line[1:]
])
if annotation_type == 'train':
# image, bboxes = random_horizontal_flip(np.copy(image), np.copy(bboxes))
# image, bboxes = random_crop(np.copy(image), np.copy(bboxes))
# image, bboxes = random_translate(np.copy(image), np.copy(bboxes))
augm = augmentation(image=image)
image = augm['image'].astype(np.float32) / 255.
# image, bboxes = image_preprocess(np.copy(image), [train_input_size, train_input_size], np.copy(bboxes))
return image, bboxes, exist_boxes
def get_train_transform(self):
# fill values for cutout or cropping portion
fill_value = [255. * mean for mean in self.means]
rc_padding = 32
rc_pval = 0.2
randomCrop = [
albumentations.PadIfNeeded(min_height=self.size + rc_padding,
min_width=self.size + rc_padding,
border_mode=cv2.BORDER_REPLICATE,
value=fill_value,
p=1.0),
albumentations.OneOf([
albumentations.RandomCrop(
height=self.size, width=self.size, p=rc_pval),
albumentations.CenterCrop(
height=self.size, width=self.size, p=1 - rc_pval),
],
p=1.0)
]
train_tf = albumentations.Compose([
self.align_face,
albumentations.Resize(self.size, self.size),
albumentations.RandomBrightness(limit=0.3, p=0.7),
albumentations.RandomContrast(limit=0.3, p=0.7),
#albumentations.Rotate(limit=(-10,10), p=0.70),
randomCrop[0],
randomCrop[1],
albumentations.HorizontalFlip(p=0.7),
#albumentations.ElasticTransform(sigma=50, alpha=1, alpha_affine=10,p=0.10),
albumentations.CoarseDropout(max_holes=1,
max_height=64,
max_width=64,
min_height=16,
min_width=16,
fill_value=fill_value,
p=0.70),
albumentations.Normalize(mean=self.means, std=self.stds),
ToTensor()
])
train_tf = AlbumCompose(train_tf)
return train_tf
def __init__(self, split):
self.split = split
self.aug = albumentations.Compose([
albumentations.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
AT.ToTensor()
])
if self.split == 'train':
self.aug = albumentations.Compose([
albumentations.HorizontalFlip(),
albumentations.RandomBrightness(),
#albumentations.ShiftScaleRotate(rotate_limit=15, scale_limit=0.10),
#albumentations.HueSaturationValue(),
albumentations.Cutout(1, 4, 4, 0.5),
#albumentations.GaussNoise(),
#albumentations.ElasticTransform(),
albumentations.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
AT.ToTensor()
])
def __init__(self,
tp,
fp=None,
config=None,
mode='train',
inv_counts=None):
self.tp = tp
self.fp = pd.read_csv("../input/rfcxextras/cornell-train.csv")
self.fp = self.fp[self.fp.ebird_code < 'c'].reset_index(drop=True)
self.fp_root = "../input/birdsong-resampled-train-audio-00/"
self.inv_counts = inv_counts
self.config = config
self.sr = self.config.sr
self.total_duration = self.config.total_duration
self.duration = self.config.duration
self.data_root = self.config.TRAIN_AUDIO_ROOT
self.nmels = self.config.nmels
self.fmin, self.fmax = 84, self.sr // 2
self.mode = mode
self.num_classes = self.config.num_classes
self.resampler = torchaudio.transforms.Resample(orig_freq=48_000,
new_freq=self.sr)
self.mel = torchaudio.transforms.MelSpectrogram(sample_rate=self.sr,
n_mels=self.nmels,
f_min=self.fmin,
f_max=self.fmax,
n_fft=2048)
self.transform = Compose([
OneOf([GaussianNoiseSNR(min_snr=10),
PinkNoiseSNR(min_snr=10)]),
TimeShift(sr=self.sr),
VolumeControl(p=0.5)
])
self.img_transform = A.Compose([
A.OneOf([
A.Cutout(max_h_size=5, max_w_size=20),
A.CoarseDropout(max_holes=4),
A.RandomBrightness(p=0.25),
],
p=0.5)
])
self.num_splits = self.config.total_duration // self.duration
assert self.config.total_duration == self.duration * self.num_splits, "not a multiple"
def get_training_augmentation():
train_transform = [
A.Resize(size[0], size[1], interpolation=1,
always_apply=True), #cv2.INTER_LINEAR
A.HorizontalFlip(p=0.5),
A.ShiftScaleRotate(scale_limit=0.5,
rotate_limit=0,
shift_limit=0.1,
p=1,
border_mode=0),
A.PadIfNeeded(min_height=size[0],
min_width=size[1],
always_apply=True,
border_mode=0),
# A.RandomCrop(height=size[0], width=size[1], always_apply=True),
A.IAAAdditiveGaussianNoise(p=0.2),
A.IAAPerspective(p=0.5),
A.OneOf(
[
A.CLAHE(p=1),
A.RandomBrightness(p=1),
A.RandomGamma(p=1),
],
p=0.9,
),
A.OneOf(
[
A.IAASharpen(p=1),
A.Blur(blur_limit=3, p=1),
A.MotionBlur(blur_limit=3, p=1),
],
p=0.9,
),
A.OneOf(
[
A.RandomContrast(p=1),
A.HueSaturationValue(p=1),
],
p=0.9,
),
A.Lambda(mask=round_clip_0_1)
]
return A.Compose(train_transform)
def get_preprocessing(preprocessing_fn, apply_augmentation=False):
"""Construct preprocessing transform
Args:
preprocessing_fn (callable): data normalization function (can be specific for each pretrained neural network)
apply_augmentation (boolean): apply data augmentation or not
Return:
transform: albumentations.Compose
"""
_transform = [A.Resize(384, 480)]
if apply_augmentation:
_transform += [
A.HorizontalFlip(p=0.5),
A.ShiftScaleRotate(scale_limit=0.5,
rotate_limit=0,
shift_limit=0.1,
p=1,
border_mode=0),
A.IAAAdditiveGaussianNoise(p=0.2),
A.IAAPerspective(p=0.5),
A.OneOf(
[A.CLAHE(p=1),
A.RandomBrightness(p=1),
A.RandomGamma(p=1)],
p=0.9),
A.OneOf([
A.IAASharpen(p=1),
A.Blur(blur_limit=3, p=1),
A.MotionBlur(blur_limit=3, p=1)
],
p=0.9),
A.OneOf([A.RandomContrast(p=1),
A.HueSaturationValue(p=1)], p=0.9)
]
_transform += [
A.Lambda(image=preprocessing_fn),
A.Lambda(image=to_CHW, mask=to_CHW)
]
return A.Compose(_transform)
def __init__(self, N=2, M=5):
'''
Args:
N: Number of augmentation transformations to apply sequentially.
M: Magnitude for all the transformations.
'''
self.N = N
self.M = M
magnitude = M / 10.0
Identity = A.NoOp(p=1.0)
Brightness = A.RandomBrightness(limit=0.5 * magnitude, p=1.0)
Contrast = A.RandomContrast(limit=0.5 * magnitude, p=1.0)
#Solarize = albu.Solarize(threshold= int(256 * magnitude), p=1.0)
#HorizontalFlip = A.HorizontalFlip(p=1.0)
Translate = A.ShiftScaleRotate(shift_limit=0.45 * magnitude,
scale_limit=0,
rotate_limit=0,
interpolation=1,
border_mode=0,
p=1.0)
Scale = A.ShiftScaleRotate(shift_limit=0,
scale_limit=0.5 * magnitude,
rotate_limit=0,
interpolation=1,
border_mode=0,
p=1.0)
#Shear = albu.IAAAffine(shear=100, p=1.0)
#Perspective = albu.IAAPerspective(scale=(0, 0.3), keep_size=True, p=1.0)
Rotate = A.ShiftScaleRotate(shift_limit=0,
scale_limit=0,
rotate_limit=30 * magnitude,
interpolation=1,
border_mode=0,
p=1.0)
self.augment_list = [
Identity, Translate, Scale, Rotate, Brightness, Contrast
]
def train_dataloader(self):
hparams = self.hparams
augs = []
if hparams.aug_flip:
augs.append(albu.HorizontalFlip(p=1.0))
if hparams.aug_brightness:
augs.append(albu.RandomBrightness(limit=0.2, p=1.0))
if hparams.aug_randomcrop:
aug = albu.RandomSizedBBoxSafeCrop(hparams.img_height,
hparams.img_width)
augs.append(aug)
dataset = TransformDataset(
self.train_dataset,
albu.Compose(
[
*augs,
albu.Resize(hparams.img_height // 4,
hparams.img_width // 4),
albu.ToFloat(255),
ToTensorV2(),
],
bbox_params=AIEdgeDataset.bbox_params,
),
)
if self.hparams.gpus > 1:
sampler = data.distributed.DistributedSampler(dataset,
shuffle=True)
else:
sampler = None
return data.DataLoader(
dataset,
batch_size=hparams.batch_size,
collate_fn=CollateFn(self.net.stride, hparams, "train"),
num_workers=hparams.num_workers,
shuffle=(sampler is None),
sampler=sampler,
pin_memory=(hparams.gpus > 0),
drop_last=True,
)
def build_train(self):
return A.Compose([
A.Flip(p=0.55),
A.ShiftScaleRotate(scale_limit=0.5, rotate_limit=0, border_mode=0),
A.Resize(self.height, self.width),
A.RandomBrightness(),
A.RandomContrast(),
A.OneOf(
[
A.CoarseDropout(max_holes=2, max_height=128,
max_width=128),
A.CoarseDropout(max_holes=4, max_height=64, max_width=64),
],
p=0.5,
),
DistortionBase(),
A.Normalize(self.MEANS, self.STDS),
ToTensorV2(),
])
def __init__(self, phase, train_file, image_file_path, image_height, image_width, mean, std, binclass):
self.image_file_path = image_file_path
df = pd.read_csv(train_file)
if binclass == 'A':
class_map = {'A':1,'B':0,'C':0}
elif binclass == 'B':
class_map = {'A':0,'B':1,'C':0}
elif binclass == 'C':
class_map = {'A':0,'B':0,'C':1}
else:
class_map = {'A':0,'B':1,'C':2}
self.img_id = df['image_id'].apply(lambda x: x.split('.')[0]).values # just take id of image_id
self.labels = df['label'].apply(lambda x: x[-1]).map(class_map).values # encoding labels
if phase == 'valid':
# validation set
self.aug = albumentations.Compose([
albumentations.Resize(image_height, image_width),
albumentations.Normalize(mean, std),
# albumentations.ToFloat()
])
elif phase == 'train':
# training set
self.aug = albumentations.Compose([
albumentations.Resize(image_height, image_width),
albumentations.RandomRotate90(p=0.5),
albumentations.Transpose(p=0.5),
albumentations.Flip(p=0.5),
albumentations.OneOf([
albumentations.CLAHE(clip_limit=2), albumentations.IAASharpen(), albumentations.IAAEmboss(),
albumentations.RandomBrightness(), albumentations.RandomContrast(),
albumentations.JpegCompression(), albumentations.Blur(), albumentations.GaussNoise()], p=0.5),
# albumentations.HueSaturationValue(p=0.5),
albumentations.ShiftScaleRotate(shift_limit=0.15, scale_limit=0.15, rotate_limit=45, p=0.5),
albumentations.Normalize(mean, std),
# albumentations.ToFloat()
])
def augmentation(img_size):
return albu.Compose([
#spatial wise
#albu.RandomCrop(img_size[0],img_size[1]),
albu.RandomResizedCrop(img_size[0],img_size[1],
interpolation=cv2.INTER_NEAREST),
albu.Rotate(interpolation=cv2.INTER_NEAREST),
albu.HorizontalFlip(),
albu.ElasticTransform(alpha_affine=10,interpolation=cv2.INTER_NEAREST),
albu.OpticalDistortion(interpolation=cv2.INTER_NEAREST),
#pixel transform
albu.RandomGamma((100,180),p=0.8),
albu.Blur(5),
albu.RandomBrightness(limit=(0.05,0.20)),
albu.RandomContrast(limit=(0,0.20),p=0.5),
albu.MotionBlur( blur_limit =7),
])
def minty_transform(p):
return albu.Compose([
# Shift, scale, rotate
albu.ShiftScaleRotate(rotate_limit=15,
scale_limit=(-0.15, 0.1),
border_mode=cv2.BORDER_CONSTANT,
value=[255, 255, 255],
p=0.25),
# Noise
albu.IAAAdditiveGaussianNoise(p=0.25),
# Contrast, brightness
albu.OneOf([
albu.RandomGamma(p=1),
albu.RandomContrast(p=1),
albu.RandomBrightness(p=1)
], p=0.55),
# Blur
albu.GaussianBlur(p=0.25),
], p=p, additional_targets={'image{}'.format(_) : 'image' for _ in range(1, 101)})
def augmentation(self, images, is_train, info, aug_num):
if is_train:
output_path = f'{self.output_path}/train'
else:
output_path = f'{self.output_path}/valid'
aug_num = int(aug_num * 0.2)
for label in self.label_list:
if not os.path.isdir(f'{output_path}/{label}'):
os.makedirs(f'{output_path}/{label}')
for i in tqdm(range(len(images))):
image = images[i]
image_name = image.split('/')[-1]
label = image.split('/')[-2]
cnt = int(math.ceil(aug_num / info[label]))
total_images = len(os.listdir(f'{output_path}/{label}'))
if total_images <= aug_num:
image = cv2.imread(image)
transform = A.Resize(224, 224)
augmented_image = transform(image=image)['image']
cv2.imwrite(f'{output_path}/{label}/orig_{image_name}',
augmented_image)
for c in range(cnt):
transform = A.Compose([
A.Resize(224, 224, p=1),
A.HorizontalFlip(p=0.4),
A.VerticalFlip(p=0.3),
A.Blur(p=0.1),
A.OneOf([
A.RandomContrast(p=0.5, limit=(-0.5, 0.3)),
A.RandomBrightness(p=0.5, limit=(-0.2, 0.3))
],
p=0.5)
])
augmented_image = transform(image=image)['image']
cv2.imwrite(f'{output_path}/{label}/aug{c}_{image_name}',
augmented_image)
return output_path
def get_tr_augmentation(img_size):
augmentations = [
albu.HorizontalFlip(p=0.5),
albu.ShiftScaleRotate(scale_limit=0.5,
rotate_limit=0,
shift_limit=0.1,
p=1,
border_mode=0),
albu.PadIfNeeded(min_height=img_size[0],
min_width=img_size[1],
always_apply=True,
border_mode=0),
albu.RandomCrop(height=img_size[0],
width=img_size[1],
always_apply=True),
albu.IAAAdditiveGaussianNoise(p=0.2),
albu.OneOf(
[
albu.CLAHE(p=1),
albu.RandomBrightness(p=1),
albu.RandomGamma(p=1),
],
p=0.9,
),
albu.OneOf(
[
albu.IAASharpen(p=1),
albu.Blur(blur_limit=3, p=1),
albu.MotionBlur(blur_limit=3, p=1),
],
p=0.9,
),
albu.OneOf(
[
albu.RandomContrast(p=1),
albu.HueSaturationValue(p=1),
],
p=0.9,
)
]
return augmentations
