def hard_spatial_augmentations(image_size: Tuple[int, int], rot_angle=45):
return A.Compose([
A.OneOf([
A.NoOp(),
A.RandomGridShuffle(grid=(4, 4)),
A.RandomGridShuffle(grid=(3, 3)),
A.RandomGridShuffle(grid=(2, 2)),
]),
A.MaskDropout(max_objects=10),
A.OneOf([
A.ShiftScaleRotate(scale_limit=0.1,
rotate_limit=rot_angle,
border_mode=cv2.BORDER_CONSTANT,
value=0,
mask_value=0),
A.NoOp(),
]),
A.OneOf([
A.ElasticTransform(border_mode=cv2.BORDER_CONSTANT,
value=0,
mask_value=0),
A.GridDistortion(border_mode=cv2.BORDER_CONSTANT,
value=0,
mask_value=0),
A.NoOp(),
]),
# D4
A.Compose([A.Transpose(), A.RandomRotate90()]),
])
def medium_augmentations():
return A.Compose([
A.HorizontalFlip(),
A.ShiftScaleRotate(scale_limit=0.1,
rotate_limit=15,
border_mode=cv2.BORDER_CONSTANT),
# Add occasion blur/sharpening
A.OneOf([A.GaussianBlur(), A.IAASharpen(),
A.NoOp()]),
# Spatial-preserving augmentations:
A.OneOf([A.CoarseDropout(),
A.MaskDropout(max_objects=5),
A.NoOp()]),
A.GaussNoise(),
A.OneOf([
A.RandomBrightnessContrast(),
A.CLAHE(),
A.HueSaturationValue(),
A.RGBShift(),
A.RandomGamma()
]),
# Weather effects
A.RandomFog(fog_coef_lower=0.01, fog_coef_upper=0.3, p=0.1),
A.Normalize(),
])
def test_mask_dropout():
# In this case we have mask with all ones, so MaskDropout wipe entire mask and image
img = np.random.randint(0, 256, [50, 10], np.uint8)
mask = np.ones([50, 10], dtype=np.long)
aug = A.MaskDropout(p=1)
result = aug(image=img, mask=mask)
assert np.all(result["image"] == 0)
assert np.all(result["mask"] == 0)
# In this case we have mask with zeros , so MaskDropout will make no changes
img = np.random.randint(0, 256, [50, 10], np.uint8)
mask = np.zeros([50, 10], dtype=np.long)
aug = A.MaskDropout(p=1)
result = aug(image=img, mask=mask)
assert np.all(result["image"] == img)
assert np.all(result["mask"] == 0)
def light_spatial_augmentations(image_size: Tuple[int, int]):
return A.Compose([
A.ShiftScaleRotate(scale_limit=0.1,
rotate_limit=10,
border_mode=cv2.BORDER_CONSTANT),
# D4 Augmentations
A.Compose([A.Transpose(), A.RandomRotate90()]),
# Spatial-preserving augmentations:
A.RandomBrightnessContrast(),
A.MaskDropout(max_objects=10),
])
def safe_spatial_augmentations(image_size: Tuple[int, int]):
return A.Compose([
A.ShiftScaleRotate(
shift_limit=0.05,
scale_limit=0.1,
rotate_limit=5,
border_mode=cv2.BORDER_CONSTANT,
value=0,
mask_value=0,
),
A.MaskDropout(10),
A.Compose([A.Transpose(), A.RandomRotate90()]),
])
def _augmented(self, image, mask):
# always train on crops
max_w = min(image.shape[0], image.shape[1])
light = A.Compose(
[
# A.RandomSizedCrop((320, max_w), 512, 512),
# A.ShiftScaleRotate(border_mode=cv2.BORDER_CONSTANT, value=1),
A.Blur(),
# A.GaussNoise(),
# A.ElasticTransform(border_mode=cv2.BORDER_REPLICATE),
# A.ElasticTransform(border_mode=cv2.BORDER_CONSTANT, value=1),
A.MaskDropout((10, 15), p=1),
A.Cutout(p=1)
],
p=1)
augmented = light(image=image, mask=mask)
return augmented['image'], augmented['mask']
def medium_spatial_augmentations(image_size: Tuple[int, int],
no_mask_dropout=False):
return A.Compose([
A.OneOf([
A.NoOp(p=0.8),
A.RandomGridShuffle(grid=(4, 4), p=0.2),
A.RandomGridShuffle(grid=(3, 3), p=0.2),
A.RandomGridShuffle(grid=(2, 2), p=0.2),
],
p=1),
A.ShiftScaleRotate(scale_limit=0.1,
rotate_limit=10,
border_mode=cv2.BORDER_CONSTANT),
# D4 Augmentations
A.Compose([A.Transpose(), A.RandomRotate90()]),
# Spatial-preserving augmentations:
A.RandomBrightnessContrast(),
A.NoOp() if no_mask_dropout else A.MaskDropout(max_objects=10),
])
def hard_augmentations():
return A.Compose([
A.RandomRotate90(),
A.Transpose(),
A.RandomGridShuffle(),
A.ShiftScaleRotate(scale_limit=0.1,
rotate_limit=45,
border_mode=cv2.BORDER_CONSTANT,
mask_value=0,
value=0),
A.ElasticTransform(border_mode=cv2.BORDER_CONSTANT,
alpha_affine=5,
mask_value=0,
value=0),
# Add occasion blur
A.OneOf([
A.GaussianBlur(),
A.GaussNoise(),
A.IAAAdditiveGaussianNoise(),
A.NoOp()
]),
# D4 Augmentations
A.OneOf([A.CoarseDropout(),
A.MaskDropout(max_objects=10),
A.NoOp()]),
# Spatial-preserving augmentations:
A.OneOf([
A.RandomBrightnessContrast(brightness_by_max=True),
A.CLAHE(),
A.HueSaturationValue(),
A.RGBShift(),
A.RandomGamma(),
A.NoOp(),
]),
# Weather effects
A.OneOf([
A.RandomFog(fog_coef_lower=0.01, fog_coef_upper=0.3, p=0.1),
A.NoOp()
]),
A.Normalize(),
])
def hard_augmentations(mask_dropout=True) -> List[A.DualTransform]:
return [
# D4 Augmentations
A.RandomRotate90(p=1),
A.Transpose(p=0.5),
# Spatial augmentations
A.OneOf(
[
A.ShiftScaleRotate(scale_limit=0.2, rotate_limit=45, border_mode=cv2.BORDER_REFLECT101),
A.ElasticTransform(border_mode=cv2.BORDER_REFLECT101, alpha_affine=5),
]
),
# Color augmentations
A.OneOf(
[
A.RandomBrightnessContrast(brightness_by_max=True),
A.CLAHE(),
A.FancyPCA(),
A.HueSaturationValue(),
A.RGBShift(),
A.RandomGamma(),
]
),
# Dropout & Shuffle
A.OneOf(
[
A.RandomGridShuffle(),
A.CoarseDropout(),
A.MaskDropout(max_objects=2, mask_fill_value=0) if mask_dropout else A.NoOp(),
]
),
# Add occasion blur
A.OneOf([A.GaussianBlur(), A.GaussNoise(), A.IAAAdditiveGaussianNoise()]),
# Weather effects
A.RandomFog(fog_coef_lower=0.01, fog_coef_upper=0.3, p=0.1),
]
def set_transforms(self) -> dict:
d4_tansforms = [
A.SmallestMaxSize(self.img_size[0], interpolation=0, p=1.),
# D4 Group augmentations
A.HorizontalFlip(p=0.5),
A.VerticalFlip(p=0.5),
A.RandomRotate90(p=0.5),
A.Transpose(p=0.5),
]
tensor_norm = [
ToTensor(),
Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
]
geometric = [
A.SmallestMaxSize(self.img_size[0], interpolation=0, p=1.),
A.ShiftScaleRotate(shift_limit=self.shift_limit,
self.scale_limit,
rotate_limit=self.rotate_limit,
interpolation=cv2.INTER_LINEAR,
border_mode=cv2.BORDER_CONSTANT,
value=0,
mask_value=0,
p=0.5),
# crop and resize
A.RandomSizedCrop(
(self.crop_size[0],
min(self.crop_size[1], self.img_size[0], self.img_size[1])),
self.img_size[0],
self.img_size[1],
w2h_ratio=1.0,
interpolation=cv2.INTER_LINEAR,
always_apply=False,
p=0.2),
]
resize_crop = [
A.SmallestMaxSize(max(self.img_size[0], self.img_size[1]),
interpolation=0,
p=1.),
A.RandomCrop(self.img_size[0], self.img_size[1], p=1.),
]
train_light = [
A.SmallestMaxSize(self.img_size[0], interpolation=0, p=1.),
A.RandomCrop(self.img_size[0], self.img_size[1], p=1.),
A.HorizontalFlip(p=0.5),
A.RandomBrightnessContrast(p=0.5),
]
train_medium = train_light.append([
A.ShiftScaleRotate(shift_limit=self.shift_limit,
self.scale_limit,
rotate_limit=self.rotate_limit,
p=0.5),
A.OneOf([
A.RandomBrightnessContrast(p=0.7),
A.Equalize(p=0.3),
A.HueSaturationValue(p=0.5),
A.RGBShift(p=0.5),
A.RandomGamma(p=0.4),
A.ChannelShuffle(p=0.05),
],
p=0.9),
A.OneOf([
A.GaussNoise(p=0.5),
A.ISONoise(p=0.5),
A.MultiplicativeNoise(0.5),
],
p=0.2),
])
valid_ade = [
A.SmallestMaxSize(self.img_size, p=1.),
A.Lambda(name="Pad32", image=pad_x32, mask=pad_x32),
]
# from bloodaxe
# https://github.com/BloodAxe/Catalyst-Inria-Segmentation-Example/blob/master/inria/augmentations.py
crop = [ #(image_size: Tuple[int, int], min_scale=0.75, max_scale=1.25, input_size=5000):
A.OneOrOther(
A.RandomSizedCrop((self.crop_size[0],
min(self.crop_size[1], self.img_size[0],
self.img_size[1])), self.img_size[0],
self.img_size[1]),
A.CropNonEmptyMaskIfExists(self.img_size[0], self.img_size[1]),
)
]
safe_augmentations = [A.HorizontalFlip(), A.RandomBrightnessContrast()]
light_augmentations = [
A.HorizontalFlip(),
A.RandomBrightnessContrast(),
A.OneOf([
A.ShiftScaleRotate(scale_limit=self.scale_limit,
rotate_limit=self.rotate_limit,
border_mode=cv2.BORDER_CONSTANT),
A.IAAAffine(),
A.IAAPerspective(),
A.NoOp()
]),
A.HueSaturationValue(),
]
medium_augmentations = [
A.HorizontalFlip(),
A.ShiftScaleRotate(scale_limit=self.scale_limit,
rotate_limit=self.rotate_limit,
border_mode=cv2.BORDER_CONSTANT),
# Add occasion blur/sharpening
A.OneOf([A.GaussianBlur(),
A.IAASharpen(),
A.NoOp()]),
# Spatial-preserving augmentations:
A.OneOf(
[A.CoarseDropout(),
A.MaskDropout(max_objects=5),
A.NoOp()]),
A.GaussNoise(),
A.OneOf([
A.RandomBrightnessContrast(),
A.CLAHE(),
A.HueSaturationValue(),
A.RGBShift(),
A.RandomGamma()
]),
# Weather effects
A.RandomFog(fog_coef_lower=0.01, fog_coef_upper=0.3, p=0.1),
]
hard_augmentations = [
A.RandomRotate90(),
A.Transpose(),
A.RandomGridShuffle(),
A.ShiftScaleRotate(scale_limit=self.scale_limit,
rotate_limit=self.rotate_limit,
border_mode=cv2.BORDER_CONSTANT,
mask_value=0,
value=0),
A.ElasticTransform(border_mode=cv2.BORDER_CONSTANT,
alpha_affine=5,
mask_value=0,
value=0),
# Add occasion blur
A.OneOf([
A.GaussianBlur(),
A.GaussNoise(),
A.IAAAdditiveGaussianNoise(),
A.NoOp()
]),
# D4 Augmentations
A.OneOf(
[A.CoarseDropout(),
A.MaskDropout(max_objects=10),
A.NoOp()]),
# Spatial-preserving augmentations:
A.OneOf([
A.RandomBrightnessContrast(brightness_by_max=True),
A.HueSaturationValue(),
A.RGBShift(),
A.RandomGamma(),
A.NoOp(),
]),
# Weather effects
A.OneOf([
A.RandomFog(fog_coef_lower=0.01, fog_coef_upper=0.3, p=0.1),
A.NoOp()
]),
]
TRANSFORMS = {
"d4": d4_tansforms,
"resize_crop": resize_crop,
"geometric": geometric,
"light": train_light,
"medium": train_medium,
"ade_valid": valid_ade,
"flip_bright": safe_augmentations,
"crop": crop,
"inria_light": light_augmentations,
"inria_medium": medium_augmentations,
"inria_hard": hard_augmentations,
"inria_valid": safe_augmentations,
}
return TRANSFORMS
def get_transforms(self):
augs = []
if self.augs_name:
augs = self.set_transforms[self.augs_name]
augs.append(
A.Resize(height=self.img_size[0],
width=self.img_size[1],
p=1.0))
if self.use_d4:
augs.append(self.set_transforms["d4"])
if self.vflip:
augs.append(A.VerticalFlip(p=0.5))
if self.hflip:
augs.append(A.HorizontalFlip(p=0.5))
if self.normalise:
augs.append(A.Normalize())
return A.Compose(augs)
A.NoOp()
]),
A.HueSaturationValue(),
])
medium_augmentations = A.Compose([
A.HorizontalFlip(),
A.ShiftScaleRotate(scale_limit=0.3,
rotate_limit=7,
border_mode=cv2.BORDER_CONSTANT),
# Add occasion blur/sharpening
A.OneOf([A.GaussianBlur(), A.IAASharpen(),
A.NoOp()]),
# Spatial-preserving augmentations:
A.OneOf([A.CoarseDropout(),
A.MaskDropout(max_objects=5),
A.NoOp()]),
A.GaussNoise(),
A.OneOf([
A.RandomBrightnessContrast(),
A.CLAHE(),
A.HueSaturationValue(),
A.RGBShift(),
A.RandomGamma()
]),
# Weather effects
A.RandomFog(fog_coef_lower=0.01, fog_coef_upper=0.3, p=0.1),
])
hard_augmentations = A.Compose([
A.RandomRotate90(),
transform=aldu.Compose([
###pixel_lvl_transform
aldu.CLAHE(p=1),
#aldu.RandomBrightnessContrast(),
aldu.ChannelDropout(),
#aldu.ISONoise() ,
#aldu.Downscale(),
#aldu.MultiplicativeNoise(),
###spatial lvl transform
aldu.RandomCrop(256,256),
aldu.HorizontalFlip(),
aldu.Rotate(),
aldu.MaskDropout(),
aldu.ElasticTransform(),
aldu.GridDistortion(),
### normalize
#aldu.Normalize()
])
dataPath="D:\\segmentation\\bacteria\\stage1_train"
Dataset=DataLoaderDifferentMasks(dataPath,"images","masks",transform)
#DataLoader=torch.utils.data.DataLoader(dataset=Dataset,shuffle =True)
for i in range(100):
input,target = Dataset[i]
A.ShiftScaleRotate(scale_limit=0.2, rotate_limit=7, border_mode=cv2.BORDER_CONSTANT),
A.IAAAffine(),
A.IAAPerspective(),
A.NoOp()
]),
A.HueSaturationValue(),
]
medium_augmentations = [
A.HorizontalFlip(),
A.ShiftScaleRotate(scale_limit=0.3, rotate_limit=7, border_mode=cv2.BORDER_CONSTANT),
# Add occasion blur/sharpening
A.OneOf([A.GaussianBlur(), A.IAASharpen(), A.NoOp()]),
# Spatial-preserving augmentations:
A.OneOf([A.CoarseDropout(), A.MaskDropout(max_objects=5), A.NoOp()]),
A.GaussNoise(),
A.OneOf([A.RandomBrightnessContrast(), A.CLAHE(), A.HueSaturationValue(), A.RGBShift(), A.RandomGamma()]),
# Weather effects
A.RandomFog(fog_coef_lower=0.01, fog_coef_upper=0.3, p=0.1),
]
hard_augmentations = [
A.RandomGridShuffle(),
A.ShiftScaleRotate(
scale_limit=0.3, rotate_limit=0, border_mode=cv2.BORDER_CONSTANT, mask_value=0, value=0
),
A.ElasticTransform(border_mode=cv2.BORDER_CONSTANT, alpha_affine=5, mask_value=0, value=0),
# Add occasion blur
A.OneOf([A.GaussianBlur(), A.GaussNoise(), A.IAAAdditiveGaussianNoise(), A.NoOp()]),
albu.RandomRotate90(p=0.5),
albu.Flip(p=0.5),
albu.ShiftScaleRotate(shift_limit=0.0, scale_limit=0.2, rotate_limit=30, p=0.4),
albu.core.composition.PerChannel(
albu.OneOf([
albu.RandomBrightnessContrast(brightness_limit=0.05, contrast_limit=0.05, p=0.25),
albu.Blur(blur_limit=3, p=.05)
]), p=1.0),
albu.Cutout(max_h_size=70),
# albu.ChannelDropout(p=0.05)
]),
"new_dropmask": albu.Compose([
albu.RandomResizedCrop(1024, 1024, (0.8, 1)),
albu.MaskDropout(max_objects=10, p=0.9),
albu.RandomRotate90(p=0.5),
albu.Flip(p=0.5),
albu.Transpose(p=0.5),
albu.ShiftScaleRotate(shift_limit=0.0, scale_limit=0.2, rotate_limit=30, p=0.4),
albu.core.composition.PerChannel(
albu.OneOf([
albu.RandomBrightnessContrast(brightness_limit=0.2, contrast_limit=0.2, p=0.25),
# albu.HueSaturationValue(hue_shift_limit=0, sat_shift_limit=0.2, val_shift_limit=0.2, p=0.25),
albu.Blur(blur_limit=3, p=.1)
]), p=1.0),
albu.Cutout(max_h_size=70),
# albu.ChannelDropout(p=0.05)
]),
"w_dropchannel": albu.Compose([
def get_augmentation(version):
if version == "v1":
return {
"train":
A.Compose([
A.Flip(p=0.5),
A.Rotate(p=0.5),
A.Resize(height=256, width=256, p=1.0),
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
"valid":
A.Compose([
A.Resize(height=256, width=256, p=1.0),
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
}
elif version == "v2":
return {
"train":
A.Compose([
A.Flip(p=0.5),
A.Rotate(p=0.5),
A.OneOf([
A.RandomCrop(height=256, width=256, p=1),
A.RandomCrop(height=384, width=384, p=1),
A.RandomCrop(height=512, width=512, p=1),
A.RandomCrop(height=640, width=640, p=1),
],
p=0.5),
A.Resize(height=256, width=256, p=1.0),
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
"valid":
A.Compose([
A.Resize(height=256, width=256, p=1.0),
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
}
elif version == "v3":
return {
"train":
A.Compose([
A.RandomCrop(height=1024, width=1024, p=1),
A.Flip(p=0.5),
A.Rotate(p=0.5),
A.Resize(height=256, width=256, p=1.0),
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
"valid":
A.Compose([
A.Resize(height=256, width=256, p=1.0),
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
}
elif version == "v4":
# for 3x-scaled dataset | 256x256
return {
"train":
A.Compose([
A.RandomCrop(height=512, width=512, p=1),
A.Flip(p=0.5),
A.Rotate(p=0.5),
A.Resize(height=256, width=256, p=1.0),
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
"valid":
A.Compose([
A.Resize(height=256, width=256, p=1.0),
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
}
elif version == "v5":
# for 3x-scaled dataset | 512x512
return {
"train":
A.Compose([
A.RandomCrop(height=512, width=512, p=1),
A.Flip(p=0.5),
A.Rotate(p=0.5),
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
"valid":
A.Compose([
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
}
elif version == "v6":
# for 3x-scaled dataset | 512x512
return {
"train":
A.Compose([
A.Flip(p=0.5),
A.Rotate(p=0.5),
A.HueSaturationValue(hue_shift_limit=20,
sat_shift_limit=30,
val_shift_limit=20,
always_apply=False,
p=0.25),
A.RandomBrightness(limit=0.4, always_apply=False, p=0.25),
A.RandomContrast(limit=0.2, always_apply=False, p=0.25),
A.RandomShadow(shadow_roi=(0, 0, 1, 1),
num_shadows_lower=1,
num_shadows_upper=50,
shadow_dimension=5,
always_apply=False,
p=0.25),
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
"valid":
A.Compose([
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
}
elif version == "v7":
# for 3x-scaled dataset | 512x512
return {
"train":
A.Compose([
A.Flip(p=0.5),
A.Rotate(p=0.5),
A.RandomCrop(height=768, width=768, p=1),
A.Resize(height=256, width=256, p=1.0),
A.HueSaturationValue(hue_shift_limit=20,
sat_shift_limit=30,
val_shift_limit=20,
always_apply=False,
p=0.25),
A.RandomBrightness(limit=0.4, always_apply=False, p=0.25),
A.RandomContrast(limit=0.2, always_apply=False, p=0.25),
A.RandomShadow(shadow_roi=(0, 0, 1, 1),
num_shadows_lower=1,
num_shadows_upper=50,
shadow_dimension=5,
always_apply=False,
p=0.25),
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
"valid":
A.Compose([
A.Resize(height=256, width=256, p=1.0),
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
}
elif version == "v8":
# for 3x-scaled dataset | 512x512
return {
"train":
A.Compose([
A.Rotate(p=0.5),
A.RandomCrop(height=512, width=512, p=1),
A.Flip(p=0.5),
# color
A.HueSaturationValue(hue_shift_limit=20,
sat_shift_limit=30,
val_shift_limit=20,
always_apply=False,
p=0.25),
A.RandomBrightness(limit=0.4, always_apply=False, p=0.25),
A.RandomContrast(limit=0.2, always_apply=False, p=0.25),
A.RandomShadow(shadow_roi=(0, 0, 1, 1),
num_shadows_lower=1,
num_shadows_upper=50,
shadow_dimension=5,
always_apply=False,
p=0.25),
# transform
A.ElasticTransform(p=1, alpha=120, sigma=6, alpha_affine=0.25),
A.GridDistortion(p=0.25),
A.OpticalDistortion(distort_limit=2, shift_limit=0.5, p=0.25),
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
"valid":
A.Compose([
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
}
elif version == "v9":
# for 3x-scaled dataset | 512x512
return {
"train":
A.Compose([
A.Flip(p=0.5),
A.Rotate(p=0.5),
A.HueSaturationValue(hue_shift_limit=20,
sat_shift_limit=30,
val_shift_limit=20,
always_apply=False,
p=0.25),
A.RandomBrightness(limit=0.4, always_apply=False, p=0.25),
A.RandomContrast(limit=0.2, always_apply=False, p=0.25),
A.RandomShadow(shadow_roi=(0, 0, 1, 1),
num_shadows_lower=1,
num_shadows_upper=50,
shadow_dimension=5,
always_apply=False,
p=0.25),
# transform
A.OneOf([
A.ElasticTransform(
alpha=120, sigma=6, alpha_affine=0.25, p=0.25),
A.GridDistortion(p=0.25),
A.OpticalDistortion(
distort_limit=2, shift_limit=0.5, p=0.25)
],
p=0.75),
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
"valid":
A.Compose([
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
}
elif version == "v10":
# for 3x-scaled dataset | 512x512
return {
"train":
A.Compose([
A.Flip(p=0.5),
A.Rotate(p=0.5),
# size
A.OneOf([
A.CropNonEmptyMaskIfExists(height=128, width=128, p=1.0),
A.CropNonEmptyMaskIfExists(height=256, width=256, p=1.0),
A.CropNonEmptyMaskIfExists(height=384, width=384, p=1.0)
],
p=0.25),
A.PadIfNeeded(min_height=512,
min_width=512,
border_mode=4,
p=1),
# array shuffle
A.OneOf([A.MaskDropout(p=1),
A.RandomGridShuffle(p=1)], p=0.5),
# quality
A.Downscale(scale_min=0.25,
scale_max=0.75,
interpolation=0,
always_apply=False,
p=0.5),
A.GaussNoise(p=0.5),
A.OneOf([
A.GlassBlur(p=1),
A.GaussianBlur(p=1),
], p=0.5),
# colors
A.HueSaturationValue(hue_shift_limit=20,
sat_shift_limit=30,
val_shift_limit=20,
always_apply=False,
p=0.5),
A.RandomBrightness(limit=0.4, always_apply=False, p=0.5),
A.RandomContrast(limit=0.2, always_apply=False, p=0.5),
A.RandomShadow(shadow_roi=(0, 0, 1, 1),
num_shadows_lower=1,
num_shadows_upper=50,
shadow_dimension=5,
always_apply=False,
p=0.5),
A.CLAHE(p=0.5),
A.Equalize(p=0.5),
A.ChannelShuffle(p=0.5),
# transform
A.OneOf([
A.ElasticTransform(
alpha=120, sigma=6, alpha_affine=0.25, p=1),
A.GridDistortion(p=1),
A.OpticalDistortion(distort_limit=2, shift_limit=0.5, p=1)
],
p=0.5),
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
"valid":
A.Compose([
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
}
elif version == "v11":
# custom normalization (see other/img_normalization.py)
return {
"train":
A.Compose([
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
"valid":
A.Compose([
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
}
elif version == "v12":
# for 3x-scaled dataset | 512x512
return {
"train":
A.Compose([
A.Flip(p=0.5),
A.Rotate(p=0.5),
# size / quality
A.OneOf([
A.CropNonEmptyMaskIfExists(height=128, width=128, p=1.0),
A.CropNonEmptyMaskIfExists(height=256, width=256, p=1.0),
A.CropNonEmptyMaskIfExists(height=384, width=384, p=1.0),
A.Downscale(scale_min=0.25,
scale_max=0.75,
interpolation=0,
always_apply=False,
p=1.0),
],
p=0.25),
A.PadIfNeeded(min_height=512,
min_width=512,
border_mode=4,
p=1),
# array shuffle
A.OneOf([A.MaskDropout(p=1),
A.RandomGridShuffle(p=1)], p=0.15),
# noise
A.OneOf([
A.GaussNoise(p=1),
A.GlassBlur(p=1),
A.GaussianBlur(p=1),
],
p=0.15),
# colors
A.HueSaturationValue(hue_shift_limit=20,
sat_shift_limit=30,
val_shift_limit=20,
always_apply=False,
p=0.15),
A.RandomBrightness(limit=0.4, always_apply=False, p=0.15),
A.RandomContrast(limit=0.2, always_apply=False, p=0.15),
A.RandomShadow(shadow_roi=(0, 0, 1, 1),
num_shadows_lower=1,
num_shadows_upper=50,
shadow_dimension=5,
always_apply=False,
p=0.15),
A.OneOf([
A.CLAHE(p=1),
A.Equalize(p=1),
A.ChannelShuffle(p=1),
],
p=0.15),
# transform
A.OneOf([
A.ElasticTransform(
alpha=120, sigma=6, alpha_affine=0.25, p=1),
A.GridDistortion(p=1),
A.OpticalDistortion(distort_limit=2, shift_limit=0.5, p=1)
],
p=0.15),
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
"valid":
A.Compose([
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
}
else:
raise Exception(f"Augmentation version '{version}' is UNKNOWN!")
valid_transform_3 = valid_transform_1
test_transform_3 = test_transform_1
# crop 768 and very hard augs
train_transform_4 = A.Compose([
A.ShiftScaleRotate(scale_limit=0.2,
rotate_limit=45,
border_mode=0,
value=0,
p=0.7),
A.PadIfNeeded(768, 768, border_mode=0, value=0, p=1.),
A.RandomCrop(768, 768, p=1.),
A.Flip(p=0.75),
A.Downscale(scale_min=0.5, scale_max=0.75, p=0.05),
A.MaskDropout(max_objects=3, image_fill_value=0, mask_fill_value=0, p=0.1),
# color transforms
A.OneOf(
[
A.RandomBrightnessContrast(
brightness_limit=0.3, contrast_limit=0.3, p=1),
A.RandomGamma(gamma_limit=(70, 130), p=1),
A.ChannelShuffle(p=0.2),
A.HueSaturationValue(hue_shift_limit=30,
sat_shift_limit=40,
val_shift_limit=30,
p=1),
A.RGBShift(
r_shift_limit=30, g_shift_limit=30, b_shift_limit=30, p=1),
],
