def augmentations_factory(hparams: str): mean, std = 0.485, 0.229 # TODO: find more elegant way to do this try: input_image_sz = int(hparams.train_data.name.split("_")[1]) except AttributeError: input_image_sz = int(hparams.test_data.name.split("_")[1]) if hparams.aug == "baseline": train_augmentation = albumentations.Compose( [ albumentations.CLAHE(p=1), albumentations.HorizontalFlip(p=0.25), albumentations.RandomBrightnessContrast( brightness_limit=0.1, contrast_limit=0.1, p=0.5 ), albumentations.OneOf( [ albumentations.OpticalDistortion(), albumentations.ElasticTransform(), ], p=0.25, ), albumentations.Cutout( num_holes=8, max_h_size=int(hparams.sz * 0.1), max_w_size=int(hparams.sz * 0.1), p=0.25, ), albumentations.ShiftScaleRotate( shift_limit=0.0625, scale_limit=0.0, rotate_limit=10, p=0.8 ), albumentations.RandomCrop( int(input_image_sz * 0.9), int(input_image_sz * 0.9), p=1 ), albumentations.Resize(height=hparams.sz, width=hparams.sz), albumentations.Normalize( mean, std, max_pixel_value=255.0, always_apply=True ), transforms.ToTensorV2(), ] ) valid_augmentation = albumentations.Compose( [ albumentations.CLAHE(p=1), albumentations.CenterCrop( int(input_image_sz * 0.9), int(input_image_sz * 0.9) ), albumentations.Resize(height=hparams.sz, width=hparams.sz), albumentations.Normalize( mean, std, max_pixel_value=255.0, always_apply=True ), transforms.ToTensorV2(), ] ) test_augmentation = valid_augmentation return train_augmentation, valid_augmentation, test_augmentation raise ValueError("Augmentation config not recognized")
def get_aug(name='default', input_shape=[48, 48, 3]): if name == 'default': augmentations = A.Compose([ A.RandomBrightnessContrast(p=0.4), A.RandomGamma(p=0.4), A.HueSaturationValue(hue_shift_limit=20, sat_shift_limit=30, val_shift_limit=30, p=0.4), A.CLAHE(p=0.4), A.Blur(blur_limit=1, p=0.3), A.GaussNoise(var_limit=(50, 80), p=0.3) ], p=1) elif name == 'plates': augmentations = A.Compose([ A.RandomBrightnessContrast(p=0.4), A.RandomGamma(p=0.4), A.HueSaturationValue(hue_shift_limit=20, sat_shift_limit=30, val_shift_limit=30, p=0.4), A.CLAHE(p=0.4), A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5), A.Blur(blur_limit=1, p=0.3), A.GaussNoise(var_limit=(50, 80), p=0.3), A.RandomCrop(p=0.8, height=2*input_shape[1]/3, width=2*input_shape[0]/3) ], p=1) elif name == 'deepfake': augmentations = A.Compose([ A.HorizontalFlip(p=0.5), ], p=1) elif name == 'plates2': augmentations = A.Compose([ A.CLAHE(clip_limit=(1,4),p=0.3), A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5), A.RandomBrightness(limit=0.2, p=0.3), A.RandomContrast(limit=0.2, p=0.3), # A.Rotate(limit=360, p=0.9), A.RandomRotate90(p=0.3), A.HueSaturationValue(hue_shift_limit=(-50,50), sat_shift_limit=(-15,15), val_shift_limit=(-15,15), p=0.5), # A.Blur(blur_limit=(5,7), p=0.3), A.GaussNoise(var_limit=(10, 50), p=0.3), A.CenterCrop(p=1, height=2*input_shape[1]//3, width=2*input_shape[0]//3), A.Resize(p=1, height=input_shape[1], width=input_shape[0]) ], p=1) else: augmentations = None return augmentations
def get_next_augmentation(): train_transform = [ albu.ChannelShuffle(p=0.1), albu.IAAAdditiveGaussianNoise(p=0.2), albu.OneOf( [ albu.CLAHE(p=1), albu.RandomBrightness(p=1), albu.RandomGamma(p=1), ], p=0.9, ), albu.OneOf( [ albu.IAASharpen(p=1), albu.Blur(blur_limit=3, p=1), albu.MotionBlur(blur_limit=3, p=1), ], p=0.9, ), albu.OneOf( [ albu.RandomContrast(p=1), albu.HueSaturationValue(p=1), ], p=0.9, ), ] return albu.Compose(train_transform)
def __init__(self, dataset_dir, names, mode='train', image_size=512): # Get image and mask pair names self.dataset_dir = dataset_dir self.names = [ name for name in names if name.endswith(('.jpg', '.JPG', '.png')) ] # Get class values self.classes_dict = { 'egg': 128, 'pan': 255, } # Misc info self.image_size = image_size self.mode = mode assert mode in ('train', 'val', 'test'), 'Mode is unknown: {}'.format(mode) # Initialize augmentations self.augs = albu.Compose([ albu.HorizontalFlip(p=0.5), albu.VerticalFlip(p=0.5), albu.RandomRotate90(p=0.5), albu.CLAHE(p=0.5), albu.RandomBrightnessContrast(p=0.5), albu.RandomGamma(p=0.5) ])
def get_train_transform(): crop_height = 256 crop_width = 256 return albu.Compose([ albu.PadIfNeeded(min_height=crop_height, min_width=crop_width, p=1), albu.RandomSizedCrop((int(0.3 * crop_height), 288), crop_height, crop_width, p=1), albu.HorizontalFlip(p=0.5), albu.OneOf([ albu.IAAAdditiveGaussianNoise(p=0.5), albu.GaussNoise(p=0.5), ], p=0.2), albu.OneOf([ albu.MotionBlur(p=0.2), albu.MedianBlur(blur_limit=3, p=0.1), albu.Blur(blur_limit=3, p=0.1), ], p=0.2), albu.ShiftScaleRotate(shift_limit=0.0625, scale_limit=0, rotate_limit=20, p=0.1), albu.OneOf([ albu.OpticalDistortion(p=0.3), albu.GridDistortion(p=0.1), albu.IAAPiecewiseAffine(p=0.3), ], p=0.2), albu.OneOf([ albu.CLAHE(clip_limit=2, p=0.5), albu.IAASharpen(p=0.5), albu.IAAEmboss(p=0.5), albu.RandomBrightnessContrast(p=0.5), ], p=0.3), albu.HueSaturationValue(p=0.3), albu.JpegCompression(p=0.2, quality_lower=20, quality_upper=99), albu.ElasticTransform(p=0.1), albu.Normalize(p=1) ], p=1)
def test_dataloader(self): """Summary Returns: TYPE: Description """ ds_test = MultiLabelDataset(folder=self.hparams.data_path, is_train='test', fname='test.csv', types=self.hparams.types, pathology=self.hparams.pathology, resize=int(self.hparams.shape)) ds_test.reset_state() ag_test = [ imgaug.Albumentations( AB.SmallestMaxSize(self.hparams.shape, p=1.0)), iimgaug.ColorSpace(mode=cv2.COLOR_GRAY2RGB), imgaug.Albumentations(AB.CLAHE(p=1)), imgaug.ToFloat32(), ] ds_test = AugmentImageComponent(ds_test, ag_test, 0) ds_test = BatchData(ds_test, self.hparams.batch, remainder=True) # ds_test = MultiProcessRunner(ds_test, num_proc=4, num_prefetch=16) ds_test = PrintData(ds_test) ds_test = MapData(ds_test, lambda dp: [torch.tensor(np.transpose(dp[0], (0, 3, 1, 2))), torch.tensor(dp[1]).float()]) return ds_test
def get_medium_augmentations(image_size): min_size = min(image_size[0], image_size[1]) return A.Compose([ A.OneOf([A.RandomSizedCrop(min_max_height=(int(min_size* 0.85), min_size), height=image_size[0], width=image_size[1]), A.Resize(image_size[0], image_size[1]), A.CenterCrop(image_size[0], image_size[1]) ], p = 1.0), A.OneOf([ A.RandomBrightnessContrast(brightness_limit=0.15, contrast_limit=0.5), A.RandomGamma(gamma_limit=(50, 150)), A.NoOp() ], p = 1.0), A.OneOf([A.CLAHE(p=0.5, clip_limit=(10, 10), tile_grid_size=(3, 3)), A.FancyPCA(alpha=0.4), A.NoOp(), ], p = 1.0), A.OneOf([A.HorizontalFlip(), A.VerticalFlip(), A.RandomRotate90(), A.NoOp() ], p = 1.0) ])
def transform(train=True, mean=None, std=None): normalize = alb.Compose([ alb.Normalize(mean=mean or _mean, std=std or _std), ToTensorV2(), ]) if not train: return normalize return alb.Compose([ alb.HorizontalFlip(), alb.VerticalFlip(), alb.RandomRotate90(), alb.ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.2, rotate_limit=15, p=0.9, border_mode=cv2.BORDER_REFLECT), alb.OneOf([ alb.OpticalDistortion(p=0.3), alb.GridDistortion(p=.1), alb.IAAPiecewiseAffine(p=0.3), ], p=0.3), alb.OneOf([ alb.HueSaturationValue(10, 15, 10), alb.CLAHE(clip_limit=2), alb.RandomBrightnessContrast(), ], p=0.3), normalize, ])
def get_training_augmentation(): train_transform = [ albu.HorizontalFlip(p=0.5), albu.IAAAdditiveGaussianNoise(p=0.2), albu.IAAPerspective(p=0.5), albu.PadIfNeeded(min_height=1216, min_width=512, always_apply=True, border_mode=0), #0.9的機率取出OneOf中的其中一個, 各個抽中的機率皆為1/3( 因為1/(1+1+1) ) albu.OneOf( [ albu.CLAHE(p=1), albu.RandomBrightness(p=1), albu.RandomGamma(p=1), ], p=0.9, ), albu.OneOf( [ albu.IAASharpen(p=1), albu.Blur(blur_limit=3, p=1), albu.MotionBlur(blur_limit=3, p=1), ], p=0.9, ), albu.OneOf( [ albu.RandomContrast(p=1), albu.HueSaturationValue(p=1), ], p=0.9, ), ] return albu.Compose(train_transform)
def augment_image(self, image): transform = A.Compose([ A.OneOf([ A.IAAAdditiveGaussianNoise(), A.GaussNoise(), ], p=0.3), A.OneOf([ A.MotionBlur(p=.4), A.MedianBlur(blur_limit=3, p=0.3), A.Blur(blur_limit=3, p=0.3), ], p=0.4), A.OneOf([ A.CLAHE(clip_limit=2), A.IAASharpen(), A.IAAEmboss(), A.RandomBrightnessContrast(), ], p=0.3), A.HueSaturationValue(p=0.3), ]) image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) augmented_image = transform(image=image)['image'] augmented_image = cv2.cvtColor(augmented_image, cv2.COLOR_RGB2BGR) return augmented_image
def get_train_transforms(config): return A.Compose( [ A.OneOf([ A.HueSaturationValue(hue_shift_limit=0.1, sat_shift_limit= 0.1, val_shift_limit=0.1, p=0.8), A.RandomBrightnessContrast(brightness_limit=0.3, contrast_limit=0.2, p=0.8), ],p=0.7), A.Rotate (limit=15, interpolation=1, border_mode=4, value=None, mask_value=None, p=0.8), A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5), A.RandomResizedCrop (config.preprocess.height, config.preprocess.width, scale=(0.8, 0.8), ratio=(0.75, 1.3333333333333333), interpolation=1, always_apply=False, p=0.1), A.OneOf([ A.Resize(height=config.preprocess.height, width=config.preprocess.width, p=0.2), A.LongestMaxSize(max_size=config.preprocess.longest_max_size, p=0.2), A.SmallestMaxSize(max_size=config.preprocess.smallest_max_size, p=0.2), ], p=1), A.CLAHE(clip_limit=[1,4],p=1), ], p=1.0, bbox_params=A.BboxParams( format='coco', min_area=0.5, min_visibility=0.5, label_fields=['category_id'] ) )
def aug_medium(prob=1): return aug.Compose([ aug.Flip(), aug.OneOf([ aug.CLAHE(clip_limit=2, p=.5), aug.IAASharpen(p=.25), ], p=0.35), aug.OneOf([ aug.RandomContrast(), aug.RandomGamma(), aug.RandomBrightness(), ], p=0.3), aug.OneOf([ aug.ElasticTransform( alpha=120, sigma=120 * 0.05, alpha_affine=120 * 0.03), aug.GridDistortion(), aug.OpticalDistortion(distort_limit=2, shift_limit=0.5), ], p=0.3), aug.ShiftScaleRotate(rotate_limit=12), aug.OneOf([ aug.GaussNoise(p=.35), SaltPepperNoise(level_limit=0.0002, p=.7), aug.ISONoise(p=.7), ], p=.5), aug.Cutout(num_holes=3, p=.25), ], p=prob)
def cifar_alb_trainData(): '''Apply Albumentations data transforms to the dataset and returns iterable''' train_transform = [ A.HorizontalFlip(p=0.15), A.ShiftScaleRotate(shift_limit=0.05, scale_limit=0.05, rotate_limit=15, p=0.25), A.RGBShift(r_shift_limit=15, g_shift_limit=15, b_shift_limit=15, p=0.5), A.RandomBrightnessContrast(p=0.25), A.RandomGamma(p=0.25), A.CLAHE(p=0.25), A.ChannelShuffle(p=0.1), A.ElasticTransform(p=0.1), A.MotionBlur(blur_limit=17, p=0.1), A.Cutout(num_holes=1, max_h_size=16, max_w_size=16, fill_value=mean, always_apply=False, p=0.5), A.Normalize(mean=mean, std=std), ToTensor() ] transforms_result = A.Compose(train_transform) return lambda img: transforms_result(image=np.array(img))["image"]
def apply_training_augmentation(): train_transform = [ A.HorizontalFlip(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=320, min_width=320, always_apply=True, border_mode=0), A.RandomCrop(height=320, width=320, always_apply=True), A.IAAAdditiveGaussianNoise(p=0.2), A.IAAPerspective(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.Lambda(mask=round_clip_0_1) ] return A.Compose(train_transform)
def __init__(self, n, m): self.n = n self.m = m m_ratio = self.m / 30.0 self.augment_list = ( A.CLAHE(always_apply=True), A.Equalize(always_apply=True), A.InvertImg(always_apply=True), A.Rotate(limit=30 * m_ratio, always_apply=True), A.Posterize(num_bits=int(4 * m_ratio), always_apply=True), A.Solarize(threshold=m_ratio, always_apply=True), A.RGBShift(r_shift_limit=110 * m_ratio, g_shift_limit=110 * m_ratio, b_shift_limit=110 * m_ratio, always_apply=True), A.HueSaturationValue(hue_shift_limit=20 * m_ratio, sat_shift_limit=30 * m_ratio, val_shift_limit=20 * m_ratio, always_apply=True), A.RandomContrast(limit=m_ratio, always_apply=True), A.RandomBrightness(limit=m_ratio, always_apply=True), # A.Sharpen(always_apply=True), 0.1, 1.9), A.ShiftScaleRotate(shift_limit=0.3 * m_ratio, shift_limit_y=0, rotate_limit=0, always_apply=True), A.ShiftScaleRotate(shift_limit=0.3 * m_ratio, shift_limit_x=0, rotate_limit=0, always_apply=True), A.Cutout(num_holes=int(8 * m_ratio), always_apply=True), A.IAAAffine(shear=0.3 * m_ratio, always_apply=True)) assert self.n <= len(self.augment_list)
def get_training_augmentation(): train_transform = [ albu.ShiftScaleRotate(scale_limit=0.1, rotate_limit=0., shift_limit=0.1, p=1, border_mode=0), albu.IAAAdditiveGaussianNoise(p=0.2), albu.OneOf( [ albu.CLAHE(p=1), albu.RandomBrightness(p=1), albu.RandomGamma(p=1), ], p=0.6, ), albu.OneOf( [ albu.IAASharpen(p=1), albu.Blur(blur_limit=3, p=1), albu.MotionBlur(blur_limit=3, p=1), ], p=0.6, ), albu.OneOf( [ albu.RandomContrast(p=1), albu.HueSaturationValue(p=1), ], p=0.6, ), ] return albu.Compose(train_transform)
def get_train_transforms( height: int = 14 * 32, # 14*32 then 28*32 width: int = 18 * 32): #18*32 then 37*32 return A.Compose([ A.HorizontalFlip(p=0.5), A.IAAAdditiveGaussianNoise(p=0.2), A.IAAPerspective(p=0.4), A.OneOf([ A.CLAHE(p=1.0), A.RandomBrightness(p=1.0), A.RandomGamma(p=1.0), ], p=0.5), A.OneOf([ A.IAASharpen(p=1.0), A.Blur(blur_limit=3, p=1.0), A.MotionBlur(blur_limit=3, p=1.0), ], p=0.5), A.OneOf([ A.RandomContrast(p=1.0), A.HueSaturationValue(p=1.0), ], p=0.5), A.Resize(height=height, width=width, p=1.0), ], p=1.0)
def __init__(self, image_size): self.data_transform = { 'train_transform':A.Compose([ A.Transpose(p=0.5), A.VerticalFlip(p=0.5), A.HorizontalFlip(p=0.5), A.RandomBrightness(limit=0.2, p=0.75), A.RandomContrast(limit=0.2, p=0.75), A.OneOf([ A.MotionBlur(blur_limit=5), A.MedianBlur(blur_limit=5), A.GaussianBlur(blur_limit=5), A.GaussNoise(var_limit=(5.0, 30.0)),], p=0.7), A.OneOf([ A.OpticalDistortion(distort_limit=1.0), A.GridDistortion(num_steps=5, distort_limit=1.), A.ElasticTransform(alpha=3),], p=0.7), A.CLAHE(clip_limit=4.0, p=0.7), A.HueSaturationValue(hue_shift_limit=10, sat_shift_limit=20, val_shift_limit=10, p=0.5), A.ShiftScaleRotate(shift_limit=0.1, scale_limit=0.1, rotate_limit=15, border_mode=0, p=0.85), A.Resize(image_size, image_size), A.Cutout(max_h_size=int(image_size * 0.375), max_w_size=int(image_size * 0.375), num_holes=1, p=0.7), A.Normalize() ]), 'test_transform': A.Compose([ A.Resize(image_size, image_size), A.Normalize(), A.Resize(image_size, image_size) ])}
def val_dataloader(self): """Summary Returns: TYPE: Description """ ds_valid = CustomDataSet(folder=self.hparams.data, train_or_valid='valid', size=np.inf, hparams=self.hparams) ds_valid.reset_state() ag_valid = [ imgaug.Resize(self.hparams.shape, interp=cv2.INTER_NEAREST), imgaug.ToFloat32(), ] ds_valid = AugmentImageComponent(ds_valid, [ imgaug.Albumentations( AB.CLAHE(tile_grid_size=(32, 32), always_apply=True, p=1), ), ], 0) ds_valid = AugmentImageComponents(ds_valid, ag_valid, [0, 1]) ds_valid = BatchData(ds_valid, self.hparams.batch, remainder=True) ds_valid = MultiProcessRunner(ds_valid, num_proc=4, num_prefetch=16) ds_valid = PrintData(ds_valid) ds_valid = MapData( ds_valid, lambda dp: [ torch.tensor(dp[0][:, np.newaxis, :, :]).float(), torch.tensor(dp[1][:, np.newaxis, :, :]).float(), ]) return ds_valid
def transformer(self): """TRANSFORMATION DE NOTRE IMAGE AFIN DE REDUIRE LE BIAIS""" if self.is_train: transform = A.Compose([ A.CLAHE(), A.RandomRotate90(), A.DualTransform(), # adding A.Transpose(), A.Resize(height=self.img_size, width=self.img_size, interpolation=cv2.INTER_AREA), # RESIZE A.ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.50, rotate_limit=45, p=.75), A.Blur(blur_limit=3), A.OpticalDistortion(), A.GridDistortion(), A.HueSaturationValue(), ]) else: transform = A.Compose([ A.Resize(height=self.img_size, width=self.img_size, interpolation=cv2.INTER_AREA), # RESIZE ]) return transform
def get_transforms(image_size): transforms_train = albumentations.Compose([ albumentations.Transpose(p=0.5), albumentations.VerticalFlip(p=0.5), albumentations.HorizontalFlip(p=0.5), albumentations.RandomBrightness(limit=0.2, p=0.75), albumentations.RandomContrast(limit=0.2, p=0.75), albumentations.OneOf([ albumentations.MotionBlur(blur_limit=5), albumentations.MedianBlur(blur_limit=5), albumentations.GaussianBlur(blur_limit=5), albumentations.GaussNoise(var_limit=(5.0, 30.0)), ], p=0.7), albumentations.OneOf([ albumentations.OpticalDistortion(distort_limit=1.0), albumentations.GridDistortion(num_steps=5, distort_limit=1.), albumentations.ElasticTransform(alpha=3), ], p=0.7), albumentations.CLAHE(clip_limit=4.0, p=0.7), albumentations.HueSaturationValue(hue_shift_limit=10, sat_shift_limit=20, val_shift_limit=10, p=0.5), albumentations.ShiftScaleRotate(shift_limit=0.1, scale_limit=0.1, rotate_limit=15, border_mode=0, p=0.85), albumentations.Resize(image_size, image_size), albumentations.Cutout(max_h_size=int(image_size * 0.375), max_w_size=int(image_size * 0.375), num_holes=1, p=0.7), albumentations.Normalize() ]) transforms_val = albumentations.Compose([ albumentations.Resize(image_size, image_size), albumentations.Normalize() ]) return transforms_train, transforms_val
def _strong_aug(p=0.5): import albumentations return albumentations.Compose([ albumentations.HorizontalFlip(p=0.5), albumentations.ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.2, rotate_limit=0, p=0.5, border_mode=cv2.BORDER_CONSTANT), albumentations.OneOf([ albumentations.OpticalDistortion(p=0.5, border_mode=cv2.BORDER_CONSTANT), albumentations.GridDistortion(p=0.5, border_mode=cv2.BORDER_CONSTANT), albumentations.IAAPiecewiseAffine(p=0.5), albumentations.ElasticTransform(p=0.5, border_mode=cv2.BORDER_CONSTANT), ], p=0.5), albumentations.OneOf([ albumentations.CLAHE(clip_limit=2), albumentations.IAASharpen(), albumentations.IAAEmboss(), ], p=0.5), albumentations.OneOf([ albumentations.RandomBrightnessContrast(p=0.5), ], p=0.4), albumentations.HueSaturationValue(p=0.5), ], p=p)
def __init__(self): self.transform = None try: import albumentations as A check_version(A.__version__, '1.0.3', hard=True) # version requirement self.transform = A.Compose([ A.Blur(p=0.01), A.MedianBlur(p=0.01), A.ToGray(p=0.01), A.CLAHE(p=0.01), A.RandomBrightnessContrast(p=0.0), A.RandomGamma(p=0.0), A.ImageCompression(quality_lower=75, p=0.0) ], bbox_params=A.BboxParams( format='yolo', label_fields=['class_labels'])) LOGGER.info( colorstr('albumentations: ') + ', '.join(f'{x}' for x in self.transform.transforms if x.p)) except ImportError: # package not installed, skip pass except Exception as e: LOGGER.info(colorstr('albumentations: ') + f'{e}')
def Albumentations(params): augmentation = A.Compose([ A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5), A.Transpose(p=0.5), A.OneOf([ A.CLAHE(p=1.), A.RandomBrightnessContrast(0.15, 0.15, p=1.), A.RandomGamma(p=1.), A.HueSaturationValue(p=1.)], p=0.5), A.OneOf([ A.Blur(3, p=1.), A.MotionBlur(3, p=1.), A.Sharpen(p=1.)], p=0.5), A.ShiftScaleRotate( shift_limit=0.05, scale_limit=0.05, rotate_limit=15, border_mode=cv2.BORDER_CONSTANT, p=0.75) # IMPORTANT: You MUST add A.Normalize(...) in the list. A.Normalize(mean=params.mean, std=params.std, max_pixel_value=255., always_apply=True) ], bbox_params=A.BboxParams(format='coco', label_fields=['category_ids'], min_visibility=0.2)) return augmentation
def compose_albumentations(gamma_limit_lower=0, gamma_limit_upper=0, CLAHE_clip_limit=0., brightness_limit=0, contrast_limit=0., distort_limit=0.): 'Compose albumentations augmentations' augs = [] if sum([gamma_limit_lower, gamma_limit_upper]) > 0: augs.append( A.RandomGamma(gamma_limit=(gamma_limit_lower, gamma_limit_upper), p=0.5)) if CLAHE_clip_limit > 0: augs.append(A.CLAHE(clip_limit=CLAHE_clip_limit)) if sum([brightness_limit, contrast_limit]) > 0: augs.append( A.RandomBrightnessContrast(brightness_limit=brightness_limit, contrast_limit=contrast_limit)) if distort_limit > 0: augs.append( A.GridDistortion(num_steps=5, distort_limit=distort_limit, interpolation=1, border_mode=4, p=0.5)) return augs
def get_train_data_loader(path, classes_list, batch_size, shuffle=True, num_workers=4): aug = get_aug([ A.HorizontalFlip(p=.5), A.RandomSizedBBoxSafeCrop(width=448, height=448, erosion_rate=0, interpolation=cv2.INTER_CUBIC), A.RGBShift(p=.5), A.Blur(blur_limit=5, p=0.5), A.RandomBrightnessContrast(p=0.5), A.CLAHE(p=0.5), A.Normalize(), ToTensorV2() ]) voc = VOCDataset(path, classes_list=classes_list, image_set='train', transforms=aug) dataloader = torch.utils.data.DataLoader(voc, batch_size, shuffle=shuffle, num_workers=num_workers) return dataloader
def get_training_augmentation(): train_transform = [ albu.HorizontalFlip(p=0.5), # albu.ShiftScaleRotate(scale_limit=0.5, rotate_limit=0, shift_limit=0.1, p=1, border_mode=0), albu.PadIfNeeded(min_height=320, min_width=320, always_apply=True), # albu.RandomCrop(height=1000, width=1000, always_apply=True), albu.IAAAdditiveGaussianNoise(p=0.2), albu.IAAPerspective(p=0.5), albu.OneOf( [ albu.CLAHE(p=1), albu.RandomBrightness(p=1), albu.RandomGamma(p=1), ], p=0.9, ), albu.OneOf( [ albu.IAASharpen(p=1), albu.Blur(blur_limit=3, p=1), albu.MotionBlur(blur_limit=3, p=1), ], p=0.9, ), albu.OneOf( [ albu.RandomContrast(p=1), albu.HueSaturationValue(p=1), ], p=0.9, ), ] return albu.Compose(train_transform)
def main(): aug = get_aug([ A.HorizontalFlip(p=.5), A.RandomSizedBBoxSafeCrop(width=448, height=448, erosion_rate=0, interpolation=cv2.INTER_CUBIC), A.RGBShift(p=.5), A.Blur(blur_limit=5, p=0.5), A.RandomBrightnessContrast(p=0.5), A.CLAHE(p=0.5), ]) voc = VOCDataset(cfg.DATASET_PATH, classes_list=cfg.CLASSES, image_set='train', transforms=aug) for i in range(1000): image, out = voc[i] boxes = post_processing(out) im_size = image.shape[0] for det in boxes: pt1 = (det[0] - det[2] / 2, det[1] - det[3] / 2) pt2 = (det[0] + det[2] / 2, det[1] + det[3] / 2) pt1 = (int(pt1[0] * im_size), int(pt1[1] * im_size)) pt2 = (int(pt2[0] * im_size), int(pt2[1] * im_size)) cv2.rectangle(image, pt1, pt2, (255, 33, 44)) image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR) cv2.imshow("test", image) cv2.waitKeyEx(-1)
def albumentation(): transform = albumentations.Compose([ albumentations.OneOf([ albumentations.GaussNoise(), albumentations.IAAAdditiveGaussianNoise() ]), albumentations.OneOf([ albumentations.MotionBlur(blur_limit=3, p=0.2), albumentations.MedianBlur(blur_limit=3, p=0.1), albumentations.Blur(blur_limit=2, p=0.1) ]), albumentations.OneOf([ albumentations.RandomBrightness(limit=(0.1, 0.4)), albumentations.HueSaturationValue(hue_shift_limit=(0, 128), sat_shift_limit=(0, 60), val_shift_limit=(0, 20)), albumentations.RGBShift(r_shift_limit=30, g_shift_limit=30, b_shift_limit=30) ]), albumentations.OneOf([ albumentations.CLAHE(), albumentations.ChannelShuffle(), albumentations.IAASharpen(), albumentations.IAAEmboss(), albumentations.RandomBrightnessContrast(), ]), albumentations.OneOf([ albumentations.RandomGamma(gamma_limit=(35,255)), albumentations.OpticalDistortion(), albumentations.GridDistortion(), albumentations.IAAPiecewiseAffine() ]), A_torch.ToTensor(normalize={ "mean": [0.485, 0.456, 0.406], "std" : [0.229, 0.224, 0.225]}) ]) return transform
def _strong_aug(p=0.5): return albumentations.Compose([ albumentations.HorizontalFlip(), albumentations.VerticalFlip(), albumentations.ShiftScaleRotate( shift_limit=0, scale_limit=0, rotate_limit=15, p=0.3), albumentations.OneOf([ albumentations.OpticalDistortion(p=0.3), albumentations.GridDistortion(p=0.1), albumentations.IAAPiecewiseAffine(p=0.3), ], p=0.2), albumentations.OneOf([ albumentations.CLAHE(clip_limit=2), albumentations.IAASharpen(), albumentations.IAAEmboss(), ], p=0.3), albumentations.OneOf([ albumentations.RandomBrightnessContrast(p=0.3), ], p=0.4), albumentations.HueSaturationValue(p=0.3), ], p=p)