def test_multiplicative_noise_rgb(image):
dtype = image.dtype
m = 0.5
aug = A.MultiplicativeNoise(m, p=1)
result = aug(image=image)["image"]
image = F.clip(image * m, dtype, F.MAX_VALUES_BY_DTYPE[dtype])
assert np.allclose(image, result)
aug = A.MultiplicativeNoise(elementwise=True, p=1)
params = aug.get_params_dependent_on_targets({"image": image})
mul = params["multiplier"]
assert mul.shape == image.shape[:2] + (1,)
result = aug.apply(image, mul)
image = F.clip(image.astype(np.float32) * mul, dtype, F.MAX_VALUES_BY_DTYPE[dtype])
assert np.allclose(image, result)
aug = A.MultiplicativeNoise(per_channel=True, p=1)
params = aug.get_params_dependent_on_targets({"image": image})
mul = params["multiplier"]
assert mul.shape == (3,)
result = aug.apply(image, mul)
image = F.clip(image.astype(np.float32) * mul, dtype, F.MAX_VALUES_BY_DTYPE[dtype])
assert np.allclose(image, result)
aug = A.MultiplicativeNoise(elementwise=True, per_channel=True, p=1)
params = aug.get_params_dependent_on_targets({"image": image})
mul = params["multiplier"]
assert mul.shape == image.shape
result = aug.apply(image, mul)
image = F.clip(image.astype(np.float32) * mul, image.dtype, F.MAX_VALUES_BY_DTYPE[image.dtype])
assert np.allclose(image, result)
def __multiplicative_noise(self,img):
transform = A.Compose([
A.MultiplicativeNoise(multiplier=(0.3,3.5),elementwise=False),
A.MultiplicativeNoise(multiplier=(2.3,5.5),elementwise=True),
A.MultiplicativeNoise(multiplier=(0.3,1.5),elementwise=False)
])
transformed = transform(image=img)
transformed_image = transformed["image"]
return transformed_image
def get_transforms(stage: str = None, mode: str = None):
if mode == 'train':
return albumentations.Compose([
# blur
albumentations.OneOf([
albumentations.Blur((1, 4), p=1.0),
albumentations.GaussianBlur(3, p=1.0),
albumentations.MedianBlur(blur_limit=5, p=1.0),
], p=3/4),
# transformations
albumentations.ShiftScaleRotate(scale_limit=0.2, rotate_limit=25, border_mode=cv2.BORDER_CONSTANT, value=0, p=1.0),
# cut and drop
# distortion
albumentations.OneOf([
albumentations.OpticalDistortion(0.6, p=1.0),
albumentations.GridDistortion(8, 0.06, border_mode=cv2.BORDER_CONSTANT, value=0, p=1.0),
albumentations.ElasticTransform(sigma=10, alpha=1, alpha_affine=10, border_mode=cv2.BORDER_CONSTANT, value=0, p=1.0),
], p=3/4),
# add noise
albumentations.OneOf([
albumentations.GaussNoise((0, 250), p=1.0),
albumentations.MultiplicativeNoise(p=1.0),
], p=2/3),
# common
albumentations.Normalize(TRAIN_MEAN, TRAIN_STD),
GridMask((3, 7), rotate=15, p=0.75),
ToTensorV2(),
])
elif mode == 'valid':
return albumentations.Compose([
albumentations.Normalize(TRAIN_MEAN, TRAIN_STD),
ToTensorV2(),
])
else:
raise ValueError('mode is %s' % mode)
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, outputs=6):
super().__init__()
self.net = models.resnet34(True)
self.linear = Linear(1000, outputs)
df = pd.read_csv("/home/dipet/kaggle/prostate/input/prostate-cancer-grade-assessment/train.csv")
self.train_df, self.valid_df = train_test_split(df, test_size=0.2)
self.data_dir = "/datasets/panda/train_64_100"
self.train_transforms = A.Compose(
[
A.Compose(
[
A.OneOf([A.GaussNoise(), A.MultiplicativeNoise(elementwise=True)]),
A.RandomBrightnessContrast(0.02, 0.02),
A.HueSaturationValue(0, 10, 10),
A.Flip(),
A.RandomGridShuffle(grid=(10, 10)),
A.GridDistortion(),
A.Rotate()
],
p=0.5,
),
A.ToFloat(),
]
)
self.valid_transforms = A.Compose([A.ToFloat()])
def augment_img(self, img, mask, mat, idx_item=None):
""" img already in float32 BGR format, not uint8
"""
# horizontal flip
p_flip = np.random.uniform() # in [0,1)
if p_flip > 1: # 0.33:
uv_cx = np.array([1686.2379, 0])
IMG_SHAPE = (2710, 3384, 3) # img.shape = h,w,c
uv_cx_new = self.convert_uv_to_uv_preprocessed(uv_cx, IMG_SHAPE)
cx_mat = uv_cx_new[0]
cx_img = cx_mat * self.factor_downsample
img_flipped = scripts.flip_image_hor.flip_hor_at_u(img, cx_img)
mask_flipped = scripts.flip_image_hor.flip_hor_at_u(mask, cx_img)
mat_flipped = scripts.flip_image_hor.flip_hor_at_u(mat, cx_mat)
mat_flipped[:, :, 4] *= -1 # x
mat_flipped[:, :, 2] *= -1 # sin(yaw)
mat_flipped[:, :, 3] *= -1 # roll
else:
img_flipped = img
mask_flipped = mask
mat_flipped = mat
# grayish - change HSV values
p_sat = np.random.uniform() # in [0,1)
if p_sat > 1:
img_desat = reduce_saturation(img_flipped, sat_shift_range=(-0.15, 0))
else:
img_desat = img_flipped
# gamma change
aug_gamma = albumentations.RandomGamma(gamma_limit=(85, 115),
p=0.33,
)
# gaussian noise
aug_noise = albumentations.MultiplicativeNoise(multiplier=(0.90, 1.00),
elementwise=True,
per_channel=True,
p=0.33,
)
# apply all augmentations to image
aug_tot = albumentations.Compose([aug_gamma, aug_noise], p=1)
img_augmented = aug_tot(image=img_desat)['image']
# for debugging purposes
if False:
fig, ax = plt.subplots(3, 2, figsize=(9, 6))
ax[0][0].imshow(img[:, :, ::-1])
ax[0][1].imshow(img_augmented[:, :, ::-1])
ax[1][0].imshow(mat[:, :, 0])
ax[1][1].imshow(mat_flipped[:, :, 0])
ax[2][0].imshow(mat[:, :, 4]) # x
ax[2][1].imshow(mat_flipped[:, :, 4])
# fig.tight_layout()
plt.show()
fig.savefig('plots_aug/{:05d}.png'.format(idx_item))
return img_augmented, mask_flipped, mat_flipped
def __init__(self):
self.aug = A.MultiplicativeNoise((0, 1),
per_channel=True,
elementwise=True,
p=1)
self.imgaug_transform = iaa.MultiplyElementwise(mul=(0, 1),
per_channel=True)
def r_ss_roate_m_blur(p=1.0):
return albumentations.Compose([
albumentations.ShiftScaleRotate(p=p),
albumentations.MedianBlur(p=p),
albumentations.MultiplicativeNoise(p=p)
],
p=p)
def __init__(self):
self.aug = A.Compose([
A.IAAAdditiveGaussianNoise(scale=(1., 5.), p=0.8),
A.GaussNoise(var_limit=(10.0, 300.0), p=0.8),
A.MultiplicativeNoise(p=0.8),
],
p=1)
pass
def pet_augmentation():
transform_list = [
albu.Resize(320, 320),
albu.HorizontalFlip(p=0.5),
albu.MultiplicativeNoise(p=0.7, multiplier=(0.8, 1.2), elementwise=True),
albu.GaussianBlur(p=0.5, blur_limit=3)
]
return albu.Compose(transform_list)
def pet_augmentation():
transform_list = [
albu.Resize(320, 320),
albu.HorizontalFlip(p=0.5),
albu.GaussianBlur(blur_limit=7, p=0.3, always_apply=False),
albu.MultiplicativeNoise(p=0.7,
multiplier=(0.85, 0.9),
elementwise=True),
]
return albu.Compose(transform_list)
def get_train_transforms(p=1.0):
return A.Compose(
[
A.OneOf(
[
A.CenterCrop(2 * IMG_SIZE // 3, 2 * IMG_SIZE // 3, p=0.5),
A.CenterCrop(3 * IMG_SIZE // 4, 3 * IMG_SIZE // 4, p=0.5),
],
p=0.33,
),
A.Resize(
IMG_SIZE, IMG_SIZE, interpolation=1, always_apply=True, p=1),
A.Flip(),
A.Transpose(),
GridMask(num_grid=(1, 4), rotate=15, p=0.33),
A.OneOf(
[
A.MedianBlur(blur_limit=3, p=0.5),
A.Blur(blur_limit=3, p=0.5),
],
p=0.5,
),
A.OneOf(
[
A.ShiftScaleRotate(
interpolation=1,
shift_limit=0.05,
scale_limit=0.1,
rotate_limit=15,
p=0.5,
),
A.IAAPiecewiseAffine(scale=(0.02, 0.04), p=0.5),
],
p=0.33,
),
A.OneOf(
[
A.HueSaturationValue(
hue_shift_limit=20,
sat_shift_limit=30,
val_shift_limit=20,
p=0.5,
),
A.RandomBrightnessContrast(p=0.5),
],
p=0.5,
),
A.MultiplicativeNoise(
multiplier=[0.9, 1.1], elementwise=True, p=0.3),
A.Normalize(mean, std, max_pixel_value=255.0, always_apply=True),
ToTensorV2(p=1.0),
],
p=p,
)
def augment(img_size, mean=[0.5] * 3, std=[0.5] * 3):
aug_seq1 = A.OneOf([
A.HorizontalFlip(p=1.0),
A.VerticalFlip(p=1.0),
A.Transpose(p=1.0),
],
p=1.0)
aug_seq2 = A.OneOf(
[
# A.RandomGamma(always_apply=False, p=1.0, gamma_limit=(80, 120), eps=1e-07),
A.RandomBrightnessContrast(always_apply=False,
p=1.0,
brightness_limit=(-0.2, 0.2),
contrast_limit=(-0.2, 0.2),
brightness_by_max=True),
],
p=1.0)
aug_seq3 = A.OneOf([
A.RGBShift(always_apply=False,
p=1.0,
r_shift_limit=(-10, 10),
g_shift_limit=(-10, 10),
b_shift_limit=(-10, 10)),
A.HueSaturationValue(always_apply=False,
p=1.0,
hue_shift_limit=(-4, 4),
sat_shift_limit=(-30, 30),
val_shift_limit=(-20, 20)),
],
p=1.0)
aug_seq4 = A.OneOf([
A.MultiplicativeNoise(
always_apply=False,
p=1.0,
multiplier=(0.8999999761581421, 1.100000023841858),
per_channel=True,
elementwise=True),
A.MotionBlur(always_apply=False, p=1.0, blur_limit=(3, 7)),
A.GaussNoise(always_apply=False, p=1.0, var_limit=(10.0, 50.0)),
A.Blur(always_apply=False, p=1.0, blur_limit=(3, 7)),
],
p=1.0)
aug_seq = A.Compose([
A.Resize(img_size, img_size),
aug_seq1,
aug_seq2,
aug_seq3,
aug_seq4,
A.Normalize(mean=mean, std=std),
# A.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]),
])
return aug_seq
def get_transforms(stage: str = None, mode: str = None):
if mode == 'train':
return albumentations.Compose([
# transformations
albumentations.ShiftScaleRotate(
scale_limit=0.2,
rotate_limit=25,
border_mode=cv2.BORDER_CONSTANT,
value=0,
p=1.0),
# distortion
albumentations.OneOf([
albumentations.OpticalDistortion(1.2, p=1.0),
albumentations.GridDistortion(
8,
0.06,
border_mode=cv2.BORDER_CONSTANT,
value=0,
p=1.0),
albumentations.ElasticTransform(
sigma=10,
alpha=1,
alpha_affine=10,
border_mode=cv2.BORDER_CONSTANT,
value=0,
p=1.0),
],
p=3 / 4),
# custom
MorphologyGradient(binarize=True, p=1.0),
# add noise
albumentations.OneOf([
albumentations.GaussNoise((0, 150), p=1.0),
albumentations.MultiplicativeNoise(p=1.0),
],
p=2 / 3),
# common
albumentations.Normalize(TRAIN_MEAN, TRAIN_STD),
GridMask(5, rotate=45, p=0.9),
ToTensorV2(),
])
elif mode == 'valid':
return albumentations.Compose([
MorphologyGradient(binarize=True, p=1.0),
albumentations.Normalize(TRAIN_MEAN, TRAIN_STD),
ToTensorV2(),
])
else:
raise ValueError('mode is %s' % mode)
def hard_color_augmentations():
return A.Compose([
A.RandomBrightnessContrast(brightness_limit=0.3,
contrast_limit=0.3,
brightness_by_max=True),
A.RandomGamma(gamma_limit=(90, 110)),
A.OneOf(
[A.NoOp(),
A.MultiplicativeNoise(),
A.GaussNoise(),
A.ISONoise()]),
A.OneOf([A.RGBShift(), A.HueSaturationValue(),
A.NoOp()]),
A.RandomFog(fog_coef_lower=0.05, fog_coef_upper=0.3),
])
def get_augmentation(save_path=None, load_path=None):
if load_path:
return A.load(load_path)
else:
aug_seq1 = A.OneOf([
A.Rotate(limit=(-90, 90), p=1.0),
A.Flip(p=1.0),
A.OpticalDistortion(always_apply=False, p=1.0, distort_limit=(-0.3, 0.3),
shift_limit=(-0.05, 0.05), interpolation=3,
border_mode=3, value=(0, 0, 0), mask_value=None),
], p=1.0)
aug_seq2 = A.OneOf([
# A.ChannelDropout(always_apply=False, p=1.0, channel_drop_range=(1, 1), fill_value=0),
A.RGBShift(r_shift_limit=15, g_shift_limit=15,
b_shift_limit=15, p=1.0),
A.RandomBrightnessContrast(always_apply=False, p=1.0, brightness_limit=(
-0.2, 0.2), contrast_limit=(-0.2, 0.2), brightness_by_max=True)
], p=1.0)
aug_seq3 = A.OneOf([
A.GaussNoise(always_apply=False, p=1.0, var_limit=(10, 50)),
A.ISONoise(always_apply=False, p=1.0, intensity=(
0.1, 1.0), color_shift=(0.01, 0.3)),
A.MultiplicativeNoise(always_apply=False, p=1.0, multiplier=(
0.8, 1.6), per_channel=True, elementwise=True),
], p=1.0)
aug_seq4 = A.OneOf([
A.Equalize(always_apply=False, p=1.0,
mode='pil', by_channels=True),
A.InvertImg(always_apply=False, p=1.0),
A.MotionBlur(always_apply=False, p=1.0, blur_limit=(3, 7)),
A.RandomFog(always_apply=False, p=1.0,
fog_coef_lower=0.01, fog_coef_upper=0.2, alpha_coef=0.2)
], p=1.0)
aug_seq = A.Compose([
# A.Resize(self.img_size, self.img_size),
# aug_seq1,
aug_seq2,
aug_seq3,
aug_seq4,
# A.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
# A.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]),
])
# aug_path = '/home/jitesh/prj/classification/test/bolt/aug/aug_seq.json'
if save_path:
A.save(aug_seq, save_path)
# loaded_transform = A.load(aug_path)
return aug_seq
def main():
size = (432,432)
color_dic = {1:[255,255,255]}
img_paths = [p.replace('\\', '/') for p in glob('dataset/train/img_aug/**', recursive=True) if os.path.isfile(p)]
mask_paths = list(map(lambda x: x.replace('/img_aug/', '/mask_aug/'), img_paths))
batch_size = 16
splits = math.ceil(len(img_paths)/batch_size)
empty = []
# albumentation
# https://qiita.com/kurilab/items/b69e1be8d0224ae139ad
transforms = albu.OneOf([
albu.ShiftScaleRotate(shift_limit=0.2, scale_limit=0.2, rotate_limit=90),
albu.GaussNoise(),
albu.ISONoise(intensity=(0.7,0.9)),
albu.Downscale(),
albu.ElasticTransform(),
albu.GaussianBlur(),
albu.MultiplicativeNoise(multiplier=(2.0,3.0)),
])
for i in range(splits):
tfrecord_fname = '_record_' + str(i) + '.tfrecord'
save_path = os.path.join('dataset', tfrecord_fname)
# tfrecordのファイルは(画像データ数 / バッチサイズ)分作成する
with tf.io.TFRecordWriter(tfrecord_fname) as writer:
for img_d, mask_d in zip(img_paths[i::splits], mask_paths[i::splits]):
# 画像変形
img = cv2.imread(img_d)
mask = cv2.imread(mask_d)
#augmented = transforms(image=img, mask=mask)
#img, mask = augmented['image'], augmented['mask']
img = cv2.resize(img, (size[0], size[1]), cv2.INTER_NEAREST)
mask = cv2.resize(mask, (size[0], size[1]), cv2.INTER_NEAREST)
# byte列に変換
img = np2byte(img)
mask = np2byte(mask)
#img = np2byte(np.float32(img/127.5 - 1))
#mask = np2byte(convert_mask(mask, color_dic))
# シリアライズして書き出し
proto = serialize_example(img, mask)
writer.write(proto.SerializeToString())
if i>2 : break
def dataset_transforms():
p = 1. / 3.
transforms = A.Compose([
A.RandomBrightnessContrast(p=p),
A.OneOf([
A.MotionBlur(blur_limit=3),
A.MedianBlur(blur_limit=3),
A.Blur(blur_limit=3),
],
p=p),
A.OneOf([
A.MultiplicativeNoise(),
A.GaussNoise(),
], p=p),
ToTensorV2()
])
return transforms
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 get_train_transforms_v2():
return A.Compose(
[
A.Resize(config.SIZE, config.SIZE),
A.OneOf(
[
A.GaussNoise(var_limit=1.15),
A.MultiplicativeNoise(multiplier=1.1),
],
p=0.2,
),
A.RandomBrightnessContrast(
contrast_limit=0.12, brightness_limit=0.12, p=0.2
),
A.OpticalDistortion(distort_limit=0.07, shift_limit=0.07, p=0.25),
A.GaussianBlur(p=0.15),
A.RandomGridShuffle(grid=(4, 4), p=0.2),
ToTensorV2(),
]
)
def even_more_transform(height, width, mappings, p=2 / 3):
scale = random.randint(2, 4)
return Compose([
OneOf([
JpegCompression(quality_lower=20, quality_upper=70, p=0.5),
Downscale(scale_min=0.25, scale_max=0.50, interpolation=1, p=0.5),
Resize(height // scale, width // scale, interpolation=1, p=1.0)
],
p=0.6),
HorizontalFlip(p=0.5),
A.augmentations.transforms.GaussNoise(p=0.2),
A.RandomBrightnessContrast(p=0.2),
A.RandomGamma(p=0.2),
A.CLAHE(p=0.2),
A.ChannelShuffle(p=0.2),
A.MultiplicativeNoise(multiplier=[0.5, 1.5], elementwise=True, p=0.1),
A.HueSaturationValue(
hue_shift_limit=10, sat_shift_limit=10, val_shift_limit=10, p=0.2),
],
p=0.9,
additional_targets=mappings)
def get_image_augmentation():
""" Augmentations just for input and output images (not for masks) """
image_transform = [
albu.OneOf([
albu.Blur(p=0.2, blur_limit=(3, 5)),
albu.GaussNoise(p=0.2, var_limit=(10.0, 50.0)),
albu.ISONoise(p=0.2, intensity=(0.1, 0.5), color_shift=(0.01, 0.05)),
albu.ImageCompression(p=0.2, quality_lower=90, quality_upper=100, compression_type=0),
albu.MultiplicativeNoise(p=0.2, multiplier=(0.9, 1.1), per_channel=True, elementwise=True),
], p=1),
albu.OneOf([
albu.HueSaturationValue(p=0.2, hue_shift_limit=(-10, 10), sat_shift_limit=(-10, 10), val_shift_limit=(-10, 10)),
albu.RandomBrightness(p=0.3, limit=(-0.1, 0.1)),
albu.RandomGamma(p=0.3, gamma_limit=(80, 100), eps=1e-07),
albu.ToGray(p=0.1),
albu.ToSepia(p=0.1),
], p=1)
]
return albu.Compose(image_transform, additional_targets={
'image1': 'image',
'image2': 'image'
})
def __init__(self, folds, img_height, img_width, mean, std):
df = pd.read_csv('../input/train_folds.csv')
df = df[[
'image_id', 'grapheme_root', 'vowel_diacritic',
'consonant_diacritic', 'kfold'
]]
df = df[df.kfold.isin(folds)].reset_index(drop=True)
self.image_ids = df.image_id.values
self.grapheme_root = df.grapheme_root.values
self.vowel_diacritic = df.vowel_diacritic.values
self.consonant_diacritic = df.consonant_diacritic
if len(folds) == 1:
self.aug = albumentations.Compose([
albumentations.Resize(img_height, img_width),
albumentations.Normalize(mean, std, always_apply=True)
])
else:
self.aug = albumentations.Compose([
albumentations.Resize(img_height, img_width),
albumentations.ShiftScaleRotate(shift_limit=0.0625,
scale_limit=0.1,
rotate_limit=5,
p=0.9),
albumentations.Rotate(limit=5),
albumentations.RandomContrast(limit=0.2),
albumentations.GaussianBlur(blur_limit=7),
albumentations.RandomGamma(),
albumentations.RandomShadow(),
albumentations.GaussNoise(),
albumentations.ChannelShuffle(),
#albumentations.Cutout(),
albumentations.Equalize(),
albumentations.MultiplicativeNoise(),
albumentations.Normalize(mean, std, always_apply=True)
])
def get_transforms(stage: str = None, mode: str = None):
if mode == 'train':
return albumentations.Compose([
# blur
albumentations.Blur((1, 4), p=1.0),
# transformations
albumentations.ShiftScaleRotate(
scale_limit=0.2,
rotate_limit=25,
border_mode=cv2.BORDER_CONSTANT,
value=0,
p=1.0),
# cut and drop
albumentations.Cutout(num_holes=10,
max_h_size=SIZE // 6,
max_w_size=SIZE // 6,
p=1.0),
# distortion
albumentations.OpticalDistortion(0.6, p=1.0),
albumentations.GridDistortion(8,
0.06,
border_mode=cv2.BORDER_CONSTANT,
value=0,
p=1.0),
# add noise
albumentations.GaussNoise((0, 250), p=1.0),
albumentations.MultiplicativeNoise(p=1.0),
albumentations.Normalize(TRAIN_MEAN, TRAIN_STD),
ToTensorV2(),
])
elif mode == 'valid':
return albumentations.Compose([
albumentations.Normalize(TRAIN_MEAN, TRAIN_STD),
ToTensorV2(),
])
else:
raise ValueError('mode is %s' % mode)
def hard_transforms():
return albu.Compose([
albu.Rotate(limit=30,
interpolation=cv2.INTER_LINEAR,
border_mode=cv2.BORDER_CONSTANT,
value=(0, 0, 0)),
albu.RandomSizedBBoxSafeCrop(width=64, height=64, erosion_rate=0.2),
albu.InvertImg(p=0.3),
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=30, quality_upper=100, p=0.5),
albu.Cutout(
num_holes=10, max_h_size=5, max_w_size=5, fill_value=0, p=0.5),
],
p=1,
bbox_params=albu.BboxParams(format='pascal_voc'))
def training_augmentation():
train_transform = [
A.IAAAdditiveGaussianNoise(p=1.5),
A.MultiplicativeNoise(multiplier=1.5, p=1),
A.OneOf(
[
A.CLAHE(p=1),
A.RandomBrightness(p=1),
A.RandomGamma(p=1),
],
p=0.5,
),
A.OneOf(
[
A.IAASharpen(p=1.5),
A.Blur(blur_limit=3, p=1),
],
p=0.5,
),
A.HorizontalFlip(p=0.7)
]
return A.Compose(train_transform)
A.RGBShift(always_apply=False,
p=1.0,
r_shift_limit=(-10, 10),
g_shift_limit=(-10, 10),
b_shift_limit=(-10, 10)),
A.HueSaturationValue(always_apply=False,
p=1.0,
hue_shift_limit=(-4, 4),
sat_shift_limit=(-30, 30),
val_shift_limit=(-20, 20)),
],
p=1.0)
aug_seq4 = A.OneOf([
A.MultiplicativeNoise(always_apply=False,
p=1.0,
multiplier=(0.8999999761581421, 1.100000023841858),
per_channel=True,
elementwise=True),
A.MotionBlur(always_apply=False, p=1.0, blur_limit=(3, 7)),
A.GaussNoise(always_apply=False, p=1.0, var_limit=(10.0, 50.0)),
A.Blur(always_apply=False, p=1.0, blur_limit=(3, 7)),
],
p=1.0)
aug_seq = A.Compose([
A.Resize(img_size, img_size),
# aug_seq1,
# aug_seq2,
# aug_seq3,
# aug_seq4,
A.Normalize(mean=mean, std=std),
# A.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]),
def __call__(self, example):
if self.train:
x, y = example
else:
x = example
# augmix
if _evaluate_ratio(self.augmix_ratio):
x = cv2.cvtColor(x, cv2.COLOR_GRAY2RGB)
x = apply_aug(
RandomAugMix(severity=3,
width=3,
depth=-1,
alpha=1.,
always_apply=False,
p=1), x)
x = cv2.cvtColor(x.astype(np.uint8), cv2.COLOR_RGB2GRAY)
# --- Train/Test common preprocessing ---
if self.crop:
x = crop_char_image(x, threshold=self.threshold)
if self.size is not None:
x = resize(x, size=self.size) / 255
if self.sigma > 0.:
x = add_gaussian_noise(x, sigma=self.sigma)
# --- Augmentation ---
if self.affine:
x = affine_image(x)
# albumentations...
x = x.astype(np.float32)
assert x.ndim == 2
if _evaluate_ratio(self.blur_ratio):
r = np.random.uniform()
if r < 0.25:
x = apply_aug(A.Blur(p=1.0), x)
elif r < 0.5:
x = apply_aug(A.MedianBlur(blur_limit=5, p=1.0), x)
elif r < 0.75:
x = apply_aug(A.GaussianBlur(p=1.0), x)
else:
x = apply_aug(A.MotionBlur(p=1.0), x)
if _evaluate_ratio(self.noise_ratio):
r = np.random.uniform()
if r < 0.50:
x = apply_aug(A.GaussNoise(var_limit=5. / 255., p=1.0), x)
else:
x = apply_aug(A.MultiplicativeNoise(p=1.0), x)
if _evaluate_ratio(self.cutout_ratio):
# A.Cutout(num_holes=2, max_h_size=2, max_w_size=2, p=1.0) # Deprecated...
x = apply_aug(
A.CoarseDropout(max_holes=10, max_height=8, max_width=8,
p=1.0), x)
if _evaluate_ratio(self.grid_distortion_ratio):
x = apply_aug(A.GridDistortion(p=1.0), x)
if _evaluate_ratio(self.elastic_distortion_ratio):
x = apply_aug(
A.ElasticTransform(sigma=50, alpha=1, alpha_affine=10, p=1.0),
x)
if _evaluate_ratio(self.random_brightness_ratio):
# A.RandomBrightness(p=1.0) # Deprecated...
# A.RandomContrast(p=1.0) # Deprecated...
x = apply_aug(A.RandomBrightnessContrast(p=1.0), x)
if _evaluate_ratio(self.piece_affine_ratio):
x = apply_aug(A.IAAPiecewiseAffine(p=1.0), x)
if _evaluate_ratio(self.ssr_ratio):
x = apply_aug(
A.ShiftScaleRotate(shift_limit=0.0625,
scale_limit=0.1,
rotate_limit=30,
p=1.0), x)
if self.normalize:
x = (x.astype(np.float32) - 0.0692) / 0.2051
if x.ndim == 2:
x = x[None, :, :]
x = x.astype(np.float32)
if self.train:
y = y.astype(np.int64)
return x, y
else:
return x
def get_transforms(stage: str = None, mode: str = None):
if mode == 'train':
return albumentations.Compose([
# transformations
albumentations.ShiftScaleRotate(
scale_limit=0.2,
rotate_limit=10,
border_mode=cv2.BORDER_CONSTANT,
value=0,
p=1.0),
# cut and drop
albumentations.OneOf([
albumentations.Cutout(num_holes=10,
max_h_size=SIZE // 10,
max_w_size=SIZE // 10,
p=1.0),
albumentations.CoarseDropout(max_holes=10,
max_height=SIZE // 10,
max_width=SIZE // 10,
p=1.0),
GridMask((3, 5), rotate=45, p=1.0),
],
p=0.9),
# blur
albumentations.OneOf([
albumentations.Blur((1, 4), p=1.0),
albumentations.GaussianBlur(3, p=1.0),
albumentations.MedianBlur(blur_limit=5, p=1.0),
],
p=0.5),
# distortion
albumentations.OneOf([
albumentations.OpticalDistortion(
0.6, border_mode=cv2.BORDER_CONSTANT, p=1.0),
albumentations.GridDistortion(
8,
0.06,
border_mode=cv2.BORDER_CONSTANT,
value=0,
p=1.0),
albumentations.ElasticTransform(
sigma=10,
alpha=1,
alpha_affine=10,
border_mode=cv2.BORDER_CONSTANT,
value=0,
p=1.0),
],
p=0.9),
# add noise
albumentations.OneOf([
albumentations.GaussNoise((0, 50), p=1.0),
albumentations.MultiplicativeNoise(p=1.0),
],
p=0.8),
# common
albumentations.Normalize(TRAIN_MEAN, TRAIN_STD),
ToTensorV2(),
])
elif mode == 'valid':
return albumentations.Compose([
albumentations.Normalize(TRAIN_MEAN, TRAIN_STD),
ToTensorV2(),
])
else:
raise ValueError('mode is %s' % mode)
def get_transform_imagenet(use_albu_aug):
if use_albu_aug:
train_transform = al.Compose([
# al.Flip(p=0.5),
al.Resize(256, 256, interpolation=2),
al.RandomResizedCrop(224,
224,
scale=(0.08, 1.0),
ratio=(3. / 4., 4. / 3.),
interpolation=2),
al.HorizontalFlip(),
al.OneOf(
[
al.OneOf(
[
al.ShiftScaleRotate(
border_mode=cv2.BORDER_CONSTANT,
rotate_limit=30), # , p=0.05),
al.OpticalDistortion(
border_mode=cv2.BORDER_CONSTANT,
distort_limit=5.0,
shift_limit=0.1),
# , p=0.05),
al.GridDistortion(border_mode=cv2.BORDER_CONSTANT
), # , p=0.05),
al.ElasticTransform(
border_mode=cv2.BORDER_CONSTANT,
alpha_affine=15), # , p=0.05),
],
p=0.1),
al.OneOf(
[
al.RandomGamma(), # p=0.05),
al.HueSaturationValue(), # p=0.05),
al.RGBShift(), # p=0.05),
al.CLAHE(), # p=0.05),
al.ChannelShuffle(), # p=0.05),
al.InvertImg(), # p=0.05),
],
p=0.1),
al.OneOf(
[
al.RandomSnow(), # p=0.05),
al.RandomRain(), # p=0.05),
al.RandomFog(), # p=0.05),
al.RandomSunFlare(num_flare_circles_lower=1,
num_flare_circles_upper=2,
src_radius=110),
# p=0.05, ),
al.RandomShadow(), # p=0.05),
],
p=0.1),
al.RandomBrightnessContrast(p=0.1),
al.OneOf(
[
al.GaussNoise(), # p=0.05),
al.ISONoise(), # p=0.05),
al.MultiplicativeNoise(), # p=0.05),
],
p=0.1),
al.OneOf(
[
al.ToGray(), # p=0.05),
al.ToSepia(), # p=0.05),
al.Solarize(), # p=0.05),
al.Equalize(), # p=0.05),
al.Posterize(), # p=0.05),
al.FancyPCA(), # p=0.05),
],
p=0.1),
al.OneOf(
[
# al.MotionBlur(blur_limit=1),
al.Blur(blur_limit=[3, 5]),
al.MedianBlur(blur_limit=[3, 5]),
al.GaussianBlur(blur_limit=[3, 5]),
],
p=0.1),
al.OneOf(
[
al.CoarseDropout(), # p=0.05),
al.Cutout(), # p=0.05),
al.GridDropout(), # p=0.05),
al.ChannelDropout(), # p=0.05),
al.RandomGridShuffle(), # p=0.05),
],
p=0.1),
al.OneOf(
[
al.Downscale(), # p=0.1),
al.ImageCompression(quality_lower=60), # , p=0.1),
],
p=0.1),
],
p=0.5),
al.Normalize(),
ToTensorV2()
])
else:
train_transform = transforms.Compose([
transforms.Resize(256),
transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
])
test_transform = transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
])
if use_albu_aug:
train_transform = MultiDataTransformAlbu(train_transform)
else:
train_transform = MultiDataTransform(train_transform)
return train_transform, test_transform
