def augment(self, x):
x = x.transpose(1, 2, 0)
# cutout
x = CoarseDropout(max_holes=1,
max_height=16,
max_width=16,
min_holes=1,
min_height=1,
min_width=1,
fill_value=0,
p=0.5)(image=x)["image"]
# width height shift and rotate
x = ShiftScaleRotate(
shift_limit=0.25,
scale_limit=0,
rotate_limit=0,
interpolation=cv2.INTER_LINEAR,
border_mode=cv2.BORDER_REFLECT_101,
value=0,
mask_value=0,
p=0.5,
)(image=x)["image"]
# flip
x = HorizontalFlip(p=0.5)(image=x)["image"]
x = x.transpose(2, 0, 1)
return (x - self.mean) / self.std
def __init__(self, settype):
self.settype = settype
self.stddev, self.means = self.dataset_calculate_mean_std()
if self.settype == 'train':
print("Train set")
self.albumentation_transform = Compose([
RandomBrightnessContrast(always_apply=False, p=0.5, brightness_limit=(-0.40, 0.82), contrast_limit=(-0.40, 0.82), brightness_by_max=True),
HorizontalFlip(always_apply=False, p=0.5),
# Cutout(always_apply=False, p=1.0, num_holes=2, max_h_size=6, max_w_size=6, fill_value=[127.5,127.5,127.5]),
GaussNoise(always_apply=False, p=1.0, var_limit=(60, 100)),
CoarseDropout(max_holes=2, max_height=16, max_width=16, min_holes=1, min_height=8, min_width=8, fill_value=list(255 * self.means), always_apply=False, p=1.0),
Normalize(
mean = list(self.means),
std = list(self.stddev),
),
ToTensor()
])
elif self.settype == 'test':
print("Test set")
self.albumentation_transform = Compose([
Normalize(
mean = list(self.means),
std = list(self.stddev),
),
ToTensor()
])
def strong_aug(p=0.6, im_height=700, im_width=1200):
dropout_w = int(im_width / 82)
dropout_h = int(im_height / 9.)
return Compose([
Rotate(limit=2, p=0.5),
RandomCrop(
height=int(im_height * 0.95), width=int(im_width * 0.9), p=0.3),
ElasticTransform(p=0.8),
HorizontalFlip(p=0.5),
CoarseDropout(max_holes=8,
max_height=dropout_w,
max_width=dropout_h,
min_holes=1,
min_height=5,
min_width=5,
fill_value=0,
always_apply=False,
p=0.85),
OneOf([
MotionBlur(p=0.8),
Blur(blur_limit=20, p=0.8),
], p=0.35),
Resize(height=256, width=256, p=1)
],
p=p)
def test_aug():
img = Image.open(
'/media/wenyan/data_nataliya/camera21062019/depth_camera1246.svo/depth000005.png'
)
# img = img.resize((640, 480), Image.ANTIALIAS)
a = np.array(img).astype('uint16')
a = cv2.resize(a, dsize=(640, 480), interpolation=cv2.INTER_CUBIC)
print(a.shape)
b = a / 65525. * 255
show(b)
im_w = b.shape[1]
im_h = b.shape[0]
aug = HorizontalFlip(p=1)
aug = CoarseDropout(max_holes=8,
max_height=50,
max_width=45,
min_holes=1,
min_height=30,
min_width=30,
fill_value=0,
always_apply=False,
p=0.85)
for i in range(10):
# Rotate(limit=20, p=1) # RandomCrop(height=640, width=1000, p=1) # Blur(blur_limit=(50, 50), p=1) # ElasticTransform()
aug = strong_aug(im_height=im_h, im_width=im_w)
augment_and_show(aug, b)
"""
def albumentations_transforms(p=1.0, is_train=False):
# Mean and standard deviation of train dataset
mean = np.array([0.4914, 0.4822, 0.4465])
std = np.array([0.2023, 0.1994, 0.2010])
transforms_list = []
# Use data aug only for train data
if is_train:
transforms_list.extend([
PadIfNeeded(min_height=72, min_width=72, p=1.0),
RandomCrop(height=64, width=64, p=1.0),
HorizontalFlip(p=0.25),
Rotate(limit=15, p=0.25),
RGBShift(r_shift_limit=20,
g_shift_limit=20,
b_shift_limit=20,
p=0.25),
CoarseDropout(max_holes=1,
max_height=32,
max_width=32,
min_height=8,
min_width=8,
fill_value=mean * 255.0,
p=0.5),
])
transforms_list.extend([
Normalize(mean=mean, std=std, max_pixel_value=255.0, p=1.0),
ToTensor()
])
data_transforms = Compose(transforms_list, p=p)
return lambda img: data_transforms(image=np.array(img))["image"]
def box_segmentation_aug():
return Compose([
OneOf([
RandomBrightnessContrast(brightness_limit=0.2, p=0.5),
RandomGamma(gamma_limit=50, p=0.5),
ChannelShuffle(p=0.5)
]),
OneOf([
ImageCompression(quality_lower=0, quality_upper=20, p=0.5),
MultiplicativeNoise(multiplier=(0.3, 0.8),
elementwise=True,
per_channel=True,
p=0.5),
Blur(blur_limit=(15, 15), p=0.5)
]),
OneOf([
CenterCrop(height=1000, width=1000, p=0.1),
RandomGridShuffle(grid=(3, 3), p=0.2),
CoarseDropout(max_holes=20,
max_height=100,
max_width=100,
fill_value=53,
p=0.2)
]),
OneOf([
GridDistortion(p=0.5, num_steps=2, distort_limit=0.2),
ElasticTransform(alpha=157, sigma=80, alpha_affine=196, p=0.5),
OpticalDistortion(distort_limit=0.5, shift_limit=0.5, p=0.5)
]),
OneOf([
VerticalFlip(p=0.5),
HorizontalFlip(p=0.5),
Rotate(limit=44, p=0.5)
])
])
def albumentations_transforms(p=1.0, is_train=False):
# Mean and standard deviation of train dataset
mean = np.array([0.4914, 0.4822, 0.4465])
std = np.array([0.2023, 0.1994, 0.2010])
transforms_list = []
# Use data aug only for train data
if is_train:
transforms_list.extend([
HueSaturationValue(p=0.25),
HorizontalFlip(p=0.5),
Rotate(limit=15),
CoarseDropout(max_holes=1, max_height=16, max_width=16, min_height=4,
min_width=4, fill_value=mean*255.0, p=0.75),
])
transforms_list.extend([
Normalize(
mean=mean,
std=std,
max_pixel_value=255.0,
p=1.0
),
ToTensor()
])
transforms = Compose(transforms_list, p=p)
return lambda img:transforms(image=np.array(img))["image"
def albumentations_transforms(p=1.0, is_train=False): # Mean and standard deviation of train dataset mean = np.array([0.4914, 0.4822, 0.4465]) std = np.array([0.2023, 0.1994, 0.2010]) transforms_list = [] # Use data aug only for train data if is_train: transforms_list.extend([ PadIfNeeded(min_height=40, min_width=40, border_mode=BORDER_CONSTANT, value=mean*255.0, p=1.0), OneOf([ RandomCrop(height=32, width=32, p=0.8), CenterCrop(height=32, width=32, p=0.2), ], p=1.0), HorizontalFlip(p=0.5), CoarseDropout(max_holes=1, max_height=8, max_width=8, min_height=8, min_width=8, fill_value=mean*255.0, p=0.75), ]) transforms_list.extend([ Normalize( mean=mean, std=std, max_pixel_value=255.0, p=1.0 ), ToTensor() ]) transforms = Compose(transforms_list, p=p) return lambda img:transforms(image=np.array(img))["image"]
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 __init__(self, means, stddev, settype):
self.settype = settype
self.means = np.array(means)
self.stddev = np.array(stddev)
if self.settype == 'train':
print("Train set")
self.albumentation_transform = Compose([
PadIfNeeded(min_height=72, min_width=72, border_mode=1, value=list(255 * self.means), p=1.0),
# RandomBrightnessContrast(always_apply=False, p=0.5, brightness_limit=(-0.40, 0.82), contrast_limit=(-0.40, 0.82), brightness_by_max=True),
RandomCrop(height=64, width=64, always_apply=True, p=1.0),
HorizontalFlip(always_apply=False, p=0.5),
Rotate(limit=15, interpolation=1, border_mode=4, value=None, mask_value=None, always_apply=False, p=0.5),
# Cutout(always_apply=True, p=1.0, num_holes=1, max_h_size=8, max_w_size=8, fill_value=list(255 * self.means)),
GaussNoise(always_apply=False, p=1.0, var_limit=(60, 100)),
CoarseDropout(max_holes=1, max_height=16, max_width=16, min_holes=1, min_height=8, min_width=8, fill_value=list(255 * self.means), always_apply=False, p=1.0),
Normalize(
mean = list(self.means),
std = list(self.stddev),
),
ToTensor()
])
elif self.settype == 'test':
print("Test set")
self.albumentation_transform = Compose([
Normalize(
mean = list(self.means),
std = list(self.stddev),
),
ToTensor()
])
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 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 get_train_transforms():
return Compose(
[
#Resize(args.img_size, args.img_size),
RandomResizedCrop(args.img_size, args.img_size),
Transpose(p=0.5),
HorizontalFlip(p=0.5),
VerticalFlip(p=0.25),
ShiftScaleRotate(p=0.25),
HueSaturationValue(hue_shift_limit=0.2,
sat_shift_limit=0.2,
val_shift_limit=0.2,
p=0.25),
RandomBrightnessContrast(brightness_limit=(-0.1, 0.1),
contrast_limit=(-0.1, 0.1),
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),
CoarseDropout(p=0.5),
# Cutout(p=0.5),
ToTensorV2(p=1.0),
],
p=1.)
def gettraintransforms(self, mean, std, p=1):
# Train Phase transformations
albumentations_transform = Compose([
# RandomRotate90(),
PadIfNeeded(72, 72, border_mode=cv2.BORDER_REFLECT, always_apply=True),
RandomCrop(64, 64, True),
Flip(),
GaussNoise(p=0.8, mean=mean),
OneOf([
MotionBlur(p=0.4),
MedianBlur(blur_limit=3, p=0.2),
Blur(blur_limit=3, p=0.2),
], p=0.4),
ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=0.6),
OneOf([
OpticalDistortion(p=0.8),
GridDistortion(p=0.4),
], p=0.6),
HueSaturationValue(hue_shift_limit=20, sat_shift_limit=0.1, val_shift_limit=0.1, p=0.6),
CoarseDropout(always_apply=True, max_holes=1, min_holes=1, max_height=16, max_width=16,
fill_value=(255 * .6), min_height=16, min_width=16),
Normalize(mean=mean, std=std, always_apply=True),
pytorch.ToTensorV2(always_apply=True),
], p=p)
return albumentations_transform;
def _prepare_data(self):
# Augumentation used only while training
train_transforms_album = Compose([
HueSaturationValue(p=0.25),
HorizontalFlip(p=0.5),
Rotate(limit=15),
CoarseDropout(
max_holes=1,
max_height=16,
max_width=16,
min_height=4,
min_width=4,
fill_value=np.array(self._train_mean()) * 255.0,
p=0.75,
),
Normalize(mean=self._train_mean(), std=self._train_std()),
ToTensor(),
])
def train_transforms(img):
return train_transforms_album(image=np.array(img))["image"]
# train_transforms = transforms.Compose(
# [
# transforms.RandomCrop(32, padding=4),
# transforms.RandomHorizontalFlip(),
# transforms.ToTensor(),
# transforms.Normalize(self._train_mean(), self._train_std()),
# ]
# )
train_dataset = datasets.CIFAR10(root="./data",
train=True,
download=True,
transform=train_transforms)
# No Augumentation while testing
test_transforms_album = Compose([
Normalize(mean=self._test_mean(), std=self._test_std()),
ToTensor()
# transforms.ToTensor(),
# transforms.Normalize(self._test_mean(), self._test_std()),
])
def test_transforms(img):
return test_transforms_album(image=np.array(img))["image"]
# Pytorch default approach
# test_transforms = transforms.Compose(
# [
# transforms.ToTensor(),
# transforms.Normalize(self._test_mean(), self._test_std()),
# ]
# )
test_dataset = datasets.CIFAR10(root="./data",
train=False,
transform=test_transforms)
return train_dataset, test_dataset
def cutout_aug_3():
augs_list = [
OneOf([
CoarseDropout(min_holes=2,
max_holes=10,
max_height=12,
max_width=12,
fill_value=0,
p=0.3),
CoarseDropout(max_holes=1,
max_height=64,
max_width=64,
fill_value=0,
p=0.3)
]),
Normalize(),
ToTensorV2()
]
return Compose(augs_list, p=1)
def __init__(self):
self.albumentation_transforms = Compose([ # Resize(256, 256),
Rotate((-7.0, 7.0)),
#Cutout(),
CoarseDropout(),
# RandomCrop(224,224),
HorizontalFlip(),
Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]),
ToTensor()
])
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 cutout_aug_2():
augs_list = [
CoarseDropout(max_holes=1,
max_height=64,
max_width=64,
fill_value=0,
p=0.3),
Normalize(),
ToTensorV2()
]
return Compose(augs_list, p=1)
def generate_cutout_augmentation(aug_cfg):
cutout_aug_list = []
if aug_cfg.COARSE_DROPOUT_PROB > 0:
cutout_aug_list.append(CoarseDropout(max_holes=5, max_height=7, max_width=7, p=aug_cfg.COARSE_DROPOUT_PROB))
if len(cutout_aug_list) > 0:
cutout_aug = Compose(cutout_aug_list, p=1)
return cutout_aug
else:
return None
def augument():
augm = Compose([
RGBShift(),
RandomBrightness(),
RandomContrast(),
HueSaturationValue(p=0.2),
ChannelShuffle(),
CLAHE(),
Blur(),
ToGray(),
CoarseDropout()
],
p=0.5)
return augm
def transforms(size, p=0.5):
area = size**2
transform = [
CoarseDropout(max_holes=256,
max_height=8,
max_width=8,
min_holes=16,
min_height=1,
min_width=1,
p=p),
HorizontalFlip(p=p),
VerticalFlip(p=p),
RandomRotate90(p=p),
Resize(size, size),
]
return Compose(transform)
def __init__(self, annotations, root_dir, augmented):
"""
Args:
annotations [[string, int]]
root_dir (string): Directory with all the images.
augmented (bool): True if we want to augment the dataset with flips, rotate, etc
"""
self.annotations = annotations
self.root_dir = root_dir
self.augmented = augmented
if (augmented):
self.augmentations = Compose([HorizontalFlip(), VerticalFlip(), RandomRotate90(),
CoarseDropout(max_holes=12, max_height=24, max_width=24)])
else:
self.augmentations = Compose([])
def __init__(self, image_filenames, labels, root_directory='',
batch_size=128, mix=False,
shuffle=True, augment=True):
self.image_filenames = image_filenames
self.labels = labels
self.root_directory = root_directory
self.batch_size = batch_size
self.is_mix = mix
self.is_augment = augment
self.shuffle = shuffle
if self.shuffle:
self.on_epoch_end()
if self.is_augment:
self.generator = Compose([Blur(), Flip(), Transpose(), ShiftScaleRotate(),
RandomBrightnessContrast(), HueSaturationValue(),
CLAHE(), GridDistortion(), ElasticTransform(), CoarseDropout(),
ToFloat(max_value=255.0, p=1.0)], p=1.0)
else:
self.generator = Compose([ToFloat(max_value=255.0, p=1.0)], p=1.0)
def gridmask_aug():
augs_list = [
OneOf([
OneOf([
GridMask(num_grid=(10, 15), rotate=10, mode=0, fill_value=0),
GridMask(num_grid=(10, 15), rotate=10, mode=2, fill_value=0),
GridMask(num_grid=(10, 15), rotate=0, mode=0, fill_value=0),
GridMask(num_grid=(10, 15), rotate=0, mode=2, fill_value=0)
],
p=0.7),
CoarseDropout(min_holes=2,
max_holes=10,
max_height=15,
max_width=15,
fill_value=0,
p=0.7)
]),
Normalize(),
ToTensorV2()
]
return Compose(augs_list)
def __init__(self):
transformation = []
transformation += [
RandomResizedCrop(512, 512, scale=(0.8, 1.0)),
ShiftScaleRotate(),
OneOf([
GridDistortion(),
OpticalDistortion(),
ElasticTransform(approximate=True)
],
p=0.8),
OneOf([
IAAAdditiveGaussianNoise(),
GaussNoise(),
MedianBlur(blur_limit=3),
Blur(blur_limit=3)
],
p=0.8),
CoarseDropout(max_holes=2, max_height=32, max_width=32)
]
self.transform = Compose(transformation)
def get_train_transforms(size=300):
return Compose([
ImageCompression(quality_lower=60, quality_upper=100, p=0.5),
GaussNoise(p=0.1),
GaussianBlur(blur_limit=3, p=0.05),
HorizontalFlip(),
Resize(height=size, width=size),
PadIfNeeded(min_height=size,
min_width=size,
border_mode=cv2.BORDER_CONSTANT),
OneOf([RandomBrightnessContrast(),
HueSaturationValue()], p=0.5), # FancyPCA(),
OneOf([CoarseDropout(), GridDropout()], p=0.2),
ToGray(p=0.2),
ShiftScaleRotate(shift_limit=0.1,
scale_limit=0.2,
rotate_limit=10,
border_mode=cv2.BORDER_CONSTANT,
p=0.5),
Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)),
ToTensorV2()
])
def build_aun_fn(image_size):
transforms = Compose([
RandomResizedCrop(image_size, image_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),
Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225],
max_pixel_value=255.0,
p=1.0),
CoarseDropout(p=0.5),
Cutout(p=0.5)
],
p=1.)
def aug_fn(image):
data = {"image": image}
aug_data = transforms(**data)
aug_img = aug_data["image"]
aug_img = tf.cast(aug_img / 255.0, tf.float32)
aug_img = tf.image.resize(aug_img, size=[image_size, image_size])
return aug_img
def augment(image, label):
aug_img = tf.numpy_function(func=aug_fn, inp=[image], Tout=tf.float32)
return aug_img, label
return augment
def build_train(self):
train_transform = Compose([
RandomResizedCrop(width=512,
height=512,
scale=(0.08, 1.0),
ratio=(0.75, 1.3333333333333333)),
Transpose(p=0.5),
HorizontalFlip(p=0.5),
VerticalFlip(p=0.5),
ShiftScaleRotate(p=0.5),
HueSaturationValue(p=0.5),
RandomBrightnessContrast(brightness_limit=(-0.1, 0.1),
contrast_limit=(-0.1, 0.1),
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),
CoarseDropout(p=0.5),
ToTensorV2(p=1.0)
],
p=1)
return train_transform
def strong_aug(img_shape, p=0.5):
return [
RandomRotate90(),
Flip(),
CoarseDropout(2,
int(img_shape[0] * 0.1),
int(img_shape[1] * 0.1),
1,
int(img_shape[0] * 0.05),
int(img_shape[1] * 0.05),
p=1.), # mudar para 5 a 10 % do tamanho da imagem
OneOf(
[
IAAAdditiveGaussianNoise(
scale=(0.05 * 255,
0.1 * 255)), # default: (0.01 * 255, 0.05 * 255)
GaussNoise(),
],
p=1.),
OneOf([
MotionBlur(p=0.2),
MedianBlur(blur_limit=3, p=0.1),
Blur(blur_limit=3, p=0.1),
],
p=1.),
ShiftScaleRotate(shift_limit=0.0625,
scale_limit=(0.0, 0.3),
rotate_limit=25,
p=0.35),
OneOf(
[
CLAHE(clip_limit=2),
IAASharpen(),
RandomBrightnessContrast(brightness_limit=0.3), #default: 0.2
],
p=1.),
]