def __init__(self, args): self.args = args self.args.start_epoch = 0 self.args.cuda = True # data transforms input_transform = transform.Compose([ transform.ToTensor(), transform.Normalize([.490, .490, .490], [.247, .247, .247]) ]) # TODO: change mean and std # dataset train_chain = Compose([ HorizontalFlip(p=0.5), OneOf([ ElasticTransform( alpha=300, sigma=300 * 0.05, alpha_affine=300 * 0.03), GridDistortion(), OpticalDistortion(distort_limit=2, shift_limit=0.5), ], p=0.3), RandomSizedCrop( min_max_height=(900, 1024), height=1024, width=1024, p=0.5), ShiftScaleRotate(rotate_limit=20, p=0.5), Resize(self.args.size, self.args.size) ], p=1) val_chain = Compose([Resize(self.args.size, self.args.size)], p=1) num_fold = self.args.num_fold df_train = pd.read_csv(os.path.join(args.imagelist_path, 'train.csv')) df_val = pd.read_csv(os.path.join(args.imagelist_path, 'val.csv')) df_full = pd.concat((df_train, df_val), ignore_index=True, axis=0) df_full['lbl'] = (df_full['mask_name'].astype(str) == '-1').astype(int) skf = StratifiedKFold(8, shuffle=True, random_state=777) train_ids, val_ids = list( skf.split(df_full['mask_name'], df_full['lbl']))[num_fold] df_test = pd.read_csv( os.path.join(args.imagelist_path, 'test_true.csv')) df_new_train = pd.concat((df_full.iloc[train_ids], df_test), ignore_index=True, axis=0, sort=False) df_new_val = df_full.iloc[val_ids] df_new_train.to_csv(f'/tmp/train_new_pneumo_{num_fold}.csv') df_new_val.to_csv(f'/tmp/val_new_pneumo_{num_fold}.csv') trainset = SegmentationDataset(f'/tmp/train_new_pneumo_{num_fold}.csv', args.image_path, args.masks_path, input_transform=input_transform, transform_chain=train_chain, base_size=1024) testset = SegmentationDataset(f'/tmp/val_new_pneumo_{num_fold}.csv', args.image_path, args.masks_path, input_transform=input_transform, transform_chain=val_chain, base_size=1024) imgs = trainset.mask_img_map[:, [0, 3]] weights = make_weights_for_balanced_classes(imgs, 2) weights = torch.DoubleTensor(weights) train_sampler = (torch.utils.data.sampler.WeightedRandomSampler( weights, len(weights))) # dataloader kwargs = {'num_workers': args.workers, 'pin_memory': True} self.trainloader = data.DataLoader( trainset, batch_size=args.batch_size, drop_last=True, sampler=train_sampler, #shuffle=True, **kwargs) self.valloader = data.DataLoader(testset, batch_size=args.batch_size, drop_last=False, shuffle=False, **kwargs) self.nclass = 1 if self.args.model == 'unet': model = UNet(n_classes=self.nclass, norm_layer=SyncBatchNorm) params_list = [ { 'params': model.parameters(), 'lr': args.lr }, ] elif self.args.model == 'encnet': model = EncNet( nclass=self.nclass, backbone=args.backbone, aux=args.aux, se_loss=args.se_loss, norm_layer=SyncBatchNorm #nn.BatchNorm2d ) # optimizer using different LR params_list = [ { 'params': model.pretrained.parameters(), 'lr': args.lr }, ] if hasattr(model, 'head'): params_list.append({ 'params': model.head.parameters(), 'lr': args.lr * 10 }) if hasattr(model, 'auxlayer'): params_list.append({ 'params': model.auxlayer.parameters(), 'lr': args.lr * 10 }) print(model) optimizer = torch.optim.SGD(params_list, lr=args.lr, momentum=0.9, weight_decay=args.wd) # criterions if self.nclass == 1: self.criterion = SegmentationLossesBCE(se_loss=args.se_loss, aux=args.aux, nclass=self.nclass, se_weight=args.se_weight, aux_weight=args.aux_weight, use_dice=args.use_dice) else: self.criterion = SegmentationLosses( se_loss=args.se_loss, aux=args.aux, nclass=self.nclass, se_weight=args.se_weight, aux_weight=args.aux_weight, ) self.model, self.optimizer = model, optimizer self.best_pred = 0.0 self.model = DataParallelModel(self.model).cuda() self.criterion = DataParallelCriterion(self.criterion).cuda() # resuming checkpoint if args.resume is not None: if not os.path.isfile(args.resume): raise RuntimeError("=> no checkpoint found at '{}'".format( args.resume)) checkpoint = torch.load(args.resume) #, map_location='cpu') self.args.start_epoch = checkpoint['epoch'] state_dict = {k: v for k, v in checkpoint['state_dict'].items()} self.model.load_state_dict(state_dict) self.optimizer.load_state_dict(checkpoint['optimizer']) for g in self.optimizer.param_groups: g['lr'] = args.lr self.best_pred = checkpoint['best_pred'] print("=> loaded checkpoint '{}' (epoch {})".format( args.resume, checkpoint['epoch'])) print(f'Best dice: {checkpoint["best_pred"]}') print(f'LR: {get_lr(self.optimizer):.5f}') self.scheduler = ReduceLROnPlateau(self.optimizer, mode='min', factor=0.8, patience=4, threshold=0.001, threshold_mode='abs', min_lr=0.00001) self.logger = Logger(args.logger_dir) self.step_train = 0 self.best_loss = 20 self.step_val = 0
def make_prediction( device_num: int, equalization: bool = False, normalization: bool = False, ): device = torch.device(f'cuda:{device_num}') trn_lbl_df = load_trn_lbl_df() trn_hdr_df = pd.read_pickle(TRN_HDR_DF_PATH) tst_hdr_df = pd.read_pickle(TST_HDR_DF_PATH) trn_df = pd.concat([trn_hdr_df, trn_lbl_df], axis=1, join='inner') trn_outlier_mask, tst_outlier_mask = get_outlier(trn_df, tst_hdr_df) valid_trn_df = trn_df[~trn_outlier_mask] trn_dset_kwargs = { 'training': True, 'dataframe': valid_trn_df, 'window_ranges': DEFAULT_WINDOW_RANGES, 'equalization': equalization, 'regularize_dim': 512, 'low_memory': True, } tst_dset_kwargs = { 'training': False, 'dataframe': tst_hdr_df, 'window_ranges': DEFAULT_WINDOW_RANGES, 'equalization': equalization, 'regularize_dim': 512, 'low_memory': True, } if normalization: channel_avgs, channel_stds, nan_sample_ids = \ normalize_dset(trn_dset_kwargs, num_workers=-1, batch_size=128) valid_trn_df.drop(nan_sample_ids, inplace=True) trn_transform = Compose([ Resize(IMG_DIM, IMG_DIM), Normalize(mean=channel_avgs, std=channel_stds), HorizontalFlip(), RandomBrightnessContrast(), ShiftScaleRotate(), ToTensor() ]) tst_transform = Compose([ Resize(IMG_DIM, IMG_DIM), Normalize(mean=channel_avgs, std=channel_stds), ToTensor() ]) else: trn_transform = Compose([ Resize(IMG_DIM, IMG_DIM), HorizontalFlip(), RandomBrightnessContrast(), ShiftScaleRotate(), ToTensor() ]) tst_transform = Compose([Resize(IMG_DIM, IMG_DIM), ToTensor()]) trn_dset = ICHDataset(**trn_dset_kwargs, transform=trn_transform) tst_dset = ICHDataset(**tst_dset_kwargs, transform=tst_transform) dldr_kwargs = { 'batch_size': 32, 'num_workers': 32, 'pin_memory': True, 'timeout': 1000, } trn_dldr = DataLoader(trn_dset, **dldr_kwargs) tst_dldr = DataLoader(tst_dset, **dldr_kwargs) model = torch.hub.load( 'facebookresearch/WSL-Images', f'resnext101_32x{NUM_CARDINALITY}d_wsl', ).to(device) model.fc = torch.nn.Linear(2048, len(DIAGNOSIS)).to(device) criterion = torch.nn.BCEWithLogitsLoss( weight=torch.FloatTensor([2, 1, 1, 1, 1, 1]).to(device)) optim = torch.optim.Adam(params=model.parameters(), lr=2e-5) amp.initialize(model, optim, opt_level='O1') for epoch in range(NUM_EPOCHS): print('Epoch {}/{}'.format(epoch, NUM_EPOCHS - 1)) print('-' * 10) # model.train() # tr_loss = 0 # # trn_iter = tqdm(trn_dldr, desc="Iteration") # # for step, batch in enumerate(trn_iter): # # inputs = batch["image"] # labels = batch["labels"] # # inputs = inputs.to(device, dtype=torch.float) # labels = labels.to(device, dtype=torch.float) # # outputs = model(inputs) # loss = criterion(outputs, labels) # # loss.backward() # # tr_loss += loss.item() # # optim.step() # optim.zero_grad() # # if epoch == 1 and step > 6000: # epoch_loss = tr_loss / 6000 # print('Training Loss: {:.4f}'.format(epoch_loss)) # break # # epoch_loss = tr_loss / len(trn_dldr) # print('Training Loss: {:.4f}'.format(epoch_loss)) with torch.no_grad(): model.eval() ids = [] predictions = [] tst_iter = tqdm(tst_dldr, desc="Iteration") for step, batch in enumerate(tst_iter): inputs = batch['image'] ids.extend(batch['id']) inputs = inputs.to(device, dtype=torch.float) # labels = labels.to(device, dtype=torch.float) predictions.extend(torch.sigmoid(model(inputs)).tolist()) pred_df = pd.DataFrame(predictions, columns=DIAGNOSIS, index=ids) pred_df.index.name = 'ID' masked_pred_df = pred_df.copy(deep=True) masked_pred_df.loc[tst_outlier_mask] = \ [[0, 0, 0, 0, 0, 0]] * tst_outlier_mask.sum() print(pred_df.head()) print(masked_pred_df.head()) tst_lbl_df_to_submission_csv( pred_df, f'./e_{equalization}_n_{normalization}_{epoch+1}.csv') tst_lbl_df_to_submission_csv( masked_pred_df, f'./masked_e_{equalization}_n_{normalization}_{epoch+1}.csv')
import random random.seed(1000) from albumentations import (Compose, HorizontalFlip, CLAHE, HueSaturationValue, RandomBrightness, RandomContrast, RandomGamma, RandomRotate90, VerticalFlip, RandomCrop, ToFloat, ShiftScaleRotate, GaussianBlur) AUGMENTATIONS_TRAIN = Compose([ HorizontalFlip(p=1), VerticalFlip(p=0.5), # RandomContrast(limit=0.2, p=0.5), RandomRotate90(p=0.5), RandomGamma(gamma_limit=(80, 120), p=0.5), # RandomBrightness(limit=0.2, p=0.5), # HueSaturationValue(hue_shift_limit=5, sat_shift_limit=20, # val_shift_limit=10, p=.9), # CLAHE(p=1.0, clip_limit=2.0), ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.1, rotate_limit=15, border_mode=cv2.BORDER_REFLECT_101, p=0.5), # RandomCrop(227, 227, p=1.0), # ToFloat(max_value=255) ]) AUGMENTATIONS_TEST = Compose([ # CLAHE(p=1.0, clip_limit=2.0), # RandomCrop(227, 227, p=1.0), # ToFloat(max_value=255,p=1) ])
import cv2 from albumentations import Compose, OneOf, Normalize, ShiftScaleRotate from albumentations import GaussNoise, OpticalDistortion, GridDistortion from albumentations import Cutout, Rotate, ElasticTransform, IAAAffine, IAAPerspective augmix_transform = [ ShiftScaleRotate(rotate_limit=15, p=1), OpticalDistortion(p=1), Cutout(max_h_size=8, max_w_size=8, p=1), # GridDistortion(p=1), Rotate(limit=15, p=1) ] faa_transform = Compose([ # GaussNoise(p=0.2), GridDistortion(num_steps=6, distort_limit=0.046, p=0.02), # OneOf([ # OpticalDistortion(p=1), # ElasticTransform(p=1), # ], p=0.2), Cutout(num_holes=7, max_h_size=18, max_w_size=2, p=0.05), ]) train_transform = Compose([ ShiftScaleRotate(rotate_limit=15, p=0.5), # GaussNoise(p=0.2), # GridDistortion(p=0.5), # OneOf([ # OpticalDistortion(p=1), # ElasticTransform(p=1), # ], p=0.2),
from albumentations import Compose, Resize, RandomCrop, Flip, HorizontalFlip, VerticalFlip, Transpose, RandomRotate90, \ ShiftScaleRotate, OneOf, OpticalDistortion, Blur, MotionBlur, GaussianBlur from albumentations.pytorch import ToTensor train_aug = Compose([ RandomCrop(height=96, width=96, p=0.2), OneOf([ VerticalFlip(p=0.2), HorizontalFlip(p=0.3), Transpose(p=0.2), RandomRotate90(p=0.2), ], p=0.3), ShiftScaleRotate(p=0.2), OneOf([ Blur(p=0.2), MotionBlur(p=0.2), GaussianBlur(p=0.2), OpticalDistortion(p=0.2), ], p=0.3), Resize(128, 128, always_apply=True), ToTensor() ]) valid_aug = Compose([Resize(128, 128, always_apply=True), ToTensor()])
def get_transforms(*, data): if data == 'train': return Compose( [ #Resize(CFG.size, CFG.size), RandomResizedCrop(CFG.size, CFG.size, scale=(0.85, 1.0)), HorizontalFlip(p=0.5), RandomBrightnessContrast(p=0.2, brightness_limit=(-0.2, 0.2), contrast_limit=(-0.2, 0.2)), HueSaturationValue(p=0.2, hue_shift_limit=0.2, sat_shift_limit=0.2, val_shift_limit=0.2), ShiftScaleRotate(p=0.2, shift_limit=0.0625, scale_limit=0.2, rotate_limit=20), CoarseDropout(p=0.2), Cutout(p=0.2, max_h_size=16, max_w_size=16, fill_value=(0., 0., 0.), num_holes=16), Normalize( mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], ), ToTensorV2(), ], additional_targets={'image_annot': 'image'}) elif data == 'check': return Compose( [ #Resize(CFG.size, CFG.size), RandomResizedCrop(CFG.size, CFG.size, scale=(0.85, 1.0)), HorizontalFlip(p=0.5), RandomBrightnessContrast(p=0.2, brightness_limit=(-0.2, 0.2), contrast_limit=(-0.2, 0.2)), HueSaturationValue(p=0.2, hue_shift_limit=0.2, sat_shift_limit=0.2, val_shift_limit=0.2), ShiftScaleRotate(p=0.2, shift_limit=0.0625, scale_limit=0.2, rotate_limit=20), CoarseDropout(p=0.2), Cutout(p=0.2, max_h_size=16, max_w_size=16, fill_value=(0., 0., 0.), num_holes=16), #Normalize( # mean=[0.485, 0.456, 0.406], # std=[0.229, 0.224, 0.225], #), ToTensorV2(), ], additional_targets={'image_annot': 'image'}) elif data == 'valid': return Compose([ Resize(CFG.size, CFG.size), Normalize( mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], ), ToTensorV2(), ])
def generate_transforms(image_size): # train_transform = Compose( # [ # Resize(height=int(image_size[0]), width=int(image_size[1])), # OneOf([RandomBrightness(limit=0.1, p=1), RandomContrast(limit=0.1, p=1)]), # OneOf([MotionBlur(blur_limit=3), MedianBlur(blur_limit=3), GaussianBlur(blur_limit=3)], p=0.5), # VerticalFlip(p=0.5), # HorizontalFlip(p=0.5), # # Transpose(p=0.5), # HueSaturationValue(hue_shift_limit=0.2, sat_shift_limit=0.2, val_shift_limit=0.2, p=0.5), # CoarseDropout(p=0.5), # Cutout(p=0.5), # ShiftScaleRotate( # shift_limit=0.2, # scale_limit=0.2, # rotate_limit=20, # interpolation=cv2.INTER_LINEAR, # border_mode=cv2.BORDER_REFLECT_101, # 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), # ] # ) train_transform = Compose( [ RandomResizedCrop(int(image_size[0]), int(image_size[1]), scale=(0.08, 1.0), ratio=(0.75, 1.3333333333333333)), Transpose(p=0.5), HorizontalFlip(p=0.5), VerticalFlip(p=0.5), ShiftScaleRotate(p=0.5), HueSaturationValue(hue_shift_limit=0.2, sat_shift_limit=0.2, val_shift_limit=0.2, p=0.5), RandomBrightnessContrast(brightness_limit=(-0.1, 0.1), contrast_limit=(-0.1, 0.1), p=0.5), Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], max_pixel_value=255.0, p=1.0), # CoarseDropout(p=0.5), # Cutout(p=0.5), # ToTensorV2(p=1.0), ], p=1.) val_transform = Compose([ Resize(height=int(image_size[0]), width=int(image_size[1])), Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), max_pixel_value=255.0, p=1.0), ]) return { "train_transforms": train_transform, "val_transforms": val_transform }
bad_images = [ '046586a', '1588d4c', '1e40a05', '41f92e5', '449b792', '563fc48', '8bd81ce', 'b092cc1', 'c0306e5', 'c26c635', 'e04fea3', 'e5f2f24', 'eda52f2', 'fa645da' ] AUGMENTATIONS_TRAIN = Compose([ RandomRotate90(p=0.25), RandomResizedCrop( height=TRAIN_SHAPE[0], width=TRAIN_SHAPE[1], scale=(0.8, 1.0)), HorizontalFlip(p=0.5), VerticalFlip(p=0.5), ShiftScaleRotate(shift_limit=(-0.2, 0.2), scale_limit=(-0.2, 0.2), rotate_limit=(-20, 20), border_mode=0, interpolation=1, p=0.25), OneOf([ RandomBrightnessContrast(brightness_limit=(-0.2, 0.2), contrast_limit=(-0.2, 0.2)), RandomGamma(), CLAHE() ], p=0.4), OneOf([ ElasticTransform( p=0.2, alpha=120, sigma=120 * 0.1, alpha_affine=120 * 0.03), GridDistortion(p=0.5), OpticalDistortion(border_mode=0, distort_limit=0.05,
train = train.set_index('Image').loc[png].reset_index() # get fold valdf = train[train['fold'] == fold].reset_index(drop=True) trndf = train[train['fold'] != fold].reset_index(drop=True) # Data loaders mean_img = [0.22363983, 0.18190407, 0.2523437] std_img = [0.32451536, 0.2956294, 0.31335256] transform_train = Compose([ #ShiftScaleRotate(), #CenterCrop(height = SIZE//10, width = SIZE//10, p=0.3), HorizontalFlip(p=0.5), ShiftScaleRotate(shift_limit=0.05, scale_limit=0.05, rotate_limit=20, p=0.3, border_mode=cv2.BORDER_REPLICATE), Transpose(p=0.5), Normalize(mean=mean_img, std=std_img, max_pixel_value=255.0, p=1.0), ToTensor() ]) HFLIPVAL = 1.0 if HFLIP == 'T' else 0.0 TRANSPOSEVAL = 1.0 if TRANSPOSE == 'P' else 0.0 transform_test = Compose([ HorizontalFlip(p=HFLIPVAL), Transpose(p=TRANSPOSEVAL), Normalize(mean=mean_img, std=std_img, max_pixel_value=255.0, p=1.0), ToTensor() ])
def train_transform(self): # albumentations transforms cfg at_cfg = self.cfg.abtfs height, width = self.img_size transforms_list = [Resize(height, width), Flip()] # random_grid_shuffle if at_cfg.random_grid_shuffle.enable: grid = at_cfg.random_grid_shuffle.grid grid = (grid, grid) transforms_list.append(RandomGridShuffle((grid))) # channel_shuffle if at_cfg.channel_shuffle.enable: transforms_list.append(ChannelShuffle(p=1)) # channel_dropout if at_cfg.channel_dropout.enable: drop_range = at_cfg.channel_dropout.drop_range fill_value = at_cfg.channel_dropout.fill_value transforms_list.append(ChannelDropout(drop_range, fill_value, p=1)) # noise if at_cfg.noise.enable: transforms_list.append( OneOf([ IAAAdditiveGaussianNoise(), GaussNoise(), ], p=1)) # blur if at_cfg.blur.enable: transforms_list.append( OneOf([ MotionBlur(), Blur(blur_limit=3, ), ], p=1)) # rotate if at_cfg.rotate.enable: transforms_list.append( ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=1)) # distortion if at_cfg.distortion.enable: transforms_list.append( OneOf([ OpticalDistortion(p=0.3), GridDistortion(p=.3), ], p=1)) # bright if at_cfg.bright.enable: transforms_list.append( OneOf([ CLAHE(clip_limit=2), RandomBrightnessContrast(p=0.8), ], p=1)) # hue color if at_cfg.hue.enable: transforms_list.append(HueSaturationValue(p=0.3)) # cutout if at_cfg.cutout.enable: num_holes = at_cfg.cutout.num_holes size = at_cfg.cutout.size fill_value = at_cfg.cutout.fill_value transforms_list.append(Cutout(num_holes, size, size, fill_value, 1)) transforms_list.append(self.normalize) transforms_list.append(ToTensor()) return Compose(transforms_list)
def imgClassificationfolder(self, img_path, model_list=None, tfms=True, advance_augmentation=False, size=224, bs=16, epochs=1, test_size=0.3): """ RETURNS MODEL model_list: list of names of all models that need to be trained Call Model_Names() function to get the list of available models img_path: path to the images root folder containing the individual image folders tfms: augmentation transforms. Possible methods are True or False advance_augmentation: Should we apply advance data augmentation? size: individual image size in dataloader. Default size set to 224 bs:batch size epochs:number of epochs for which the individual models need to be trained test_size:test size for ranking the models """ dictionary = {} dictionary["models"] = [ resnet18, resnet34, resnet50, resnet101, resnet152, densenet121, densenet169, densenet201, densenet161, vgg16_bn, vgg19_bn ] dictionary["model_names"] = [ 'resnet18', 'resnet34', 'resnet50', 'resnet101', 'resnet152', 'densenet121', 'densenet169', 'densenet201', 'densenet161', 'vgg16_bn', 'vgg19_bn' ] dictionary["efficientnets"] = [ "efficientnet-b{}".format(i) for i in range(0, 8) ] accuracy = [] roc_auc = [] list_names = [] path = '' if model_list is None: model_list = dictionary["model_names"] if tfms == True: if advance_augmentation: tfms = get_transforms(do_flip=True, max_lighting=0.2, max_zoom=1.1, max_warp=0.15, max_rotate=45, xtra_tfms=[ alb_tfm2fastai(ElasticTransform()), alb_tfm2fastai(GridDistortion()), alb_tfm2fastai(OpticalDistortion()), alb_tfm2fastai(MedianBlur()), alb_tfm2fastai(ToGray()), alb_tfm2fastai(JpegCompression()), alb_tfm2fastai(Transpose()), alb_tfm2fastai(ShiftScaleRotate()), alb_tfm2fastai(Normalize()), alb_tfm2fastai(Blur()), alb_tfm2fastai(CLAHE()), alb_tfm2fastai(RGBShift()), alb_tfm2fastai(ChannelShuffle()), alb_tfm2fastai(RandomContrast()), alb_tfm2fastai(RandomBrightness()) ]) else: tfms = get_transforms(do_flip=True, max_lighting=0.2, max_zoom=1.1, max_warp=0.15, max_rotate=45) else: tfms = False data = ImageDataBunch.from_folder( img_path, valid_pct=test_size, ds_tfms=tfms, size=224, num_workers=4).normalize(imagenet_stats) print("Loaded dataset\n") print("Labels classified from the source are {}\n".format( data.classes)) max_score = 0 for model in model_list: if model in dictionary["model_names"]: print("Started training {}\n".format(model)) acc, auroc, names, model = self.res_dense_vgg( data, eval(model), epochs) accuracy.append(acc) roc_auc.append(auroc) list_names.append(names) if model in dictionary['efficientnets']: print("Started training {}\n".format(model)) acc, auroc, names, model = self.eff(data, model, epochs) accuracy.append(acc) roc_auc.append(auroc) list_names.append(names) if acc > max_score: best_model = model max_score = acc else: del model df = pd.DataFrame(list(zip(model_list, accuracy, roc_auc)), columns=['Model', 'Accuracy', 'ROAUC']) df.sort_values('Accuracy', inplace=True, ascending=False) self.plot_table(df) return best_model
def _get_data_loader(imgs, trn_df, vld_df): from albumentations import ( Rotate, HorizontalFlip, IAAPerspective, ShiftScaleRotate, CLAHE, RandomRotate90, Transpose, ShiftScaleRotate, Blur, OpticalDistortion, GridDistortion, HueSaturationValue, IAAAdditiveGaussianNoise, GaussNoise, MotionBlur, MedianBlur, RandomBrightnessContrast, IAAPiecewiseAffine, IAASharpen, IAAEmboss, Flip, OneOf, Compose) from albumentations.pytorch import ToTensor, ToTensorV2 train_transforms = Compose([ Rotate(20), OneOf([ IAAAdditiveGaussianNoise(), GaussNoise(), ], p=0.2), OneOf([ MotionBlur(p=.2), MedianBlur(blur_limit=3, p=0.1), Blur(blur_limit=3, p=0.1), ], p=0.2), ShiftScaleRotate( shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=0.2), OneOf([ OpticalDistortion(p=0.3), GridDistortion(p=.1), IAAPiecewiseAffine(p=0.3), ], p=0.2), OneOf([ CLAHE(clip_limit=2), IAASharpen(), IAAEmboss(), RandomBrightnessContrast(), ], p=0.3), HueSaturationValue(p=0.3), ToTensor() ], p=1.0) valid_transforms = Compose([ToTensor()]) from torch.utils.data import Dataset, DataLoader trn_dataset = BangaliDataset(imgs=imgs, label_df=trn_df, transform=train_transforms) vld_dataset = BangaliDataset(imgs=imgs, label_df=vld_df, transform=valid_transforms) trn_loader = DataLoader(trn_dataset, shuffle=True, num_workers=NUM_WORKERS, batch_size=BATCH_SIZE) vld_loader = DataLoader(vld_dataset, shuffle=False, num_workers=NUM_WORKERS, batch_size=BATCH_SIZE) return trn_loader, vld_loader
def __init__(self, shift_limit=0.01, scale_limit=0.2, rotate_limit=180, apply_prob=1.0): self.aug = Compose([ShiftScaleRotate(shift_limit=shift_limit, scale_limit=scale_limit, rotate_limit=rotate_limit, border_mode=cv2.BORDER_CONSTANT, value=0)], p=apply_prob, keypoint_params={'format': 'xy'})
def build_databunch(cfg, tmp_dir): dataset = cfg.data.dataset validate_dataset(dataset) img_sz = cfg.data.img_sz batch_sz = cfg.solver.batch_sz num_workers = cfg.data.num_workers data_cache_dir = '/opt/data/data-cache' if cfg.data.dataset == pascal2007: if cfg.base_uri.startswith('s3://'): data_dir = join(data_cache_dir, 'pascal2007-data') if not os.path.isdir(data_dir): print('Downloading pascal2007.zip...') zip_path = download_if_needed( join(cfg.base_uri, 'pascal2007.zip'), data_cache_dir) unzip(zip_path, data_dir) else: data_dir = join(cfg.base_uri, 'data', 'pascal_2007') train_dir = join(data_dir, 'train') train_anns = [ join(data_dir, 'train.json'), join(data_dir, 'valid.json') ] test_dir = join(data_dir, 'test') test_anns = [join(data_dir, 'test.json')] label_names = get_label_names(train_anns[0]) aug_transforms = [] if cfg.data.train_aug.hflip: aug_transforms.append(HorizontalFlip(p=0.5)) if cfg.data.train_aug.rgb_shift: aug_transforms.append(RGBShift(20, 20, 20, p=0.5)) if cfg.data.train_aug.shift_scale_rotate: aug_transforms.append( ShiftScaleRotate(shift_limit=0.1, scale_limit=0.3, rotate_limit=0, border_mode=cv2.BORDER_CONSTANT)) basic_transforms = [Resize(img_sz, img_sz), ToTensor()] aug_transforms.extend(basic_transforms) bbox_params = BboxParams(format='coco', min_area=0., min_visibility=0.2, label_fields=['labels']) aug_transforms = Compose(aug_transforms, bbox_params=bbox_params) transforms = Compose(basic_transforms, bbox_params=bbox_params) train_ds, valid_ds, test_ds = None, None, None if cfg.overfit_mode: train_ds = CocoDataset(train_dir, train_anns, transforms=transforms) train_ds = Subset(train_ds, range(batch_sz)) test_ds = train_ds elif cfg.test_mode: train_ds = CocoDataset(train_dir, train_anns, transforms=aug_transforms) train_ds = Subset(train_ds, range(batch_sz)) valid_ds = train_ds test_ds = train_ds else: train_ds = CocoDataset(train_dir, train_anns, transforms=aug_transforms) test_ds = CocoDataset(test_dir, test_anns, transforms=transforms) valid_ds = Subset(test_ds, range(len(test_ds.imgs) // 5)) train_dl = DataLoader(train_ds, shuffle=True, collate_fn=collate_fn, batch_size=batch_sz, num_workers=num_workers, pin_memory=True) \ if train_ds else None valid_dl = DataLoader(valid_ds, collate_fn=collate_fn, batch_size=batch_sz, num_workers=num_workers, pin_memory=True) \ if valid_ds else None test_dl = DataLoader(test_ds, collate_fn=collate_fn, batch_size=batch_sz, num_workers=num_workers, pin_memory=True) \ if test_ds else None return DataBunch(train_ds, train_dl, valid_ds, valid_dl, test_ds, test_dl, label_names)
def __init__(self, split: Callable[[str], str] = lambda x: path.splitext(x)[0], suffix: str = '.gt.txt', normalization: Optional[str] = None, whitespace_normalization: bool = True, reorder: bool = True, im_transforms: Callable[[Any], torch.Tensor] = transforms.Compose( []), preload: bool = True, augmentation: bool = False) -> None: """ Reads a list of image-text pairs and creates a ground truth set. Args: split (func): Function for generating the base name without extensions from paths suffix (str): Suffix to attach to image base name for text retrieval mode (str): Image color space. Either RGB (color) or L (grayscale/bw). Only L is compatible with vertical scaling/dewarping. scale (int, tuple): Target height or (width, height) of dewarped line images. Vertical-only scaling is through CenterLineNormalizer, resizing with Lanczos interpolation. Set to 0 to disable. normalization (str): Unicode normalization for gt whitespace_normalization (str): Normalizes unicode whitespace and strips whitespace. reorder (bool): Whether to rearrange code points in "display"/LTR order im_transforms (func): Function taking an PIL.Image and returning a tensor suitable for forward passes. preload (bool): Enables preloading and preprocessing of image files. """ self.suffix = suffix self.split = lambda x: split(x) + self.suffix self._images = [] # type: Union[List[Image], List[torch.Tensor]] self._gt = [] # type: List[str] self.alphabet = Counter() # type: Counter self.text_transforms = [] # type: List[Callable[[str], str]] # split image transforms into two. one part giving the final PIL image # before conversion to a tensor and the actual tensor conversion part. self.head_transforms = transforms.Compose(im_transforms.transforms[:2]) self.tail_transforms = transforms.Compose(im_transforms.transforms[2:]) self.aug = None self.preload = preload self.seg_type = 'bbox' # built text transformations if normalization: self.text_transforms.append( lambda x: unicodedata.normalize(cast(str, normalization), x)) if whitespace_normalization: self.text_transforms.append( lambda x: regex.sub('\s', ' ', x).strip()) if reorder: self.text_transforms.append(bd.get_display) if augmentation: from albumentations import ( Compose, ToFloat, FromFloat, Flip, OneOf, MotionBlur, MedianBlur, Blur, ShiftScaleRotate, OpticalDistortion, ElasticTransform, RandomBrightnessContrast, ) self.aug = Compose([ ToFloat(), OneOf([ MotionBlur(p=0.2), MedianBlur(blur_limit=3, p=0.1), Blur(blur_limit=3, p=0.1), ], p=0.2), ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=0.2), OneOf([ OpticalDistortion(p=0.3), ElasticTransform(p=0.1), ], p=0.2), ], p=0.5) self.im_mode = '1'
"2017-08-04", "2017-08-19", ) rgb_file_path = f"{args.root}/train_rgb.csv" nir_file_path = f"{args.root}/train_b08.csv" additional_targets = { f"image{n}": "image" for n, _ in enumerate(dates[:-1]) } data_transform = Compose( [ RandomCrop(128, 128), VerticalFlip(p=0.3), Transpose(p=0.3), ShiftScaleRotate(p=0.3), RandomRotate90(p=0.3), GridDistortion(p=0.3), ElasticTransform(p=0.3), Normalize(), ], additional_targets=additional_targets, ) val_transform = Compose( [RandomCrop(128, 128), Normalize()], additional_targets=additional_targets) #fold_sets = [[(0, 1, 2), (0, 1, 2)]] fold_sets = [[(1, 2), (0, )], [(0, 2), (1, )], [(0, 1), (2, )]] # # KOSTIL' ALERT
def __init__(self, imgs: Sequence[str] = None, suffix: str = '.path', line_width: int = 4, im_transforms: Callable[[Any], torch.Tensor] = transforms.Compose( []), mode: str = 'path', augmentation: bool = False, valid_baselines: Sequence[str] = None, merge_baselines: Dict[str, Sequence[str]] = None, valid_regions: Sequence[str] = None, merge_regions: Dict[str, Sequence[str]] = None): """ Reads a list of image-json pairs and creates a data set. Args: imgs (list): suffix (int): Suffix to attach to image base name to load JSON files from. line_width (int): Height of the baseline in the scaled input. target_size (tuple): Target size of the image as a (height, width) tuple. mode (str): Either path, alto, page, xml, or None. In alto, page, and xml mode the baseline paths and image data is retrieved from an ALTO/PageXML file. In `None` mode data is iteratively added through the `add` method. augmentation (bool): Enable/disable augmentation. valid_baselines (list): Sequence of valid baseline identifiers. If `None` all are valid. merge_baselines (dict): Sequence of baseline identifiers to merge. Note that merging occurs after entities not in valid_* have been discarded. valid_regions (list): Sequence of valid region identifiers. If `None` all are valid. merge_regions (dict): Sequence of region identifiers to merge. Note that merging occurs after entities not in valid_* have been discarded. """ super().__init__() self.mode = mode self.im_mode = '1' self.aug = None self.targets = [] # n-th entry contains semantic of n-th class self.class_mapping = { 'aux': { '_start_separator': 0, '_end_separator': 1 }, 'baselines': {}, 'regions': {} } self.class_stats = { 'baselines': defaultdict(int), 'regions': defaultdict(int) } self.num_classes = 2 self.mbl_dict = merge_baselines if merge_baselines is not None else {} self.mreg_dict = merge_regions if merge_regions is not None else {} self.valid_baselines = valid_baselines self.valid_regions = valid_regions if mode in ['alto', 'page', 'xml']: if mode == 'alto': fn = parse_alto elif mode == 'page': fn = parse_page elif mode == 'xml': fn = parse_xml im_paths = [] self.targets = [] for img in imgs: try: data = fn(img) im_paths.append(data['image']) lines = defaultdict(list) for line in data['lines']: if valid_baselines is None or line[ 'script'] in valid_baselines: lines[self.mbl_dict.get(line['script'], line['script'])].append( line['baseline']) self.class_stats['baselines'][self.mbl_dict.get( line['script'], line['script'])] += 1 regions = defaultdict(list) for k, v in data['regions'].items(): if valid_regions is None or k in valid_regions: regions[self.mreg_dict.get(k, k)].extend(v) self.class_stats['regions'][self.mreg_dict.get( k, k)] += len(v) data['regions'] = regions self.targets.append({ 'baselines': lines, 'regions': data['regions'] }) except KrakenInputException as e: logger.warning(e) continue # get line types imgs = im_paths # calculate class mapping line_types = set() region_types = set() for page in self.targets: for line_type in page['baselines'].keys(): line_types.add(line_type) for reg_type in page['regions'].keys(): region_types.add(reg_type) idx = -1 for idx, line_type in enumerate(line_types): self.class_mapping['baselines'][ line_type] = idx + self.num_classes self.num_classes += idx + 1 idx = -1 for idx, reg_type in enumerate(region_types): self.class_mapping['regions'][ reg_type] = idx + self.num_classes self.num_classes += idx + 1 elif mode == 'path': pass elif mode is None: imgs = [] else: raise Exception('invalid dataset mode') if augmentation: from albumentations import ( Compose, ToFloat, FromFloat, RandomRotate90, Flip, OneOf, MotionBlur, MedianBlur, Blur, ShiftScaleRotate, OpticalDistortion, ElasticTransform, RandomBrightnessContrast, HueSaturationValue, ) self.aug = Compose([ ToFloat(), RandomRotate90(), Flip(), OneOf([ MotionBlur(p=0.2), MedianBlur(blur_limit=3, p=0.1), Blur(blur_limit=3, p=0.1), ], p=0.2), ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=0.2), OneOf([ OpticalDistortion(p=0.3), ElasticTransform(p=0.1), ], p=0.2), HueSaturationValue(hue_shift_limit=20, sat_shift_limit=0.1, val_shift_limit=0.1, p=0.3), ], p=0.5) self.imgs = imgs self.line_width = line_width # split image transforms into two. one part giving the final PIL image # before conversion to a tensor and the actual tensor conversion part. self.head_transforms = transforms.Compose(im_transforms.transforms[:2]) self.tail_transforms = transforms.Compose(im_transforms.transforms[2:]) self.seg_type = None
while True: batch_indices = np.random.choice(x_len, size=batch_size) for idx in batch_indices: batch_y.append(y[idx]) batch_x.append(aug(image=x[idx])['image'] / 255.0) batch_x, batch_y = np.stack(batch_x), np.stack(batch_y) yield batch_x, batch_y batch_x, batch_y = [], [] aug_for_train = albu.Compose([ HorizontalFlip(p=0.5), ShiftScaleRotate(shift_limit=0.1, scale_limit=0.25, rotate_limit=20, p=0.5), GridDistortion(p=0.5) ]) aug_for_valid = albu.Compose([]) train_gen = input_generator(x_train, y_train, aug_for_train, batch_size) valid_gen = input_generator(x_test, y_test, aug_for_valid, batch_size) def display_training_result(history): plt.figure(figsize=(16, 12)) plt.subplot(2, 1, 1) plt.plot(history.history['loss'], label='train_loss', color='g') plt.plot(history.history['val_loss'], label='valid_loss', color='r')
from albumentations import Compose, Resize, RandomCrop, Flip, HorizontalFlip, VerticalFlip, Transpose, RandomRotate90, \ ShiftScaleRotate, OneOf, Blur, MotionBlur, MedianBlur, GaussianBlur, RandomBrightnessContrast from albumentations.pytorch import ToTensor train_aug = Compose([ RandomCrop(height=96, width=96, p=0.4), OneOf([ VerticalFlip(p=0.2), HorizontalFlip(p=0.3), Transpose(p=0.2), RandomRotate90(p=0.2), ], p=0.5), ShiftScaleRotate(p=0.5), OneOf([ Blur(p=0.2), MotionBlur(p=0.2), MedianBlur(p=0.2), GaussianBlur(p=0.2), ], p=0.4), RandomBrightnessContrast(p=0.5, brightness_limit=0.4, contrast_limit=0.4), Resize(128, 128, always_apply=True), ToTensor() ]) valid_aug = Compose([Resize(128, 128, always_apply=True), ToTensor()])
def train_transform(self): height, width = self.img_size transforms_list = [Resize(height, width), Flip()] # random_grid_shuffle if self.random_grid_shuffle['enable']: grid = self.random_grid_shuffle['grid'] grid = (grid, grid) transforms_list.append(RandomGridShuffle((grid))) # channel_shuffle if self.channel_shuffle['enable']: transforms_list.append(ChannelShuffle(p=1)) # channel_dropout if self.channel_dropout['enable']: drop_range = self.channel_dropout.drop_range fill_value = self.channel_dropout.fill_value transforms_list.append(ChannelDropout(drop_range, fill_value, p=1)) # noise if self.noise['enable']: transforms_list.append( OneOf([ IAAAdditiveGaussianNoise(), GaussNoise(), ], p=1)) # blur if self.blur['enable']: transforms_list.append( OneOf([ MotionBlur(), Blur(blur_limit=3, ), ], p=1)) # rotate if self.rotate['enable']: params = { key: value for key, value in self.rotate.items() if key != 'enable' } transforms_list.append(ShiftScaleRotate(**params)) # distortion if self.distortion['enable']: transforms_list.append( OneOf([ OpticalDistortion(p=0.3), GridDistortion(p=.3), ], p=1)) # bright if self.bright['enable']: transforms_list.append( OneOf([ CLAHE(clip_limit=self.bright['clip_limit']), RandomBrightnessContrast(p=0.8), ], p=1)) # hue color if self.hue['enable']: transforms_list.append(HueSaturationValue(p=0.3)) # cutout if self.cutout['enable']: num_holes = self.cutout['num_holes'] size = self.cutout['size'] fill_value = self.cutout['fill_value'] transforms_list.append(Cutout(num_holes, size, size, fill_value, 1)) transforms_list.append(self.normalize) transforms_list.append(ToTensor()) return Compose(transforms_list)
from albumentations import Compose, Resize, RandomCrop, Flip, HorizontalFlip, VerticalFlip, Transpose, RandomRotate90, \ ShiftScaleRotate, OneOf, Blur, MotionBlur, MedianBlur, GaussianBlur, RandomBrightness, RandomBrightnessContrast, \ Normalize from albumentations.pytorch import ToTensor train_aug = Compose([ OneOf([ VerticalFlip(p=0.2), HorizontalFlip(p=0.3), Transpose(p=0.2), RandomRotate90(p=0.2), ], p=0.4), ShiftScaleRotate(p=0.4), OneOf([ Blur(p=0.2), MotionBlur(p=0.2), MedianBlur(p=0.2), GaussianBlur(p=0.2), ], p=0.4), RandomBrightnessContrast(p=0.4, brightness_limit=0.4, contrast_limit=0.4), Resize(128, 128, always_apply=True), Normalize(mean=0.06922848809290576, std=0.20515700083327537), ToTensor() ]) valid_aug = Compose([ Resize(128, 128, always_apply=True), Normalize(mean=0.06922848809290576, std=0.20515700083327537), ToTensor()
def Shift_Scale_Rotate(img): transform = Compose([HorizontalFlip(), ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.5, rotate_limit=45, interpolation=2), RandomCrop(img.shape[1], img.shape[1])]) Aug_img = transform(image=img) return Aug_img
holdout = pd.read_csv(config['PATH_DATA'] + 'holdout.csv') holdout['is_valid'] = True train_df = train_df.append(holdout) print('train_df.shape:', train_df.shape) nunique = list(train_df.nunique())[1:-2] print('nunique:', nunique) # --- IMAGE DATABUNCH --- if not config['FINETUNE']: train_tf = Compose([ OneOf([ ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.1, rotate_limit=15, always_apply=True), IAAPerspective(always_apply=True), IAAPiecewiseAffine(always_apply=True) ], p=0.5) ]) def new_open_image(fn: PathOrStr, div: bool = True, convert_mode: str = 'L', after_open: Callable = None, transforms=True) -> Image: "Return `Image` object created from image in file `fn`." with warnings.catch_warnings(): warnings.simplefilter("ignore",
GridDistortion, OpticalDistortion, RandomSizedCrop, OneOf, CLAHE, RandomContrast, RandomGamma, RandomBrightness, ShiftScaleRotate ) aug = Compose( [ VerticalFlip(p=0.5), HorizontalFlip(p=0.5), ShiftScaleRotate(shift_limit=0.0625,scale_limit=0.5,rotate_limit=45,p=0.5), GridDistortion(p=0.5), # RandomRotate90(p=0.5), # ], p=0.8), # RandomContrast(p=0.5), # RandomBrightness(p=0.5), # RandomGamma(p=0.5), ], p=0.5) def augment_flips_color(p=.5): return Compose([ VerticalFlip(p=0.5), HorizontalFlip(p=0.5), #GridDistortion(p=0.5), ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.50, rotate_limit=10, p=0.5),
def train(model, cfg, model_cfg, start_epoch=0): cfg.batch_size = 28 if cfg.batch_size < 1 else cfg.batch_size cfg.val_batch_size = cfg.batch_size cfg.input_normalization = model_cfg.input_normalization crop_size = model_cfg.crop_size loss_cfg = edict() loss_cfg.instance_loss = SigmoidBinaryCrossEntropyLoss() loss_cfg.instance_loss_weight = 1.0 num_epochs = 120 num_masks = 1 train_augmentator = Compose([ Flip(), RandomRotate90(), ShiftScaleRotate(shift_limit=0.03, scale_limit=0, rotate_limit=(-3, 3), border_mode=0, p=0.75), PadIfNeeded( min_height=crop_size[0], min_width=crop_size[1], border_mode=0), RandomCrop(*crop_size), RandomBrightnessContrast(brightness_limit=(-0.25, 0.25), contrast_limit=(-0.15, 0.4), p=0.75), RGBShift(r_shift_limit=10, g_shift_limit=10, b_shift_limit=10, p=0.75) ], p=1.0) val_augmentator = Compose([ PadIfNeeded( min_height=crop_size[0], min_width=crop_size[1], border_mode=0), RandomCrop(*crop_size) ], p=1.0) def scale_func(image_shape): return random.uniform(0.75, 1.25) points_sampler = MultiPointSampler(model_cfg.num_max_points, prob_gamma=0.7, merge_objects_prob=0.15, max_num_merged_objects=2) trainset = SBDDataset( cfg.SBD_PATH, split='train', num_masks=num_masks, augmentator=train_augmentator, points_from_one_object=False, input_transform=model_cfg.input_transform, min_object_area=80, keep_background_prob=0.0, image_rescale=scale_func, points_sampler=points_sampler, samples_scores_path='./models/sbd/sbd_samples_weights.pkl', samples_scores_gamma=1.25) valset = SBDDataset(cfg.SBD_PATH, split='val', augmentator=val_augmentator, num_masks=num_masks, points_from_one_object=False, input_transform=model_cfg.input_transform, min_object_area=80, image_rescale=scale_func, points_sampler=points_sampler) optimizer_params = {'lr': 5e-4, 'betas': (0.9, 0.999), 'eps': 1e-8} lr_scheduler = partial(torch.optim.lr_scheduler.MultiStepLR, milestones=[100], gamma=0.1) trainer = ISTrainer(model, cfg, model_cfg, loss_cfg, trainset, valset, optimizer_params=optimizer_params, lr_scheduler=lr_scheduler, checkpoint_interval=5, image_dump_interval=200, metrics=[AdaptiveIoU()], max_interactive_points=model_cfg.num_max_points) logger.info(f'Starting Epoch: {start_epoch}') logger.info(f'Total Epochs: {num_epochs}') for epoch in range(start_epoch, num_epochs): trainer.training(epoch) trainer.validation(epoch)
def get_transforms(phase_config): list_transforms = [] if phase_config.Resize.p > 0: list_transforms.append( Resize(phase_config.Resize.height, phase_config.Resize.width, p=1)) if phase_config.HorizontalFlip: list_transforms.append(HorizontalFlip()) if phase_config.VerticalFlip: list_transforms.append(VerticalFlip()) if phase_config.RandomCropScale: if phase_config.Resize.p > 0: height = phase_config.Resize.height width = phase_config.Resize.width else: height = HEIGHT width = WIDTH list_transforms.append( RandomSizedCrop(min_max_height=(int(height * 0.90), height), height=height, width=width, w2h_ratio=width / height)) if phase_config.ShiftScaleRotate: list_transforms.append(ShiftScaleRotate(p=1)) if phase_config.RandomCrop.p > 0: list_transforms.append( RandomCrop(phase_config.RandomCrop.height, phase_config.RandomCrop.width, p=1)) if phase_config.Noise: list_transforms.append( OneOf([ GaussNoise(), IAAAdditiveGaussianNoise(), ], p=0.5), ) if phase_config.Contrast: list_transforms.append( OneOf([ RandomContrast(0.5), RandomGamma(), RandomBrightness(), ], p=0.5), ) if phase_config.Blur: list_transforms.append( OneOf([ MotionBlur(p=.2), MedianBlur(blur_limit=3, p=0.1), Blur(blur_limit=3, p=0.1), ], p=0.5)) if phase_config.Distort: list_transforms.append( OneOf([ OpticalDistortion(p=0.3), GridDistortion(p=.1), IAAPiecewiseAffine(p=0.3), ], p=0.5)) if phase_config.Cutout.num_holes > 0: num_holes = phase_config.Cutout.num_holes hole_size = phase_config.Cutout.hole_size list_transforms.append(Cutout(num_holes, hole_size)) list_transforms.extend([ Normalize(mean=phase_config.mean, std=phase_config.std, p=1), ToTensor(), ]) return Compose(list_transforms)
# Also prepare the test data test[['ID','Image','Diagnosis']] = test['ID'].str.split('_', expand=True) test['Image'] = 'ID_' + test['Image'] test = test[['Image', 'Label']] test.drop_duplicates(inplace=True) test.to_csv('test.csv', index=False) # Data loaders transform_train = Compose([CenterCrop(200, 200), #Resize(224, 224), HorizontalFlip(), RandomBrightnessContrast(), ShiftScaleRotate(), ToTensor() ]) transform_test= Compose([CenterCrop(200, 200), #Resize(224, 224), ToTensor() ]) train_dataset = IntracranialDataset( csv_file='train.csv', data_dir=dir_train_img, transform=transform_train, labels=True) test_dataset = IntracranialDataset( csv_file='test.csv', data_dir=dir_test_img, transform=transform_test, labels=False) data_loader_train = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=False, num_workers=8)
def __init__(self, normalization: Optional[str] = None, whitespace_normalization: bool = True, reorder: bool = True, im_transforms: Callable[[Any], torch.Tensor] = transforms.Compose( []), preload: bool = True, augmentation: bool = False) -> None: self._images = [] # type: Union[List[Image], List[torch.Tensor]] self._gt = [] # type: List[str] self.alphabet = Counter() # type: Counter self.text_transforms = [] # type: List[Callable[[str], str]] # split image transforms into two. one part giving the final PIL image # before conversion to a tensor and the actual tensor conversion part. self.head_transforms = transforms.Compose(im_transforms.transforms[:2]) self.tail_transforms = transforms.Compose(im_transforms.transforms[2:]) self.transforms = im_transforms self.preload = preload self.aug = None self.seg_type = 'baselines' # built text transformations if normalization: self.text_transforms.append( lambda x: unicodedata.normalize(cast(str, normalization), x)) if whitespace_normalization: self.text_transforms.append( lambda x: regex.sub('\s', ' ', x).strip()) if reorder: self.text_transforms.append(bd.get_display) if augmentation: from albumentations import ( Compose, ToFloat, FromFloat, Flip, OneOf, MotionBlur, MedianBlur, Blur, ShiftScaleRotate, OpticalDistortion, ElasticTransform, RandomBrightnessContrast, ) self.aug = Compose([ ToFloat(), OneOf([ MotionBlur(p=0.2), MedianBlur(blur_limit=3, p=0.1), Blur(blur_limit=3, p=0.1), ], p=0.2), ShiftScaleRotate( shift_limit=0.0625, scale_limit=0.2, rotate_limit=3, p=0.2), OneOf([ OpticalDistortion(p=0.3), ElasticTransform(p=0.1), ], p=0.2), ], p=0.5) self.im_mode = '1'
def aug_baseline_simple(image, mask): aug = Compose([HorizontalFlip(), VerticalFlip(), ShiftScaleRotate()]) aug_img = aug(image=image, mask=mask) return aug_img['image'], aug_img['mask']
aug = Compose([ RandomRotate90(), Flip(), Transpose(), OneOf([ IAAAdditiveGaussianNoise(), GaussNoise(), ], p=0.2), OneOf([ MotionBlur(p=.2), MedianBlur(blur_limit=3, p=.1), Blur(blur_limit=3, p=.1), ], p=0.2), ShiftScaleRotate( shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=.2), OneOf([ OpticalDistortion(p=0.3), GridDistortion(p=.1), IAAPiecewiseAffine(p=0.3), ], p=0.2), OneOf([ CLAHE(clip_limit=2), IAASharpen(), IAAEmboss(), RandomContrast(), RandomBrightness(), ], p=0.3), HueSaturationValue(p=0.3),