def get_training_augmentation(): train_transform = [ A.RandomSizedCrop(min_max_height=(300, 360), height=320, width=320, always_apply=True), A.HorizontalFlip(p=0.5), A.OneOf([ A.CLAHE(), A.RandomBrightnessContrast(), A.RandomGamma(), A.HueSaturationValue(), A.NoOp() ]), A.OneOf([ A.IAAAdditiveGaussianNoise(p=0.2), A.IAASharpen(), A.Blur(blur_limit=3), A.MotionBlur(blur_limit=3), A.NoOp() ]), A.OneOf([ A.RandomFog(), A.RandomSunFlare(), A.RandomRain(), A.RandomSnow(), A.NoOp() ]), A.Normalize(), ] return A.Compose(train_transform)
def augment(self, img0, img1): transform = A.Compose([ A.IAAAdditiveGaussianNoise(p=0.05), A.OneOf([ A.IAASharpen(p=1.0), A.Blur(blur_limit=3, p=1.0), ], p=0.5), A.OneOf([ A.RandomBrightnessContrast(p=1.0), A.HueSaturationValue(p=1.0), A.RandomGamma(p=1.0), ], p=0.5), A.OneOf([ A.RandomFog(p=1.0), A.RandomRain(p=1.0), A.RandomShadow(p=1.0), A.RandomSnow(p=1.0), A.RandomSunFlare(p=1.0) ], p=0.05), ], additional_targets={'img1': 'image'}) transformed = transform(image=img0, img1=img1) img0 = transformed["image"] img1 = transformed["img1"] return img0, img1
def get_training_augmentation(min_area=0., min_visibility=0.): train_transform = [ albu.OneOf([ albu.ISONoise(p=.5), albu.GaussNoise(p=0.4), albu.Blur(blur_limit=3, p=0.1), ]), albu.OneOf([ albu.CLAHE(clip_limit=2), ], p=0.2), albu.OneOf([ albu.RandomSnow(snow_point_lower=0., snow_point_upper=0.2, brightness_coeff=2., p=0.5), albu.RandomSunFlare(p=0.5), ]), albu.OneOf([ albu.RGBShift(p=0.1), albu.ChannelShuffle(p=0.2), ]) ] return albu.Compose(train_transform, bbox_params={ 'format': 'coco', 'min_area': min_area, 'min_visibility': min_visibility, 'label_fields': ['category_id'] })
def snow(img, msk): aug = A.Compose([ A.RandomSnow(snow_point_lower=0.6, snow_point_upper=0.8, brightness_coeff=1.2, always_apply=True) ]) data = aug(image=img) return data['image'], msk
def augment_and_save(path_to_get_data, path_to_save_data, number_of_tranformation=10): """ Function defined to apply an image / rounding boxes transformation pipeline and save the corresponding files. Args: ----- - path_to_get_data: str, the folder path where untouched data is - path_to_save_data: str, the folder path where to save augmented data - number_of_tranformation: int, number of transformation to perform Returns: -------- - None """ images_names, yolo_names = get_images_and_box_files_names(path_to_get_data) augmentation_pipeline = A.Compose([ A.Resize(416, 416), A.Equalize(by_channels=True), A.RGBShift(r_shift_limit=(-30, 30), g_shift_limit=(-30, 30), b_shift_limit=(-30, 30), p=0.25), A.HorizontalFlip(p=0.35), A.VerticalFlip(p=0.35), A.ShiftScaleRotate(border_mode=cv2.BORDER_REPLICATE, p=0.35), A.RandomSnow(brightness_coeff=2.0, p=0.2) ], A.BboxParams('yolo', ['class_labels'])) # Iterate through each image for idx, name in enumerate(images_names): image_path = path_to_get_data + '/' + name image = cv2.imread(image_path) yolo_file_path = path_to_get_data + '/' + yolo_names[idx] labels, coordinates = get_labels_and_coordinates(yolo_file_path) # Generate x tranformation of the images for i in tqdm(range(number_of_tranformation)): new_image_name, new_yolos_name = set_new_files_names( name, i, "jpg", "txt") # Catch error due to unproper labelling try: new_image, new_coordinates, labels = get_data_from_pipeline( augmentation_pipeline, image, coordinates, labels) except ValueError as e: print("**** Error Message ****\n") print(f"{e}\n") print(f"""Invalid transformation of box: {str(new_coordinates)}\n""") print(f"Image: {new_image_name}\n") continue # Same each image to jpg with its corresponding coordinates save_image_bbox_data(path_to_save_data, new_image, new_image_name, new_coordinates, labels, new_yolos_name)
def generate_transforms2(img_size): train_transform = Compose([ # A.RandomCrop(p=1, height=img_size, width=img_size), A.Resize(height=img_size, width=img_size), A.RandomSunFlare(p=1), A.RandomFog(p=1), A.RandomBrightness(p=1), A.Rotate(p=1, limit=90), A.RGBShift(p=1), A.RandomSnow(p=1), A.HorizontalFlip(p=1), A.VerticalFlip(p=1), A.RandomContrast(limit=0.5, p=1), A.HueSaturationValue(p=1, hue_shift_limit=20, sat_shift_limit=30, val_shift_limit=50), # A.Cutout(p=1), # A.Transpose(p=1), A.JpegCompression(p=1), A.CoarseDropout(p=1), A.IAAAdditiveGaussianNoise(loc=0, scale=(2.5500000000000003, 12.75), per_channel=False, p=1), A.IAAAffine(scale=1.0, translate_percent=None, translate_px=None, rotate=0.0, shear=0.0, order=1, cval=0, mode='reflect', p=1), A.IAAAffine(rotate=90., p=1), A.IAAAffine(rotate=180., p=1), Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), max_pixel_value=255.0, p=1.0), ToTensorV2() ]) val_transform = Compose([ Resize(height=img_size, width=img_size), Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), max_pixel_value=255.0, p=1.0), ToTensorV2(), ]) return {"train": train_transform, "val": val_transform}
def get_training_augmentation(): train_transform = [ # albu.Resize(height=1248, width=1248, p=1), # albu.HorizontalFlip(p=0.5), albu.Flip(p=0.5), albu.Transpose(p=0.5), # albu.ShiftScaleRotate(scale_limit=0.5, rotate_limit=0, shift_limit=0.1, p=1, border_mode=0), albu.RandomCrop(height=512, width=512, always_apply=True), # albu.RandomGridShuffle(p=0.5), albu.RandomSnow(brightness_coeff=1.0, p=0.5), # albu.RandomSunFlare(p=0.5), ] return albu.Compose(train_transform)
def augmentation_function(n_augment: int) -> A.core.composition.Compose: """Performs data augmentation on images with realistic parameters Returns a Albumentation composition function""" proba_transfo = 1 / n_augment def random_proba(proba_transfo: float) -> float: return max(0.4, min(1, proba_transfo + (2 * np.random.random() - 1) / 3)) return A.Compose( [ A.HorizontalFlip(p=1), A.Rotate(limit=25, p=random_proba(proba_transfo)), A.RandomBrightness(limit=0.1, p=random_proba(proba_transfo)), A.RandomSnow(brightness_coeff=0.95, snow_point_lower=0.1, snow_point_upper=0.3, p=random_proba(proba_transfo)), A.RandomFog(fog_coef_lower=0.1, fog_coef_upper=0.4, alpha_coef=0.1, p=random_proba(proba_transfo)), ], p=1.0, bbox_params=A.BboxParams(format='yolo', label_fields=['category_ids']) )
def augment(self, img, mask, do_affine_transform = True): if do_affine_transform: afine_transform = A.Compose([ A.HorizontalFlip(p=0.4), A.OneOf([ A.GridDistortion(interpolation=cv2.INTER_NEAREST, border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0, p=1.0), A.ElasticTransform(interpolation=cv2.INTER_NEAREST, alpha_affine=10, border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0, p=1.0), A.ShiftScaleRotate(interpolation=cv2.INTER_NEAREST, shift_limit=0.03, rotate_limit=4, border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0, p=1.0), A.OpticalDistortion(interpolation=cv2.INTER_NEAREST, border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0, p=1.0) ], p=0.6), ], additional_targets={'mask': 'image'}) afine_transformed = afine_transform(image=img, mask=mask) img = afine_transformed["image"] mask = afine_transformed["mask"] transform = A.Compose([ A.IAAAdditiveGaussianNoise(p=0.05), A.OneOf([ A.IAASharpen(p=1.0), A.Blur(blur_limit=3, p=1.0), ] , p=0.5), A.OneOf([ A.RandomBrightnessContrast(p=1.0), A.HueSaturationValue(p=1.0), A.RandomGamma(p=1.0), ], p=0.5), A.OneOf([ A.RandomFog(p=1.0), A.RandomRain(p=1.0), A.RandomShadow(p=1.0), A.RandomSnow(p=1.0), A.RandomSunFlare(p=1.0) ], p=0.05), ]) transformed = transform(image=img) img = transformed["image"] return img, mask
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
def augment(self, img1, bbox1 = [], keypoints1 = [], filtered_objs1 = [], img0 = None, bbox0 = [], keypoints0 = [], filtered_objs0 = [], do_img_aug = True, do_affine_aug = False, img1_to_img0 = False ): if img0 is None: img0 = img1.copy() replay_img_aug = [] keypoints = keypoints1 + keypoints0 bboxes = bbox1 + bbox0 # Afine augmentations # -------------------------------------- if do_affine_aug: afine_transform = A.ReplayCompose( [ A.HorizontalFlip(p=0.4), A.OneOf([ # A.GridDistortion(interpolation=cv2.INTER_NEAREST, border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0, p=1.0), # A.ElasticTransform(interpolation=cv2.INTER_NEAREST, alpha_affine=10, border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0, p=1.0), A.ShiftScaleRotate(interpolation=cv2.INTER_NEAREST, shift_limit=0.035, rotate_limit=5, border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0, p=1.0), # A.OpticalDistortion(interpolation=cv2.INTER_NEAREST, border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0, p=1.0), ], p=0.65), ], additional_targets={"img0": "image"}, keypoint_params=A.KeypointParams(format="xy", remove_invisible=False), bbox_params=A.BboxParams(format='coco', label_fields=["bbox_ids"]), # coco format: [x-min, y-min, width, height] ) transformed = afine_transform(image=img1, img0=img0, keypoints=keypoints, bboxes=bboxes, bbox_ids=np.arange(len(bboxes))) replay_img_aug.append(transformed["replay"]) img1 = transformed["image"] img0 = transformed["img0"] transformed_keypoints = transformed['keypoints'] transformed_bboxes = transformed['bboxes'] bbox_ids = transformed["bbox_ids"] # it can happend that bounding boxes are removed, we have to account for that # and also remove the objects and keypoints in question idx_offset = len(bbox1) keypoints1 = [] keypoints0 = [] bbox1 = [] bbox0 = [] tmp_filtered_objs1 = [] tmp_filtered_objs0 = [] for i, bbox_id in enumerate(bbox_ids): kp_idx_start = bbox_id * 8 kp_idx_end = bbox_id * 8 + 8 if bbox_id < idx_offset: tmp_filtered_objs1.append(filtered_objs1[i]) bbox1.append(transformed_bboxes[i]) keypoints1 += transformed_keypoints[kp_idx_start:kp_idx_end] else: tmp_filtered_objs0.append(filtered_objs0[i]) bbox0.append(transformed_bboxes[i]) keypoints0 += transformed_keypoints[kp_idx_start:kp_idx_end] filtered_objs1 = tmp_filtered_objs1 filtered_objs0 = tmp_filtered_objs0 # Translate img0 + bbox0/keypoints0 for single track centernet # -------------------------------------- if img1_to_img0: transform = A.Compose( [A.ShiftScaleRotate(shift_limit=0.1, scale_limit=0.15, rotate_limit=0, always_apply=True, border_mode=cv2.BORDER_CONSTANT)], keypoint_params=A.KeypointParams(format="xy", remove_invisible=False), bbox_params=A.BboxParams(format='coco', label_fields=[]) ) keypoints = list(np.array(piped_params["gt_2d_info"])[:,:2] * self.params.R) transformed = transform(image=img1, keypoints=keypoints1, bboxes=bboxes1) img0 = transformed["image"] bboxes0 = transformed['bboxes'] keypoints0 = transformed['keypoints'] # Augmentation for images # -------------------------------------- if do_img_aug: transform = A.ReplayCompose([ A.IAAAdditiveGaussianNoise(p=0.02), A.OneOf([ A.IAASharpen(p=1.0), A.Blur(blur_limit=3, p=1.0), ] , p=0.5), A.OneOf([ A.RandomBrightnessContrast(p=1.0), A.HueSaturationValue(p=1.0), A.RandomGamma(p=1.0), ], p=0.6), A.OneOf([ A.RandomFog(p=1.0), A.RandomRain(p=1.0), A.RandomShadow(p=1.0), A.RandomSnow(p=1.0) ], p=0.02), ], additional_targets={"img0": "image"}) transformed = transform(image=img1, img0=img0) img1 = transformed["image"] img0 = transformed["img0"] return img1, bbox1, keypoints1, filtered_objs1, img0, bbox0, keypoints0, filtered_objs0, replay_img_aug
def __call__(self, data): rgb, thermal, depth, audio, label, id = data rgb = rgb.astype(np.float32) height, width, _ = rgb.shape albumentations_transform_pixel = { 'Blur': albumentations.Blur(), #'CLAHE':albumentations.CLAHE(), 'ChannelDropout': albumentations.ChannelDropout(), 'ChannelShuffle': albumentations.ChannelShuffle(), 'CoarseDropout': albumentations.CoarseDropout(), #'Equalize':albumentations.Equalize(), #'FancyPCA':albumentations.FancyPCA(), 'GaussNoise': albumentations.GaussNoise(), 'GaussianBlur': albumentations.GaussianBlur(), #'GlassBlur':albumentations.GlassBlur(), 'HueSaturationValue': albumentations.HueSaturationValue(), 'IAAAdditiveGaussianNoise': albumentations.IAAAdditiveGaussianNoise(), #'ISONoise':albumentations.ISONoise(), 'RGBShift': albumentations.RGBShift(), 'RandomBrightnessContrast': albumentations.RandomBrightnessContrast(), 'RandomFog': albumentations.RandomFog(), #'RandomGamma':albumentations.RandomGamma(), 'RandomRain': albumentations.RandomRain(), 'RandomShadow': albumentations.RandomShadow(), 'RandomSnow': albumentations.RandomSnow(), 'RandomSunFlare': albumentations.RandomSunFlare(), 'Solarize': albumentations.Solarize(), } albumentations_transform_bbox = { #'HorizontalFlip':albumentations.HorizontalFlip(), #'VerticalFlip':albumentations.VerticalFlip(), #'CenterCrop':albumentations.CenterCrop(height=height-10, width=width-10, p=0.5), #'RandomCropNearBBox':albumentations.RandomCropNearBBox(p=0.5), #'Crop':albumentations.Crop(x_min=10, y_min =10, y_max=height-10, x_max=width-10, p=0.5), #'ElasticTransform':albumentations.ElasticTransform(), #'ShiftScaleRotate':albumentations.ShiftScaleRotate(), } transform = np.random.choice( ['None'] + list(albumentations_transform_pixel.keys()) + list(albumentations_transform_bbox.keys())) if transform in albumentations_transform_pixel: aug = albumentations.Compose( [albumentations_transform_pixel[transform]], bbox_params={ 'format': 'pascal_voc', 'label_fields': ['labels'] }) try: annots = np.array(annots).astype(np.float32) aug_result = aug(image=rgb, bboxes=annots[:, :4], labels=annots[:, 4]) rgb = aug_result['image'] annots = np.hstack([ aug_result['bboxes'], np.array(aug_result['labels']).reshape(-1, 1) ]) except Exception as e: print( f"transform={transform} aug_result['bboxes']={aug_result['bboxes']} aug_result['labels']={aug_result['labels']}" ) raise Exception(e) elif transform in albumentations_transform_bbox: aug = albumentations.Compose( [albumentations_transform_bbox[transform]], bbox_params={ 'format': 'pascal_voc', 'label_fields': ['labels'] }) try: annots = np.array(annots).astype(np.float32) aug_result = aug(image=rgb, bboxes=annots[:, :4], labels=annots[:, 4]) rgb = aug_result['image'] label = np.hstack([ aug_result['bboxes'], np.array(aug_result['labels']).reshape(-1, 1) ]) except Exception as e: print( f"transform={transform} aug_result['bboxes']={aug_result['bboxes']} aug_result['labels']={aug_result['labels']}" ) raise Exception(e) return rgb, thermal, depth, audio, label, id
def data_snow(): return A.Compose([ A.Resize(size, size), A.RandomSnow(), ToTensorV2(transpose_mask=True) ])
def get_train_transforms(height: int = 437, width: int = 582, level: str = 'hard'): if level == 'light': return A.Compose([ A.HorizontalFlip(p=0.5), A.IAAAdditiveGaussianNoise(p=0.2), 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), A.PadIfNeeded(pad_to_multiple(height), pad_to_multiple(width), border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0) ], p=1.0) elif level == 'hard': return A.Compose([ A.HorizontalFlip(p=0.5), A.IAAAdditiveGaussianNoise(p=0.2), A.OneOf([ A.GridDistortion(border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0, p=1.0), A.ElasticTransform(alpha_affine=10, border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0, p=1.0), A.ShiftScaleRotate(shift_limit=0, scale_limit=0, rotate_limit=10, border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0, p=1.0), A.OpticalDistortion(border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0, p=1.0), ], p=0.5), A.OneOf([ A.CLAHE(p=1.0), A.RandomBrightness(p=1.0), A.RandomGamma(p=1.0), A.ISONoise(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), A.Cutout(p=0.3), A.PadIfNeeded(pad_to_multiple(height), pad_to_multiple(width), border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0) ], p=1.0) elif level == 'hard_weather': return A.Compose([ A.HorizontalFlip(p=0.5), A.IAAAdditiveGaussianNoise(p=0.2), A.OneOf([ A.GridDistortion(border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0, p=1.0), A.ElasticTransform(alpha_affine=10, border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0, p=1.0), A.ShiftScaleRotate(shift_limit=0, scale_limit=0, rotate_limit=10, border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0, p=1.0), A.OpticalDistortion(border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0, p=1.0), ], p=0.5), A.OneOf([ A.CLAHE(p=1.0), A.RandomBrightness(p=1.0), A.RandomGamma(p=1.0), A.ISONoise(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.OneOf([ A.RandomFog(fog_coef_upper=0.8, p=1.0), A.RandomRain(p=1.0), A.RandomSnow(p=1.0), A.RandomSunFlare(src_radius=100, p=1.0) ], p=0.4), A.Resize(height=height, width=width, p=1.0), A.Cutout(p=0.3), A.PadIfNeeded(pad_to_multiple(height), pad_to_multiple(width), border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0) ], p=1.0)
def get_transforms(aug_type: str): """ Data augmentation 객체 생성 Args: aug_type(str) : augmentation타입 지정 Returns : list :: train, validation, test데이터 셋에 대한 transform """ # TODO: Normalize if False: pass else: norm_mean = (0, 0, 0) norm_std = (1, 1, 1) if aug_type == 'no': train_transform = A.Compose( [A.Normalize(mean=norm_mean, std=norm_std), ToTensorV2()]) val_transform = A.Compose( [A.Normalize(mean=norm_mean, std=norm_std), ToTensorV2()]) test_transform = A.Compose( [A.Normalize(mean=norm_mean, std=norm_std), ToTensorV2()]) elif aug_type == 'dev': pass elif aug_type == 'final': train_transform = A.Compose([ A.HorizontalFlip(p=0.5), A.RandomResizedCrop(512, 512, p=0.8, scale=(0.7, 1.0), ratio=(0.5, 1.5)), A.Rotate(limit=30, p=0.8), A.Cutout(num_holes=4, max_h_size=16, max_w_size=16, p=0.8), A.ElasticTransform(alpha=40, p=0.8), A.CLAHE(clip_limit=3.0, p=0.8), A.Normalize(mean=norm_mean, std=norm_std), ToTensorV2() ]) val_transform = A.Compose( [A.Normalize(mean=norm_mean, std=norm_std), ToTensorV2()]) test_transform = A.Compose( [A.Normalize(mean=norm_mean, std=norm_std), ToTensorV2()]) # TODO: 아래 코드 정리 중 elif aug_type == 'basic': train_transform = A.Compose([ A.Normalize(mean=(0.46009655, 0.43957878, 0.41827092), std=(0.2108204, 0.20766491, 0.21656131), max_pixel_value=255.0, p=1.0), ToTensorV2() ]) val_transform = A.Compose([ A.Normalize(mean=(0.46009655, 0.43957878, 0.41827092), std=(0.2108204, 0.20766491, 0.21656131), max_pixel_value=255.0, p=1.0), ToTensorV2() ]) test_transform = A.Compose([ToTensorV2()]) elif aug_type == "aug1": train_transform = A.Compose([ A.OneOf([ A.ElasticTransform(alpha=120, sigma=120 * 0.05, alpha_affine=120 * 0.03, p=0.5), A.GridDistortion(p=1.0), A.OpticalDistortion(distort_limit=2, shift_limit=0.5, p=1) ], p=0.8), A.VerticalFlip(p=0.5), A.RandomBrightnessContrast(p=0.8), A.RandomGamma(p=0.8), A.RandomRotate90(p=0.5), ToTensorV2() ]) val_transform = A.Compose([ToTensorV2()]) test_transform = A.Compose([ToTensorV2()]) elif aug_type == "aug2": train_transform = A.Compose([ A.OneOf([ A.RandomShadow(p=1), A.RandomSunFlare(num_flare_circles_lower=1, num_flare_circles_upper=5, src_radius=250, p=1), A.RandomRain(p=1), A.RandomSnow(brightness_coeff=1.5, p=1), A.RandomFog( fog_coef_lower=0.8, fog_coef_upper=1, alpha_coef=0.08, p=1) ], p=0.8), ToTensorV2() ]) val_transform = A.Compose([ToTensorV2()]) test_transform = A.Compose([ToTensorV2()]) elif aug_type == "aug3": train_transform = A.Compose([ A.OneOf([ A.HueSaturationValue(hue_shift_limit=0.2, sat_shift_limit=0.2, val_shift_limit=0.2, p=1), A.MultiplicativeNoise( multiplier=(0.9, 1.1), per_channel=True, p=1), A.RGBShift(r_shift_limit=0.1, g_shift_limit=0.1, b_shift_limit=0.1, p=1), A.ChannelShuffle(0.05) ], p=0.8), ToTensorV2() ]) val_transform = A.Compose([ToTensorV2()]) test_transform = A.Compose([ToTensorV2()]) elif aug_type == "aug4": train_transform = A.Compose([ A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5), A.RandomRotate90(p=0.5), ToTensorV2() ]) val_transform = A.Compose([ToTensorV2()]) test_transform = A.Compose([ToTensorV2()]) elif aug_type == "aug5": train_transform = A.Compose([ A.VerticalFlip(p=0.5), A.RandomRotate90(p=0.5), #A.ElasticTransform(p=1, alpha=120, sigma=120 * 0.05, alpha_affine=120 * 0.03), #A.GridDistortion(p=1.0), #A.OpticalDistortion(distort_limit=2, shift_limit=0.5, p=1) #A.VerticalFlip(p=0.5), #A.RandomBrightnessContrast(p=0.8), #A.RandomGamma(p=0.8), #A.RandomRotate90(p=0.5), #A.MultiplicativeNoise(multiplier=(0.9, 1.1), per_channel=True, p=0.8), ToTensorV2() ]) val_transform = A.Compose([ToTensorV2()]) test_transform = A.Compose([ToTensorV2()]) return train_transform, val_transform, test_transform
float(elems[2]), float(elems[3]), float(elems[4]), int(elems[0]) ]) lines.close() image = cv2.imread(imgpath) for i in range(n): #A.ShiftScaleRotate(p=0.2) print(".", end="", flush=True) transform_list = list() #A.Resize() seed_weather = random.randint(0, 2) seed_contrast = random.randint(0, 2) seed_rotate = random.randint(0, 2) if seed_weather == 0: transform_list.append(A.RandomSnow(p=0.5)) else: transform_list.append(A.RandomRain(p=0.5)) if seed_contrast == 1: transform_list.append(A.RandomBrightnessContrast(p=0.5)) if seed_rotate == 1: transform_list.append( A.ShiftScaleRotate(p=0.5, rotate_limit=15)) transform = A.Compose(transforms=transform_list, bbox_params=A.BboxParams(format="yolo")) res = transform(image=image, bboxes=bboxes) outputimgpath = outputImgs + originname + '-' + str(i) + '.jpg' outputannpath = outputAnns + originname + '-' + str(i) + '.txt' cv2.imwrite(outputimgpath, res["image"]) outfile = open(outputannpath, "wt") for elems in res["bboxes"]:
chosen_image = cv2.imread(image_path) plt.imshow(chosen_image) #%% # ref) # Albumentations part adapted from my good friend Hongnan's notebbok in the Global Wheat Detection competition (https://www.kaggle.com/reighns/augmentations-data-cleaning-and-bounding-boxes#Bounding-Boxes-with-Albumentations) #%% albumentation_list = [ A.RandomSunFlare(p=1), A.RandomFog(p=1), A.RandomBrightness(p=1), A.RandomCrop(p=1, height=512, width=512), A.Rotate(p=1, limit=90), A.RGBShift(p=1), A.RandomSnow(p=1), A.HorizontalFlip(p=1), A.VerticalFlip(p=1), A.RandomContrast(limit=0.5, p=1), A.HueSaturationValue(p=1, hue_shift_limit=20, sat_shift_limit=30, val_shift_limit=50), A.Cutout(p=1), A.Transpose(p=1), A.JpegCompression(p=1), A.CoarseDropout(p=1), A.IAAAdditiveGaussianNoise(loc=0, scale=(2.5500000000000003, 12.75), per_channel=False, p=1),
""" def __init__(self, transforms): self.transforms = transforms def __call__(self, img): n = len(self.transforms) idx = np.random.randint(0, n - 1) t = self.transforms[idx] return t(image=img) rand_weather = OneOf([ am.RandomRain(), am.RandomFog(), am.RandomSnow(), ]) # 策略2,随机天气,自然界可能随机发生一些天气现象,增强模型对天气现象的抗干扰能力,参考链接https://github.com/UjjwalSaxena/Automold--Road-Augmentation-Library sharpOrBlur = OneOf([ am.GaussianBlur(), # 高斯模糊在mnist中我已经提供了一个自己实现的版本,这里选择调库 am.IAASharpen(), ]) noiser = OneOf([ GaussNoise(), SaltAndPepper(), ]) strategy = [eraser, rand_weather, sharpOrBlur, noiser] # res_images = np.zeros(shape=(100000, 32, 32, 3))
def get_train_transforms_mmdetection(input_size, use_crop=False, use_no_color_aug=False, use_center_crop=False, center_crop_ratio=0.9, use_gray=False): if isinstance(input_size, int): input_size = (input_size[0], input_size[1]) return al.Compose([ al.RandomResizedCrop(height=input_size[0], width=input_size[1], scale=(0.4, 1.0), interpolation=0, p=0.5), al.Resize(input_size[0], input_size[1], p=1.0), al.HorizontalFlip(p=0.5), al.OneOf([ al.ShiftScaleRotate(border_mode=0, shift_limit=(-0.2, 0.2), scale_limit=(-0.2, 0.2), rotate_limit=(-20, 20)), al.OpticalDistortion(border_mode=0, distort_limit=[-0.5, 0.5], shift_limit=[-0.5, 0.5]), al.GridDistortion( num_steps=5, distort_limit=[-0., 0.3], border_mode=0), al.ElasticTransform(border_mode=0), al.IAAPerspective(), al.RandomGridShuffle() ], p=0.1), al.Rotate(limit=(-25, 25), border_mode=0, p=0.1), al.OneOf([ al.RandomBrightnessContrast(brightness_limit=(-0.2, 0.2), contrast_limit=(-0.2, 0.2)), al.HueSaturationValue(hue_shift_limit=(-20, 20), sat_shift_limit=(-30, 30), val_shift_limit=(-20, 20)), al.RandomGamma(gamma_limit=(30, 150)), al.RGBShift(), al.CLAHE(clip_limit=(1, 15)), al.ChannelShuffle(), al.InvertImg(), ], p=0.1), 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), al.GaussNoise(var_limit=(10, 20), p=0.05), al.ISONoise(color_shift=(0, 15), p=0.05), al.MultiplicativeNoise(p=0.05), al.OneOf([ al.ToGray(p=1. if use_gray else 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.05), al.OneOf([ al.MotionBlur(blur_limit=(3, 7)), al.Blur(blur_limit=(3, 7)), al.MedianBlur(blur_limit=3), al.GaussianBlur(blur_limit=3), ], p=0.05), al.CoarseDropout(p=0.05), al.Cutout(num_holes=30, max_h_size=37, max_w_size=37, fill_value=0, p=0.05), al.GridDropout(p=0.05), al.ChannelDropout(p=0.05), al.Downscale(scale_min=0.5, scale_max=0.9, p=0.1), al.ImageCompression(quality_lower=60, p=0.2), al.Normalize(), ToTensorV2() ])
def get_train_transforms_atopy(input_size, use_crop=False, use_no_color_aug=False): if use_crop: resize = [ al.Resize(int(input_size * 1.2), int(input_size * 1.2)), al.RandomSizedCrop(min_max_height=(int(input_size * 0.6), int(input_size * 1.2)), height=input_size, width=input_size) ] else: resize = [al.Resize(input_size, input_size)] return al.Compose(resize + [ al.Flip(p=0.5), al.OneOf([ al.RandomRotate90(), al.Rotate(limit=180), ], p=0.5), al.OneOf([ al.ShiftScaleRotate(), al.OpticalDistortion(), al.GridDistortion(), al.ElasticTransform(), ], p=0.3), al.RandomGridShuffle(p=0.05), al.OneOf([ al.RandomGamma(), al.HueSaturationValue(), al.RGBShift(), al.CLAHE(), al.ChannelShuffle(), al.InvertImg(), ], p=0.1), al.RandomSnow(p=0.05), al.RandomRain(p=0.05), al.RandomFog(p=0.05), al.RandomSunFlare(p=0.05), al.RandomShadow(p=0.05), al.RandomBrightnessContrast(p=0.05), al.GaussNoise(p=0.2), al.ISONoise(p=0.2), al.MultiplicativeNoise(p=0.2), 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), al.OneOf([ al.MotionBlur(blur_limit=3), al.Blur(blur_limit=3), al.MedianBlur(blur_limit=3), al.GaussianBlur(blur_limit=3), ], p=0.05), al.CoarseDropout(p=0.05), al.Cutout(p=0.05), al.GridDropout(p=0.05), al.ChannelDropout(p=0.05), al.Downscale(p=0.1), al.ImageCompression(quality_lower=60, p=0.2), al.Normalize(), ToTensorV2() ])
A.OneOf([ A.CLAHE(clip_limit=2), A.IAASharpen(), A.IAAEmboss(), ], p=0.2), A.OneOf([ A.OpticalDistortion(p=0.3), A.GridDistortion(p=.1), A.IAAPiecewiseAffine(p=0.3), ], p=0.2), A.OneOf([ A.RandomFog(p=0.05), A.RandomShadow(p=0.05), A.RandomSnow(p=0.05), A.HueSaturationValue(p=0.05), ], p=0.1), A.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)), albumentations.pytorch.transforms.ToTensor() ]) def UpDown_Resize(image, upsize, downsize, p=0.1): num = random.random() if num<p: image = cv2.resize(image, (upsize,upsize)) image = cv2.resize(image, (downsize,downsize)) return image
def __call__(self, image, boxes=None, labels=None): #initialize the format for lib albumentations if boxes.shape[0] == 0: return image, boxes, labels bbox = [] for i in boxes: bbox.append(list(i)) #create annotations annotations = { 'image': image, 'bboxes': boxes, 'category_id': list(labels) } #create translation #Color_Level Change if self.cfg.DATA_LOADER.AUGMENTATION_WEATHER: trans_color_level = A.Compose([ A.Cutout(num_holes=20, max_h_size=64, max_w_size=64, fill_value=255, always_apply=False, p=0.8), A.Equalize(p=1), A.HueSaturationValue(hue_shift_limit=50, sat_shift_limit=50, val_shift_limit=50, always_apply=False, p=0.8), A.OneOf([ A.RandomFog(fog_coef_lower=0.3, fog_coef_upper=0.7, alpha_coef=0.08, always_apply=False, p=0.5), A.RandomSnow(snow_point_lower=0.1, snow_point_upper=0.3, brightness_coeff=2.5, always_apply=False, p=0.5), A.RandomSunFlare(flare_roi=(0, 0, 1, 0.5), angle_lower=0, angle_upper=1, num_flare_circles_lower=6, num_flare_circles_upper=10, src_radius=400, src_color=(255, 255, 255), always_apply=False, p=0.5), A.RandomRain(slant_lower=-10, slant_upper=10, drop_length=20, drop_width=1, drop_color=(200, 200, 200), blur_value=7, brightness_coefficient=0.7, rain_type=None, always_apply=False, p=0.5) ]), A.OneOf([ A.RandomSizedBBoxSafeCrop(720, 960, erosion_rate=0.0, interpolation=1, always_apply=False, p=0.5), A.RandomSizedBBoxSafeCrop(480, 640, erosion_rate=0.0, interpolation=1, always_apply=False, p=0.5), A.RandomSizedBBoxSafeCrop(240, 320, erosion_rate=0.0, interpolation=1, always_apply=False, p=0.5), ]), ]) else: trans_color_level = A.Compose([ A.Cutout(num_holes=20, max_h_size=64, max_w_size=64, fill_value=255, always_apply=False, p=0.5), A.Equalize(p=1), A.HueSaturationValue(hue_shift_limit=50, sat_shift_limit=50, val_shift_limit=50, always_apply=False, p=0.5), A.OneOf([ A.RandomSizedBBoxSafeCrop(720, 960, erosion_rate=0.0, interpolation=1, always_apply=False, p=0.5), A.RandomSizedBBoxSafeCrop(480, 640, erosion_rate=0.0, interpolation=1, always_apply=False, p=0.5), A.RandomSizedBBoxSafeCrop(240, 320, erosion_rate=0.0, interpolation=1, always_apply=False, p=0.5), ]), ]) #Spatial_Level if self.cfg.DATA_LOADER.AUGMENTATION_SPATIAL_LEVEL: trans_rotate_level = A.Compose([ A.OneOf([ A.Rotate(limit=90, interpolation=1, border_mode=4, value=None, mask_value=None, always_apply=False, p=0.5), A.RandomRotate90(always_apply=False, p=0.5), A.VerticalFlip(always_apply=False, p=0.5), A.HorizontalFlip(always_apply=False, p=0.5) ]), ]) #Apply the trans aug = get_aug(trans_color_level) augmented = aug(**annotations) img = augmented['image'] bbox = augmented['bboxes'] bbox = np.array(bbox) label = augmented['category_id'] #try rotate if self.cfg.DATA_LOADER.AUGMENTATION_SPATIAL_LEVEL: aug1 = get_aug(trans_rotate_level) augmented1 = aug1(**augmented) img1 = augmented1['image'] bbox1 = augmented1['bboxes'] bbox1 = np.array(bbox1) label1 = augmented1['category_id'] #if rotate fail if bbox1.shape[0] == 0: return img, bbox.astype(np.float32), np.array(label) else: return img1, bbox1.astype(np.float32), np.array(label1) else: return img, bbox.astype(np.float32), np.array(label)