def transform_train(image, mask): if random.random() < 0.5: image = albumentations.RandomRotate90(p=1)(image=image)['image'] mask = albumentations.RandomRotate90(p=1)(image=mask)['image'] if random.random() < 0.5: image = albumentations.Transpose(p=1)(image=image)['image'] mask = albumentations.Transpose(p=1)(image=mask)['image'] if random.random() < 0.5: image = albumentations.VerticalFlip(p=1)(image=image)['image'] mask = albumentations.VerticalFlip(p=1)(image=mask)['image'] if random.random() < 0.5: image = albumentations.HorizontalFlip(p=1)(image=image)['image'] mask = albumentations.HorizontalFlip(p=1)(image=mask)['image'] # if random.random() < 0.5: # image = albumentations.ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.15, rotate_limit=45, p=1)(image=image)['image'] # mask = albumentations.ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.15, rotate_limit=45, p=1)(image=mask)['image'] if random.random() < 0.5: image = albumentations.RandomBrightness(0.1)(image=image)['image'] image = albumentations.RandomContrast(0.1)(image=image)['image'] image = albumentations.Blur(blur_limit=3)(image=image)['image'] # if random.random() < 0.5: # image = albumentations.Cutout(num_holes=1, max_h_size=32, max_w_size=32, p=1)(image) # mask = albumentations.Cutout(num_holes=1, max_h_size=32, max_w_size=32, p=1)(mask) return image, mask
def tta_transforms(self): tfms = [ [], [A.VerticalFlip(p=1.)], [A.HorizontalFlip(p=1.)], [A.VerticalFlip(p=1.), A.HorizontalFlip(p=1.)], [A.Transpose(p=1.)], [A.Transpose(p=1.), A.VerticalFlip(p=1.)], [A.Transpose(p=1.), A.HorizontalFlip(p=1.)], [A.Transpose(p=1.), A.VerticalFlip(p=1.), A.HorizontalFlip(p=1.)], ] return [ A.Compose([ self.normalizer(), A.PadIfNeeded( self.hparams.aug_pad_size, self.hparams.aug_pad_size, border_mode=self.hparams.aug_border_mode, p=1. ), ] + tfm + [ ToTensorV2(), ]) for tfm in tfms ]
def get_aug(atype, size): print('using aug', atype) if atype == '0': return alb.Compose([ alb.Resize(size, size, p=1), alb.Transpose(p=0.5), alb.HorizontalFlip(p=0.5), alb.VerticalFlip(p=0.5), alb.ShiftScaleRotate(p=0.5), alb.Normalize(p=1), ToTensorV2(p=1), ]) elif atype == '1': return alb.Compose([ alb.RandomResizedCrop(size, size), alb.Transpose(p=0.5), alb.HorizontalFlip(p=0.5), alb.VerticalFlip(p=0.5), alb.ShiftScaleRotate(p=0.5), alb.HueSaturationValue(hue_shift_limit=0.2, sat_shift_limit=0.2, val_shift_limit=0.2, p=0.5), alb.RandomBrightnessContrast(brightness_limit=(-0.1, 0.1), contrast_limit=(-0.1, 0.1), p=0.5), alb.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], max_pixel_value=255.0, p=1.0), alb.CoarseDropout(p=0.5), alb.Cutout(p=0.5), ToTensorV2(p=1.0), ]) elif atype == '2': return alb.Compose([ alb.RandomResizedCrop(size, size, p=1, scale=(0.9, 1)), alb.HueSaturationValue(hue_shift_limit=0.2, sat_shift_limit=0.2, val_shift_limit=0.2, p=0.2), alb.RandomBrightnessContrast(brightness_limit=(-0.1, 0.1), contrast_limit=(-0.1, 0.1), p=0.2), alb.Transpose(p=0.2), alb.HorizontalFlip(p=0.2), alb.VerticalFlip(p=0.2), alb.ShiftScaleRotate(p=0.2), alb.Normalize(p=1), ToTensorV2(p=1), ]) elif atype == '3': return alb.Compose([ alb.RandomResizedCrop(size, size, p=1), alb.HorizontalFlip(p=0.2), alb.Normalize(p=1), ToTensorV2(p=1), ]) else: raise Exception('atype |{}| not supoprted'.format(atype))
def get_tta_transform(tta_idx): if tta_idx == 0: # original tta_test_transform = A.Compose([ ColorConstancy(p=1), A.Normalize(), ToTensor(), ]) elif tta_idx == 1: # horizontal flip tta_test_transform = A.Compose([ ColorConstancy(p=1), A.HorizontalFlip(p=1), A.Normalize(), ToTensor(), ]) elif tta_idx == 2: # vertical flip tta_test_transform = A.Compose([ ColorConstancy(p=1), A.VerticalFlip(p=1), A.Normalize(), ToTensor(), ]) elif tta_idx == 3: # random rotate 90 degree tta_test_transform = A.Compose([ ColorConstancy(p=1), A.RandomRotate90(p=1), A.Normalize(), ToTensor(), ]) elif tta_idx == 4: # flip and transpose tta_test_transform = A.Compose([ ColorConstancy(p=1), A.Flip(p=0.5), A.Transpose(p=1), A.Normalize(), ToTensor(), ]) else: # train transform tta_test_transform = A.Compose([ ColorConstancy(p=1), A.OneOf([ A.Flip(p=0.5), A.IAAFliplr(p=0.5), A.Transpose(p=0.5), A.IAAFlipud(p=0.5), ], p=0.5), A.OneOf([ A.Rotate(limit=365, p=0.75), A.ShiftScaleRotate(p=0.75), ], p=0.75), A.Blur(blur_limit=3, p=0.5), A.Normalize(), ToTensor(), ]) return tta_test_transform
def transform_train(image, mask, infor): if random.random() < 0.5: image = albumentations.VerticalFlip(p=1)(image=image)['image'] mask = albumentations.VerticalFlip(p=1)(image=mask)['image'] if random.random() < 0.5: image = albumentations.HorizontalFlip(p=1)(image=image)['image'] mask = albumentations.HorizontalFlip(p=1)(image=mask)['image'] # if random.random() < 0.5: # image = albumentations.OneOf([ # albumentations.RandomGamma(gamma_limit=(60, 120), p=0.1), # albumentations.RandomBrightnessContrast(brightness_limit=0.2, contrast_limit=0.2, p=0.1), # albumentations.CLAHE(clip_limit=4.0, tile_grid_size=(4, 4), p=0.1), # ])(image=image)['image'] # if random.random() < 0.25: # image = albumentations.OneOf([ # albumentations.Blur(blur_limit=4, p=1), # albumentations.MotionBlur(blur_limit=4, p=1), # albumentations.MedianBlur(blur_limit=4, p=1) # ], p=0.5)(image=image)['image'] if random.random() < 0.25: image = albumentations.Cutout(num_holes=2, max_h_size=8, max_w_size=8, p=1)(image=image)['image'] mask = albumentations.Cutout(num_holes=2, max_h_size=8, max_w_size=8, p=1)(image=mask)['image'] if random.random() < 0.5: image = albumentations.RandomRotate90(p=1)(image=image)['image'] mask = albumentations.RandomRotate90(p=1)(image=mask)['image'] if random.random() < 0.5: image = albumentations.Transpose(p=1)(image=image)['image'] mask = albumentations.Transpose(p=1)(image=mask)['image'] # if random.random() < 0.5: # image = albumentations.ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.15, rotate_limit=45, p=1)(image=image)['image'] # mask = albumentations.ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.15, rotate_limit=45, p=1)(image=mask)['image'] image = albumentations.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), max_pixel_value=255.0, p=1.0)(image=image)['image'] # image = albumentations.Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5), max_pixel_value=255.0, p=1.0)(image=image)['image'] return image, mask, infor
def train_get_transforms(): return A.Compose([ # A.Resize(random.randint(config.img_size, config.img_size+128), random.randint(config.img_size, config.img_size+128)), # A.RandomCrop(config.img_size, config.img_size), # A.crops.transforms.CenterCrop(256, 256, p=1.0), # A.Resize(config.img_size, config.img_size), # A.crops.transforms.CenterCrop(224, 224, p=1.0), 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.8), A.RandomBrightness(limit=0.1, p=0.5), A.RandomContrast(limit=[0.9, 1.1], p=0.5), A.Transpose(p=0.5), A.Rotate(limit=90, interpolation=1, border_mode=4, always_apply=False, p=0.5), A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5), A.ShiftScaleRotate(p=0.5), # A.HueSaturationValue(hue_shift_limit=0.2, sat_shift_limit=0.2, val_shift_limit=0.2, p=0.5), # A.RandomBrightnessContrast(brightness_limit=(-0.1,0.1), contrast_limit=(-0.1, 0.1), p=0.5), # A.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], max_pixel_value=255.0, p=1.0), # A.CoarseDropout(p=0.5), # A.Cutout(max_h_size=int(config.img_size * 0.5), max_w_size=int(config.img_size * 0.5), num_holes=1, p=0.8), ToTensorV2() ])
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 get_transforms(size: int, scope: str = 'geometric', crop='random'): augs = { 'weak': albu.Compose([ albu.HorizontalFlip(), ]), 'geometric': albu.OneOf([ albu.HorizontalFlip(always_apply=True), albu.ShiftScaleRotate(always_apply=True), albu.Transpose(always_apply=True), albu.OpticalDistortion(always_apply=True), albu.ElasticTransform(always_apply=True), ]) } 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, pad, crop_fn], additional_targets={'target': 'image'}) def process(a, b): r = pipeline(image=a, target=b) return r['image'], r['target'] return process
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 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 __init__(self, img_size=224, mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)): super(ImageTransform_3, self).__init__() self.transform = { 'train': albu.Compose([ albu.RandomResizedCrop(img_size, img_size), albu.ColorJitter(p=0.5), albu.HorizontalFlip(p=0.5), albu.VerticalFlip(p=0.5), albu.Transpose(p=0.5), albu.MotionBlur(p=0.5), albu.Normalize(mean, std), ToTensorV2(), ], p=1.0), 'val': albu.Compose([ albu.Resize(img_size, img_size), albu.Normalize(mean, std), ToTensorV2(), ], p=1.0) }
def get_train_transform(img_size): train_transform = A.Compose([ A.Resize(img_size, img_size), A.Transpose(p=0.5), A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5), A.ShiftScaleRotate(p=0.5), A.HueSaturationValue(hue_shift_limit=0.2, sat_shift_limit=0.2, val_shift_limit=0.2, p=0.5), A.RandomBrightnessContrast(brightness_limit=(-0.1, 0.1), contrast_limit=(-0.1, 0.1), p=0.5), A.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], max_pixel_value=255.0, p=1.0), A.CoarseDropout(p=0.5), A.Cutout(p=0.5), ToTensor() ]) return train_transform
def __init__(self, outputs=5): super().__init__() self.net = EfficientNet.from_pretrained('efficientnet-b0') self.linear = Sequential(ReLU(), Dropout(), Linear(1000, outputs)) df = pd.read_csv("../input/prostate-cancer-grade-assessment/train.csv") self.train_df, self.valid_df = train_test_split(df, test_size=0.2) self.data_dir = "../input/prostate-cancer-grade-assessment/train_images" self.train_transforms = A.Compose( [ A.InvertImg(p=1), A.RandomSizedCrop([int(IMAGE_SIZE * 0.9), IMAGE_SIZE], IMAGE_SIZE, IMAGE_SIZE), A.Transpose(), A.Flip(), A.Rotate(90, border_mode=cv.BORDER_CONSTANT, value=(0, 0, 0)), A.RandomBrightnessContrast(0.02, 0.02), A.HueSaturationValue(0, 10, 10), A.Normalize(mean, std, 1), ] ) self.valid_transforms = A.Compose([A.InvertImg(p=1), A.Normalize(mean, std, 1),]) self.criterion = BCEWithLogitsLoss() if False and BATCH_SIZE == 1: for m in self.modules(): if isinstance(m, nn.BatchNorm2d): m.weight.requires_grad = False m.bias.requires_grad = False
def get_train_transform(cfg): return A.Compose([ A.Resize(height=cfg.DATASET.IMG_HEIGHT, width=cfg.DATASET.IMG_WIDTH), A.RandomResizedCrop(cfg.DATASET.IMG_HEIGHT, cfg.DATASET.IMG_HEIGHT, p=cfg.DATASET.P_RANDOMRESCROP), A.CoarseDropout(p=cfg.DATASET.P_COARSEDROP), A.Cutout(num_holes=cfg.DATASET.NUM_HOLES, p=cfg.DATASET.P_CUTOUT), A.HorizontalFlip(cfg.DATASET.P_HORIZONATL_FLIP), A.VerticalFlip(cfg.DATASET.P_VERTICAL_FLIP), A.HueSaturationValue(hue_shift_limit=0.2, sat_shift_limit=0.2, val_shift_limit=0.2, p=0.5), A.RandomBrightnessContrast(brightness_limit=(-0.1, 0.1), contrast_limit=(-0.1, 0.1), p=0.5), A.Transpose(cfg.DATASET.P_TRASPOSE), A.ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.2, rotate_limit=15, p=cfg.DATASET.P_SHIFT_SCALE, border_mode=cv2.BORDER_REFLECT), A.Normalize( mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], ), ToTensorV2() ])
def __init__(self, outputs=5): super().__init__() self.net = EfficientNet.from_pretrained('efficientnet-b0') self.linear = Sequential(ReLU(), Dropout(), Linear(1000, outputs)) df = pd.read_csv("../input/prostate-cancer-grade-assessment/train.csv") self.train_df, self.valid_df = train_test_split(df, test_size=0.2) self.data_dir = "/datasets/panda/train_128_100" self.train_transforms = A.Compose([ A.InvertImg(p=1), A.RandomSizedCrop([100, 128], 128, 128), A.Transpose(), A.Flip(), A.Rotate(90), # A.RandomBrightnessContrast(0.02, 0.02), # A.HueSaturationValue(0, 10, 10), A.Normalize(mean, std, 1), ]) self.valid_transforms = A.Compose([ A.InvertImg(p=1), A.Normalize(mean, std, 1), ]) self.criterion = BCEWithLogitsLoss()
def flip_transpose(image, mask): aug_list = [[image, mask]] augmented = A.HorizontalFlip(p=1)(image=image, mask=mask) image_hf, mask_hf = augmented['image'], augmented['mask'] aug_list.append([image_hf, mask_hf]) augmented = A.VerticalFlip(p=1)(image=image, mask=mask) image_vf, mask_vf = augmented['image'], augmented['mask'] aug_list.append([image_vf, mask_vf]) augmented = A.VerticalFlip(p=1)(image=image_hf, mask=mask_hf) image_hf_vf, mask_hf_vf = augmented['image'], augmented['mask'] aug_list.append([image_hf_vf, mask_hf_vf]) augmented = A.Transpose(p=1)(image=image, mask=mask) image_t, mask_t = augmented['image'], augmented['mask'] aug_list.append([image_t, mask_t]) augmented = A.HorizontalFlip(p=1)(image=image_t, mask=mask_t) image_t_hf, mask_t_hf = augmented['image'], augmented['mask'] aug_list.append([image_t_hf, mask_t_hf]) augmented = A.VerticalFlip(p=1)(image=image_t, mask=mask_t) image_t_vf, mask_t_vf = augmented['image'], augmented['mask'] aug_list.append([image_t_vf, mask_t_vf]) augmented = A.VerticalFlip(p=1)(image=image_t_hf, mask=mask_t_hf) image_t_hf_vf, mask_t_hf_vf = augmented['image'], augmented['mask'] aug_list.append([image_t_hf_vf, mask_t_hf_vf]) return aug_list
def get_transforms(type="albumentations"): if type == "albumentations": train_transforms = albumentations.Compose([ albumentations.Transpose(p=0.5), albumentations.OneOf([ albumentations.VerticalFlip(p=0.5), albumentations.HorizontalFlip(p=0.5), ]), albumentations.OneOf([ 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.OneOf([ # 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(256, 256), # albumentations.Cutout(max_h_size=int(256 * 0.375), max_w_size=int(256 * 0.375), num_holes=1, p=0.7), # albumentations.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) test_transforms = albumentations.Compose([ albumentations.Resize(256, 256), # albumentations.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) else: train_transforms = transforms.Compose([ # AdvancedHairAugmentation(hairs_folder='/kaggle/input/melanoma-hairs'), transforms.RandomResizedCrop(size=256, scale=(0.9, 1.0)), transforms.RandomHorizontalFlip(), transforms.RandomVerticalFlip(), Microscope(p=0.5), transforms.Resize((256, 256)), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) test_transforms = transforms.Compose([ transforms.Resize((256, 256)), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) return train_transforms, test_transforms
def strong_aug(p=.5): return A.Compose([ A.RandomRotate90(), A.Flip(), A.Transpose(), A.OneOf([ A.IAAAdditiveGaussianNoise(), A.GaussNoise(), ], p=0.2), A.OneOf([ A.MotionBlur(p=.2), A.MedianBlur(blur_limit=3, p=.1), A.Blur(blur_limit=3, p=.1), ], p=0.2), A.ShiftScaleRotate( shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=.2), A.OneOf([ A.OpticalDistortion(p=0.3), A.GridDistortion(p=.1), A.IAAPiecewiseAffine(p=0.3), ], p=0.2), A.OneOf([ A.CLAHE(clip_limit=2), A.IAASharpen(), A.IAAEmboss(), A.RandomContrast(), A.RandomBrightness(), ], p=0.3), A.HueSaturationValue(p=0.3), ], p=p)
class Crop256(object): width = height = 256 train_transform = A.Compose( [ A.RandomCrop(height=height, width=width, p=1.0), A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5), A.Transpose(p=0.5), # TTA×8 ToTensorV2(p=1.0), ], p=1.0, additional_targets={'gt': 'image'}) divisor = 8 # padding成8的倍数 val_transform = A.Compose([ A.PadIfNeeded(min_height=None, min_width=None, pad_height_divisor=divisor, pad_width_divisor=divisor, p=1.0), ToTensorV2(p=1.0), ], p=1.0, additional_targets={'gt': 'image'})
def affine_transform( self): # Affine Transforms: Scale & Translation & Rotation return A.Compose( [ # Transpose the input by swapping rows and columns. A.Transpose(p=self.p), A.OneOf( [ # Randomly rotate the input by 90 degrees zero or more times. A.RandomRotate90(p=self.p), # Rotate the input by an angle selected randomly from the uniform distribution. A.Rotate(limit=90, p=self.p), # Randomly apply affine transforms: translate, scale and rotate the input. A.ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.1, rotate_limit=45, p=self.p) ], p=1), A.OneOf( [ A.HorizontalFlip( p=self.p ), # Flip the input vertically around the x-axis. A.VerticalFlip( p=self.p ), # Flip the input horizontally around the y-axis. A.Flip( p=self.p ) # Flip the input either horizontally, vertically or both horizontally and vertically. ], p=1) ], p=1)
def get_lung_transforms(*, augment, args): transforms_train = A.Compose([ A.SmallestMaxSize(max_size=args.img_size), A.Transpose(p=0.5), A.VerticalFlip(p=0.5), A.HorizontalFlip(p=0.5), A.RandomBrightnessContrast(brightness_limit=0.2, contrast_limit=0.2, p=0.75), A.Resize(args.img_size, args.img_size), A.Normalize( mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], ), ToTensorV2() ]) transforms_val = A.Compose([ A.Resize(args.img_size, args.img_size), A.Normalize( mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], ), ToTensorV2() ]) if augment == 'augment': return transforms_train else: return transforms_val
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 __init__(self, batch_size, data_dir, img_size=(256, 256)): super().__init__() self.data_dir = data_dir self.batch_size = batch_size self.train_transform = A.Compose( [ GrayToRGB(), A.RandomResizedCrop(img_size, img_size, p=1.0), A.Transpose(p=0.5), A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5), A.ShiftScaleRotate(p=0.5), A.HueSaturationValue(hue_shift_limit=0.2, sat_shift_limit=0.2, val_shift_limit=0.2, p=0.5), A.RandomBrightnessContrast(brightness_limit=(-0.1, 0.1), contrast_limit=(-0.1, 0.1), p=0.5), A.Normalize( mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], max_pixel_value=255.0, p=1.0, ), A.CoarseDropout(p=0.5), A.Cutout(p=0.5), RGBToGray(), ToTensorV2(p=1.0), ], p=1.0, )
def train_image_augmentation(image, img_size): image = np.array(image) augmentation = A.Compose( [ A.Resize(img_size, img_size), A.CenterCrop(img_size, img_size, p=1.0), A.Transpose(p=0.5), A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5), A.ShiftScaleRotate(p=0.5), A.Blur(blur_limit=3), A.OpticalDistortion(p=0.5), A.GridDistortion(p=0.5), A.HueSaturationValue(hue_shift_limit=0.2, sat_shift_limit=0.2, val_shift_limit=0.2, p=0.5), A.CoarseDropout(p=0.5), A.Cutout(p=0.5), A.Normalize( mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], max_pixel_value=255.0, p=1.0, ) ], p=1.0, ) augmented_image = augmentation(image=image) return augmented_image['image']
def test_transpose_both_image_and_mask(): image = np.ones((8, 6, 3)) mask = np.ones((8, 6)) augmentation = A.Transpose(p=1) augmented = augmentation(image=image, mask=mask) assert augmented['image'].shape == (6, 8, 3) assert augmented['mask'].shape == (6, 8)
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 get_individual_transforms(): transforms = A.Compose([ A.OneOf( [ A.Transpose(p=1.0), A.VerticalFlip(p=1.0), A.HorizontalFlip(p=1.0), A.RandomRotate90(p=1.0), A.NoOp(), ], p=1.0, ), A.OneOf( [ A.ElasticTransform(p=1.0), A.GridDistortion(p=1.0), A.OpticalDistortion(p=1.0), A.NoOp(), ], p=1.0, ), A.OneOf( [ A.GaussNoise(p=1.0), A.GaussianBlur(p=1.0), A.ISONoise(p=1.0), A.CoarseDropout( p=1.0, max_holes=16, max_height=16, max_width=16), A.NoOp(), ], p=1.0, ), ]) return transforms
def get_train_aug(size): return A.Compose([ # allows to combine RandomCrop and RandomScale A.RandomResizedCrop(size, size), # Transpose the input by swapping rows and columns. A.Transpose(p=0.5), # Flip the input horizontally around the y-axis. A.HorizontalFlip(p=0.5), # Flip the input horizontally around the x-axis. A.VerticalFlip(p=0.5), # Randomly apply affine transforms: translate, scale and rotate the input. A.ShiftScaleRotate(p=0.5), # Randomly change hue, saturation and value of the input image. A.HueSaturationValue(hue_shift_limit=0.2, sat_shift_limit=0.2, val_shift_limit=0.2, p=0.5), # Randomly change brightness and contrast of the input image. A.RandomBrightnessContrast(brightness_limit=(-0.1, 0.1), contrast_limit=(-0.1, 0.1), p=0.5), # CoarseDropout of the rectangular regions in the image. A.CoarseDropout(p=0.5), # CoarseDropout of the square regions in the image. A.Cutout(p=0.5) ])
def get_train_transforms(): return A.Compose([ A.RandomSizedCrop( min_max_height=(800, 1024), height=1024, width=1024, p=0.5), A.OneOf([ A.HueSaturationValue(hue_shift_limit=0.2, sat_shift_limit=0.2, val_shift_limit=0.2, p=0.9), A.RandomBrightnessContrast( brightness_limit=0.2, contrast_limit=0.2, p=0.9), ], p=0.9), A.ToGray(p=0.01), A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5), A.RandomRotate90(p=0.5), A.Transpose(p=0.5), A.JpegCompression(quality_lower=85, quality_upper=95, p=0.2), A.OneOf( [A.Blur(blur_limit=3, p=1.0), A.MedianBlur(blur_limit=3, p=1.0)], p=0.1), A.Resize(height=1024, width=1024, p=1), A.Cutout( num_holes=8, max_h_size=64, max_w_size=64, fill_value=0, p=0.5), ToTensorV2(p=1.0), ], p=1.0, bbox_params=A.BboxParams(format='pascal_voc', min_area=0, min_visibility=0, label_fields=['labels']))
def get_transform(image_size, normalize=True, train=True): if train: transforms = [ A.OneOf([ A.HueSaturationValue(hue_shift_limit=20, sat_shift_limit=30, val_shift_limit=30, p=0.6), A.RandomBrightnessContrast( brightness_limit=0.2, contrast_limit=0.2, p=0.6), ], p=0.9), A.Transpose(p=0.5), A.VerticalFlip(p=0.5), A.HorizontalFlip(p=0.5), # A.CoarseDropout( # max_holes=8, max_height=22, # max_width=22, fill_value=255, p=0.7), ] else: transforms = [] if normalize: transforms.append(A.Normalize()) transforms.extend([ ToTensorV2(), ]) return A.Compose(transforms)