def train_transform(resize, normalize=None): if normalize == 'imagenet': trans_fucn = [ albu.VerticalFlip(p=0.5), albu.HorizontalFlip(p=0.5), # albu.ToFloat(max_value=255, p=1.0), albu.Normalize(p=1.0), ToTensorV2(p=1.0) ] elif normalize == 'global_norm': trans_fucn = [ albu.VerticalFlip(p=0.5), albu.HorizontalFlip(p=0.5), GlobalNormalize(p=1.0), # albu.ToFloat(max_value=255, p=1.0), ToTensorV2(p=1.0) ] else: trans_fucn = [ albu.VerticalFlip(p=0.5), albu.HorizontalFlip(p=0.5), albu.Normalize(mean=(0, 0, 0), std=(1, 1, 1)), # albu.ToFloat(max_value=255, p=1.0), ToTensorV2(p=1.0) ] return Compose(trans_fucn, p=1.0)
def get_transformv2(opt): transform_list = [] # Transforms in opt.preprocess if 'fixsize' in opt.preprocess: transform_list.append(tr.Resize(286, 286, interpolation=2, p=1)) if 'resize' in opt.preprocess: transform_list.append( tr.Resize(opt.load_size, opt.load_size, interpolation=2, p=1)) if 'crop' in opt.preprocess: transform_list.append(tr.RandomCrop(opt.crop_size, opt.crop_size, p=1)) # Transforms in colorspace if 'color' in opt.preprocess: transform_list.extend([ tr.RandomContrast(limit=0.2, p=0.5), tr.RandomBrightness(limit=0.2, p=0.5), tr.HueSaturationValue(hue_shift_limit=20, sat_shift_limit=30, val_shift_limit=20, p=0.5), # tr.ISONoise() ]) # Necessary transforms transform_list.extend([ tr.HorizontalFlip(p=0.5), tr.VerticalFlip(p=0.5), tr.Normalize(p=1.0), ToTensorV2(p=1) ]) return Compose(transform_list, additional_targets={'imageB': 'image'})
def common_aug(mode, params): ''' :param mode: 'train', 'test', 'inference' :param params: ''' #aug_params = params.get('augm_params', dict()) augs_list = [] assert mode in {'train', 'debug', 'inference'} if mode == 'train': augs_list.append(albumentations.PadIfNeeded(min_height=params.data.net_hw[0], min_width=params.data.net_hw[1], border_mode=cv2.BORDER_REPLICATE, always_apply=True)) augs_list.append(albumentations.RandomCrop(height=params.data.net_hw[0], width=params.data.net_hw[1], always_apply=True)) if params.augmentation.rotate_limit: augs_list.append(T.Rotate(limit=params.augmentation.rotate_limit, border_mode=cv2.BORDER_CONSTANT, always_apply=True)) # augs_list.append(T.OpticalDistortion(border_mode=cv2.BORDER_CONSTANT)) - can't handle boundboxes elif mode == 'debug': augs_list.append(albumentations.CenterCrop(height=params.data.net_hw[0], width=params.data.net_hw[1], always_apply=True)) if mode != 'inference': if params.augmentation.get('blur_limit', 4): augs_list.append(T.Blur(blur_limit=params.augmentation.get('blur_limit', 4))) if params.augmentation.get('RandomBrightnessContrast', True): augs_list.append(T.RandomBrightnessContrast()) #augs_list.append(T.MotionBlur()) if params.augmentation.get('JpegCompression', True): augs_list.append(T.JpegCompression(quality_lower=30, quality_upper=100)) #augs_list.append(T.VerticalFlip()) if params.augmentation.get('HorizontalFlip', True): augs_list.append(T.HorizontalFlip()) return albumentations.ReplayCompose(augs_list, p=1., bbox_params = {'format':'albumentations', 'min_visibility':0.5})
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 __init__(self, root, input_transform=None, target_transform=None, _train=False): self.images_root = os.path.join(root, 'Images') self.labels_root = os.path.join(root, 'Labels') self._train = _train self.filenames = [ image_basename(f) for f in os.listdir(self.labels_root) if is_image(f) ] random.shuffle(self.filenames) self.input_transform = input_transform self.target_transform = target_transform self.A_transform = A.Compose([ A.Rotate(limit=40, p=0.9), A.HorizontalFlip(p=0.5), A.RGBShift(r_shift_limit=25, g_shift_limit=25, b_shift_limit=25, p=0.9), A.OneOf([A.Blur(blur_limit=2, p=0.5), A.ColorJitter(p=0.5)], p=1.0) ])
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 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 flip_augment(image, mask): ''' flip an image vertically or horizontally. Args: image(nd.array) mask(nd.array) Returns: (flip_image, flip_mask) (tuple) : tuple of flipped image and mask. ''' if (random.randint(0, 1) == 0): flip_img = transforms.HorizontalFlip().apply(image) flip_mask = transforms.HorizontalFlip().apply_to_mask(mask) else: flip_img = transforms.VerticalFlip().apply(image) flip_mask = transforms.VerticalFlip().apply_to_mask(mask) return (flip_img, flip_mask)
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 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 ben_augmentation(): # !! Need to do something to change color _probably_ return ACompose([ atransforms.HorizontalFlip(p=0.5), atransforms.RandomRotate90(p=1.0), atransforms.ShiftScaleRotate(shift_limit=0, scale_limit=0, p=1.0), atransforms.RandomSizedCrop((60, 120), height=128, width=128, interpolation=3), # atransforms.GridDistortion(num_steps=5, p=0.5), # !! Maybe too much noise? atransforms.Normalize(mean=BEN_BAND_STATS['mean'], std=BEN_BAND_STATS['std']), # atransforms.ChannelDropout(channel_drop_range=(1, 2), p=0.5), AToTensor(), ])
def get_augmentations(): """Get a list of 'major' and 'minor' augmentation functions for the pipeline in a dictionary.""" return { "major": { "shift-scale-rot": trans.ShiftScaleRotate( shift_limit=0.05, rotate_limit=35, border_mode=cv2.BORDER_REPLICATE, always_apply=True, ), "crop": trans.RandomResizedCrop(100, 100, scale=(0.8, 0.95), ratio=(0.8, 1.2), always_apply=True), # "elastic": trans.ElasticTransform( # alpha=0.8, # alpha_affine=10, # sigma=40, # border_mode=cv2.BORDER_REPLICATE, # always_apply=True, # ), "distort": trans.OpticalDistortion(0.2, always_apply=True), }, "minor": { "blur": trans.GaussianBlur(7, always_apply=True), "noise": trans.GaussNoise((20.0, 40.0), always_apply=True), "bright-contrast": trans.RandomBrightnessContrast(0.4, 0.4, always_apply=True), "hsv": trans.HueSaturationValue(30, 40, 50, always_apply=True), "rgb": trans.RGBShift(always_apply=True), "flip": trans.HorizontalFlip(always_apply=True), }, }
def augmentation(in_path='./train/raw_images/', out_path='./train/aug_images/'): for filename in os.listdir(in_path): hf = transforms.HorizontalFlip(always_apply=True) vf = transforms.VerticalFlip(always_apply=True) tp = transforms.Transpose(always_apply=True) rt = transforms.Rotate(limit=80, always_apply=True) image = np.array(Image.open(in_path + filename)) hf_image = hf(image=image)['image'] vf_image = vf(image=image)['image'] tp_image = tp(image=image)['image'] rt_image = rt(image=image)['image'] count = 1 for img in [image, hf_image, vf_image, tp_image, rt_image]: if len(img.shape) == 2: img = Image.fromarray(img) img.convert(mode='RGB') else: img = Image.fromarray(img, mode='RGB') img.save(out_path + filename.replace('.jpg', '_' + str(count) + '.jpg')) count += 1
def create_transform(self, args, is_train): """ Convert numpy array into Tensor if dataset is for validation. Apply data augmentation method to train dataset while cv or test if args.use_aug is 1. is_train: boolean flg that dataset is for validation in cv or test return: Compose of albumentations """ if is_train and args.use_aug == 1: transform = A.Compose([ trans.Normalize(mean=self.cifar_10_mean, std=self.cifar_10_std, max_pixel_value=1.0), trans.HorizontalFlip(p=0.5), trans.ShiftScaleRotate(shift_limit=0, scale_limit=0.25, rotate_limit=30, p=1), trans.CoarseDropout(max_holes=1, min_holes=1, min_width=12, min_height=12, max_height=12, max_width=12, p=0.5), ToTensorV2() ]) else: transform = A.Compose([ trans.Normalize(mean=self.cifar_10_mean, std=self.cifar_10_std, max_pixel_value=1.0), ToTensorV2() ]) return transform
def __init__(self, im_paths=None, labels=None, phase=None, resize=False): """ Args: im_paths (numpy): image_data y (numpy): label data transform: pytorch transforms for transforms and tensor conversion """ self.im_paths = im_paths self.labels = labels self.resize = resize self.albumentations_transform = { 'train': Compose([ ab_transforms.HorizontalFlip(p=0.2), ab_transforms.VerticalFlip(p=0.2), ab_transforms.Rotate(limit=180, p=0.2), ab_transforms.HueSaturationValue(p=0.1), ab_transforms.RandomContrast(p=0.1), ab_transforms.GaussianBlur(blur_limit=3, p=0.2), ab_transforms.GaussNoise(p=0.05), ab_transforms.CLAHE(p=0.2), ab_transforms.Normalize(mean=[0.5944, 0.4343, 0.5652], std=[0.2593, 0.2293, 0.2377]), ToTensor() ]), 'val': Compose([ ab_transforms.Normalize(mean=[0.5944, 0.4343, 0.5652], std=[0.2593, 0.2293, 0.2377]), ToTensor() ]), } if phase == 'train': self.transform = self.albumentations_transform['train'] else: self.transform = self.albumentations_transform['val']
def main(): args = parse_args() if args.name is None: args.name = '%s_%s' % (args.arch, datetime.now().strftime('%m%d%H')) if not os.path.exists('models/%s' % args.name): os.makedirs('models/%s' % args.name) if args.resume: args = joblib.load('models/%s/args.pkl' % args.name) args.resume = True print('Config -----') for arg in vars(args): print('- %s: %s' % (arg, getattr(args, arg))) print('------------') with open('models/%s/args.txt' % args.name, 'w') as f: for arg in vars(args): print('- %s: %s' % (arg, getattr(args, arg)), file=f) joblib.dump(args, 'models/%s/args.pkl' % args.name) if args.seed is not None and not args.resume: print('set random seed') random.seed(args.seed) np.random.seed(args.seed) torch.manual_seed(args.seed) if args.loss == 'BCEWithLogitsLoss': criterion = BCEWithLogitsLoss().cuda() elif args.loss == 'WeightedBCEWithLogitsLoss': criterion = BCEWithLogitsLoss(weight=torch.Tensor([1., 1., 1., 1., 1., 2.]), smooth=args.label_smooth).cuda() elif args.loss == 'FocalLoss': criterion = FocalLoss().cuda() elif args.loss == 'WeightedFocalLoss': criterion = FocalLoss(weight=torch.Tensor([1., 1., 1., 1., 1., 2.])).cuda() else: raise NotImplementedError if args.pred_type == 'all': num_outputs = 6 elif args.pred_type == 'except_any': num_outputs = 5 else: raise NotImplementedError cudnn.benchmark = True # create model model = get_model(model_name=args.arch, num_outputs=num_outputs, freeze_bn=args.freeze_bn, dropout_p=args.dropout_p, pooling=args.pooling, lp_p=args.lp_p) model = model.cuda() train_transform = Compose([ transforms.Resize(args.img_size, args.img_size), transforms.HorizontalFlip() if args.hflip else NoOp(), transforms.VerticalFlip() if args.vflip else NoOp(), transforms.ShiftScaleRotate( shift_limit=args.shift_limit, scale_limit=args.scale_limit, rotate_limit=args.rotate_limit, border_mode=cv2.BORDER_CONSTANT, value=0, p=args.shift_scale_rotate_p ) if args.shift_scale_rotate else NoOp(), transforms.RandomContrast( limit=args.contrast_limit, p=args.contrast_p ) if args.contrast else NoOp(), RandomErase() if args.random_erase else NoOp(), transforms.CenterCrop(args.crop_size, args.crop_size) if args.center_crop else NoOp(), ForegroundCenterCrop(args.crop_size) if args.foreground_center_crop else NoOp(), transforms.RandomCrop(args.crop_size, args.crop_size) if args.random_crop else NoOp(), transforms.Normalize(mean=model.mean, std=model.std), ToTensor(), ]) if args.img_type: stage_1_train_dir = 'processed/stage_1_train_%s' %args.img_type else: stage_1_train_dir = 'processed/stage_1_train' df = pd.read_csv('inputs/stage_1_train.csv') img_paths = np.array([stage_1_train_dir + '/' + '_'.join(s.split('_')[:-1]) + '.png' for s in df['ID']][::6]) labels = np.array([df.loc[c::6, 'Label'].values for c in range(6)]).T.astype('float32') df = df[::6] df['img_path'] = img_paths for c in range(6): df['label_%d' %c] = labels[:, c] df['ID'] = df['ID'].apply(lambda s: '_'.join(s.split('_')[:-1])) meta_df = pd.read_csv('processed/stage_1_train_meta.csv') meta_df['ID'] = meta_df['SOPInstanceUID'] test_meta_df = pd.read_csv('processed/stage_1_test_meta.csv') df = pd.merge(df, meta_df, how='left') patient_ids = meta_df['PatientID'].unique() test_patient_ids = test_meta_df['PatientID'].unique() if args.remove_test_patient_ids: patient_ids = np.array([s for s in patient_ids if not s in test_patient_ids]) train_img_paths = np.hstack(df[['img_path', 'PatientID']].groupby(['PatientID'])['img_path'].apply(np.array).loc[patient_ids].to_list()).astype('str') train_labels = [] for c in range(6): train_labels.append(np.hstack(df[['label_%d' %c, 'PatientID']].groupby(['PatientID'])['label_%d' %c].apply(np.array).loc[patient_ids].to_list())) train_labels = np.array(train_labels).T if args.resume: checkpoint = torch.load('models/%s/checkpoint.pth.tar' % args.name) # train train_set = Dataset( train_img_paths, train_labels, transform=train_transform) train_loader = torch.utils.data.DataLoader( train_set, batch_size=args.batch_size, shuffle=True, num_workers=args.num_workers, # pin_memory=True, ) if args.optimizer == 'Adam': optimizer = optim.Adam( filter(lambda p: p.requires_grad, model.parameters()), lr=args.lr, weight_decay=args.weight_decay) elif args.optimizer == 'AdamW': optimizer = optim.AdamW( filter(lambda p: p.requires_grad, model.parameters()), lr=args.lr, weight_decay=args.weight_decay) elif args.optimizer == 'RAdam': optimizer = RAdam( filter(lambda p: p.requires_grad, model.parameters()), lr=args.lr, weight_decay=args.weight_decay) elif args.optimizer == 'SGD': optimizer = optim.SGD(filter(lambda p: p.requires_grad, model.parameters()), lr=args.lr, momentum=args.momentum, weight_decay=args.weight_decay, nesterov=args.nesterov) else: raise NotImplementedError if args.apex: amp.initialize(model, optimizer, opt_level='O1') if args.scheduler == 'CosineAnnealingLR': scheduler = lr_scheduler.CosineAnnealingLR( optimizer, T_max=args.epochs, eta_min=args.min_lr) elif args.scheduler == 'MultiStepLR': scheduler = lr_scheduler.MultiStepLR(optimizer, milestones=[int(e) for e in args.milestones.split(',')], gamma=args.gamma) else: raise NotImplementedError log = { 'epoch': [], 'loss': [], } start_epoch = 0 if args.resume: model.load_state_dict(checkpoint['state_dict']) optimizer.load_state_dict(checkpoint['optimizer']) scheduler.load_state_dict(checkpoint['scheduler']) start_epoch = checkpoint['epoch'] log = pd.read_csv('models/%s/log.csv' % args.name).to_dict(orient='list') for epoch in range(start_epoch, args.epochs): print('Epoch [%d/%d]' % (epoch + 1, args.epochs)) # train for one epoch train_loss = train(args, train_loader, model, criterion, optimizer, epoch) if args.scheduler == 'CosineAnnealingLR': scheduler.step() print('loss %.4f' % (train_loss)) log['epoch'].append(epoch) log['loss'].append(train_loss) pd.DataFrame(log).to_csv('models/%s/log.csv' % args.name, index=False) torch.save(model.state_dict(), 'models/%s/model.pth' % args.name) print("=> saved model") state = { 'epoch': epoch + 1, 'state_dict': model.state_dict(), 'optimizer': optimizer.state_dict(), 'scheduler': scheduler.state_dict(), } torch.save(state, 'models/%s/checkpoint.pth.tar' % args.name)
pmda_train_transform = transforms.Compose([ transforms.RandomCrop(32, padding=4, padding_mode='reflect'), transforms.RandomHorizontalFlip(), transforms.CenterCrop(32), transforms.ToTensor(), transforms.Normalize(*stats) ]) train_transform = A.Compose([ # cutout, HorizontalFlip albtransforms.RandomCrop(28, 28, always_apply=False, p=1.0), albtransforms.Rotate(30, p=0.1), albtransforms.Cutout(num_holes=8, max_h_size=8, max_w_size=8, always_apply=False, p=0.1), albtransforms.HorizontalFlip(1.0), A.Normalize(*stats), ToTensor() ]) test_transform = A.Compose([A.Normalize(*stats), ToTensor()]) # loaded only when loaddata() invoked trainset = None trainloader = None testset = None testloader = None def __custom_getitem__(self, index): image, label = self.data[index], self.targets[index]
import torch from torchvision import transforms, utils import albumentations as alb import albumentations.augmentations.transforms as aat class AlbuWrapperNumpy: # typing: ignore def __init__(self, atrans: alb.BasicTransform): self.atrans = atrans def __call__(self, img): return self.atrans(image=img)["image"] alb_transforms = alb.Compose( [ alb.Resize(256, 256, always_apply=True), alb.RandomCrop(244, 244, always_apply=True), aat.HorizontalFlip(), aat.Cutout(2, 10, 10) ]) alb_rescale = alb.Resize(244, 244, always_apply=True) transform = transforms.Compose( [transforms.ToTensor(), transforms.Normalize(0.449, 0.226)]) test_transforms = transforms.Compose( [AlbuWrapperNumpy(alb_rescale), transform]) train_transforms = transforms.Compose( [AlbuWrapperNumpy(alb_transforms), transform])
def augment(im, params=None): """ Perform data augmentation on some image using the albumentations package. Parameters ---------- im : Numpy array params : dict or None Contains the data augmentation parameters Mandatory keys: - h_flip ([0,1] float): probability of performing an horizontal left-right mirroring. - v_flip ([0,1] float): probability of performing an vertical up-down mirroring. - rot ([0,1] float): probability of performing a rotation to the image. - rot_lim (int): max degrees of rotation. - stretch ([0,1] float): probability of randomly stretching an image. - crop ([0,1] float): randomly take an image crop. - zoom ([0,1] float): random zoom applied to crop_size. --> Therefore the effective crop size at each iteration will be a random number between 1 and crop*(1-zoom). For example: * crop=1, zoom=0: no crop of the image * crop=1, zoom=0.1: random crop of random size between 100% image and 90% of the image * crop=0.9, zoom=0.1: random crop of random size between 90% image and 80% of the image * crop=0.9, zoom=0: random crop of always 90% of the image Image size refers to the size of the shortest side. - blur ([0,1] float): probability of randomly blurring an image. - pixel_noise ([0,1] float): probability of randomly adding pixel noise to an image. - pixel_sat ([0,1] float): probability of randomly using HueSaturationValue in the image. - cutout ([0,1] float): probability of using cutout in the image. Returns ------- Numpy array """ ## 1) Crop the image effective_zoom = np.random.rand() * params['zoom'] crop = params['crop'] - effective_zoom ly, lx, channels = im.shape crop_size = int(crop * min([ly, lx])) rand_x = np.random.randint(low=0, high=lx - crop_size + 1) rand_y = np.random.randint(low=0, high=ly - crop_size + 1) crop = transforms.Crop(x_min=rand_x, y_min=rand_y, x_max=rand_x + crop_size, y_max=rand_y + crop_size) im = crop(image=im)['image'] ## 2) Now add the transformations for augmenting the image pixels transform_list = [] # Add random stretching if params['stretch']: transform_list.append( imgaug_transforms.IAAPerspective(scale=0.1, p=params['stretch'])) # Add random rotation if params['rot']: transform_list.append( transforms.Rotate(limit=params['rot_lim'], p=params['rot'])) # Add horizontal flip if params['h_flip']: transform_list.append(transforms.HorizontalFlip(p=params['h_flip'])) # Add vertical flip if params['v_flip']: transform_list.append(transforms.VerticalFlip(p=params['v_flip'])) # Add some blur to the image if params['blur']: transform_list.append( albumentations.OneOf([ transforms.MotionBlur(blur_limit=7, p=1.), transforms.MedianBlur(blur_limit=7, p=1.), transforms.Blur(blur_limit=7, p=1.), ], p=params['blur'])) # Add pixel noise if params['pixel_noise']: transform_list.append( albumentations.OneOf( [ transforms.CLAHE(clip_limit=2, p=1.), imgaug_transforms.IAASharpen(p=1.), imgaug_transforms.IAAEmboss(p=1.), transforms.RandomBrightnessContrast(contrast_limit=0, p=1.), transforms.RandomBrightnessContrast(brightness_limit=0, p=1.), transforms.RGBShift(p=1.), transforms.RandomGamma(p=1.) #, # transforms.JpegCompression(), # transforms.ChannelShuffle(), # transforms.ToGray() ], p=params['pixel_noise'])) # Add pixel saturation if params['pixel_sat']: transform_list.append( transforms.HueSaturationValue(p=params['pixel_sat'])) # Remove randomly remove some regions from the image if params['cutout']: ly, lx, channels = im.shape scale_low, scale_high = 0.05, 0.25 # min and max size of the squares wrt the full image scale = np.random.uniform(scale_low, scale_high) transform_list.append( transforms.Cutout(num_holes=8, max_h_size=int(scale * ly), max_w_size=int(scale * lx), p=params['cutout'])) # Compose all image transformations and augment the image augmentation_fn = albumentations.Compose(transform_list) im = augmentation_fn(image=im)['image'] return im
transforms.RandomHorizontalFlip(), transforms.CenterCrop(32), transforms.ToTensor(), transforms.Normalize(*stats) ]) train_transform = A.Compose([ albtransforms.PadIfNeeded(min_height=40, min_width=40, border_mode=4, value=[0, 0, 0], always_apply=False, p=1.), #albtransforms.RandomCrop(32,32,always_apply=False, p=1.0), albtransforms.RandomCrop(32, 32, always_apply=False, p=1.), #albtransforms.HorizontalFlip(1.0), albtransforms.HorizontalFlip(0.5), albtransforms.Cutout(num_holes=8, max_h_size=8, max_w_size=8, always_apply=False, p=0.1), A.Normalize(*stats), ToTensor() ]) test_transform = A.Compose([A.Normalize(*stats), ToTensor()]) # loaded only when loaddata() invoked trainset = None trainloader = None testset = None
def augment(im, params=None): """ Perform data augmentation on some image using the albumentations package. Parameters ---------- im : Numpy array params : dict or None Contains the data augmentation parameters Mandatory keys: - h_flip ([0,1] float): probability of performing an horizontal left-right mirroring. - v_flip ([0,1] float): probability of performing an vertical up-down mirroring. - rot ([0,1] float): probability of performing a rotation to the image. - rot_lim (int): max degrees of rotation. - stretch ([0,1] float): probability of randomly stretching an image. - expand ([True, False] bool): whether to pad the image to a square shape with background color canvas. - crop ([0,1] float): randomly take an image crop. - invert_col ([0, 1] float): randomly invert the colors of the image. p=1 -> invert colors (VPR) - zoom ([0,1] float): random zoom applied to crop_size. --> Therefore the effective crop size at each iteration will be a random number between 1 and crop*(1-zoom). For example: * crop=1, zoom=0: no crop of the image * crop=1, zoom=0.1: random crop of random size between 100% image and 90% of the image * crop=0.9, zoom=0.1: random crop of random size between 90% image and 80% of the image * crop=0.9, zoom=0: random crop of always 90% of the image Image size refers to the size of the shortest side. - blur ([0,1] float): probability of randomly blurring an image. - pixel_noise ([0,1] float): probability of randomly adding pixel noise to an image. - pixel_sat ([0,1] float): probability of randomly using HueSaturationValue in the image. - cutout ([0,1] float): probability of using cutout in the image. Returns ------- Numpy array """ ## 1) Expand the image by padding it with bg-color canvas if params["expand"]: desired_size = max(im.shape) # check bg if np.argmax(im.shape) > 0: bgcol = tuple(np.repeat(int(np.mean(im[[0, -1], :, :])), 3)) else: bgcol = tuple(np.repeat(int(np.mean(im[:, [0, -1], :])), 3)) im = Image.fromarray(im) old_size = im.size # old_size[0] is in (width, height) format ratio = float(desired_size) / max(old_size) new_size = tuple([int(x * ratio) for x in old_size]) im = im.resize(new_size, Image.ANTIALIAS) # create a new image and paste the resized on it new_im = Image.new("RGB", (desired_size, desired_size), color=bgcol) new_im.paste(im, ((desired_size - new_size[0]) // 2, (desired_size - new_size[1]) // 2)) im = np.array(new_im) ## 2) Crop the image if params["crop"] and params["crop"] != 1: effective_zoom = np.random.rand() * params['zoom'] crop = params['crop'] - effective_zoom ly, lx, channels = im.shape crop_size = int(crop * min([ly, lx])) rand_x = np.random.randint(low=0, high=lx - crop_size + 1) rand_y = np.random.randint(low=0, high=ly - crop_size + 1) crop = transforms.Crop(x_min=rand_x, y_min=rand_y, x_max=rand_x + crop_size, y_max=rand_y + crop_size) im = crop(image=im)['image'] if params["enhance"]: im = Image.fromarray(im) enhancer = ImageEnhance.Contrast(im) im = np.array(enhancer.enhance(params["enhance"])) ## 3) Now add the transformations for augmenting the image pixels transform_list = [] if params['invert_col']: transform_list.append(transforms.InvertImg(p=params['invert_col'])) # Add random stretching if params['stretch']: transform_list.append( imgaug_transforms.IAAPerspective(scale=0.1, p=params['stretch'])) # Add random rotation if params['rot']: transform_list.append( transforms.Rotate(limit=params['rot_lim'], p=params['rot'])) # Add horizontal flip if params['h_flip']: transform_list.append(transforms.HorizontalFlip(p=params['h_flip'])) # Add vertical flip if params['v_flip']: transform_list.append(transforms.VerticalFlip(p=params['v_flip'])) # Add some blur to the image if params['blur']: transform_list.append( albumentations.OneOf([ transforms.MotionBlur(blur_limit=7, p=1.), transforms.MedianBlur(blur_limit=7, p=1.), transforms.Blur(blur_limit=7, p=1.), ], p=params['blur'])) # Add pixel noise if params['pixel_noise']: transform_list.append( albumentations.OneOf( [ transforms.CLAHE(clip_limit=2, p=1.), imgaug_transforms.IAASharpen(p=1.), imgaug_transforms.IAAEmboss(p=1.), transforms.RandomBrightnessContrast(contrast_limit=0, p=1.), transforms.RandomBrightnessContrast(brightness_limit=0, p=1.), transforms.RGBShift(p=1.), transforms.RandomGamma(p=1.) #, # transforms.JpegCompression(), # transforms.ChannelShuffle(), # transforms.ToGray() ], p=params['pixel_noise'])) # Add pixel saturation if params['pixel_sat']: transform_list.append( transforms.HueSaturationValue(p=params['pixel_sat'])) # Remove randomly remove some regions from the image if params['cutout']: ly, lx, channels = im.shape scale_low, scale_high = 0.05, 0.25 # min and max size of the squares wrt the full image scale = np.random.uniform(scale_low, scale_high) transform_list.append( transforms.Cutout(num_holes=8, max_h_size=int(scale * ly), max_w_size=int(scale * lx), p=params['cutout'])) # Compose all image transformations and augment the image augmentation_fn = albumentations.Compose(transform_list) im = augmentation_fn(image=im)['image'] return im
from dataset import TRAFFIC_LABELS_TO_NUM alb_transforms = [ alb.IAAAdditiveGaussianNoise(p=1), alb.GaussNoise(p=1), alb.MotionBlur(p=1), alb.MedianBlur(blur_limit=3, p=1), alb.Blur(blur_limit=3, p=1), alb.OpticalDistortion(p=1), alb.GridDistortion(p=1), alb.IAAPiecewiseAffine(p=1), aat.CLAHE(clip_limit=2, p=1), alb.IAASharpen(p=1), alb.IAAEmboss(p=1), aat.HueSaturationValue(p=0.3), aat.HorizontalFlip(p=1), aat.RGBShift(), aat.RandomBrightnessContrast(), aat.RandomGamma(p=1), aat.Cutout(2, 10, 10, p=1), aat.Equalize(mode='cv', p=1), aat.FancyPCA(p=1), aat.RandomFog(p=1), aat.RandomRain(blur_value=3, p=1), albumentations.IAAAffine(p=1), albumentations.ShiftScaleRotate(rotate_limit=15, p=1) ] def one_by_one(): data_dir = 'train_val/pic'
def HorizontalFlip(p=0.5): return transforms.HorizontalFlip(p=p)
def seed_everything(seed): random.seed(seed) os.environ['PYTHONHASHSEED'] = str(seed) np.random.seed(seed) torch.manual_seed(seed) torch.cuda.manual_seed(seed) torch.backends.cudnn.deterministic = True seed_everything(config.SEED) # In[58]: traindf, valdf = prepare_data(config.SEED, n_samples=5000) augmentation = Compose([A.HorizontalFlip(p=0.5)]) traindataset = Lepton(traindf, augmentation, mode='train') valdataset = Lepton(valdf, None, mode='validation') # Iterator to make batches trainloader = DataLoader(traindataset, batch_size=config.BATCH_SIZE, sampler=RandomSampler(traindataset)) valloader = DataLoader(valdataset, batch_size=config.BATCH_SIZE, sampler=SequentialSampler(valdataset)) # Initialise Model model = PaperCNN()