def main(args):
tracker_dir = os.path.join(args.tracker_path, args.dataset)
trackers = glob(
os.path.join(args.tracker_path, args.dataset,
args.tracker_prefix + '*'))
trackers = [x.split('/')[-1] for x in trackers]
# trackers = os.listdir(os.path.join(args.tracker_path, args.dataset, args.tracker_prefix))
assert len(trackers) > 0
args.num = min(args.num, len(trackers))
root = os.path.realpath(
os.path.join(os.path.dirname(__file__), '../testing_dataset'))
root = os.path.join(root, args.dataset)
if 'OTB' in args.dataset:
dataset = OTBDataset(args.dataset, root)
dataset.set_tracker(tracker_dir, trackers)
benchmark = OPEBenchmark(dataset)
success_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_success,
trackers),
desc='eval success',
total=len(trackers),
ncols=100):
success_ret.update(ret)
precision_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_precision,
trackers),
desc='eval precision',
total=len(trackers),
ncols=100):
precision_ret.update(ret)
benchmark.show_result(success_ret,
precision_ret,
show_video_level=args.show_video_level)
def main():
tracker_dir = os.path.join(args.tracker_path, args.dataset)
trackers = glob(
os.path.join(args.tracker_path, args.dataset,
args.tracker_prefix + '*'))
trackers = [x.split('/')[-1] for x in trackers]
assert len(trackers) > 0
args.num = min(args.num, len(trackers))
root = os.path.realpath(
os.path.join(os.path.dirname(__file__), '../../pysot/testing_dataset'))
root = os.path.join(root, args.dataset)
if 'OTB' in args.dataset:
dataset = OTBDataset(args.dataset, root)
dataset.set_tracker(tracker_dir, trackers)
benchmark = OPEBenchmark(dataset)
success_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_success,
trackers),
desc='eval success',
total=len(trackers),
ncols=100):
success_ret.update(ret)
precision_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_precision,
trackers),
desc='eval precision',
total=len(trackers),
ncols=100):
precision_ret.update(ret)
benchmark.show_result(success_ret,
precision_ret,
show_video_level=args.show_video_level)
elif 'LaSOT' == args.dataset:
dataset = LaSOTDataset(args.dataset, root)
dataset.set_tracker(tracker_dir, trackers)
benchmark = OPEBenchmark(dataset)
success_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_success,
trackers),
desc='eval success',
total=len(trackers),
ncols=100):
success_ret.update(ret)
precision_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_precision,
trackers),
desc='eval precision',
total=len(trackers),
ncols=100):
precision_ret.update(ret)
norm_precision_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_norm_precision,
trackers),
desc='eval norm precision',
total=len(trackers),
ncols=100):
norm_precision_ret.update(ret)
benchmark.show_result(success_ret,
precision_ret,
norm_precision_ret,
show_video_level=args.show_video_level)
elif 'UAV' in args.dataset:
dataset = UAVDataset(args.dataset, root)
dataset.set_tracker(tracker_dir, trackers)
benchmark = OPEBenchmark(dataset)
success_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_success,
trackers),
desc='eval success',
total=len(trackers),
ncols=100):
success_ret.update(ret)
precision_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_precision,
trackers),
desc='eval precision',
total=len(trackers),
ncols=100):
precision_ret.update(ret)
benchmark.show_result(success_ret,
precision_ret,
show_video_level=args.show_video_level)
elif 'NFS' in args.dataset:
dataset = NFSDataset(args.dataset, root)
dataset.set_tracker(tracker_dir, trackers)
benchmark = OPEBenchmark(dataset)
success_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_success,
trackers),
desc='eval success',
total=len(trackers),
ncols=100):
success_ret.update(ret)
precision_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_precision,
trackers),
desc='eval precision',
total=len(trackers),
ncols=100):
precision_ret.update(ret)
benchmark.show_result(success_ret,
precision_ret,
show_video_level=args.show_video_level)
elif args.dataset in ['VOT2016', 'VOT2017', 'VOT2018', 'VOT2019']:
dataset = VOTDataset(args.dataset, root)
dataset.set_tracker(tracker_dir, trackers)
ar_benchmark = AccuracyRobustnessBenchmark(dataset)
ar_result = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(ar_benchmark.eval, trackers),
desc='eval ar',
total=len(trackers),
ncols=100):
ar_result.update(ret)
benchmark = EAOBenchmark(dataset)
eao_result = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval, trackers),
desc='eval eao',
total=len(trackers),
ncols=100):
eao_result.update(ret)
ar_benchmark.show_result(ar_result,
eao_result,
show_video_level=args.show_video_level)
elif 'VOT2018-LT' == args.dataset:
dataset = VOTLTDataset(args.dataset, root)
dataset.set_tracker(tracker_dir, trackers)
benchmark = F1Benchmark(dataset)
f1_result = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval, trackers),
desc='eval f1',
total=len(trackers),
ncols=100):
f1_result.update(ret)
benchmark.show_result(f1_result,
show_video_level=args.show_video_level)
elif 'GOT-10k' == args.dataset:
dataset = GOT10kDataset(args.dataset, root)
dataset.set_tracker(tracker_dir, trackers)
benchmark = OPEBenchmark(dataset)
success_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_success,
trackers),
desc='eval success',
total=len(trackers),
ncols=100):
success_ret.update(ret)
precision_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_precision,
trackers),
desc='eval precision',
total=len(trackers),
ncols=100):
precision_ret.update(ret)
benchmark.show_result(success_ret,
precision_ret,
show_video_level=args.show_video_level)
def main():
# load config
cfg.merge_from_file(args.config)
cur_dir = os.path.dirname(os.path.realpath(__file__))
#dataset_root = os.path.join(cur_dir, '../testing_dataset', args.dataset)
dataset_root = '/home/sy/dataset/VOT/VOT2018'
# create model
model = ModelBuilder()
# load model
model = load_pretrain(model, args.snapshot).cuda().eval()
# build tracker
tracker = build_tracker(model)
# create dataset
dataset = DatasetFactory.create_dataset(name=args.dataset,
dataset_root=dataset_root,
load_img=False)
root = dataset_root
if 'OTB' in args.dataset:
dataset_eval = OTBDataset(args.dataset, root)
elif 'LaSOT' == args.dataset:
dataset_eval = LaSOTDataset(args.dataset, root)
elif 'UAV' in args.dataset:
dataset_eval = UAVDataset(args.dataset, root)
elif 'NFS' in args.dataset:
dataset_eval = NFSDataset(args.dataset, root)
if args.dataset in ['VOT2016', 'VOT2017', 'VOT2018', 'VOT2019']:
dataset_eval = VOTDataset(args.dataset, root)
elif 'VOT2018-LT' == args.dataset:
dataset_eval = VOTLTDataset(args.dataset, root)
model_name = args.snapshot.split('/')[-1].split('.')[0]
tracker_name = os.path.join('tune_results',args.dataset, model_name, model_name + \
'_wi-{:.3f}'.format(cfg.TRACK.WINDOW_INFLUENCE) + \
'_pk-{:.3f}'.format(cfg.TRACK.PENALTY_K) + \
'_lr-{:.3f}'.format(cfg.TRACK.LR))
total_lost = 0
if args.dataset in ['VOT2016', 'VOT2018', 'VOT2019']:
# restart tracking
for v_idx, video in enumerate(dataset):
if args.video != '':
# test one special video
if video.name != args.video:
continue
frame_counter = 0
lost_number = 0
toc = 0
pred_bboxes = []
for idx, (img, gt_bbox) in enumerate(video):
if len(gt_bbox) == 4:
gt_bbox = [
gt_bbox[0], gt_bbox[1], gt_bbox[0],
gt_bbox[1] + gt_bbox[3] - 1,
gt_bbox[0] + gt_bbox[2] - 1,
gt_bbox[1] + gt_bbox[3] - 1,
gt_bbox[0] + gt_bbox[2] - 1, gt_bbox[1]
]
tic = cv2.getTickCount()
if idx == frame_counter:
cx, cy, w, h = get_axis_aligned_bbox(np.array(gt_bbox))
gt_bbox_ = [cx - (w - 1) / 2, cy - (h - 1) / 2, w, h]
tracker.init(img, gt_bbox_)
pred_bbox = gt_bbox_
pred_bboxes.append(1)
elif idx > frame_counter:
outputs = tracker.track(img)
pred_bbox = outputs['bbox']
overlap = vot_overlap(pred_bbox, gt_bbox,
(img.shape[1], img.shape[0]))
if overlap > 0:
# not lost
pred_bboxes.append(pred_bbox)
else:
# lost object
pred_bboxes.append(2)
frame_counter = idx + 5 # skip 5 frames
lost_number += 1
else:
pred_bboxes.append(0)
toc += cv2.getTickCount() - tic
if idx == 0:
cv2.destroyAllWindows()
if args.vis and idx > frame_counter:
cv2.polylines(
img, [np.array(gt_bbox, np.int).reshape(
(-1, 1, 2))], True, (0, 255, 0), 3)
bbox = list(map(int, pred_bbox))
cv2.rectangle(img, (bbox[0], bbox[1]),
(bbox[0] + bbox[2], bbox[1] + bbox[3]),
(0, 255, 255), 3)
cv2.putText(img, str(idx), (40, 40),
cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 255), 2)
cv2.putText(img, str(lost_number), (40, 80),
cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)
cv2.imshow(video.name, img)
cv2.waitKey(1)
toc /= cv2.getTickFrequency()
# save results
video_path = os.path.join('results', args.dataset, model_name,
'baseline', video.name)
if not os.path.isdir(video_path):
os.makedirs(video_path)
result_path = os.path.join(video_path,
'{}_001.txt'.format(video.name))
with open(result_path, 'w') as f:
for x in pred_bboxes:
if isinstance(x, int):
f.write("{:d}\n".format(x))
else:
f.write(','.join([vot_float2str("%.4f", i)
for i in x]) + '\n')
print(
'({:3d}) Video: {:12s} Time: {:4.1f}s Speed: {:3.1f}fps Lost: {:d}'
.format(v_idx + 1, video.name, toc, idx / toc, lost_number))
total_lost += lost_number
print("{:s} total lost: {:d}".format(model_name, total_lost))
auc = eval(dataset=dataset_eval, tracker_name=tracker_name)
info = "{:s} window_influence: {:1.17f}, penalty_k: {:1.17f}, scale_lr: {:1.17f}, AUC: {:1.3f}".format(
model_name, cfg.TRACK.WINDOW_INFLUENCE, cfg.TRACK.PENALTY_K,
cfg.TRACK.LR, auc)
else:
# OPE tracking
for v_idx, video in enumerate(dataset):
if args.video != '':
# test one special video
if video.name != args.video:
continue
toc = 0
pred_bboxes = []
scores = []
track_times = []
for idx, (img, gt_bbox) in enumerate(video):
tic = cv2.getTickCount()
if idx == 0:
cx, cy, w, h = get_axis_aligned_bbox(np.array(gt_bbox))
gt_bbox_ = [cx - (w - 1) / 2, cy - (h - 1) / 2, w, h]
tracker.init(img, gt_bbox_)
pred_bbox = gt_bbox_
scores.append(None)
if 'VOT2018-LT' == args.dataset:
pred_bboxes.append([1])
else:
pred_bboxes.append(pred_bbox)
else:
outputs = tracker.track(img)
pred_bbox = outputs['bbox']
pred_bboxes.append(pred_bbox)
scores.append(outputs['best_score'])
toc += cv2.getTickCount() - tic
track_times.append(
(cv2.getTickCount() - tic) / cv2.getTickFrequency())
if idx == 0:
cv2.destroyAllWindows()
if args.vis and idx > 0:
gt_bbox = list(map(int, gt_bbox))
pred_bbox = list(map(int, pred_bbox))
cv2.rectangle(
img, (gt_bbox[0], gt_bbox[1]),
(gt_bbox[0] + gt_bbox[2], gt_bbox[1] + gt_bbox[3]),
(0, 255, 0), 3)
cv2.rectangle(img, (pred_bbox[0], pred_bbox[1]),
(pred_bbox[0] + pred_bbox[2],
pred_bbox[1] + pred_bbox[3]), (0, 255, 255),
3)
cv2.putText(img, str(idx), (40, 40),
cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 255), 2)
cv2.imshow(video.name, img)
cv2.waitKey(1)
toc /= cv2.getTickFrequency()
# save results
if 'VOT2018-LT' == args.dataset:
video_path = os.path.join('results', args.dataset, model_name,
'longterm', video.name)
if not os.path.isdir(video_path):
os.makedirs(video_path)
result_path = os.path.join(video_path,
'{}_001.txt'.format(video.name))
with open(result_path, 'w') as f:
for x in pred_bboxes:
f.write(','.join([str(i) for i in x]) + '\n')
result_path = os.path.join(
video_path, '{}_001_confidence.value'.format(video.name))
with open(result_path, 'w') as f:
for x in scores:
f.write('\n') if x is None else f.write(
"{:.6f}\n".format(x))
result_path = os.path.join(video_path,
'{}_time.txt'.format(video.name))
with open(result_path, 'w') as f:
for x in track_times:
f.write("{:.6f}\n".format(x))
elif 'GOT-10k' == args.dataset:
video_path = os.path.join('results', args.dataset, model_name,
video.name)
if not os.path.isdir(video_path):
os.makedirs(video_path)
result_path = os.path.join(video_path,
'{}_001.txt'.format(video.name))
with open(result_path, 'w') as f:
for x in pred_bboxes:
f.write(','.join([str(i) for i in x]) + '\n')
result_path = os.path.join(video_path,
'{}_time.txt'.format(video.name))
with open(result_path, 'w') as f:
for x in track_times:
f.write("{:.6f}\n".format(x))
else:
model_path = os.path.join('results', args.dataset, model_name)
if not os.path.isdir(model_path):
os.makedirs(model_path)
result_path = os.path.join(model_path,
'{}.txt'.format(video.name))
with open(result_path, 'w') as f:
for x in pred_bboxes:
f.write(','.join([str(i) for i in x]) + '\n')
print('({:3d}) Video: {:12s} Time: {:5.1f}s Speed: {:3.1f}fps'.
format(v_idx + 1, video.name, toc, idx / toc))
net = load_pretrain(net, args.snapshot)
net.eval()
net = net.cuda()
# create dataset
dataset = DatasetFactory.create_dataset(name=args.dataset,
dataset_root=dataset_root,
load_img=False)
# Eval dataset
# root = os.path.realpath(os.path.join(os.path.dirname(__file__),
# '../testing_dataset'))
root = "/ssd"
root = os.path.join(root, args.dataset)
if 'OTB' in args.dataset:
dataset_eval = OTBDataset(args.dataset, root)
elif 'LaSOT' == args.dataset:
dataset_eval = LaSOTDataset(args.dataset, root)
elif 'UAV' in args.dataset:
dataset_eval = UAVDataset(args.dataset, root)
elif 'NFS' in args.dataset:
dataset_eval = NFSDataset(args.dataset, root)
if args.dataset in ['VOT2016', 'VOT2017', 'VOT2018', 'VOT2019']:
dataset_eval = VOTDataset(args.dataset, root)
elif 'VOT2018-LT' == args.dataset:
dataset_eval = VOTLTDataset(args.dataset, root)
tune_result = os.path.join('tune_results', args.dataset)
if not os.path.isdir(tune_result):
os.makedirs(tune_result)
log_path = os.path.join(
def main():
tracker_dir = os.path.join(args.tracker_path, args.dataset)
trackers = glob(
os.path.join(args.tracker_path, args.dataset,
args.tracker_prefix + '*'))
trackers = [x.split('/')[-1] for x in trackers]
assert len(trackers) > 0
args.num = min(args.num, len(trackers))
root = os.path.join(dataset_root_, args.dataset)
if 'OTB' in args.dataset:
dataset = OTBDataset(args.dataset, root)
dataset.set_tracker(tracker_dir, trackers)
benchmark = OPEBenchmark(dataset)
success_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_success,
trackers),
desc='eval success',
total=len(trackers),
ncols=100):
success_ret.update(ret)
precision_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_precision,
trackers),
desc='eval precision',
total=len(trackers),
ncols=100):
precision_ret.update(ret)
benchmark.show_result(success_ret,
precision_ret,
show_video_level=args.show_video_level)
if args.vis:
for attr, videos in dataset.attr.items():
if attr == 'ALL':
draw_success_precision(success_ret,
name=dataset.name,
videos=videos,
attr=attr,
precision_ret=precision_ret)
elif 'LaSOT' == args.dataset:
dataset = LaSOTDataset(args.dataset, root)
dataset.set_tracker(tracker_dir, trackers)
benchmark = OPEBenchmark(dataset)
success_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_success,
trackers),
desc='eval success',
total=len(trackers),
ncols=100):
success_ret.update(ret)
precision_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_precision,
trackers),
desc='eval precision',
total=len(trackers),
ncols=100):
precision_ret.update(ret)
norm_precision_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_norm_precision,
trackers),
desc='eval norm precision',
total=len(trackers),
ncols=100):
norm_precision_ret.update(ret)
benchmark.show_result(success_ret,
precision_ret,
norm_precision_ret,
show_video_level=args.show_video_level)
if args.vis:
draw_success_precision(success_ret,
name=dataset.name,
videos=dataset.attr['ALL'],
attr='ALL',
precision_ret=precision_ret,
norm_precision_ret=norm_precision_ret)
elif 'UAV' in args.dataset:
dataset = UAVDataset(args.dataset, root)
dataset.set_tracker(tracker_dir, trackers)
benchmark = OPEBenchmark(dataset)
success_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_success,
trackers),
desc='eval success',
total=len(trackers),
ncols=100):
success_ret.update(ret)
precision_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_precision,
trackers),
desc='eval precision',
total=len(trackers),
ncols=100):
precision_ret.update(ret)
benchmark.show_result(success_ret,
precision_ret,
show_video_level=args.show_video_level)
elif 'NFS' in args.dataset:
dataset = NFSDataset(args.dataset, root)
dataset.set_tracker(tracker_dir, trackers)
benchmark = OPEBenchmark(dataset)
success_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_success,
trackers),
desc='eval success',
total=len(trackers),
ncols=100):
success_ret.update(ret)
precision_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_precision,
trackers),
desc='eval precision',
total=len(trackers),
ncols=100):
precision_ret.update(ret)
benchmark.show_result(success_ret,
precision_ret,
show_video_level=args.show_video_level)
elif args.dataset in ['VOT2016', 'VOT2017', 'VOT2018', 'VOT2019']:
dataset = VOTDataset(args.dataset, root)
dataset.set_tracker(tracker_dir, trackers)
ar_benchmark = AccuracyRobustnessBenchmark(dataset)
ar_result = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(ar_benchmark.eval, trackers),
desc='eval ar',
total=len(trackers),
ncols=100):
ar_result.update(ret)
benchmark = EAOBenchmark(dataset)
eao_result = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval, trackers),
desc='eval eao',
total=len(trackers),
ncols=100):
eao_result.update(ret)
ar_benchmark.show_result(ar_result,
eao_result,
show_video_level=args.show_video_level)
elif 'VOT2018-LT' == args.dataset:
dataset = VOTLTDataset(args.dataset, root)
dataset.set_tracker(tracker_dir, trackers)
benchmark = F1Benchmark(dataset)
f1_result = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval, trackers),
desc='eval f1',
total=len(trackers),
ncols=100):
f1_result.update(ret)
benchmark.show_result(f1_result,
show_video_level=args.show_video_level)
def main():
tracker_dir = Path(args.tracker_path)
tracker_path = tracker_dir / args.dataset
trackers = tracker_path.glob("*")
trackers = [Path(x).stem for x in trackers]
assert len(trackers) > 0
args.num = min(args.num, len(trackers))
root = str(Path(args.dataset_root) / args.dataset)
if 'OTB' in args.dataset:
dataset = OTBDataset(args.dataset, root)
dataset.set_tracker(tracker_dir, trackers)
benchmark = OPEBenchmark(dataset)
success_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_success,
trackers),
desc='eval success',
total=len(trackers),
ncols=100):
success_ret.update(ret)
precision_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_precision,
trackers),
desc='eval precision',
total=len(trackers),
ncols=100):
precision_ret.update(ret)
benchmark.show_result(success_ret,
precision_ret,
show_video_level=args.show_video_level)
elif 'LaSOT' == args.dataset:
dataset = LaSOTDataset(args.dataset, root)
dataset.set_tracker(tracker_dir, trackers)
benchmark = OPEBenchmark(dataset)
success_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_success,
trackers),
desc='eval success',
total=len(trackers),
ncols=100):
success_ret.update(ret)
precision_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_precision,
trackers),
desc='eval precision',
total=len(trackers),
ncols=100):
precision_ret.update(ret)
norm_precision_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_norm_precision,
trackers),
desc='eval norm precision',
total=len(trackers),
ncols=100):
norm_precision_ret.update(ret)
benchmark.show_result(success_ret,
precision_ret,
norm_precision_ret,
show_video_level=args.show_video_level)
elif args.dataset in ['VOT2016', 'VOT2017', 'VOT2018', 'VOT2019', 'debug']:
dataset = VOTDataset(args.dataset, root)
dataset.set_tracker(tracker_path, trackers)
ar_benchmark = AccuracyRobustnessBenchmark(dataset)
ar_result = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(ar_benchmark.eval, trackers),
desc='eval ar',
total=len(trackers),
ncols=100):
ar_result.update(ret)
benchmark = EAOBenchmark(dataset)
eao_result = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval, trackers),
desc='eval eao',
total=len(trackers),
ncols=100):
eao_result.update(ret)
ar_benchmark.show_result(ar_result,
eao_result,
show_video_level=args.show_video_level)
def evaluation(dataset='VOT2018',
tracker_prefix='DaSiamRPN',
tracker_path='./results',
num=4,
show_video_level=True):
tracker_dir = os.path.join(tracker_path)
trackers = glob(os.path.join(tracker_path, tracker_prefix))
# tracker_prefix+'*'))
trackers = [x.split('/')[-1] for x in trackers]
assert len(trackers) > 0
num = min(num, len(trackers))
# root = os.path.realpath(os.path.join(os.path.dirname(__file__),
# '../datasets'))
root = '/home/lyuyu/dataset/'
root = os.path.join(root, dataset)
if 'OTB' in dataset:
dataset = OTBDataset(dataset, root)
dataset.set_tracker(tracker_dir, trackers)
benchmark = OPEBenchmark(dataset)
success_ret = {}
with Pool(processes=num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_success,
trackers),
desc='eval success',
total=len(trackers),
ncols=100):
success_ret.update(ret)
precision_ret = {}
with Pool(processes=num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_precision,
trackers),
desc='eval precision',
total=len(trackers),
ncols=100):
precision_ret.update(ret)
benchmark.show_result(success_ret,
precision_ret,
show_video_level=show_video_level)
elif 'LaSOT' == dataset:
dataset = LaSOTDataset(dataset, root)
dataset.set_tracker(tracker_dir, trackers)
benchmark = OPEBenchmark(dataset)
success_ret = {}
with Pool(processes=num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_success,
trackers),
desc='eval success',
total=len(trackers),
ncols=100):
success_ret.update(ret)
precision_ret = {}
with Pool(processes=num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_precision,
trackers),
desc='eval precision',
total=len(trackers),
ncols=100):
precision_ret.update(ret)
norm_precision_ret = {}
with Pool(processes=num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_norm_precision,
trackers),
desc='eval norm precision',
total=len(trackers),
ncols=100):
norm_precision_ret.update(ret)
benchmark.show_result(success_ret,
precision_ret,
norm_precision_ret,
show_video_level=show_video_level)
elif 'UAV' in dataset:
dataset = UAVDataset(dataset, root)
dataset.set_tracker(tracker_dir, trackers)
benchmark = OPEBenchmark(dataset)
success_ret = {}
with Pool(processes=num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_success,
trackers),
desc='eval success',
total=len(trackers),
ncols=100):
success_ret.update(ret)
precision_ret = {}
with Pool(processes=num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_precision,
trackers),
desc='eval precision',
total=len(trackers),
ncols=100):
precision_ret.update(ret)
benchmark.show_result(success_ret,
precision_ret,
show_video_level=show_video_level)
elif 'NFS' in dataset:
dataset = NFSDataset(dataset, root)
dataset.set_tracker(tracker_dir, trackers)
benchmark = OPEBenchmark(dataset)
success_ret = {}
with Pool(processes=num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_success,
trackers),
desc='eval success',
total=len(trackers),
ncols=100):
success_ret.update(ret)
precision_ret = {}
with Pool(processes=num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_precision,
trackers),
desc='eval precision',
total=len(trackers),
ncols=100):
precision_ret.update(ret)
benchmark.show_result(success_ret,
precision_ret,
show_video_level=show_video_level)
elif dataset in ['VOT2016', 'VOT2017', 'VOT2018', 'VOT2019']:
dataset = VOTDataset(dataset, root)
dataset.set_tracker(tracker_dir, trackers)
ar_benchmark = AccuracyRobustnessBenchmark(dataset)
ar_result = {}
with Pool(processes=num) as pool:
for ret in tqdm(pool.imap_unordered(ar_benchmark.eval, trackers),
desc='eval ar',
total=len(trackers),
ncols=100):
ar_result.update(ret)
benchmark = EAOBenchmark(dataset)
eao_result = {}
with Pool(processes=num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval, trackers),
desc='eval eao',
total=len(trackers),
ncols=100):
eao_result.update(ret)
ar_benchmark.show_result(ar_result,
eao_result,
show_video_level=show_video_level)
elif 'VOT2018-LT' == dataset:
dataset = VOTLTDataset(dataset, root)
dataset.set_tracker(tracker_dir, trackers)
benchmark = F1Benchmark(dataset)
f1_result = {}
with Pool(processes=num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval, trackers),
desc='eval f1',
total=len(trackers),
ncols=100):
f1_result.update(ret)
benchmark.show_result(f1_result, show_video_level=show_video_level)
def evaluate(args):
tracker_dir = os.path.join(args.tracker_path, args.dataset)
trackers = glob(
os.path.join(args.tracker_path, args.dataset, args.tracker_name + '*'))
trackers = [x.split('/')[-1] for x in trackers]
assert len(trackers) > 0
args.num = min(args.num, len(trackers))
#root = os.path.realpath(os.path.join(os.path.dirname(__file__),
# 'testing_dataset'))
root = './datasets'
root = os.path.join(root, args.dataset)
if 'OTB' in args.dataset:
dataset = OTBDataset(args.dataset, root)
dataset.set_tracker(tracker_dir, trackers)
benchmark = OPEBenchmark(dataset)
success_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_success,
trackers),
desc='eval success',
total=len(trackers),
ncols=100):
success_ret.update(ret)
precision_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_precision,
trackers),
desc='eval precision',
total=len(trackers),
ncols=100):
precision_ret.update(ret)
benchmark.show_result(success_ret,
precision_ret,
show_video_level=args.show_video_level)
elif 'DTB70' in args.dataset:
dataset = DTB70Dataset(args.dataset, root)
dataset.set_tracker(tracker_dir, trackers)
benchmark = OPEBenchmark(dataset)
success_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_success,
trackers),
desc='eval success',
total=len(trackers),
ncols=100):
success_ret.update(ret)
precision_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_precision,
trackers),
desc='eval precision',
total=len(trackers),
ncols=100):
precision_ret.update(ret)
benchmark.show_result(success_ret,
precision_ret,
show_video_level=args.show_video_level)
elif 'UAVDT' in args.dataset:
dataset = UAVDTDataset(args.dataset, root)
dataset.set_tracker(tracker_dir, trackers)
benchmark = OPEBenchmark(dataset)
success_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_success,
trackers),
desc='eval success',
total=len(trackers),
ncols=100):
success_ret.update(ret)
precision_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_precision,
trackers),
desc='eval precision',
total=len(trackers),
ncols=100):
precision_ret.update(ret)
benchmark.show_result(success_ret,
precision_ret,
show_video_level=args.show_video_level)
elif 'VisDrone' in args.dataset:
dataset = VisDroneDataset(args.dataset, root)
dataset.set_tracker(tracker_dir, trackers)
benchmark = OPEBenchmark(dataset)
success_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_success,
trackers),
desc='eval success',
total=len(trackers),
ncols=100):
success_ret.update(ret)
precision_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_precision,
trackers),
desc='eval precision',
total=len(trackers),
ncols=100):
precision_ret.update(ret)
benchmark.show_result(success_ret,
precision_ret,
show_video_level=args.show_video_level)
elif 'GOT-10k' in args.dataset:
root_dir = os.path.abspath('datasets/GOT-10k')
e = ExperimentGOT10k(root_dir)
ao, sr, speed = e.report(['siamcar'])
ss = 'ao:%.3f --sr:%.3f -speed:%.3f' % (float(ao), float(sr),
float(speed))
print(ss)
elif 'LaSOT' == args.dataset:
dataset = LaSOTDataset(args.dataset, root)
dataset.set_tracker(tracker_dir, trackers)
benchmark = OPEBenchmark(dataset)
success_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_success,
trackers),
desc='eval success',
total=len(trackers),
ncols=100):
success_ret.update(ret)
precision_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_precision,
trackers),
desc='eval precision',
total=len(trackers),
ncols=100):
precision_ret.update(ret)
norm_precision_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_norm_precision,
trackers),
desc='eval norm precision',
total=len(trackers),
ncols=100):
norm_precision_ret.update(ret)
benchmark.show_result(success_ret,
precision_ret,
norm_precision_ret,
show_video_level=args.show_video_level)
elif 'UAV' in args.dataset: #注意UAVDT和 UAV123 以及 UAV20L的区别
dataset = UAVDataset(args.dataset, root)
dataset.set_tracker(tracker_dir, trackers)
benchmark = OPEBenchmark(dataset)
success_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_success,
trackers),
desc='eval success',
total=len(trackers),
ncols=100):
success_ret.update(ret)
precision_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_precision,
trackers),
desc='eval precision',
total=len(trackers),
ncols=100):
precision_ret.update(ret)
benchmark.show_result(success_ret,
precision_ret,
show_video_level=args.show_video_level)
elif 'NFS' in args.dataset:
dataset = NFSDataset(args.dataset, root)
dataset.set_tracker(tracker_dir, trackers)
benchmark = OPEBenchmark(dataset)
success_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_success,
trackers),
desc='eval success',
total=len(trackers),
ncols=100):
success_ret.update(ret)
precision_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_precision,
trackers),
desc='eval precision',
total=len(trackers),
ncols=100):
precision_ret.update(ret)
benchmark.show_result(success_ret,
precision_ret,
show_video_level=args.show_video_level)
elif args.dataset in ['VOT2016', 'VOT2017', 'VOT2018', 'VOT2019']:
dataset = VOTDataset(args.dataset, root)
dataset.set_tracker(tracker_dir, trackers)
ar_benchmark = AccuracyRobustnessBenchmark(dataset)
ar_result = {}
with Pool(processes=args.num) as pool:
# for ret in tqdm(pool.imap_unordered(ar_benchmark.eval,
# trackers), desc='eval ar', total=len(trackers), ncols=100):
# ar_result.update(ret)
for ret in pool.imap_unordered(ar_benchmark.eval, trackers):
ar_result.update(ret)
benchmark = EAOBenchmark(dataset)
eao_result = {}
with Pool(processes=args.num) as pool:
for ret in pool.imap_unordered(benchmark.eval, trackers):
eao_result.update(ret)
ar_benchmark.show_result(ar_result,
eao_result,
show_video_level=args.show_video_level)
elif 'VOT2018-LT' == args.dataset:
dataset = VOTLTDataset(args.dataset, root)
dataset.set_tracker(tracker_dir, trackers)
benchmark = F1Benchmark(dataset)
f1_result = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval, trackers),
desc='eval f1',
total=len(trackers),
ncols=100):
f1_result.update(ret)
benchmark.show_result(f1_result,
show_video_level=args.show_video_level)
def main():
tracker_dir = os.path.join(args.tracker_path, args.dataset)
trackers = glob(
os.path.join(args.tracker_path, args.dataset,
args.tracker_prefix + '*'))
trackers = [x.split('/')[-1] for x in trackers]
assert len(trackers) > 0
args.num = min(args.num, len(trackers))
root = os.path.realpath(
os.path.join(os.path.dirname(__file__), '../testing_dataset'))
root = os.path.join(root, args.dataset)
if 'OTB' in args.dataset:
dataset = OTBDataset(args.dataset, root)
dataset.set_tracker(tracker_dir, trackers)
benchmark = OPEBenchmark(dataset)
success_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_success,
trackers),
desc='eval success',
total=len(trackers),
ncols=100):
success_ret.update(ret)
precision_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_precision,
trackers),
desc='eval precision',
total=len(trackers),
ncols=100):
precision_ret.update(ret)
benchmark.show_result(success_ret,
precision_ret,
show_video_level=args.show_video_level)
if args.vis:
for attr, videos in dataset.attr.items():
draw_success_precision(success_ret,
name=dataset.name,
videos=videos,
attr=attr,
precision_ret=precision_ret,
bold_name='Ours')
elif 'LaSOT' == args.dataset:
dataset = LaSOTDataset(args.dataset, root)
dataset.set_tracker(tracker_dir, trackers)
benchmark = OPEBenchmark(dataset)
success_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_success,
trackers),
desc='eval success',
total=len(trackers),
ncols=100):
success_ret.update(ret)
precision_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_precision,
trackers),
desc='eval precision',
total=len(trackers),
ncols=100):
precision_ret.update(ret)
norm_precision_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_norm_precision,
trackers),
desc='eval norm precision',
total=len(trackers),
ncols=100):
norm_precision_ret.update(ret)
benchmark.show_result(success_ret,
precision_ret,
norm_precision_ret,
show_video_level=args.show_video_level)
if args.vis:
draw_success_precision(success_ret,
name=dataset.name,
videos=dataset.attr['ALL'],
attr='ALL',
precision_ret=precision_ret,
norm_precision_ret=norm_precision_ret,
bold_name='Ours')
elif 'UAV' in args.dataset:
dataset = UAVDataset(args.dataset, root)
dataset.set_tracker(tracker_dir, trackers)
benchmark = OPEBenchmark(dataset)
success_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_success,
trackers),
desc='eval success',
total=len(trackers),
ncols=100):
success_ret.update(ret)
precision_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_precision,
trackers),
desc='eval precision',
total=len(trackers),
ncols=100):
precision_ret.update(ret)
benchmark.show_result(success_ret,
precision_ret,
show_video_level=args.show_video_level)
if args.vis:
for attr, videos in dataset.attr.items():
draw_success_precision(success_ret,
name=dataset.name,
videos=videos,
attr=attr,
precision_ret=precision_ret,
bold_name='Ours')
elif 'NFS' in args.dataset:
dataset = NFSDataset(args.dataset, root)
dataset.set_tracker(tracker_dir, trackers)
benchmark = OPEBenchmark(dataset)
success_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_success,
trackers),
desc='eval success',
total=len(trackers),
ncols=100):
success_ret.update(ret)
precision_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_precision,
trackers),
desc='eval precision',
total=len(trackers),
ncols=100):
precision_ret.update(ret)
benchmark.show_result(success_ret,
precision_ret,
show_video_level=args.show_video_level)
if args.vis:
for attr, videos in dataset.attr.items():
draw_success_precision(success_ret,
name=dataset.name,
video=videos,
attr=attr,
precision_ret=precision_ret,
bold_name='Ours')
elif args.dataset in ['VOT2016', 'VOT2017', 'VOT2018', 'VOT2019']:
dataset = VOTDataset(args.dataset, root)
dataset.set_tracker(tracker_dir, trackers)
ar_benchmark = AccuracyRobustnessBenchmark(dataset)
ar_result = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(ar_benchmark.eval, trackers),
desc='eval ar',
total=len(trackers),
ncols=100):
ar_result.update(ret)
if args.vis:
benchmark = EAOBenchmark(dataset,
tags=[
"all", "camera_motion",
"illum_change", "motion_change",
"size_change", "occlusion", "empty"
])
else:
benchmark = EAOBenchmark(dataset)
eao_result = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval, trackers),
desc='eval eao',
total=len(trackers),
ncols=100):
eao_result.update(ret)
ar_benchmark.show_result(ar_result,
eao_result,
show_video_level=args.show_video_level)
if args.vis:
draw_eao(eao_result)
elif 'VOT2018-LT' == args.dataset:
dataset = VOTLTDataset(args.dataset, root)
dataset.set_tracker(tracker_dir, trackers)
benchmark = F1Benchmark(dataset)
f1_result = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval, trackers),
desc='eval f1',
total=len(trackers),
ncols=100):
f1_result.update(ret)
benchmark.show_result(f1_result,
show_video_level=args.show_video_level)
if args.vis:
draw_f1(f1_result, bold_name='Ours')
elif 'TrackingNet' in args.dataset:
print('Please evaluate on the server!')
elif 'VisDrone' in args.dataset:
dataset = VisDroneDataset(args.dataset, root)
dataset.set_tracker(tracker_dir, trackers)
benchmark = OPEBenchmark(dataset)
success_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_success,
trackers),
desc='eval success',
total=len(trackers),
ncols=100):
success_ret.update(ret)
precision_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_precision,
trackers),
desc='eval precision',
total=len(trackers),
ncols=100):
precision_ret.update(ret)
benchmark.show_result(success_ret,
precision_ret,
show_video_level=args.show_video_level)
def main():
trackers = []
tracker_dir = os.path.join(args.tracker_path, args.dataset)
for prfx in args.tracker_prefix:
trackers1 = glob(
os.path.join(args.tracker_path, args.dataset, prfx + '*'))
trackers.extend([x.split('/')[-1] for x in trackers1])
assert len(trackers) > 0
args.num = min(args.num, len(trackers))
root = os.path.realpath(
os.path.join(os.path.dirname(__file__), '../testing_dataset'))
root = os.path.join(root, args.dataset)
if 'OTB' in args.dataset:
dataset = OTBDataset(args.dataset, root)
dataset.set_tracker(tracker_dir, trackers)
benchmark = OPEBenchmark(dataset)
success_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_success,
trackers),
desc='eval success',
total=len(trackers),
ncols=100):
success_ret.update(ret)
precision_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_precision,
trackers),
desc='eval precision',
total=len(trackers),
ncols=100):
precision_ret.update(ret)
benchmark.show_result(success_ret,
precision_ret,
show_video_level=args.show_video_level)
# videos=[]
# attr = 'occlusion'
# for v_idx, video in enumerate(dataset):
# if hasattr(video.attr, attr):
# videos.append(video.name)
####################################################################
for k, v in dataset.attr.items():
# if k=='Occlusion':
draw_success_precision(success_ret, 'OTB100', v, str(k),
precision_ret)
#####################################################################
elif 'LaSOT' == args.dataset:
dataset = LaSOTDataset(args.dataset, root)
dataset.set_tracker(tracker_dir, trackers)
benchmark = OPEBenchmark(dataset)
success_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_success,
trackers),
desc='eval success',
total=len(trackers),
ncols=100):
success_ret.update(ret)
precision_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_precision,
trackers),
desc='eval precision',
total=len(trackers),
ncols=100):
precision_ret.update(ret)
norm_precision_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_norm_precision,
trackers),
desc='eval norm precision',
total=len(trackers),
ncols=100):
norm_precision_ret.update(ret)
benchmark.show_result(success_ret,
precision_ret,
norm_precision_ret,
show_video_level=args.show_video_level)
elif 'UAV' in args.dataset:
dataset = UAVDataset(args.dataset, root)
dataset.set_tracker(tracker_dir, trackers)
benchmark = OPEBenchmark(dataset)
success_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_success,
trackers),
desc='eval success',
total=len(trackers),
ncols=100):
success_ret.update(ret)
precision_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_precision,
trackers),
desc='eval precision',
total=len(trackers),
ncols=100):
precision_ret.update(ret)
benchmark.show_result(success_ret,
precision_ret,
show_video_level=args.show_video_level)
####################################################################
for k, v in dataset.attr.items():
if k == 'Full Occlusion':
draw_success_precision(success_ret, 'UAV123', v, str(k),
precision_ret)
#####################################################################
elif 'NFS' in args.dataset:
dataset = NFSDataset(args.dataset, root)
dataset.set_tracker(tracker_dir, trackers)
benchmark = OPEBenchmark(dataset)
success_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_success,
trackers),
desc='eval success',
total=len(trackers),
ncols=100):
success_ret.update(ret)
precision_ret = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval_precision,
trackers),
desc='eval precision',
total=len(trackers),
ncols=100):
precision_ret.update(ret)
benchmark.show_result(success_ret,
precision_ret,
show_video_level=args.show_video_level)
elif args.dataset in ['VOT2016', 'VOT2017', 'VOT2018', 'VOT2019']:
dataset = VOTDataset(args.dataset, root)
dataset.set_tracker(tracker_dir, trackers)
ar_benchmark = AccuracyRobustnessBenchmark(dataset)
ar_result = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(ar_benchmark.eval, trackers),
desc='eval ar',
total=len(trackers),
ncols=100):
ar_result.update(ret)
benchmark = EAOBenchmark(dataset)
eao_result = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval, trackers),
desc='eval eao',
total=len(trackers),
ncols=100):
eao_result.update(ret)
ar_benchmark.show_result(ar_result,
eao_result,
show_video_level=args.show_video_level)
elif 'VOT2018-LT' == args.dataset:
dataset = VOTLTDataset(args.dataset, root)
dataset.set_tracker(tracker_dir, trackers)
benchmark = F1Benchmark(dataset)
f1_result = {}
with Pool(processes=args.num) as pool:
for ret in tqdm(pool.imap_unordered(benchmark.eval, trackers),
desc='eval f1',
total=len(trackers),
ncols=100):
f1_result.update(ret)
benchmark.show_result(f1_result,
show_video_level=args.show_video_level)
