def main(args): warnings.filterwarnings('ignore') # Set Primary Device device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu') # Define Network net = circle_detector() print('Network Info:') print('Number of Network parameters: {0:.2f} Million'.format( sum(param.numel() for param in net.parameters()) / 1e6)) net.to(device) print(net) if args.resume or args.phase == 'test': net.load_state_dict( torch.load(args.resumed_ckpt, map_location='cuda:0' if torch.cuda.is_available() else 'cpu')['net_state_dict']) print('Resumed Checkpoint: {} is Loaded!'.format(args.resumed_ckpt)) if args.phase == 'train': train.train(args, net) else: net.eval() output = cv_practical.main.test_runner(args, net) print(output['message'])
def maybe_train_model(args, cfg): df = pd.read_csv(args.train_val_files[0]) for i in range(1, len(args.train_val_files)): d = pd.read_csv(args.train_val_files[i]) df = pd.concat([df, d]) merged_save_path = os.path.dirname( args.train_val_files[0]) + '/train_val_merge.csv' df.to_csv(merged_save_path) save_dir = cfg.TRAIN.save_dir train(cfg, merged_save_path, merged_save_path, save_dir)
def main(param): # 设置GPU仅需要时申请显存空间 gpus = tf.config.experimental.list_physical_devices('GPU') for gpu in gpus: tf.config.experimental.set_memory_growth(gpu, True) # 解析命令行参数 mode = None argv = sys.argv[1:] try: opts, args = getopt.getopt(argv, "m:") # 短选项模式 except Exception as err: print("Error:", err) for opt, arg in opts: if opt in ['-m']: mode = arg # 执行训练或测试 if mode == 'test': test(param) else: train(param)
def main(args): warnings.filterwarnings('ignore') device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu') if args.use_case == 'stage1': net = KP_Orientation_Net.CoarseRegressor() elif args.use_case == 'stage2': net = KP_Orientation_Net.KeyPointModel() if args.phase == 'train': # Load the stage 1 checkpoint and freeze its weights net.coarse_estimator.load_state_dict(torch.load(args.stage1_ckpt)['net_state_dict']) for param in net.coarse_estimator.parameters(): param.requires_grad = False print('stage1 weights have been initialized with pre-trained weights and are frozen!') else: raise NameError('use case should be either "stage1" or "stage2"') net = net.to(device) print('Total number of Parameters = %s' % sum(p.numel() for p in net.parameters())) print('Total number of trainable Parameters = %s' % sum(p.numel() for p in net.parameters() if p.requires_grad)) if args.resume or args.phase == 'test': checkpoint = torch.load(args.resumed_ckpt) net.load_state_dict(checkpoint['net_state_dict']) print('Resumed Checkpoint :{} is Loaded!'.format(args.resumed_ckpt)) if torch.cuda.device_count() > 1 and args.mGPU: net = torch.nn.DataParallel(net) if args.phase == 'train': train.train(args, net) elif args.phase == 'test': net.eval() output = test.test(args, net) print(output['message']) else: raise NameError('phase should be either "train" or "test"')
def kfold_train(cfg, args,n_fold = 6, train_folds= [0,1,2,3,4,5]): split_data(args.train_val_files, n_fold, save_dir = os.path.dirname(args.train_val_files[0]), random_state=666) score_avg = 0 nn = 0 for i in range(n_fold): if i not in train_folds: continue train_data_path = os.path.join(cfg.DATA.data_dir, 'train_fold_{}.csv'.format(i)) val_data_path = os.path.join(cfg.DATA.data_dir, 'val_fold_{}.csv'.format(i)) save_dir = '{}/fold_{}/'.format(cfg.TRAIN.save_dir, i) score = train(cfg, train_data_path, val_data_path, save_dir) score_avg += score nn += 1 print('avg score: ', score_avg / nn)
def main( config_path: Path, dataset_path: Path, predict_path: Path, input_path: Path, evaluate_path: Optional[Path] = None, ) -> None: """ Main function responsible for prediction with passed model. Arguments: Path config_path: Path to main config (of :class:`DefaultConfig` class) Path dataset_path: Path to dataset Path predict_path: Path to file with model predictions Path input_path: Path to file with input data Path evaluate_path: Path to evaluations """ logger.info("Trainer") result = train(config_path=config_path, dataset_path=dataset_path) info = "Pipline required training_config.py with attribute save = True" assert len(vars(result)) != 1, info root = result.model_path.parent.parent logger.info("Predictor") predict( config_path=config_path, input_path=input_path, model_path=result.model_path, predict_path=root / predict_path, val_loader=result.val_loader, ) if evaluate_path: logger.info("Evaluator") evaluate( config_path=config_path, input_path=input_path, predict_path=root / predict_path, evaluate_path=root / evaluate_path, val_loader=result.val_loader, )
# import torch.nn as nn # import numpy as np # import random # from torch.cuda.amp import autocast as autocast, GradScaler # # cudnn.benchmark = True os.environ['CUDA_VISIBLE_DEVICES'] = cfg.MODEL.DEVICE_ID from tools.train import train from tools.test import test from filter_data import filter_data if __name__ == '__main__': if cfg.INPUT.FILTER: filter_data(cfg.INPUT.LABEL_PATH, cfg.INPUT.FILTER_DATA_PATH, cfg.INPUT.FILTER_DATA_NUM) train_loader, val_loader, num_query, num_classes, query_name, gallery_name = make_dataloader( cfg) if cfg.MODEL.MODE == 'train': ######################################### resume model ################################### train(train_loader, num_classes) with torch.no_grad(): test(val_loader, num_query, query_name, gallery_name, num_classes) if cfg.MODEL.MODE == 'evaluate': with torch.no_grad(): test(val_loader, num_query, query_name, gallery_name, num_classes)
target_risk = get_risk(args.target_risk) if args.target_risk == 'cvar': target_risk = partial(target_risk, betabar=args.betabar) elif args.target_risk == 'meanstd': target_risk = partial(target_risk, c=args.stdmult) """ THE RISK THAT YOU WANT TO RECORD. """ risklist = [ Avg, partial(CVaR, betabar=0.2), partial(CVaR, betabar=0.4), partial(CVaR, betabar=0.6), partial(CVaR, betabar=0.8) ] """ TRAIN """ train_risks, test_risks = train(model, train_loader, test_loader, optimizer, target_risk, risklist, args.train_steps, args.print_steps) """ SAVE """ RISK_PATH = f'./results/{args.seed}' if not os.path.exists(RISK_PATH): os.makedirs(RISK_PATH) if args.target_risk == 'meanstd': torch.save([train_risks, test_risks], RISK_PATH + f'/{args.target_risk}_{args.stdmult}.tsr') elif args.target_risk == 'avg': torch.save([train_risks, test_risks], RISK_PATH + f'/{args.target_risk}.tsr') else: torch.save([train_risks, test_risks], RISK_PATH + f'/{args.target_risk}_{args.betabar}.tsr')