def main(): options = get_parser().parse_args() if not os.path.exists(EXPERIMENT_PATH): os.makedirs(EXPERIMENT_PATH) print(options.is_validation) print(options.classes_per_it_tr) tr_dataloader = init_dataloader(options, 'train') if options.is_validation: val_dataloader = init_dataloader(options, 'test') model = init_protonet(options) optim = init_optim(options, model) lr_scheduler = init_lr_scheduler(options, optim) if options.is_validation: train(opt=options, tr_dataloader=tr_dataloader, val_dataloader=val_dataloader, model=model, optim=optim, lr_scheduler=lr_scheduler) else: train(opt=options, tr_dataloader=tr_dataloader, val_dataloader=None, model=model, optim=optim, lr_scheduler=lr_scheduler)
def main(): ''' Initialize everything and train ''' options = get_parser().parse_args() if not os.path.exists(options.experiment_root): os.makedirs(options.experiment_root) if torch.cuda.is_available() and not options.cuda: print( "WARNING: You have a CUDA device, so you should probably run with --cuda" ) init_seed(options) # trainval_dataloader = init_dataloader(options, 'trainval') test_dataloader = init_dataloader(options, 'test') model = init_protonet(options) optim = init_optim(options, model) lr_scheduler = init_lr_scheduler(options, optim) # model.load_state_dict(best_state) print('Testing with best model..') test(opt=options, test_dataloader=test_dataloader, model=model)
def eval(opt): ''' Initialize everything and train ''' options = get_parser().parse_args() if torch.cuda.is_available() and not options.cuda: print("WARNING: You have a CUDA device, so you should probably run with --cuda") print("Evaluation mode") init_seed(options) test_dataloader = init_dataloader(options, 'test') model = init_protonet(options) model_path = os.path.join(opt.experiment_root, 'best_model.pth') model.load_state_dict(torch.load(model_path)) distance_fn = "cosine" if options.distance_fn==0 else "euclidean" test_loss_fn = PrototypicalLoss(options.num_support_val, distance_fn, options.regularizer) test(opt=options, test_dataloader=test_dataloader, model=model, loss_fn=test_loss_fn)
def main(): ''' Initialize everything and train ''' options = get_parser().parse_args() device = 'cuda:2' if torch.cuda.is_available() and options.cuda else 'cpu' if not os.path.exists(options.experiment_root): os.makedirs(options.experiment_root) if torch.cuda.is_available() and not options.cuda: print( "WARNING: You have a CUDA device, so you should probably run with --cuda" ) init_seed(options) tr_dataloader, mytrain_dataloader = init_dataloader(options, 'train') val_dataloader, _ = init_dataloader(options, 'val') # trainval_dataloader = init_dataloader(options, 'trainval') test_dataloader, mytest_dataloader = init_dataloader(options, 'val') model = init_protonet(options, device=device) optim = init_optim(options, model) lr_scheduler = init_lr_scheduler(options, optim) res = train(opt=options, tr_dataloader=tr_dataloader, val_dataloader=val_dataloader, test_dataloader=test_dataloader, mytrain_dataloader=mytrain_dataloader, mytest_dataloader=mytest_dataloader, model=model, optim=optim, lr_scheduler=lr_scheduler, device=device) avg_train_loss, avg_train_acc, avg_val_loss, avg_val_acc, avg_test_acc = res print('draw training loss and accuracy curve!!!') plt.subplot(121) plt.plot(range(options.epochs), avg_train_loss, 'g', label='train loss') plt.plot(range(options.epochs), avg_val_loss, 'r', label='val loss') plt.xlabel('epoch') plt.ylabel('loss') plt.legend(loc='best') plt.subplot(122) plt.plot(range(options.epochs), avg_train_acc, 'g', label='train acc') plt.plot(range(options.epochs), avg_val_acc, 'r', label='val acc') plt.plot(range(options.epochs), avg_test_acc, 'b', label='test acc') plt.xlabel('epoch') plt.ylabel('accuracy') plt.legend(loc='best') plt.savefig('result.jpg') plt.show()
def main(): ''' Initialize everything and train ''' options = get_parser().parse_args() print(options) if not os.path.exists(options.experiment_root): os.makedirs(options.experiment_root) if torch.cuda.is_available() and not options.cuda: print("WARNING: You have a CUDA device, so you should probably run with --cuda") init_seed(options) tr_dataloader = init_dataloader(options, 'train') val_dataloader = init_dataloader(options, 'val') # trainval_dataloader = init_dataloader(options, 'trainval') test_dataloader = init_dataloader(options, 'test') model = init_protonet(options) optim = init_optim(options, model) lr_scheduler = init_lr_scheduler(options, optim) distance_fn = "cosine" if options.distance_fn==0 else "euclidean" train_loss_fn = PrototypicalLoss(options.num_support_tr, distance_fn) train_loss_fn = PrototypicalLoss(options.num_support_vals, distance_fn) res = train(opt=options, tr_dataloader=tr_dataloader, val_dataloader=val_dataloader, model=model, optim=optim, lr_scheduler=lr_scheduler) best_state, best_acc, train_loss, train_acc, val_loss, val_acc = res print('Testing with last model..') test(opt=options, test_dataloader=test_dataloader, model=model) model.load_state_dict(best_state) print('Testing with best model..') test(opt=options, test_dataloader=test_dataloader, model=model)
def eval(opt): ''' Initialize everything and train ''' options = get_parser().parse_args() if torch.cuda.is_available() and not options.cuda: print("WARNING: You have a CUDA device, so you should probably run with --cuda") init_seed(options) test_dataloader = init_dataset(options)[-1] model = init_protonet(options) model_path = os.path.join(opt.experiment_root, 'best_model.pth') model.load_state_dict(torch.load(model_path)) test(opt=options, test_dataloader=test_dataloader, model=model)
def main(): options = get_parser().parse_args() opt = {} for arg in vars(options): opt[arg] = getattr(options, arg) split_dir = os.path.join(options.dataset_root, "tabula_muris_split") tissues = ["Marrow", "Skin", "Large_Intestine", "Tongue", "Lung", "Thymus", "Liver", "Aorta", "Trachea", "Pancreas"] for tissue in tqdm(tissues): full_dir = os.path.join(options.experiment_root, tissue) utils.mkdir_p(full_dir) opt["experiment_root"] = full_dir opt["split_file"] = os.path.join(split_dir, tissue, "split.json") command = "python train.py" for arg in opt: command += " --{} {}".format(arg, opt[arg]) print(command) os.system(command)
def main(): ''' Initialize everything and run test ''' options = get_parser().parse_args() if torch.cuda.is_available() and not options.cuda: print( "WARNING: You have a CUDA device, so you should probably run with --cuda" ) init_seed(options) test_dataloader = init_dataloader(options, 'test') model = init_protonet(options, x_dim=test_dataloader.dataset.get_dim()) model_path = os.path.join(options.experiment_root, 'best_model.pth') model.load_state_dict(torch.load(model_path)) print('Testing with best model..') test(opt=options, test_dataloader=test_dataloader, model=model)
def main(): ''' Initialize everything and train ''' options = get_parser().parse_args() if not os.path.exists(options.experiment_root): os.makedirs(options.experiment_root) if torch.cuda.is_available() and not options.cuda: print( "WARNING: You have a CUDA device, so you should probably run with --cuda" ) init_seed(options) tr_dataloader = init_dataloader(options, 'train') val_dataloader = init_dataloader(options, 'val') # trainval_dataloader = init_dataloader(options, 'trainval') # test_dataloader = init_dataloader(options, 'test') model = init_protonet(options) optim = init_optim(options, model) lr_scheduler = init_lr_scheduler(options, optim) res = train(opt=options, tr_dataloader=tr_dataloader, val_dataloader=val_dataloader, model=model, optim=optim, lr_scheduler=lr_scheduler) best_state, best_acc, train_loss, train_acc, val_loss, val_acc = res print( '************************ Congrats! Training over ************************' ) # test(opt=options, # test_dataloader=test_dataloader, # model=model) # model.load_state_dict(best_state) print('Now train for few shot classes')
def main(): ''' Initialize everything and train ''' # 返回所有的参数选项 options = get_parser().parse_args() # 创建输出路径 if not os.path.exists(options.experiment_root): os.makedirs(options.experiment_root) # 有cuda但命令行中没有指定 if torch.cuda.is_available() and not options.cuda: print( "WARNING: You have a CUDA device, so you should probably run with --cuda" ) init_seed(options) tr_dataloader = init_dataloader(options, 'train') val_dataloader = init_dataloader(options, 'val') # trainval_dataloader = init_dataloader(options, 'trainval') test_dataloader = init_dataloader(options, 'test') model = init_protonet(options) optim = init_optim(options, model) lr_scheduler = init_lr_scheduler(options, optim) res = train(opt=options, tr_dataloader=tr_dataloader, val_dataloader=val_dataloader, model=model, optim=optim, lr_scheduler=lr_scheduler) best_state, best_acc, train_loss, train_acc, val_loss, val_acc = res print('Testing with last model..') test(opt=options, test_dataloader=test_dataloader, model=model) model.load_state_dict(best_state) print('Testing with best model..') test(opt=options, test_dataloader=test_dataloader, model=model)
def main(): ''' Initialize everything and train ''' options = get_parser().parse_args() if not os.path.exists(options.experiment_root): os.makedirs(options.experiment_root) if options.distance_fn == "euk": from prototypical_loss import prototypical_loss as loss_fn elif options.distance_fn == "rbf": print("using RBF distance") from prototypical_loss import prototypical_loss_rbf as loss_fn else: raise NotImplementedError("Unknown distance function") if torch.cuda.is_available() and not options.cuda: print( "WARNING: You have a CUDA device, so you should probably run with --cuda" ) init_seed(options) tr_dataloader = init_dataloader(options, 'train') # trainval_dataloader = init_dataloader(options, 'trainval') model = init_protonet(options) optim = init_optim(options, model) lr_scheduler = init_lr_scheduler(options, optim) res = train(opt=options, tr_dataloader=tr_dataloader, val_dataloader=tr_dataloader, model=model, loss_fn=loss_fn, optim=optim, lr_scheduler=lr_scheduler, bg_weight=options.bg_weight)
def main(): ''' Initialize everything and train ''' options = get_parser().parse_args() if not os.path.exists(options.experiment_root): os.makedirs(options.experiment_root) if torch.cuda.is_available() and not options.cuda: print("WARNING: You have a CUDA device, so you should probably run with --cuda") init_seed(options) dataset_root = options.dataset_root train_split = 0.7 val_split = 0.1 test_split = 0.2 image_folders = [os.path.join(dataset_root, SKU, image) for SKU in os.listdir(dataset_root) \ if os.path.isdir(os.path.join(dataset_root, SKU)) for image in os.listdir(os.path.join(dataset_root, SKU))] total_num = len(image_folders) train_num = int(train_split*total_num) val_num = int(val_split*total_num) test_num = total_num - (train_num + val_num) random.seed(0) random.shuffle(image_folders) metatrain = image_folders[:train_num] print("No: of Images in train:", len(metatrain)) metaval = image_folders[train_num:train_num+val_num] print("No: of images in validation: ", len(metaval)) metatest = image_folders[train_num+val_num:] print("No: of images in test: ", len(metatest)) root_folder = '/home/caffe/data/' train_folder = root_folder +'train' val_folder = root_folder+'val' test_folder = root_folder+'test' split_dataset(train_folder, metatrain) split_dataset(val_folder, metaval) split_dataset(test_folder, metatest) tr_dataloader = init_dataloader(options, 'train', root = train_folder) torch.cuda.empty_cache() val_dataloader = init_dataloader(options, 'val', root = val_folder) torch.cuda.empty_cache() # trainval_dataloader = init_dataloader(options, 'trainval') test_dataloader = init_dataloader(options, 'test', root = test_folder) torch.cuda.empty_cache() filepath = '/home/caffe/orbix/Prototypical-Networks-for-Few-shot-Learning-PyTorch/output/best_model_rgb28.pth' model = init_protonet(opt = options,pretrained_file = filepath, pretrained = True) optim = init_optim(options, model) lr_scheduler = init_lr_scheduler(options, optim) res = train(opt=options, tr_dataloader=tr_dataloader, val_dataloader=val_dataloader, model=model, optim=optim, lr_scheduler=lr_scheduler) best_state, best_acc, train_loss, train_acc, val_loss, val_acc = res print('Testing with last model..') test(opt=options, test_dataloader=test_dataloader, model=model) model.load_state_dict(best_state) print('Testing with best model..') test(opt=options, test_dataloader=test_dataloader, model=model)
_, preds = torch.max(outputs, 1) if test_pred is None: test_pred = outputs.data.cpu() else: test_pred = torch.cat((test_pred, outputs.data.cpu()), dim=0) test_pred = torch.softmax(test_pred, dim=1, dtype=float) submission_df[['healthy', 'multiple_diseases', 'rust', 'scab']] = test_pred submission_df.to_csv(options.output_root + options.output_name + '.csv', index=False) if __name__ == "__main__": options = get_parser().parse_args() # model_idx = options.model batch_size = options.batch_size num_epoch = options.epochs data_root = options.data_root input_size = options.input_size train_csv_path = data_root + "train.csv" test_csv_path = data_root + "test.csv" images_dir = data_root + "images/" submission_df_path = data_root + "sample_submission.csv" num_classes = 4 num_cv_folds = 5 device = get_device()
def config_parser(): import parser_util return parser_util.get_parser()