def strong_aug(p=.5):
return Compose([
HorizontalFlip(),
OneOf([
IAAAdditiveGaussianNoise(),
GaussNoise(),
], p=0.4),
OneOf([
MotionBlur(p=.2),
MedianBlur(blur_limit=3, p=.1),
Blur(blur_limit=3, p=.1),
],
p=0.3),
OneOf([
OpticalDistortion(p=0.3),
GridDistortion(p=.1),
IAAPiecewiseAffine(p=0.3),
],
p=0.2),
OneOf([
CLAHE(clip_limit=2),
IAASharpen(),
RandomContrast(),
RandomBrightness(),
],
p=0.3),
HueSaturationValue(p=0.3),
ChannelShuffle(),
Cutout(num_holes=20, max_h_size=16, max_w_size=16)
],
p=p)
def strong_aug(p=0.5):
return Compose([
OneOf([
CoarseDropout(p=0.5),
Cutout(p=0.5),
], p=0.3),
OneOf([
IAAAdditiveGaussianNoise(),
GaussNoise(),
], p=0.2),
ShiftScaleRotate(
shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=0.2),
OneOf([
MotionBlur(p=0.2),
MedianBlur(blur_limit=3, p=0.1),
Blur(blur_limit=3, p=0.1),
],
p=0.2),
OneOf([
OpticalDistortion(p=0.3),
GridDistortion(p=0.1),
IAAPiecewiseAffine(p=0.3),
],
p=0.2),
OneOf([
IAASharpen(),
IAAEmboss(),
RandomBrightnessContrast(),
], p=0.2)
],
p=p)
def prepare_data(self):
if self.data_prepared:
return True
transformation_list = [
ShiftScaleRotate(shift_limit=0.1,
scale_limit=0.1,
rotate_limit=0.5),
GridDistortion(),
Cutout()
]
albumentations_transform = Compose(transformation_list)
# Dataset parameters
data_param = {
'mode': self.hparams.output_mode,
'transform': albumentations_transform,
'metadata': self.hparams.metadata,
'one_hot_time': self.hparams.one_hot_time,
'consensus_threshold': self.hparams.consensus_threshold,
'cleaning_strat': self.hparams.cleaning_strat,
'relabeled_name': self.hparams.relabeled_name,
}
# Creating dataset
self.dataset = SONYCUST_TALNet(self.hparams.path_to_SONYCUST,
**data_param)
self.train_dataset, self.val_dataset, self.test_dataset = self.dataset.train_validation_test_split(
)
self.data_prepared = True
def __init__(self):
self.albumentations_transform = Compose({
Cutout(max_h_size=12, max_w_size=12, num_holes=1, p=0.5),
HorizontalFlip(p=0.5),
VerticalFlip(p=0.5),
Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
})
def __init__(self, df, image_idx, mode='train'):
self.imglist = df['image_path'].values
self.labellist = df['label'].values
self.index = image_idx
self.mode = mode
self.train_transformation = Compose([
# RandomRotate90(),
GridDistortion(p=0.6),
HorizontalFlip(p=0.6),
ElasticTransform(alpha=1, sigma=25, alpha_affine=50, p=0.75),
OneOf([
IAAAdditiveGaussianNoise(),
GaussNoise(),
], p=0.5),
Cutout(num_holes=30,
max_h_size=9,
max_w_size=11,
fill_value=128,
p=0.75),
ShiftScaleRotate(shift_limit=0.0625,
scale_limit=0.15,
rotate_limit=15,
p=0.75),
# Normalize(),
# ToTensor(),
])
self.valid_transformation = Compose([
# Normalize(),
# ToTensor(),
])
def strong_aug(self):
color_r = random.randint(0, 256)
color_g = random.randint(0, 256)
color_b = random.randint(0, 256)
num_holes = random.randint(1, 2)
if num_holes == 2:
max_h_size = random.randint(15, 30)
max_w_size = random.randint(15, 30)
else:
max_h_size = random.randint(30, 60)
max_w_size = random.randint(30, 60)
return Compose([
OneOf([
OneOf([
MultiplicativeNoise(multiplier=[0.5, 1.5], elementwise=True, per_channel=True, p=0.2),
IAAAdditiveGaussianNoise(),
GaussNoise()]),
OneOf([
InvertImg(),
ToSepia()]),
OneOf([
ChannelDropout(channel_drop_range=(1, 1), fill_value=0),
ChannelShuffle()]),
HueSaturationValue(hue_shift_limit=20, sat_shift_limit=30, val_shift_limit=20, p=0.1)],
p=0.25),
Cutout(num_holes=num_holes, max_h_size=max_h_size, max_w_size=max_w_size,
fill_value=[color_r, color_g, color_b], p=0.9),
])
def get_transforms(phase):
"""
This function returns the transformation list.
These are some commonly used augmentation techniques that
I believed would be useful.
"""
list_transforms = []
if phase == "train":
list_transforms.extend([
HorizontalFlip(p=0.5),
VerticalFlip(p=0.5),
Cutout(num_holes=4, p=0.5),
ShiftScaleRotate(p=1, border_mode=cv2.BORDER_CONSTANT),
# OneOf([
# ElasticTransform(p=0.1, alpha=1, sigma=50, alpha_affine=50,border_mode=cv2.BORDER_CONSTANT),
# GridDistortion(distort_limit =0.05 ,border_mode=cv2.BORDER_CONSTANT, p=0.1),
# OpticalDistortion(p=0.1, distort_limit= 0.05, shift_limit=0.2,border_mode=cv2.BORDER_CONSTANT)
# ], p=0.3),
# OneOf([
# Blur(blur_limit=7)
# ], p=0.4),
# RandomGamma(p=0.8)
])
list_transforms.extend([
# RandomResizedCrop(height = 224, width = 224, p = 1),
# Normalize(mean=[0.485,0.456,0.406], std=[0.229,0.224,0.225], p=1),
ToTensor(),
])
list_trfms = Compose(list_transforms)
return list_trfms
def get_transforms1(*, data, CFG):
if data == 'train':
return Compose([
#RandomCrop(512,512,p=1),
HorizontalFlip(p=CFG.augmentation.augmix_p),
VerticalFlip(p=CFG.augmentation.augmix_p),
RandomContrast(p=CFG.augmentation.contrast_p),
#GaussNoise(p=0.5),
RandomRotate90(p=CFG.augmentation.rotate_90_p),
#RandomGamma(p=0.5),
RandomBrightnessContrast(p=CFG.augmentation.bright_contrast_p),
RandomAugMix(severity=CFG.augmentation.augmix_s,
width=3,
alpha=1.,
p=CFG.augmentation.augmix_p),
#GaussianBlur(p=0.5),
GridMask(num_grid=CFG.augmentation.grdimask_n,
p=CFG.augmentation.grdimask_p),
Cutout(p=CFG.augmentation.cutout_p,
max_h_size=CFG.augmentation.cutout_h,
max_w_size=CFG.augmentation.cutout_w),
Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])
elif data == 'valid':
return Compose([
Normalize(
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225],
)
])
def strong_aug(p=1.0):
return Compose(
[
Cutout(num_holes=1,
max_h_size=16,
max_w_size=16,
fill_value=[0.4914 * 255, 0.4822 * 255, 0.4465 * 255],
p=1.),
HorizontalFlip(p=0.5),
# RandomGamma(p=0.5),
# ElasticTransform(value=10),
ShiftScaleRotate(
shift_limit=0.0625, scale_limit=0.2, rotate_limit=20, p=1.),
# Below are Required
OneOf([
CLAHE(clip_limit=2),
IAASharpen(),
IAAEmboss(),
RandomContrast(),
RandomBrightness(),
],
p=0.3),
# HueSaturationValue(p=0.3),
ToTensor(normalize={
'mean': (0.4914, 0.4822, 0.4465),
'std': (0.2023, 0.1994, 0.2010)
})
],
p=p)
def policy_space(self, trial):
augments = list()
# Shiftscalerotate
shift_limit = trial.suggest_uniform(f"shift_limit", 0, 0.25)
scale_limit = trial.suggest_uniform(f"scale_limit", 0, 0.25)
rotate_limit = trial.suggest_int(f"rotate_limit", 0, 45)
p = trial.suggest_uniform(f"shiftscalerotate_prob", 0, 1)
augments.append(
ShiftScaleRotate(shift_limit=shift_limit,
scale_limit=scale_limit,
rotate_limit=rotate_limit,
p=p))
# GridDistortion
num_steps = trial.suggest_int("num_steps", 1, 7)
distort_limit = trial.suggest_uniform("distort_limit", 0, 0.5)
p = trial.suggest_uniform(f"griddistortion_prob", 0, 1)
augments.append(
GridDistortion(num_steps=num_steps,
distort_limit=distort_limit,
p=p))
# Cutout
n_hole = trial.suggest_int("num_holes", 1, 16)
h_size = trial.suggest_int("max_h_size", 1, 20)
w_size = trial.suggest_int("max_w_size", 1, 20)
p = trial.suggest_uniform(f"cutout_prob", 0, 1)
augments.append(
Cutout(num_holes=n_hole, max_h_size=h_size, max_w_size=w_size,
p=p))
return Compose(augments)
def __init__(self):
self.mean = np.array([0.4914, 0.4822, 0.4465])
self.std = np.array([0.2023, 0.1994, 0.2010])
self.transforms_elist = [
PadIfNeeded(min_height=36, min_width=36, value=self.mean * 255.0),
RandomCrop(height=32, width=32, p=1.0),
HorizontalFlip(p=0.5),
# RandomBrightnessContrast(),
# Rotate(limit=7),
Cutout(num_holes=1,
max_h_size=8,
max_w_size=8,
fill_value=self.mean * 255.0,
p=0.5),
]
self.transforms_test = [
Resize(32, 32),
]
self.transforms_main = [
Normalize(mean=self.mean,
std=self.std,
max_pixel_value=255.0,
p=1.0),
ToTensor(),
]
def train_transform(upside_down=False):
return Compose(
[
Resize(202, 202, interpolation=cv2.INTER_NEAREST),
PadIfNeeded(min_height=SIZE,
min_width=SIZE,
border_mode=cv2.BORDER_REPLICATE),
VerticalFlip(p=int(upside_down)),
HorizontalFlip(p=0.5),
Cutout(p=0.5, num_holes=5, max_h_size=5, max_w_size=5),
OneOf([
Blur(),
IAAAdditiveGaussianNoise(),
], p=0.1),
ElasticTransform(
p=0.25,
alpha=1,
sigma=30, # TODO
alpha_affine=30), # TODO
ShiftScaleRotate(
p=0.25,
rotate_limit=.15, # TODO
shift_limit=.15, # TODO
scale_limit=.15, # TODO
interpolation=cv2.INTER_CUBIC,
#border_mode=cv2.BORDER_REFLECT_101),
border_mode=cv2.BORDER_REPLICATE),
Normalize(),
],
p=1)
def get_transforms(*, data):
if data == 'train':
return Compose([
#Resize(CFG.size, CFG.size),
RandomResizedCrop(CFG.size, CFG.size, scale=(0.85, 1.0)),
HorizontalFlip(p=0.5),
RandomBrightnessContrast(p=0.2, brightness_limit=(-0.2, 0.2), contrast_limit=(-0.2, 0.2)),
HueSaturationValue(p=0.2, hue_shift_limit=0.2, sat_shift_limit=0.2, val_shift_limit=0.2),
ShiftScaleRotate(p=0.2, shift_limit=0.0625, scale_limit=0.2, rotate_limit=20),
CoarseDropout(p=0.2),
Cutout(p=0.2, max_h_size=16, max_w_size=16, fill_value=(0., 0., 0.), num_holes=16),
Normalize(
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225],
),
ToTensorV2(),
])
elif data == 'valid':
return Compose([
Resize(CFG.size, CFG.size),
Normalize(
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225],
),
ToTensorV2(),
])
def hard_transform(image_size=224, p=0.5):
transforms = [
Cutout(
num_holes=4,
max_w_size=image_size // 4,
max_h_size=image_size // 4,
p=p
),
ShiftScaleRotate(
shift_limit=0.1,
scale_limit=0.1,
rotate_limit=15,
border_mode=cv2.BORDER_REFLECT,
p=p
),
IAAPerspective(scale=(0.02, 0.05), p=p),
OneOf(
[
HueSaturationValue(p=p),
ToGray(p=p),
RGBShift(p=p),
ChannelShuffle(p=p),
]
),
RandomBrightnessContrast(
brightness_limit=0.5, contrast_limit=0.5, p=p
),
RandomGamma(p=p),
CLAHE(p=p),
JpegCompression(quality_lower=50, p=p),
]
transforms = Compose(transforms)
return transforms
def get_transforms(*, data):
if data == 'train':
return Compose([
RandomResizedCrop(CFG.size, CFG.size),
Transpose(p=0.5),
HorizontalFlip(p=0.5),
VerticalFlip(p=0.5),
ShiftScaleRotate(p=0.5),
HueSaturationValue(hue_shift_limit=0.2, sat_shift_limit=0.2, val_shift_limit=0.2, p=0.5),
RandomBrightnessContrast(brightness_limit=(-0.1,0.1), contrast_limit=(-0.1, 0.1), p=0.5),
CoarseDropout(p=0.5),
Cutout(p=0.5),
Normalize(
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225],
),
ToTensorV2(),
])
elif data == 'valid':
return Compose([
Resize(CFG.size, CFG.size),
Normalize(
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225],
),
ToTensorV2(),
])
def gettraintransforms(self, mean, std, p=1):
# Train Phase transformations
albumentations_transform = Compose([
RandomRotate90(),
Flip(),
GaussNoise(p=0.6, mean=mean),
OneOf([
MotionBlur(p=0.2),
MedianBlur(blur_limit=3, p=0.1),
Blur(blur_limit=3, p=0.1),
],
p=0.2),
ShiftScaleRotate(
shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=0.3),
OneOf([
OpticalDistortion(p=0.4),
GridDistortion(p=0.2),
], p=0.3),
HueSaturationValue(hue_shift_limit=20,
sat_shift_limit=0.1,
val_shift_limit=0.1,
p=0.3),
Cutout(always_apply=True,
num_holes=2,
max_h_size=10,
max_w_size=10,
fill_value=(255 * .6)),
Normalize(mean=mean, std=std, always_apply=True),
pytorch.ToTensorV2(always_apply=True),
],
p=p)
return albumentations_transform
def transform_v2(config):
train_transforms = Compose([
HorizontalFlip(p=0.5),
ImageCompression(quality_lower=99, quality_upper=100),
ShiftScaleRotate(shift_limit=0.25,
scale_limit=0.25,
rotate_limit=10,
border_mode=0,
p=0.7),
Resize(config.image_size, config.image_size),
Cutout(max_h_size=int(config.image_size * 0.6),
max_w_size=int(config.image_size * 0.6),
num_holes=1,
p=0.5),
Normalize(),
ToTensor()
])
test_transforms = Compose([
Resize(config.image_size, config.image_size),
Normalize(),
ToTensor()
])
return train_transforms, test_transforms
def __init__(self,flag):
self.traintransform = Compose([HorizontalFlip(),
Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
Cutout(num_holes=1, max_h_size=4, max_w_size=4, p =0.3),
ToTensor()])
self.testtransform = Compose([Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
ToTensor()])
self.flag = flag
def __init__(self):
self.albTrainTransforms = Compose([ # Resize(256, 256),
Rotate((-10.0, 10.0)),
HorizontalFlip(p=0.5),
VerticalFlip(p=0.5),
Cutout(num_holes=8, max_h_size=8, max_w_size=8),
Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]),
ToTensor()
]) # this is train transforms
def __init__(self):
self.alb_transform = Compose([
Rotate((-30.0, 30.0)),
HorizontalFlip(),
RGBShift(r_shift_limit=50, g_shift_limit=50, b_shift_limit=50, p=0.5),
Cutout(num_holes=8, max_h_size=8, max_w_size=8, fill_value=[0.4914*255, 0.4822*255, 0.4465*255], always_apply=False, p=0.7),
Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
ToTensor()
])
def __init__(self):
self.albumentation_transforms = Compose([
PadIfNeeded(min_height=36, min_width=36),
Cutout(num_holes=4),
# RandomSizedCrop':{'height':32,'width':32,'min_max_height':[28,28]},
RandomCrop(32,32),
HorizontalFlip(),
Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
ToTensor()])
def __init__(self):
self.albumentations_transform = Compose({
PadIfNeeded(min_height=40,min_width=40),
RandomCrop(32,32),
Flip(),
VerticalFlip(p=0.5),
Cutout(max_h_size=8,max_w_size=8,num_holes=1),
Normalize((0.49139968, 0.48215841, 0.44653091), (0.24703223, 0.24348513, 0.26158784))
})
def strong_aug(p=1.0):
return Compose([
PadIfNeeded(min_height=36, min_width=36, p=1),
RandomCrop(height=32, width=32, p=1),
HorizontalFlip(p=0.5),
Cutout(
num_holes=1, max_h_size=8, max_w_size=8, fill_value=127,
p=0.4),
],
p=p)
def __init__(self, p=0.5):
self.aug = Compose([
RandomBrightnessContrast(),
RandomGamma(),
CLAHE(),
OneOf([
GaussNoise(),
Cutout(num_holes=10, max_h_size=5, max_w_size=5)
])
])
def strong_aug(self,p=.5):
return Compose([
Transpose(),
ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=0.2),
HueSaturationValue(p=0.3),
HorizontalFlip(always_apply=False, p=0.5),
Cutout(num_holes=1, max_h_size=8, max_w_size=8, fill_value=0.5*255)
# Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
# ToTensor()
], p=p)
def __init__(self, image_size=(126, 32)):
self.image_size = image_size
self.background_blend = BackgroundBlend(
"/home/agarcia/repos/mafat-radar-challenge/mafat_radar_challenge/data/mafat_background_v1_spectrogram.npy",
alpha=0.8,
p=0.2,
)
self.gaussian_filter = GaussianFilter(kernel_size=(20, 1))
self.rolling_x = RollingX(shift=(-20, 20))
self.rolling_y = RollingY(shift=(-35, 35))
self.delta = Delta()
self.deltadelta = DeltaDelta()
self.background_supp = BackgroundSuppression()
self.freq_mask = FreqMask(F=(5, 25), num_masks=(1, 3))
self.time_mask = TimeMask(T=(1, 5), num_masks=(1, 10))
self.aug = Compose([
Lambda(self.rolling_x.transform),
Lambda(self.rolling_y.transform),
# Lambda(self.background_supp.transform), # Background suppresion
Lambda(minmax_norm), # This is needed for Noise and Blur addition
HorizontalFlip(p=0.5),
VerticalFlip(p=0.5),
Rotate(limit=(180, 180), p=0.5),
# ShiftScaleRotate(
# shift_limit=0.1,
# scale_limit=0,
# rotate_limit=0,
# p=0.5,
# border_mode=cv2.BORDER_CONSTANT,
# ),
# OneOf(
# [
# MultiplicativeNoise(
# multiplier=[0.8, 1.3], elementwise=True, p=0.25
# ),
# GaussianBlur(p=0.25, blur_limit=(1, 3)),
# ]
# ),
# RandomBrightnessContrast(
# brightness_limit=0.1, contrast_limit=0.1, p=0.1
# ),
Cutout(
num_holes=1,
max_h_size=int(0.2 * self.image_size[0]),
max_w_size=int(0.2 * self.image_size[1]),
p=0.5,
),
# Lambda(self.delta.transform),
# Lambda(self.deltadelta.transform),
# Lambda(self.background_blend.transform),
# Lambda(self.gaussian_filter.transform), # Gaussian
Lambda(self.time_mask.transform),
Lambda(self.freq_mask.transform),
# iaa.CenterCropToFixedSize(height=90, width=None),
])
def __init__(self):
self.albumentation_transforms = Compose([
Rotate((-7.0, 7.0)),
Cutout(),
CoarseDropout(),
# RandomSizedCrop':{'height':32,'width':32,'min_max_height':[28,28]},
# RandomCrop(10,10),
HorizontalFlip(),
Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]),
ToTensor()
])
def __init__(self):
self.albTrainTransforms = Compose([ # Resize(256, 256),
Rotate((-10.0, 10.0)),
HorizontalFlip(p=0.5),
ChannelShuffle(p=0.5),
PadIfNeeded(min_height=36, min_width=36),
RandomCrop(height=32, width=32, p=1.0),
Cutout(num_holes=1, max_h_size=8, max_w_size=8),
Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]),
ToTensor()
])
def build_train(self):
return Compose([
HorizontalFlip(p=0.5),
VerticalFlip(p=0.5),
Normalize(mean=self.MEAN, std=self.STD),
RandomContrast(p=0.2),
RandomBrightness(p=0.2),
RandomSizedCrop((240, 256), self.H, self.W, w2h_ratio=1600 / 256),
Cutout(max_h_size=32, max_w_size=32),
ToTensor(),
])
def __init__(self):
self.albumentations_transform_train = Compose([
HorizontalFlip(),
Cutout(),
# CLAHE(),
Normalize(
mean=[0.5, 0.5, 0.5],
std=[0.5, 0.5, 0.5],
),
ToTensor()
])
