def __jpeg_compression(self,img):
transform = A.Compose([
A.JpegCompression(quality_lower=5,quality_upper=10),
A.JpegCompression(quality_lower=3,quality_upper=5),
A.JpegCompression(quality_lower=2,quality_upper=4),
])
transformed = transform(image=img)
transformed_image = transformed["image"]
return transformed_image
def get_transform(training, width=512, height=512):
t = A.Compose([
A.Resize(width, height),
# Augmentation
A.Compose(
[
A.ShiftScaleRotate(shift_limit=0.05,
scale_limit=0.05,
rotate_limit=5,
border_mode=cv2.BORDER_CONSTANT),
A.RandomRotate90(),
A.HorizontalFlip(),
A.JpegCompression(quality_lower=90),
A.RandomBrightness(),
A.RandomContrast(),
# A.RandomGamma(),
A.HueSaturationValue(
hue_shift_limit=5, sat_shift_limit=30, val_shift_limit=20),
A.CLAHE(),
A.MedianBlur(),
A.MotionBlur(),
A.GaussNoise()
],
p=float(training)),
])
return t
def get_train_transforms():
return A.Compose([
A.JpegCompression(p=0.5),
A.Rotate(limit=80, p=1.0),
A.OneOf([
A.OpticalDistortion(),
A.GridDistortion(),
A.IAAPiecewiseAffine(),
]),
A.RandomSizedCrop(min_max_height=(int(resolution * 0.7), input_res),
height=resolution,
width=resolution,
p=1.0),
A.HorizontalFlip(p=0.5),
A.VerticalFlip(p=0.5),
A.GaussianBlur(p=0.3),
A.OneOf([
A.RandomBrightnessContrast(),
A.HueSaturationValue(),
]),
A.Cutout(num_holes=8,
max_h_size=resolution // 8,
max_w_size=resolution // 8,
fill_value=0,
p=0.3),
A.Normalize(),
ToTensorV2(),
],
p=1.0)
def __init__(self, noisy=False, p=1):
argumentors = [
RandomBrightness(p=0.25),
RandomContrast(p=0.25),
RandomHue(p=0.25),
RandomSaturation(p=0.25),
RandomEqualize(p=0.0625),
RandomAutoContrast(p=0.0625),
RandomAlpha(p=0.25),
]
if noisy:
argumentors.extend(
[
RandomPosterize(p=0.0625),
A.Solarize(threshold=(50, 255 - 50), p=0.0625),
RandomBlur(p=0.125),
RandomUnsharpMask(p=0.125),
A.IAASharpen(alpha=(0, 0.5), p=0.125),
GaussNoise(p=0.125),
SpeckleNoise(p=0.125),
A.ISONoise(color_shift=(0, 0.05), intensity=(0, 0.5), p=0.125),
A.JpegCompression(quality_lower=50, quality_upper=100, p=0.125),
]
)
super().__init__(argumentors, p=p)
def __init__(self, metadata: DataFrame, bbox: DataFrame, params: dict,
transform, data_filter, diff):
self.metadata_df = metadata
self.real_filename = list(data_filter(metadata).index)
self.bbox_df = bbox
self.bbox_index_fn = set(bbox.index.get_level_values(0))
self.transform = transform
self.same_transform = params['same_transform']
self.diff = diff
self.video_path = pathlib.Path(params['data_path'])
self.cached_path = pathlib.Path(params['cache_path'])
self.cached_path.mkdir(exist_ok=True)
self.real2fakes = {fn: [] for fn in self.real_filename}
filename_set = set(self.real_filename)
for fn, row in metadata.iterrows():
if row['label'] == 'FAKE' and row['original'] in filename_set:
self.real2fakes[row['original']].append(fn)
import albumentations as aug
self.trans = aug.OneOf([
aug.Downscale(0.5, 0.5, p=0.66),
aug.JpegCompression(quality_lower=20, quality_upper=20, p=0.66),
aug.Flip(p=0)
])
def hard_transforms():
result = [
# random flip
albu.RandomRotate90(),
# Random shifts, stretches and turns with a 50% probability
albu.ShiftScaleRotate(shift_limit=0.1,
scale_limit=0.1,
rotate_limit=15,
border_mode=0,
p=0.5),
# add random brightness and contrast, 30% prob
albu.RandomBrightnessContrast(brightness_limit=0.2,
contrast_limit=0.2,
p=0.3),
# Random gamma changes with a 30% probability
albu.RandomGamma(gamma_limit=(85, 115), p=0.3),
# Randomly changes the hue, saturation, and color value of the input image
albu.HueSaturationValue(p=0.3),
albu.JpegCompression(quality_lower=80),
albu.OneOf([
albu.MotionBlur(p=0.2),
albu.MedianBlur(blur_limit=3, p=0.1),
albu.Blur(blur_limit=3, p=0.1),
],
p=0.2),
albu.OneOf([
albu.OpticalDistortion(p=0.3),
albu.GridDistortion(p=0.1),
albu.IAAPiecewiseAffine(p=0.3),
],
p=0.2),
]
return result
def get_transform(is_train):
if is_train:
return albumentations.Compose(
[
albumentations.Resize(224,224),
albumentations.OneOf([
albumentations.JpegCompression(quality_lower=20, quality_upper=70, p=0.5),
albumentations.Downscale(scale_min=0.25, scale_max=0.50, interpolation=1, p=0.5),
], p=0.6),
albumentations.HorizontalFlip(p=0.5),
albumentations.VerticalFlip(p=0.5),
# albumentations.ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.1, rotate_limit=45),
albumentations.GaussNoise(p=0.2),
albumentations.RandomBrightnessContrast(0.3,0.3, p=0.7),
albumentations.RandomGamma(p=0.2),
albumentations.CLAHE(p=0.2),
albumentations.ChannelShuffle(p=0.2),
albumentations.MultiplicativeNoise(multiplier=[0.5, 1.5], elementwise=True, p=0.3),
albumentations.HueSaturationValue(hue_shift_limit=10, sat_shift_limit=10, val_shift_limit=10, p=0.7),
albumentations.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), max_pixel_value=255.0)
])
else:
return albumentations.Compose(
[
albumentations.Resize(224,224),
albumentations.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), max_pixel_value=255.0)
])
def __init__(self, metadata: DataFrame, bbox: DataFrame, params: dict,
transform, data_filter, diff):
self.metadata_df = metadata
self.real_filename = list(data_filter(metadata).index)
self.bbox_df = bbox
self.bbox_index_fn = set(bbox.index.get_level_values(0))
self.transform = transform
self.same_transform = params['same_transform']
self.diff = diff
self.use_diff = params["img_diff"]
self.smooth = params["smooth"]
self.fix_fake = params["fix_fake"]
self.video_path = pathlib.Path(params['data_path'])
self.cached_path = pathlib.Path(params['cache_path'])
self.cached_path.mkdir(exist_ok=True)
self.real2fakes = {fn: [] for fn in self.real_filename}
filename_set = set(self.real_filename)
for fn, row in metadata.iterrows():
if row['label'] == 'FAKE' and row['original'] in filename_set:
self.real2fakes[row['original']].append(fn)
if self.fix_fake == 1:
for key in self.real2fakes.keys():
if len(self.real2fakes[key]) > 0:
self.real2fakes[key] = np.random.choice(
self.real2fakes[key])
import albumentations as aug
self.trans1 = aug.Downscale(0.5, 0.5, p=1)
self.trans2 = aug.JpegCompression(quality_lower=20,
quality_upper=20,
p=1)
def __init__(self,
metadata: DataFrame,
params: dict,
transform,
data_filter,
frame_num=8):
self.metadata_df = metadata
self.real_filename = list(data_filter(metadata).index)
self.transform = transform
self.frame_num = frame_num
self.same_transform = params['same_transform']
self.smooth = params['label_smoothing']
self.trans = aug.OneOf([
aug.Downscale(0.5, 0.5, p=0.666),
aug.JpegCompression(quality_lower=20, quality_upper=20, p=0.666),
aug.Flip(p=0)
])
self.video_path = pathlib.Path(params['data_path'])
self.cached_path = pathlib.Path(params['cache_path'])
self.cached_path.mkdir(exist_ok=True)
self.data_dropout = params['data_dropout']
self.input_mix = params['input_mix']
np.random.shuffle(self.real_filename)
self.real_filename = self.real_filename[:int(
len(self.real_filename) * (1 - self.data_dropout))]
self.real2fakes = {fn: [] for fn in self.real_filename}
filename_set = set(self.real_filename)
for fn, row in metadata.iterrows():
if row['label'] == 'FAKE' and row['original'] in filename_set:
self.real2fakes[row['original']].append(fn)
def get_train_transform():
crop_height = 256
crop_width = 256
return albu.Compose([
albu.PadIfNeeded(min_height=crop_height, min_width=crop_width, p=1),
albu.RandomSizedCrop((int(0.3 * crop_height), 288), crop_height, crop_width, p=1),
albu.HorizontalFlip(p=0.5),
albu.OneOf([
albu.IAAAdditiveGaussianNoise(p=0.5),
albu.GaussNoise(p=0.5),
], p=0.2),
albu.OneOf([
albu.MotionBlur(p=0.2),
albu.MedianBlur(blur_limit=3, p=0.1),
albu.Blur(blur_limit=3, p=0.1),
], p=0.2),
albu.ShiftScaleRotate(shift_limit=0.0625, scale_limit=0, rotate_limit=20, p=0.1),
albu.OneOf([
albu.OpticalDistortion(p=0.3),
albu.GridDistortion(p=0.1),
albu.IAAPiecewiseAffine(p=0.3),
], p=0.2),
albu.OneOf([
albu.CLAHE(clip_limit=2, p=0.5),
albu.IAASharpen(p=0.5),
albu.IAAEmboss(p=0.5),
albu.RandomBrightnessContrast(p=0.5),
], p=0.3),
albu.HueSaturationValue(p=0.3),
albu.JpegCompression(p=0.2, quality_lower=20, quality_upper=99),
albu.ElasticTransform(p=0.1),
albu.Normalize(p=1)
], p=1)
def hard_transforms():
result = [
# random flip
albu.Flip(),
# add random brightness and contrast, 70% prob
albu.RandomBrightnessContrast(brightness_limit=0.2,
contrast_limit=0.2,
p=0.7),
# Random gamma changes with a 30% probability
albu.RandomGamma(gamma_limit=(85, 115), p=0.3),
# Randomly changes the hue, saturation, and color value of the input image
albu.HueSaturationValue(p=0.3),
# apply compression to lower the image quality
albu.JpegCompression(quality_lower=80),
# add cutout with 0.5 prob on the image
albu.Cutout(num_holes=15,
max_h_size=20,
max_w_size=20,
fill_value=5,
p=0.5),
# randomly select of these operations
albu.OneOf([
albu.MotionBlur(p=0.2),
albu.MedianBlur(blur_limit=3, p=0.1),
albu.Blur(blur_limit=3, p=0.1),
],
p=0.2),
]
return result
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 preprocessing_augmentation_function(param_p=0.0):
transform = [
A.Rotate(limit=10,
interpolation=1,
border_mode=4,
value=None,
mask_value=None,
p=param_p),
A.OpticalDistortion(distort_limit=0.5,
shift_limit=0.1,
interpolation=1,
border_mode=4,
p=param_p),
A.ElasticTransform(alpha=1,
sigma=5,
alpha_affine=5,
interpolation=1,
border_mode=4,
p=param_p),
A.JpegCompression(quality_lower=0, quality_upper=20, p=param_p),
]
augmentation_function = A.Compose(transform)
def augmentation(x):
augmentation_image = augmentation_function(image=x)
return augmentation_image['image']
return augmentation
def getDataLoader(df, image_folder, process, batch_size = 64, image_size = 224, train_weights = None, replacement = True, option_da = []):
if process == 'train':
trnsfms = albumentations.Compose([
albumentations.Resize(height=image_size, width=image_size),
RGBToGray(always_apply = True) if 'gray' in option_da else Empty(),
albumentations.HorizontalFlip(),
albumentations.OneOf([
albumentations.RandomContrast(),
albumentations.RandomBrightness(),
]),
albumentations.ShiftScaleRotate(rotate_limit=20, scale_limit=0.2),
albumentations.JpegCompression(80),
albumentations.HueSaturationValue(),
albumentations.Normalize(),
AT.ToTensor()
])
elif process == 'val' or process =='test':
trnsfms = albumentations.Compose([
albumentations.Resize(height=image_size, width=image_size),
RGBToGray(always_apply = True) if 'gray' in option_da else Empty(),
albumentations.Normalize(),
AT.ToTensor()
])
dataset = WhaleDataLoader(image_folder = image_folder, process=process, df=df, transform=trnsfms)
if process == 'train':
tr_ind = np.arange(0, df.shape[0], 1)
train_sampler = WeightedSubsetRandomSampler(tr_ind, train_weights, replacement = replacement)
loader = DataLoader(dataset, batch_size=batch_size, num_workers=4, pin_memory=True, sampler=train_sampler)
else:
loader = DataLoader(dataset, batch_size=batch_size, num_workers=4, pin_memory=True, shuffle=False)
return loader
def medium_augmentations(image_size: Tuple[int, int], rot_angle=15):
return A.Compose([
A.OneOf([
A.RandomSizedCrop((image_size[0], int(image_size[0] * 1.25)),
image_size[0],
image_size[1],
p=0.05),
A.RandomSizedCrop((image_size[0], int(image_size[0] * 1.5)),
image_size[0],
image_size[1],
p=0.10),
A.RandomSizedCrop((image_size[0], int(image_size[0] * 2)),
image_size[0],
image_size[1],
p=0.15),
A.Resize(image_size[0], image_size[1], p=0.7),
],
p=1.0),
A.HorizontalFlip(p=0.5),
A.ShiftScaleRotate(shift_limit=0.1,
scale_limit=0.05,
rotate_limit=15,
border_mode=cv2.BORDER_REFLECT,
p=0.3),
A.RandomBrightnessContrast(brightness_limit=0.2,
contrast_limit=0.2,
p=0.2),
A.RandomGamma(gamma_limit=(85, 115), p=0.2),
A.HueSaturationValue(p=0.2),
A.CLAHE(p=0.2),
A.JpegCompression(quality_lower=50, p=0.2),
A.Normalize(),
ToTensor()
])
def __init__(self, prob=0.5):
import albumentations
self.transform = albumentations.Compose([
albumentations.Blur(blur_limit=3, p=prob),
albumentations.JpegCompression(quality_lower=30,
quality_upper=100,
p=prob),
])
def compression(quality_lower=4, quality_upper=100, p=0.5):
"""
:param quality_lower:
:param quality_upper:
:param p: probability of applying the transform.
:return: albumentations JpegCompression
"""
return album.JpegCompression(quality_lower=quality_lower, quality_upper=quality_upper, p=p)
def __init__(self):
import albumentations
self.transform = albumentations.Compose([
albumentations.Blur(blur_limit=3),
albumentations.JpegCompression(quality_lower=30,
quality_upper=100,
p=0.5),
albumentations.RandomBrightnessContrast(),
albumentations.RandomGamma(gamma_limit=(80, 120)),
albumentations.CLAHE(),
])
def __init__(self):
self.augmentor = A.Compose(
[
A.MotionBlur(p=0.25),
A.ColorJitter(p=0.5),
A.RandomRain(p=0.1), # random occlusion
A.RandomSunFlare(p=0.1),
A.JpegCompression(p=0.25),
A.ISONoise(p=0.25)
],
p=1.0)
def get_train_transforms():
return A.Compose([
A.OneOf([
A.HueSaturationValue(hue_shift_limit=20, sat_shift_limit= 20, val_shift_limit=20, p=1),
A.RandomBrightnessContrast(brightness_limit=0.2, contrast_limit=0.2, p=1),
],p=0.5),
A.JpegCompression (quality_lower=90, quality_upper=100, always_apply=False, p=0.5),
A.RandomSizedCrop(min_max_height=(164, 256), height=256, width=512, p=0.5),
A.ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.1, rotate_limit=30, interpolation=1, border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=None, always_apply=False, p=0.5),
A.Cutout(num_holes=8, max_h_size=28, max_w_size=28, fill_value=0, p=0.5),
A.HorizontalFlip(p=0.5),
], p=1.0)
def generate_transforms2(img_size):
train_transform = Compose([
# A.RandomCrop(p=1, height=img_size, width=img_size),
A.Resize(height=img_size, width=img_size),
A.RandomSunFlare(p=1),
A.RandomFog(p=1),
A.RandomBrightness(p=1),
A.Rotate(p=1, limit=90),
A.RGBShift(p=1),
A.RandomSnow(p=1),
A.HorizontalFlip(p=1),
A.VerticalFlip(p=1),
A.RandomContrast(limit=0.5, p=1),
A.HueSaturationValue(p=1,
hue_shift_limit=20,
sat_shift_limit=30,
val_shift_limit=50),
# A.Cutout(p=1),
# A.Transpose(p=1),
A.JpegCompression(p=1),
A.CoarseDropout(p=1),
A.IAAAdditiveGaussianNoise(loc=0,
scale=(2.5500000000000003, 12.75),
per_channel=False,
p=1),
A.IAAAffine(scale=1.0,
translate_percent=None,
translate_px=None,
rotate=0.0,
shear=0.0,
order=1,
cval=0,
mode='reflect',
p=1),
A.IAAAffine(rotate=90., p=1),
A.IAAAffine(rotate=180., p=1),
Normalize(mean=(0.485, 0.456, 0.406),
std=(0.229, 0.224, 0.225),
max_pixel_value=255.0,
p=1.0),
ToTensorV2()
])
val_transform = Compose([
Resize(height=img_size, width=img_size),
Normalize(mean=(0.485, 0.456, 0.406),
std=(0.229, 0.224, 0.225),
max_pixel_value=255.0,
p=1.0),
ToTensorV2(),
])
return {"train": train_transform, "val": val_transform}
def get_gray_aug_trans(use_color_aug,
use_shape_aug,
mean=(0.5, 0.5, 0.5),
std=(0.5, 0.5, 0.5)):
transform = transforms.Compose([
transforms.ToTensor(), # range [0, 255] -> [0.0,1.0]
# range [0.0, 1.0] -> [-1.0,1.0]
transforms.Normalize(mean=mean, std=std)
])
if use_color_aug:
c_aug = A.Compose([
A.RandomBrightnessContrast(p=0.7,
brightness_limit=0.5,
contrast_limit=0.5),
A.CoarseDropout(p=0.5,
max_holes=8,
max_height=16,
max_width=16,
min_height=8,
min_width=8,
fill_value=0),
A.OneOf([
A.Blur(p=1, blur_limit=7),
A.MotionBlur(p=1, blur_limit=7),
A.MedianBlur(p=1, blur_limit=7),
A.GaussianBlur(p=1, blur_limit=7)
],
p=0.5),
A.OneOf([
A.RandomGamma(p=1, gamma_limit=(80, 120)),
A.GaussNoise(p=1, var_limit=(10.0, 50.0)),
A.ISONoise(p=1, color_shift=(0.01, 0.05),
intensity=(0.1, 0.5)),
],
p=0.3),
A.JpegCompression(quality_lower=10, quality_upper=30, p=0.3),
# A.JpegCompression(quality_lower=50, quality_upper=100, p=1),
])
else:
c_aug = None
# crop_size = (args.train_input_h, args.train_input_w)
if use_shape_aug:
shape_aug = EzImageBaseAug()
else:
shape_aug = None
return transform, c_aug, shape_aug
def hard_augmentations(image_size: Tuple[int, int], rot_angle=30):
pad_h, pad_w = padding_for_rotation(image_size, rot_angle)
crop_height = int(image_size[0] + pad_h * 2)
crop_width = int(image_size[1] + pad_w * 2)
crop_transform = A.Compose([
A.RandomSizedCrop((int(crop_height * 0.75), int(crop_height * 1.25)), crop_height, crop_width),
A.ShiftScaleRotate(shift_limit=0, scale_limit=0, rotate_limit=rot_angle, border_mode=cv2.BORDER_CONSTANT),
A.CenterCrop(image_size[0], image_size[1]),
])
return A.Compose([
# spatial transform
A.PadIfNeeded(int(crop_height * 1.25), int(crop_height * 1.25)),
A.OneOf([
crop_transform,
A.RandomSizedCrop((image_size[0], int(image_size[0] * 1.25)), image_size[0], image_size[1], p=0.25),
A.RandomSizedCrop((image_size[0], int(image_size[0] * 1.5)), image_size[0], image_size[1], p=0.25),
A.RandomSizedCrop((image_size[0], int(image_size[0] * 2)), image_size[0], image_size[1], p=0.25),
A.Resize(image_size[0], image_size[1], p=0.75)
], p=1.0),
# add occasion blur/sharpening
A.OneOf([
A.GaussianBlur(),
A.MotionBlur(),
A.IAASharpen(),
A.JpegCompression(quality_lower=75, p=0.25),
]),
# D4 augmentations
A.Compose([
A.HorizontalFlip(),
]),
# spatial-preserving augmentations
A.OneOf([
A.Cutout(),
A.GaussNoise(),
]),
A.OneOf([
A.RandomBrightnessContrast(),
A.CLAHE(),
A.HueSaturationValue(),
A.RGBShift(),
A.RandomGamma()
]),
A.Normalize(),
ToTensor()
])
def color_augment_pool():
augs = [
A.RGBShift(),
A.ToGray(),
A.ChannelShuffle(),
A.CLAHE(),
A.HueSaturationValue(),
A.RandomContrast(),
A.RandomGamma(),
A.Blur(),
A.MedianBlur(),
A.JpegCompression()
]
return augs
def get_tta_transforms():
return A.Compose([
A.JpegCompression(p=0.5),
A.RandomSizedCrop(min_max_height=(int(
resolution * 0.9), int(resolution * 1.1)),
height=resolution,
width=resolution,
p=1.0),
A.HorizontalFlip(p=0.5),
A.VerticalFlip(p=0.5),
A.Transpose(p=0.5),
A.Normalize(),
ToTensorV2(),
],
p=1.0)
def generate_transforms3(img_size):
train_transform = Compose([
A.RandomResizedCrop(img_size, img_size, scale=(0.9, 1), p=1),
A.HorizontalFlip(p=0.5),
A.VerticalFlip(p=0.5),
A.ShiftScaleRotate(p=0.5),
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.2),
A.Resize(img_size, img_size),
A.OneOf([
A.JpegCompression(),
A.Downscale(scale_min=0.1, scale_max=0.15),
],
p=0.2),
A.IAAPerspective(p=0.2),
A.IAASharpen(p=0.2),
A.Cutout(max_h_size=int(img_size * 0.1),
max_w_size=int(img_size * 0.1),
num_holes=5,
p=0.5),
Normalize(mean=(0.485, 0.456, 0.406),
std=(0.229, 0.224, 0.225),
max_pixel_value=255.0,
p=1.0),
ToTensorV2(),
])
val_transform = Compose([
Resize(height=img_size, width=img_size),
Normalize(mean=(0.485, 0.456, 0.406),
std=(0.229, 0.224, 0.225),
max_pixel_value=255.0,
p=1.0),
ToTensorV2(),
])
return {"train": train_transform, "val": val_transform}
def make_augmentation_transforms(args):
transforms = []
for transform_name in args.augmentation_list:
if transform_name == "HorizontalFlip":
transform = albumentations.HorizontalFlip(p=0.5)
elif transform_name == "VerticalFlip":
transform = albumentations.VerticalFlip(p=0.5)
elif transform_name == "ElasticTransform":
transform = albumentations.ElasticTransform(
alpha=args.elastic_alpha,
sigma=args.elastic_sigma,
alpha_affine=args.elastic_alpha_affine,
interpolation=cv2.INTER_NEAREST,
border_mode=cv2.BORDER_CONSTANT,
)
elif transform_name == "ShiftScaleRotate":
transform = albumentations.ShiftScaleRotate(
shift_limit=args.shift_limit,
scale_limit=args.scale_limit,
rotate_limit=args.rotate_limit,
border_mode=cv2.BORDER_CONSTANT,
p=args.p_shift_scale_rotate,
)
elif transform_name == "RandomBrightnessContrast":
transform = albumentations.RandomBrightnessContrast(
brightness_limit=args.brightness_limit,
contrast_limit=args.contrast_limit,
)
elif transform_name == "GridDistortion":
transform = albumentations.GridDistortion(
num_steps=args.grid_distortion_steps,
distort_limit=args.distort_limit,
border_mode=cv2.BORDER_CONSTANT,
)
elif transform_name == "Cutout":
transform = albumentations.CoarseDropout(
max_holes=args.cutout_max_holes,
max_width=args.cutout_max_width,
max_height=args.cutout_max_height,
)
elif transform_name == "JpegCompression":
transform = albumentations.JpegCompression()
else:
raise ValueError(f"Unrecognized transform type: {transform_name}")
transforms.append(transform)
bboxes_params = albumentations.BboxParams("pascal_voc",
label_fields=["labels"])
return albumentations.Compose(transforms, bboxes_params)
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 hard_transforms(crop_size=512):
return albu.Compose([
albu.ShiftScaleRotate(shift_limit=0,
scale_limit=0.1,
rotate_limit=180,
border_mode=cv2.BORDER_CONSTANT,
value=0,
mask_value=0),
albu.CropNonEmptyMaskIfExists(crop_size, crop_size, p=1),
albu.RandomShadow(shadow_roi=(0, 0, 1, 1),
num_shadows_lower=1,
num_shadows_upper=4,
shadow_dimension=7,
always_apply=False,
p=0.5),
albu.HueSaturationValue(p=0.3),
albu.OneOf([
albu.IAAAdditiveGaussianNoise(),
albu.GaussNoise(),
albu.MultiplicativeNoise(
multiplier=[0.5, 1.5], per_channel=True, p=1)
],
p=0.3),
albu.OneOf([
albu.MotionBlur(p=0.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(),
albu.RandomBrightnessContrast(
brightness_limit=0.2, contrast_limit=0.2, p=0.3),
albu.RandomGamma(gamma_limit=(85, 115), p=0.3),
],
p=0.3),
albu.JpegCompression(quality_lower=40, quality_upper=100, p=0.5),
albu.Cutout(
num_holes=25, max_h_size=5, max_w_size=5, fill_value=0, p=0.3),
],
p=1)
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()
])
