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')