def test_transform_pipeline_serialization_with_keypoints(
seed, image, keypoints, keypoint_format, labels):
aug = A.Compose(
[
A.OneOrOther(
A.Compose([
A.RandomRotate90(),
A.OneOf([A.HorizontalFlip(p=0.5),
A.VerticalFlip(p=0.5)])
]),
A.Compose([
A.Rotate(p=0.5),
A.OneOf([A.HueSaturationValue(p=0.5),
A.RGBShift(p=0.7)],
p=1)
]),
),
A.SomeOf(
n=2,
transforms=[
A.HorizontalFlip(p=1),
A.Transpose(p=1),
A.HueSaturationValue(p=0.5),
A.RandomBrightnessContrast(p=0.5),
],
replace=False,
),
],
keypoint_params={
"format": keypoint_format,
"label_fields": ["labels"]
},
)
serialized_aug = A.to_dict(aug)
deserialized_aug = A.from_dict(serialized_aug)
set_seed(seed)
aug_data = aug(image=image, keypoints=keypoints, labels=labels)
set_seed(seed)
deserialized_aug_data = deserialized_aug(image=image,
keypoints=keypoints,
labels=labels)
assert np.array_equal(aug_data["image"], deserialized_aug_data["image"])
assert np.array_equal(aug_data["keypoints"],
deserialized_aug_data["keypoints"])
def get_augumentation(phase, width=1024, height=1024, min_area=0., min_visibility=0.):
list_transforms = []
if phase == 'train':
list_transforms.extend([
albu.augmentations.transforms.LongestMaxSize(
max_size=width, always_apply=True),
albu.PadIfNeeded(min_height=height, min_width=width,
always_apply=True, border_mode=0, value=[0, 0, 0]),
albu.augmentations.transforms.RandomResizedCrop(
height=height,
width=width, p=0.3),
albu.augmentations.transforms.Flip(),
albu.augmentations.transforms.Transpose(),
albu.OneOf([
albu.RandomBrightnessContrast(brightness_limit=0.5,
contrast_limit=0.4),
albu.RandomGamma(gamma_limit=(50, 150)),
albu.NoOp()
]),
albu.OneOf([
albu.RGBShift(r_shift_limit=20, b_shift_limit=15,
g_shift_limit=15),
albu.HueSaturationValue(hue_shift_limit=5,
sat_shift_limit=5),
albu.NoOp()
]),
albu.CLAHE(p=0.8),
albu.HorizontalFlip(p=0.5),
albu.VerticalFlip(p=0.5),
])
if(phase == 'test' or phase == 'valid'):
list_transforms.extend([
albu.Resize(height=height, width=width)
])
list_transforms.extend([
albu.Normalize(mean=(0.485, 0.456, 0.406),
std=(0.229, 0.224, 0.225), p=1),
ToTensor()
])
if(phase == 'test'):
return albu.Compose(list_transforms)
return albu.Compose(list_transforms, bbox_params=albu.BboxParams(format='pascal_voc', min_area=min_area,
min_visibility=min_visibility, label_fields=['category_id']))
def train_dataloader(self):
aug_pipeline_train = A.Compose([
A.Resize(self.hparams.image_size, self.hparams.image_size, always_apply=True, p=1.0),
A.RandomCrop(self.hparams.crop_size, self.hparams.crop_size, always_apply=True, p=1.0),
A.HorizontalFlip(p=0.5),
A.CoarseDropout(min_holes=1, max_holes=4, max_width=100, max_height=100, min_width=25, min_height=25, p=0.5),
A.ShiftScaleRotate(shift_limit=0.1, scale_limit=0.1, rotate_limit=15, border_mode=cv2.BORDER_REFLECT, p=0.5),
A.OneOf([A.HueSaturationValue(p=0.5), A.ToGray(p=0.5), A.RGBShift(p=0.5), A.RandomGamma(p=0.5)], p=0.5),
A.RandomBrightnessContrast(brightness_limit=0.2, contrast_limit=0.2, p=0.5),
A.Normalize(always_apply=True, p=1.0),
ToTensorV2(always_apply=True, p=1.0)
], p=1.0)
train_dataset = RetinaDataset(os.path.join(self.hparams.path, f'retina_labels_train.csv'), os.path.join(self.hparams.path, f'retina_data_train'),
augmentations=aug_pipeline_train, file_type='.jpg', balance_ratio=0.25)
sample_weights = [train_dataset.get_weight(i) for i in range(len(train_dataset))]
sampler = data.sampler.WeightedRandomSampler(sample_weights, len(train_dataset), replacement=True)
train_loader = data.DataLoader(train_dataset, batch_size=self.hparams.batch_size, shuffle=False, sampler=sampler, num_workers=16)
return train_loader
def get_data_transforms(self) -> Tuple[A.BasicTransform, A.BasicTransform]:
"""Get albumentations transform objects for data augmentation.
Returns:
1st tuple arg: a transform that doesn't do any data augmentation
2nd tuple arg: a transform with data augmentation
"""
cfg = self.cfg
bbox_params = self.get_bbox_params()
base_tfs = [A.Resize(cfg.data.img_sz, cfg.data.img_sz)]
if cfg.data.base_transform is not None:
base_tfs.append(A.from_dict(cfg.data.base_transform))
base_transform = A.Compose(base_tfs, bbox_params=bbox_params)
if cfg.data.aug_transform is not None:
aug_transform = A.from_dict(cfg.data.aug_transform)
aug_transform = A.Compose([aug_transform, base_transform],
bbox_params=bbox_params)
return base_transform, aug_transform
augmentors_dict = {
'Blur': A.Blur(),
'RandomRotate90': A.RandomRotate90(),
'HorizontalFlip': A.HorizontalFlip(),
'VerticalFlip': A.VerticalFlip(),
'GaussianBlur': A.GaussianBlur(),
'GaussNoise': A.GaussNoise(),
'RGBShift': A.RGBShift(),
'ToGray': A.ToGray()
}
aug_transforms = []
for augmentor in cfg.data.augmentors:
try:
aug_transforms.append(augmentors_dict[augmentor])
except KeyError as e:
log.warning(
'{0} is an unknown augmentor. Continuing without {0}. \
Known augmentors are: {1}'.format(
e, list(augmentors_dict.keys())))
aug_transforms.append(base_transform)
aug_transform = A.Compose(aug_transforms, bbox_params=bbox_params)
return base_transform, aug_transform
def color_transforms(p=0.5):
"""
Applies RandomGamma or RandomBrightnessContrast random with a probability p.
Args:
p (float, optional): probability. Defaults to 0.5.
Returns:
albumentation transforms: transforms.
"""
return albu.OneOf(
[
albu.Compose([
albu.RandomGamma(gamma_limit=(80, 120), p=1),
albu.RandomBrightnessContrast(
brightness_limit=0.1, # 0.3
contrast_limit=0.1, # 0.3
p=1,
),
]),
albu.RGBShift(
r_shift_limit=30,
g_shift_limit=0,
b_shift_limit=30,
p=1,
),
albu.HueSaturationValue(
hue_shift_limit=30,
sat_shift_limit=30,
val_shift_limit=30,
p=1,
),
albu.ColorJitter(
brightness=0.3, # 0.3
contrast=0.3, # 0.3
saturation=0.3,
hue=0.05,
p=1,
),
],
p=p,
)
def test_transform_pipeline_serialization_with_bboxes(seed, image, bboxes, bbox_format, labels):
aug = A.Compose(
[
A.OneOrOther(
A.Compose([A.RandomRotate90(), A.OneOf([A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5)]),]),
A.Compose([A.Rotate(p=0.5), A.OneOf([A.HueSaturationValue(p=0.5), A.RGBShift(p=0.7)], p=1),]),
),
A.HorizontalFlip(p=1),
A.RandomBrightnessContrast(p=0.5),
],
bbox_params={"format": bbox_format, "label_fields": ["labels"]},
)
serialized_aug = A.to_dict(aug)
deserialized_aug = A.from_dict(serialized_aug)
set_seed(seed)
aug_data = aug(image=image, bboxes=bboxes, labels=labels)
set_seed(seed)
deserialized_aug_data = deserialized_aug(image=image, bboxes=bboxes, labels=labels)
assert np.array_equal(aug_data["image"], deserialized_aug_data["image"])
assert np.array_equal(aug_data["bboxes"], deserialized_aug_data["bboxes"])
def __init__(self,
Normalize_mean_std=None,
Rotate=None,
HorizontalFlip=False,
RGBshift=None,
cutout=None):
self.transforms = []
if Rotate is not None:
self.transforms.append(A.Rotate(Rotate))
if HorizontalFlip:
self.transforms.append(A.HorizontalFlip())
if RGBshift is not None:
self.transforms.append(A.RGBShift(*RGBshift))
if Normalize_mean_std is not None:
self.transforms.append(
A.Normalize(Normalize_mean_std[0], Normalize_mean_std[1]))
if cutout is not None:
self.transforms.append(A.Cutout(*cutout))
self.transforms.append(ToTensor())
self.Transforms = A.Compose(self.transforms)
def test_transform_pipeline_serialization(seed, image, mask):
aug = A.Compose([
A.OneOrOther(
A.Compose([
A.Resize(1024, 1024),
A.RandomSizedCrop(min_max_height=(256, 1024),
height=512,
width=512,
p=1),
A.OneOf([
A.RandomSizedCrop(min_max_height=(256, 512),
height=384,
width=384,
p=0.5),
A.RandomSizedCrop(min_max_height=(256, 512),
height=512,
width=512,
p=0.5),
]),
]),
A.Compose([
A.Resize(1024, 1024),
A.RandomSizedCrop(min_max_height=(256, 1025),
height=256,
width=256,
p=1),
A.OneOf([A.HueSaturationValue(p=0.5),
A.RGBShift(p=0.7)], p=1),
]),
),
A.HorizontalFlip(p=1),
A.RandomBrightnessContrast(p=0.5),
])
serialized_aug = A.to_dict(aug)
deserialized_aug = A.from_dict(serialized_aug)
set_seed(seed)
aug_data = aug(image=image, mask=mask)
set_seed(seed)
deserialized_aug_data = deserialized_aug(image=image, mask=mask)
assert np.array_equal(aug_data["image"], deserialized_aug_data["image"])
assert np.array_equal(aug_data["mask"], deserialized_aug_data["mask"])
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 __init__(self, img, data, img_size):
"""
arguments
---------
img : list
list of images, in the original size (height, width, 3)
data : list of dict
Each dict has :
'image' : index of the image. The index should match with img
'mask' : [xx, yy]
IMPORTANT : (WIDTH, HEIGHT)
'box' : [[xmin, ymin], [xmax,ymax]]
'size' : the size of the image that the data was created with
IMPORTANT : (WIDTH, HEIGHT)
img_size : tuple
Desired output image size
The axes will be swapped to match pygame.
IMPORTANT : (WIDTH, HEIGHT)
"""
self.image = img
self.data = data
self.n = len(data)
self.output_size = img_size
self.aug = A.Compose([
A.OneOf([
A.RandomGamma((40, 200), p=1),
A.RandomBrightness(limit=0.5, p=1),
A.RandomContrast(limit=0.5, p=1),
A.RGBShift(40, 40, 40, p=1),
A.Downscale(scale_min=0.25, scale_max=0.5, p=1),
A.ChannelShuffle(p=1),
],
p=0.8),
A.InvertImg(p=0.5),
A.VerticalFlip(p=0.5),
A.RandomRotate90(p=1),
A.Resize(img_size[0], img_size[1]),
], )
for datum in data:
datum['mask_min'] = np.min(datum['mask'], axis=1)
datum['mask_max'] = np.max(datum['mask'], axis=1) + 1
def _random_crop_and_enhance(self, sample):
offset = int(self.crop_size / 10)
compose = A.Compose([
A.PadIfNeeded(self.crop_size + offset, self.crop_size + offset),
A.RandomSizedCrop(
(self.crop_size - offset + 10, self.crop_size + offset - 10),
self.crop_size,
self.crop_size,
p=1),
A.HorizontalFlip(p=0.5),
A.VerticalFlip(p=0.5),
A.RGBShift(),
A.Blur(),
A.GaussNoise(),
A.Normalize(mean=self.mean, std=self.std, p=1)
],
additional_targets={
'image': 'image',
'label': 'mask'
})
return compose(**sample)
def setup(self, stage: str):
img_files = get_img_files()
folds = KFold(
n_splits=self.hp.n_splits,
random_state=self.hp.seed,
shuffle=True,
)
train_idx, val_idx = list(folds.split(img_files))[self.hp.fold]
self.train_dataset = MaskDataset(
img_files[train_idx],
transform=A.Compose([
A.RandomResizedCrop(
self.hp.img_size,
self.hp.img_size,
),
A.Rotate(13),
A.HorizontalFlip(),
A.RandomBrightnessContrast(),
A.HueSaturationValue(),
A.RGBShift(),
A.RandomGamma(),
MyCoarseDropout(
min_holes=1,
max_holes=8,
max_height=32,
max_width=32,
),
]),
)
self.val_dataset = MaskDataset(
img_files[val_idx],
transform=A.Compose([
A.Resize(
self.hp.img_size,
self.hp.img_size,
),
]),
)
def albumentations_list(MAGN: int = 4):
"""
Returns standard list of albumentations transforms, each of mangitude `MAGN`.
Args:
MAGN (int): Magnitude of each transform in the returned list.
"""
M = MAGN
transform_list = [
# PIXEL-LEVEL
A.RandomContrast(limit=M * .1, always_apply=True),
A.RandomBrightness(limit=M * .1, always_apply=True),
A.Equalize(always_apply=True),
A.OpticalDistortion(distort_limit=M * .2,
shift_limit=M * .1,
always_apply=True),
A.RGBShift(r_shift_limit=M * 10,
g_shift_limit=M * 10,
b_shift_limit=M * 10,
always_apply=True),
A.ISONoise(color_shift=(M * .01, M * .1),
intensity=(M * .02, M * .2),
always_apply=True),
A.RandomFog(fog_coef_lower=M * .01,
fog_coef_upper=M * .1,
always_apply=True),
A.CoarseDropout(max_holes=M * 10, always_apply=True),
A.GaussNoise(var_limit=(M, M * 50), always_apply=True),
# SPATIAL
A.Rotate(always_apply=True),
A.Transpose(always_apply=True),
A.NoOp(always_apply=True),
A.ElasticTransform(alpha=M * .25,
sigma=M * 3,
alpha_affine=M * 3,
always_apply=True),
A.GridDistortion(distort_limit=M * .075, always_apply=True)
]
return transform_list
def _aug_image(self, instance):
image_name = instance['filename']
image = cv2.imread(image_name) # RGB image
if image is None:
print('Cannot find ', image_name)
image = image[:, :, ::-1] # RGB image
image_h, image_w, _ = image.shape
image, new_w, new_h = minmaxresize(image, self.min_net_size,
self.max_net_size)
# determine the amount of scaling and cropping
dw = image_w - (self.jitter * image_w)
dh = image_h - (self.jitter * image_h)
all_objs = correct_bounding_boxes(instance['object'], new_w, new_h,
new_w, new_h, 0, 0, 0, image_w,
image_h)
# alabumentation setup
annotations = {'image': image, 'bboxes': [], 'category_id': []}
for ann in all_objs:
annotations['category_id'].append(
self.names_to_labels[ann['name']])
annotations['bboxes'].append(
[ann['xmin'], ann['ymin'], ann['xmax'], ann['ymax']])
aug = albumentations.Compose(
[
albumentations.RGBShift(),
albumentations.HorizontalFlip(),
# albumentations.ShiftScaleRotate(scale_limit=1.),
albumentations.CLAHE(),
albumentations.RandomGamma(),
],
bbox_params={
'format': 'pascal_voc',
'label_fields': ['category_id']
})
augmented = aug(**annotations)
return augmented
def get_medium_augmentations(image_size):
return A.Compose([
A.OneOf([
A.ShiftScaleRotate(shift_limit=0.05,
scale_limit=0.1,
rotate_limit=15,
border_mode=cv2.BORDER_CONSTANT,
value=0),
A.OpticalDistortion(distort_limit=0.11,
shift_limit=0.15,
border_mode=cv2.BORDER_CONSTANT,
value=0),
A.NoOp()
]),
ZeroTopAndBottom(p=0.3),
A.RandomSizedCrop(min_max_height=(int(image_size[0] * 0.75),
image_size[0]),
height=image_size[0],
width=image_size[1],
p=0.3),
A.OneOf([
A.RandomBrightnessContrast(brightness_limit=0.5,
contrast_limit=0.4),
IndependentRandomBrightnessContrast(brightness_limit=0.25,
contrast_limit=0.24),
A.RandomGamma(gamma_limit=(50, 150)),
A.NoOp()
]),
A.OneOf([
FancyPCA(alpha_std=4),
A.RGBShift(r_shift_limit=20, b_shift_limit=15, g_shift_limit=15),
A.HueSaturationValue(hue_shift_limit=5, sat_shift_limit=5),
A.NoOp()
]),
A.OneOf([ChannelIndependentCLAHE(p=0.5),
A.CLAHE(),
A.NoOp()]),
A.HorizontalFlip(p=0.5),
A.VerticalFlip(p=0.5)
])
def get_transforms(size: int, scope: str = 'geometric', crop='random'):
augs = {'strong': albu.Compose([albu.HorizontalFlip(),
albu.ShiftScaleRotate(shift_limit=0.0, scale_limit=0.2, rotate_limit=20, p=.4),
albu.ElasticTransform(),
albu.OpticalDistortion(),
albu.OneOf([
albu.CLAHE(clip_limit=2),
albu.IAASharpen(),
albu.IAAEmboss(),
albu.RandomBrightnessContrast(),
albu.RandomGamma()
], p=0.5),
albu.OneOf([
albu.RGBShift(),
albu.HueSaturationValue(),
], p=0.5),
]),
'weak': albu.Compose([albu.HorizontalFlip(),
]),
'geometric': albu.OneOf([albu.HorizontalFlip(always_apply=True),
albu.ShiftScaleRotate(always_apply=True, scale_limit=.5, rotate_limit=30),
albu.Transpose(always_apply=True),
albu.OpticalDistortion(always_apply=True, distort_limit=0.1, shift_limit=0.1),
albu.ElasticTransform(always_apply=True),
]),
'empty': NoOp(),
}
aug_fn = augs[scope]
crop_fn = {'random': albu.RandomCrop(size, size, always_apply=True),
'center': albu.CenterCrop(size, size, always_apply=True)}[crop]
pad = albu.PadIfNeeded(size, size)
pipeline = albu.Compose([aug_fn, crop_fn, pad])
def process(a):
r = pipeline(image=a)
return r['image']
return process
def __init__(self, img, data, img_size):
"""
arguments
---------
img : list
list of images, in the original size (height, width, 3)
data : list of dict
Each dict has :
'image' : index of the image. The index should match with img
'mask' : [rr, cc]
'box' : [[xmin, ymin], [xmax,ymax]]
'size' : the size of the image that the data was created with
IMPORTANT : (WIDTH, HEIGHT)
img_size : tuple
Desired output image size
The axes will be swapped to match pygame.
IMPORTANT : (WIDTH, HEIGHT)
"""
self.img = img
self.data = data
self.n = len(data)
self.output_size = img_size
self.aug = A.Compose(
[
A.OneOf([
A.RandomGamma((40, 200), p=1),
A.RandomBrightness(limit=0.5, p=1),
A.RandomContrast(limit=0.5, p=1),
A.RGBShift(p=1),
],
p=0.8),
A.VerticalFlip(p=0.5),
A.RandomRotate90(p=1),
A.Resize(img_size[1], img_size[0]),
],
bbox_params=A.BboxParams(format='albumentations',
label_fields=['bbox_classes']),
keypoint_params=A.KeypointParams(format='xy'),
)
def __init__(self, opt):
super(Dataset3D, self).__init__()
self.opt = opt
self.augs = A.Compose([
A.LongestMaxSize(max(self.opt.input_h, self.opt.input_w), always_apply=True),
A.PadIfNeeded(self.opt.input_h, self.opt.input_w, border_mode=cv2.BORDER_CONSTANT, value=[0, 0, 0]),
A.Blur(blur_limit=(4, 8), p=0.1),
# A.ShiftScaleRotate(shift_limit=0.2, scale_limit=(-0.4, 0.2), rotate_limit=0,
# border_mode=cv2.BORDER_CONSTANT, value=(0, 0, 0), p=0.8),
A.OneOf([
A.RandomBrightnessContrast(always_apply=True),
A.RandomGamma(gamma_limit=(60, 140), always_apply=True),
# A.CLAHE(always_apply=True)
], p=0.5),
A.OneOf([
A.RGBShift(),
A.HueSaturationValue(),
A.ToGray()
], p=0.1)
],
keypoint_params=A.KeypointParams(format='xy', remove_invisible=False)
)
def blur_and_distortion(self, kernel_size=(3, 3)): # Blur & Distortion
return A.Compose(
[
A.OneOf(
[
# Blur the input image using a random-sized kernel.
A.Blur(blur_limit=kernel_size, p=self.p),
# Apply motion blur to the input image using a random-sized kernel.
A.MotionBlur(blur_limit=kernel_size, p=self.p),
# Blur the input image using using a median filter with a random aperture linear size.
A.MedianBlur(blur_limit=kernel_size, p=self.p),
# Blur the input image using using a Gaussian filter with a random kernel size.
A.GaussianBlur(blur_limit=kernel_size, p=self.p)
],
p=1),
A.OneOf(
[
A.RandomGamma(gamma_limit=(80, 120), p=self.p),
A.OpticalDistortion(
distort_limit=0.05, shift_limit=0.05, p=self.p),
A.ElasticTransform(p=self.p),
# Randomly change hue, saturation and value of the input image.
A.HueSaturationValue(p=self.p),
# Randomly shift values for each channel of the input RGB image.
A.RGBShift(p=self.p),
# Randomly rearrange channels of the input RGB image.
# A.ChannelShuffle(p=self.p),
# Apply Contrast Limited Adaptive Histogram Equalization to the input image.
A.CLAHE(p=self.p),
# Invert the input image by subtracting pixel values from 255.
A.InvertImg(p=self.p),
],
p=1),
# Apply gaussian noise to the input image.
A.GaussNoise(var_limit=(10.0, 50.0), mean=0, p=self.p),
# Simulates shadows for the image
A.RandomShadow(p=self.p),
],
p=1)
def augment_image(self, image, annotations):
annotation = {
'image': image,
'bboxes': annotations[:, :4],
'category_id': annotations[:, 4]
}
aug = self.get_aug([
A.VerticalFlip(),
A.HorizontalFlip(),
A.RGBShift(),
A.Blur(),
A.GaussNoise(),
])
augmented = aug(**annotation)
image = augmented['image']
annotations[:, :4] = augmented['bboxes']
annotations[:, 4] = augmented['category_id']
return image, annotations
def _aug(config):
global _augmentor
if _augmentor is None:
_augmentor = A.Compose(
[
A.VerticalFlip(p=0.4),
A.RandomSizedBBoxSafeCrop(width=config.IMAGE_WIDTH,
height=config.IMAGE_HEIGHT,
erosion_rate=0.0,
p=0.4),
A.RGBShift(p=0.4),
A.Blur(blur_limit=7, p=0.4),
A.RandomBrightness(p=0.4),
],
bbox_params={
'format': 'coco',
'min_area': 0,
'min_visibility': 0,
'label_fields': ['labels']
},
p=0.4)
return _augmentor
def main():
image = cv2.imread("cuiyan.png")
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
def visualize(image):
plt.figure(figsize=(6, 6))
plt.axis("off")
plt.imshow(image)
# plt.show()
transform = A.Compose([
A.RandomCrop(111, 222),
A.OneOf([A.RGBShift(), A.HueSaturationValue()]),
])
random.seed(42)
transformed = transform(image=image)
visualize(transformed["image"])
A.save(transform, "./transform.json")
A.save(transform, "./transform.yml", data_format="yaml")
pprint.pprint(A.to_dict(transform))
def get_data(data_dir,
voc_type,
max_len,
num_samples,
height,
width,
batch_size,
workers,
is_train,
keep_ratio,
augment=False):
transform = albu.Compose([
albu.RGBShift(p=0.5),
albu.RandomBrightnessContrast(p=0.5),
albu.OpticalDistortion(distort_limit=0.1, shift_limit=0.1, p=0.5)
]) if augment else None
if isinstance(data_dir, list):
dataset = ConcatDataset([
LmdbDataset(data_dir_, voc_type, max_len, num_samples, transform)
for data_dir_ in data_dir
])
else:
dataset = LmdbDataset(data_dir, voc_type, max_len, num_samples,
transform)
print('total image: ', len(dataset))
data_loader = DataLoader(dataset,
batch_size=batch_size,
num_workers=workers,
shuffle=is_train,
pin_memory=True,
drop_last=is_train,
collate_fn=AlignCollate(imgH=height,
imgW=width,
keep_ratio=keep_ratio))
return dataset, data_loader
def __init__(self):
self.img_transforms = A.Compose(
[
A.Resize(224, 224), A.RGBShift(), A.HorizontalFlip(p=0.5),
A.VerticalFlip(p=0.2), A.ChannelShuffle(0.2), A.ColorJitter(p=0.5),
A.Cutout(num_holes=3, max_h_size=24, max_w_size=24,
fill_value=0, always_apply=False, p=0.5),
A.ShiftScaleRotate(scale_limit=0.5, rotate_limit=0, shift_limit=0.1, p=1, border_mode=0),
A.PadIfNeeded(min_height=224, min_width=224, always_apply=True, border_mode=0),
A.IAAAdditiveGaussianNoise(p=0.2),
A.IAAPerspective(p=0.5),
A.RandomBrightnessContrast(p=0.5),
A.OneOf(
[
A.CLAHE(p=1),
A.RandomBrightness(p=1),
A.RandomGamma(p=1),
],
p=0.9,
),
A.OneOf(
[
A.IAASharpen(p=1),
A.Blur(blur_limit=3, p=1),
A.MotionBlur(blur_limit=3, p=1),
],
p=0.9,
),
A.OneOf(
[
A.RandomContrast(p=1),
A.HueSaturationValue(p=1),
],
p=0.9,
),
A.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)),
ToTensorV2(),
])
def test_force_apply():
"""
Unit test for https://github.com/albu/albumentations/issues/189
"""
aug = A.Compose([
A.OneOrOther(
A.Compose([
A.RandomSizedCrop(min_max_height=(256, 1025),
height=512,
width=512,
p=1),
A.OneOf([
A.RandomSizedCrop(min_max_height=(256, 512),
height=384,
width=384,
p=0.5),
A.RandomSizedCrop(min_max_height=(256, 512),
height=512,
width=512,
p=0.5),
]),
]),
A.Compose([
A.RandomSizedCrop(min_max_height=(256, 1025),
height=256,
width=256,
p=1),
A.OneOf([A.HueSaturationValue(p=0.5),
A.RGBShift(p=0.7)], p=1),
]),
),
A.HorizontalFlip(p=1),
A.RandomBrightnessContrast(p=0.5),
])
res = aug(image=np.zeros((1248, 1248, 3), dtype=np.uint8))
assert res["image"].shape[0] in (256, 384, 512)
assert res["image"].shape[1] in (256, 384, 512)
def get_training_pipeline(image_size, crop_size, strength=0):
if strength == 0:
return A.Compose([
A.Resize(image_size, image_size, always_apply=True, p=1.0),
A.RandomCrop(crop_size, crop_size, always_apply=True, p=1.0),
A.HorizontalFlip(p=0.5),
A.CoarseDropout(min_holes=1,
max_holes=3,
max_width=75,
max_height=75,
min_width=25,
min_height=25,
p=0.3),
A.ShiftScaleRotate(shift_limit=0.1,
scale_limit=0.3,
rotate_limit=45,
border_mode=cv2.BORDER_CONSTANT,
value=0,
p=0.5),
A.OneOf([
A.HueSaturationValue(p=0.5),
A.ToGray(p=0.5),
A.RGBShift(p=0.5)
],
p=0.3),
A.OneOf([
A.RandomBrightnessContrast(brightness_limit=0.1,
contrast_limit=0.2),
A.RandomGamma()
],
p=0.5),
A.Normalize(always_apply=True, p=1.0),
ToTensorV2(always_apply=True, p=1.0)
],
p=1.0)
else:
return None
def get_albumentations_train_transforms():
return A.Compose(
[
A.RandomSizedCrop(
min_max_height=(600, 800), height=1024, width=1024, p=0.5),
A.OneOf([
A.HueSaturationValue(hue_shift_limit=20,
sat_shift_limit=30,
val_shift_limit=20,
p=1.0),
A.RandomBrightnessContrast(
brightness_limit=0.2, contrast_limit=0.2, p=1.0),
],
p=0.8),
A.OneOf(
[
A.RGBShift(p=1.0),
A.CLAHE(p=1.0), # internal logic is rgb order
A.RandomGamma(p=1.0),
],
p=0.4),
# A.CLAHE(p=0.3),
A.ToGray(p=0.01),
A.HorizontalFlip(p=0.5),
A.VerticalFlip(p=0.5),
A.RandomRotate90(p=0.5),
A.Cutout(num_holes=8,
max_h_size=64,
max_w_size=64,
fill_value=(124, 117, 104),
p=0.5), # rgb order
],
p=1.0,
bbox_params=A.BboxParams(format='coco',
min_area=4,
min_visibility=0.01,
label_fields=['category_id']))
def make_augmentation(output_size, is_validation):
aug = None
if is_validation:
aug = get_aug([
A.Resize(width=output_size[0],
height=output_size[1],
always_apply=True),
A.Normalize(),
],
min_visibility=0.1)
else:
aug = get_aug([
A.RGBShift(p=0.1),
A.OneOf([
A.RandomBrightnessContrast(p=0.5),
A.HueSaturationValue(),
A.RandomGamma(p=0.25),
A.RandomBrightness(p=0.25),
A.Blur(blur_limit=2, p=0.25),
],
p=0.01),
A.HorizontalFlip(p=0.5),
A.VerticalFlip(p=0.05),
A.ShiftScaleRotate(shift_limit=0.1,
scale_limit=0.05,
rotate_limit=15,
border_mode=0,
p=0.2,
value=(144.75479165, 137.70713403, 129.666091),
mask_value=0.0),
A.Resize(width=output_size[0],
height=output_size[1],
always_apply=True),
A.Normalize(),
],
min_visibility=0.1)
return aug
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 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),
]
