from torchvision import transforms from timm.data.constants import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD, IMAGENET_INCEPTION_MEAN, IMAGENET_INCEPTION_STD from PIL import Image, ImageFilter, ImageOps import logging import numpy as np import torch from timm.data import create_transform import random from .randaugment import RandomAugment class GaussianBlur(object): """ Apply Gaussian Blur to the PIL image. """ def __init__(self, p=0.1, radius_min=0.1, radius_max=2.): self.prob = p self.radius_min = radius_min self.radius_max = radius_max def __call__(self, img): do_it = random.random() <= self.prob if not do_it: return img img = img.filter( ImageFilter.GaussianBlur( radius=random.uniform(self.radius_min, self.radius_max) ) ) return img class Solarization(object): """ Apply Solarization to the PIL image. """ def __init__(self, p=0.2): self.p = p def __call__(self, img): if random.random() < self.p: return ImageOps.solarize(img) else: return img class RandomGaussianNoise: def __init__(self, noise_range=(0.05, 0.2)): self.noise_range = noise_range def __call__(self, img): sig = float(torch.empty(1).uniform_(self.noise_range[0], self.noise_range[1])) return add_gaussian_noise_pil(img, sig) def add_gaussian_noise_pil(img, sig): arr = np.asarray(img) arr1 = arr + np.random.randn(*arr.shape) * sig * 255 arr1 = np.clip(arr1, 0, 255) arr1 = arr1.astype(arr.dtype) img = Image.fromarray(arr1) return img XRAY_MEAN = [0.4978] XRAY_STD = [0.2449] def get_mean_std(args): if args.norm_type == 'default': mean = IMAGENET_DEFAULT_MEAN std = IMAGENET_DEFAULT_STD elif args.norm_type == 'inception': mean = IMAGENET_INCEPTION_MEAN std = IMAGENET_INCEPTION_STD elif args.norm_type == 'xray': # from medmae mean = [0.5056, 0.5056, 0.5056] std = [0.252, 0.252, 0.252] else: raise NotImplementedError return mean, std class Identity: def __call__(self, x): return x def build_aug_trans(args): aug_trans = [] if args.rot > 0: logging.info(f'Rotation={args.rot}') aug_trans.append(transforms.RandomRotation(degrees=args.rot, interpolation=3)) has_blur = 'blur' in args.aug_type has_sol = 'sol' in args.aug_type if has_blur or has_sol: logging.info(f'blur {has_blur}, sol {has_sol}, p={args.iwm_blur_prob}') if has_blur and has_sol: t = transforms.RandomChoice([Solarization(p=1.0), GaussianBlur(p=1.0)]) elif has_blur: t = GaussianBlur(p=1.0) else: t = Solarization(p=1.0) aug_trans.append(transforms.RandomApply([t], p=args.iwm_blur_prob)) if 'jit' in args.aug_type: logging.info(f'Jitter={args.color_jitter}') aug_trans.append(transforms.RandomApply([transforms.ColorJitter(brightness=args.color_jitter, contrast=args.color_jitter)], p=1.0)) if 'noise' in args.aug_type: aug_trans.append(transforms.RandomApply([RandomGaussianNoise(noise_range=args.iwm_noise_range)], p=args.iwm_noise_prob)) if 'ra' in args.aug_type: logging.info(f'Random Augment (2,7)') trans = RandomAugment(2,7, isPIL=True,augs=['Identity','AutoContrast','Equalize','Brightness','Sharpness', 'ShearX', 'ShearY', 'TranslateX', 'TranslateY', 'Rotate']) aug_trans.append(trans) aug_trans = transforms.Compose(aug_trans) return aug_trans def build_transform_crop(args, is_train=True): img_size = args.input_size resize_size = args.input_size * 512 // 448 if args.resize_size is None else args.resize_size logging.info(f'resize size: {args.resize_size}, input size: {args.input_size}') if is_train: if args.crop_type == 'rc': crop_trans = transforms.Compose([ transforms.Resize(resize_size, interpolation=Image.BICUBIC), transforms.RandomCrop((img_size, img_size)), transforms.RandomHorizontalFlip(), ]) elif args.crop_type == 'rrc': logging.info(f'Scale Min: {args.scale_min}') crop_trans = transforms.Compose([ transforms.RandomResizedCrop(img_size,scale=(args.scale_min, 1.0), interpolation=Image.BICUBIC), transforms.RandomHorizontalFlip(), ]) else: raise NotImplementedError else: crop_trans = transforms.Compose([ transforms.Resize(resize_size, interpolation=Image.BICUBIC), transforms.CenterCrop((img_size, img_size)), ]) return crop_trans def build_transform_xray(args, is_train, ten_crop=False): mean, std = get_mean_std(args) post_trans = transforms.Compose([ transforms.Grayscale(num_output_channels=3), transforms.ToTensor(), transforms.Normalize(mean=mean,std=std) ]) if args.aug_type == 'timm' and is_train: logging.info(f'Use timm transform with aa={args.aa}, scale_min={args.scale_min}') transform = create_transform( input_size=args.input_size, is_training=True, scale=(args.scale_min, 1.0), color_jitter=args.color_jitter, auto_augment=args.aa, interpolation='bicubic', re_prob=0, mean=mean, std=std, ) return transform logging.info(f'crop type: {args.crop_type}, aug type: {args.aug_type}') crop_trans = build_transform_crop(args, is_train) if is_train: aug_trans = build_aug_trans(args) else: aug_trans = Identity() if ten_crop: logging.info('Build TenCrop Transform!') transform = transforms.Compose([ transforms.Resize(args.resize_size, interpolation=Image.BICUBIC), transforms.TenCrop(args.input_size), # this is a tuple of PIL Images transforms.Lambda(lambda crops: torch.stack([post_trans(crop) for crop in crops])) # returns a 4D tensor ]) else: transform = transforms.Compose([crop_trans, aug_trans, post_trans]) return transform def build_simclr_transform(args, img_size=224): mean, std = get_mean_std(args) transform = transforms.Compose([ transforms.RandomResizedCrop(size=img_size, scale=(0.2, 0.8)), transforms.RandomAffine(degrees=(-20, 20)), transforms.RandomHorizontalFlip(), transforms.ColorJitter(0.4, 0.4), transforms.RandomApply([transforms.GaussianBlur(kernel_size=9, sigma=(0.1, 2))], p=0.5), transforms.Grayscale(num_output_channels=3), transforms.ToTensor(), transforms.Normalize(mean=mean,std=std) ]) return transform import albumentations from albumentations.pytorch.transforms import ToTensorV2 def build_seg_transform(args, is_train): mean, std = get_mean_std(args) if is_train: if args.aug_type == 'adam': data_transforms = albumentations.Compose([ albumentations.Resize(224, 224), albumentations.OneOf([ albumentations.RandomBrightnessContrast(), albumentations.RandomGamma(), ], p=0.3), albumentations.OneOf([ albumentations.ElasticTransform(alpha=120, sigma=120 * 0.05, alpha_affine=120 * 0.03), albumentations.GridDistortion(), albumentations.OpticalDistortion(distort_limit=2, shift_limit=0.5), ], p=0.3), albumentations.RandomSizedCrop(min_max_height=(156, 224), height=224, width=224,p=0.25), albumentations.Normalize(mean, std), ToTensorV2() ],p=1) else: jit_aug = albumentations.RandomBrightnessContrast( brightness_limit=args.color_jitter, contrast_limit=args.color_jitter, p=args.iwm_jitter_prob ) rot_aug = albumentations.ShiftScaleRotate(rotate_limit=args.rot, border_mode=0) logging.info(f'Scale Aug Type: {args.aug_type}') logging.info(f'Jitter: {args.color_jitter} (p={args.iwm_jitter_prob}), Rot: {args.rot}') data_transforms = albumentations.Compose([ albumentations.Resize(args.input_size, args.input_size), rot_aug, jit_aug, albumentations.HorizontalFlip(p=0.5), albumentations.Normalize(mean, std), ToTensorV2() ]) else: data_transforms = albumentations.Compose([ albumentations.Resize(args.input_size, args.input_size), albumentations.Normalize(mean, std), ToTensorV2() ]) return data_transforms