def cifar10_albumentations(mean, std): train_transforms = A.Compose([ # A.OneOf([ # A.GridDistortion(distort_limit=(-0.3, 0.3), p=0.5), # A.Rotate(limit=(-10, 10), p=0.5) # ]), A.GridDistortion(distort_limit=(-0.3, 0.3), p=0.5), A.Rotate(limit=(-10, 10), p=0.5), A.HorizontalFlip(p=0.25), A.Cutout(num_holes=1, max_h_size=12, max_w_size=12), A.Normalize( mean=mean, std=std ), # Here, the order of normalization and ToTensor() methods matters. Same goes for test_transforms APT.ToTensor() # APT.ToTensorV2() ]) test_transforms = A.Compose([ A.Normalize(mean=mean, std=std), APT.ToTensor() # APT.ToTensorV2() ]) return Albumentation_Transforms( train_transforms), Albumentation_Transforms(test_transforms)
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 build_train(self): train_transforms = A.Compose([ A.Normalize(mean=self.mean, std=self.std), AT.ToTensor(), A.Lambda(lambda x: torch.cat([x, x, x], 0), always_apply=True) ]) return train_transforms
def AlbumentationTrainTransform(self): tf = tc.Compose([ ta.HorizontalFlip(), ta.Cutout(num_holes=1, max_h_size=16, max_w_size=16), tp.ToTensor(dict(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5))) ]) return lambda img: tf(image=np.array(img))["image"]
def AlbumentationTestTransform(self): tf = tc.Compose([ tp.ToTensor( dict(mean=(0.4802, 0.4481, 0.3975), std=(0.2302, 0.2265, 0.2262))) ]) return lambda img: tf(image=np.array(img))["image"]
def model10_resnet_train_transforms(): transforms = C.Compose([ A.HorizontalFlip(), #A.RandomCrop(height=30, width=30, p=5.0), A.Cutout(num_holes=1, max_h_size=16, max_w_size=16), P.ToTensor(dict (mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5))) ]) return lambda img: transforms(image = np.array(img))["image"]
def AlbumentationTrainTransform(self): tf = tc.Compose([ta.PadIfNeeded(4, 4, always_apply=True), ta.RandomCrop(height=32, width=32, always_apply=True), ta.Cutout(num_holes = 1, max_h_size=8, max_w_size=8, always_apply=True), ta.HorizontalFlip(), tp.ToTensor(dict (mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5))) ]) return lambda img: tf(image = np.array(img))["image"]
def cifar10_s11_albumentations(mean, std): train_transforms = A.Compose([ A.PadIfNeeded(36, 36, p=1), A.RandomCrop(32, 32, p=1), A.HorizontalFlip(p=0.5), A.Cutout(num_holes=2, max_h_size=8, max_w_size=8), A.Normalize( mean=mean, std=std ), # Here, the order of normalization and ToTensor() methods matters. Same goes for test_transforms APT.ToTensor() ]) test_transforms = A.Compose( [A.Normalize(mean=mean, std=std), APT.ToTensor()]) return Albumentation_Transforms( train_transforms), Albumentation_Transforms(test_transforms)
def test_augmentation(self): """ Testing Augmentation applied on to the Test dataset """ return AlbumentationTransforms( A.Compose([ A.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), AT.ToTensor() ]))
def test_augmentation(self): """ Testing Augmentation applied on to the Test dataset """ return AlbumentationTransforms( A.Compose([ A.Normalize(mean=[0.4802, 0.4481, 0.3975], std=[0.2302, 0.2265, 0.2262]), AT.ToTensor() ]))
def build_train(self): train_transforms = A.Compose([ A.Rotate((-15.0, 15.0), p=0.3), A.HorizontalFlip(), A.Normalize(mean=self.mean, std=self.std), A.Cutout(num_holes=4), AT.ToTensor() ]) return AlbumentationTransforms(train_transforms)
def model12_train_transforms(): transform = C.Compose([ A.PadIfNeeded(min_height=70, min_width=70, border_mode=cv2.BORDER_CONSTANT, value=0.5), A.RandomCrop(height=64, width=64), A.HorizontalFlip(p=0.5), A.Cutout(num_holes=1, max_h_size=32, max_w_size=32, p=1), P.ToTensor(dict (mean=(0.4802, 0.4481, 0.3975), std=(0.2302, 0.2265, 0.2262))) ]) return lambda img: transform(image = np.array(img))["image"]
def model11_davidnet_train_transforms(): transform = C.Compose([ A.PadIfNeeded(min_height=36, min_width=36, border_mode=cv2.BORDER_CONSTANT, value=0.5), A.RandomCrop(height=32, width=32, p=1), A.HorizontalFlip(p=0.5), A.Cutout(num_holes=1, max_h_size=8, max_w_size=8, p=1), P.ToTensor(dict (mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5))) ]) return lambda img: transform(image = np.array(img))["image"]
def build_train(self): train_transforms = A.Compose([ A.PadIfNeeded(min_height=36, min_width=36), A.RandomCrop(height=32, width=32), A.HorizontalFlip(), A.Normalize(mean=self.mean, std=self.std), A.Cutout(num_holes=4), AT.ToTensor() ]) return AlbumentationTransforms(train_transforms)
def tinyimagenet_albumentations(mean, std): train_transforms = A.Compose([ A.PadIfNeeded(68, 68, p=1), A.RandomCrop(64, 64, p=1), A.Rotate(limit=(-10, 10), p=0.5), A.HorizontalFlip(p=0.5), A.GridDistortion(distort_limit=(-0.3, 0.3), p=0.5), A.Cutout(num_holes=3, max_h_size=8, max_w_size=8), A.Normalize( mean=mean, std=std ), # Here, the order of normalization and ToTensor() methods matters. Same goes for test_transforms APT.ToTensor() ]) test_transforms = A.Compose( [A.Normalize(mean=mean, std=std), APT.ToTensor()]) return Albumentation_Transforms( train_transforms), Albumentation_Transforms(test_transforms)
def AlbumentationTrainTransform(self): tf = tc.Compose([ta.HorizontalFlip(p=0.5), ta.Rotate(limit=(-20, 20)), # ta.VerticalFlip(p=0.5), # ta.Cutout(num_holes=3, max_h_size=8, max_w_size=8, p=0.5), # ta.Blur(), # ta.ChannelShuffle(), # ta.InvertImg(), ta.RandomCrop(height=30, width=30, p=5.0), ta.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)), tp.ToTensor() ]) return lambda img: tf(image = np.array(img))["image"]
def train_augmentation(self): """ Training Augmentation applied on to the train dataset """ return AlbumentationTransforms( A.Compose([ A.PadIfNeeded(min_height=36, min_width=36), A.RandomCrop(32, 32), A.HorizontalFlip(), A.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), A.Cutout(num_holes=4), AT.ToTensor() ]))
def train_augmentation(self): """ Training Augmentation applied on to the train dataset """ return AlbumentationTransforms( A.Compose([ A.RandomCrop(64, 64), A.Rotate((-30.0, 30.0)), A.HorizontalFlip(), A.Normalize(mean=[0.4802, 0.4481, 0.3975], std=[0.2302, 0.2265, 0.2262]), A.Cutout(num_holes=4), AT.ToTensor() ]))
def get_Dataset(dframe, train_dir): # convert to Dataset objects composed_transform = Compose([ A.augmentations.transforms.Cutout(num_holes=8, max_h_size=64, max_w_size=64, p=0.5), transforms.ToTensor() ]) # to extract features, uncomment this line and comment the line prior # composed_transform = Compose([transforms.ToTensor(), ToFeatures()]) dset = GetFeatureDataset(dframe, train_dir, composed_transform) return dset
def AlbumentationTestTransform(self): tf = tc.Compose([ta.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)), tp.ToTensor() # tp.ToTensor(dict(mean=(0.4914, 0.4822, 0.4465), std=(0.247, 0.2435, 0.2616))) ]) return lambda img: tf(image = np.array(img))["image"]
def run(): if args.seed is not None: from csl_common.utils.common import init_random init_random(args.seed) # log.info(json.dumps(vars(args), indent=4)) full_sizes = { 'drive': 512, 'stare': 512, 'chase': 1024, 'hrf': 2560, } full_size = full_sizes[args.dataset_train[0]] transform_train = alb.Compose([ alb.Rotate(60, border_mode=cv2.BORDER_CONSTANT), alb.RandomSizedCrop(min_max_height=(int(full_size * 0.25), int(full_size * 0.5)), height=args.input_size, width=args.input_size, p=1.0), # alb.RandomSizedCrop( # min_max_height=(int(full_size*0.5), int(full_size*0.5)), # height=1600, width=1600, # ), # alb.Resize(width=565*2, height=584*2), # alb.RandomCrop(args.input_size, args.input_size), # alb.CenterCrop(args.input_size, args.input_size), # alb.Resize(args.input_size, args.input_size), alb.RGBShift(p=0.5), alb.RandomBrightnessContrast(brightness_limit=0.5, contrast_limit=0.5, p=0.5), alb.RandomGamma(), alb.HorizontalFlip(p=0.5), alb.VerticalFlip(p=0.5), alb_torch.ToTensor( normalize=dict(mean=[0.518, 0.418, 0.361], std=[1, 1, 1])) ]) transform_val = alb.Compose([ alb.RandomSizedCrop(min_max_height=(int(full_size * 0.25), int(full_size * 0.5)), height=args.input_size, width=args.input_size), alb.Resize(args.input_size, args.input_size, always_apply=True), alb_torch.ToTensor( normalize=dict(mean=[0.518, 0.418, 0.361], std=[1, 1, 1])) ]) torch.backends.cudnn.benchmark = True datasets = {} datasets[VAL] = retinadataset.create_dataset_multi( args.dataset_val, transform_val, num_samples=args.val_count, repeat_factor=5, train=False) if args.eval: fntr = VesselTraining(datasets, args) fntr.evaluate() else: datasets[TRAIN] = retinadataset.create_dataset_multi( args.dataset_train, transform_train, num_samples=args.train_count, train=True, repeat_factor=args.n_dataset_repeats) fntr = VesselTraining(datasets, args) fntr.train(num_epochs=args.epochs)
import os import torch import time import cv2 import numpy as np import matplotlib.pyplot as plt import albumentations as alb from albumentations.pytorch import transforms as alb_torch from csl_common.utils.nn import to_numpy from csl_common.vis import vis _crop_to_tensor = alb.Compose([ alb_torch.ToTensor( normalize=dict(mean=[0.518, 0.418, 0.361], std=[1, 1, 1])) ]) def _predict_center_crop(net, image, crop_size=544, gpu=True): h, w, c = image.shape image_probs = torch.zeros((h, w)) x = (w - crop_size) // 2 y = (h - crop_size) // 2 image_crop = image[y:y + crop_size, x:x + crop_size] input = _crop_to_tensor(image=image_crop)['image'] if gpu: input = input.cuda()
def model12_test_transforms(): transform = C.Compose([ P.ToTensor(dict (mean=(0.4802, 0.4481, 0.3975), std=(0.2302, 0.2265, 0.2262))) ]) return lambda img: transform(image = np.array(img))["image"]
def build_test(self): test_transforms = A.Compose( [A.Normalize(mean=self.mean, std=self.std), AT.ToTensor()]) return AlbumentationTransforms(test_transforms)
def model9_resnet_test_transforms(): transforms = C.Compose([ P.ToTensor(dict (mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5))) ]) return lambda img: transforms(image = np.array(img))["image"]