def test_random_sample_concatdataset():
train_cfg = dict(type='RandomSampleConcatDataset',
dataset_sampling_weights=[1, 1],
dataset_cfgs=[
dict(type='GOT10kDataset',
img_prefix=PREFIX + 'got10k',
pipeline=[],
split='train',
test_mode=False),
dict(type='TrackingNetDataset',
chunks_list=[0],
img_prefix=PREFIX + 'trackingnet',
pipeline=[],
split='train',
test_mode=False)
])
dataset = build_dataset(train_cfg)
results = dataset[0]
assert len(dataset) == 4
assert dataset.dataset_sampling_probs == [0.5, 0.5]
assert len(results) == 2
def main():
args = parse_args()
cfg = Config.fromfile(args.config)
if cfg.get('USE_MMDET', False):
from mmdet.apis import train_detector as train_model
from mmdet.models import build_detector as build_model
if 'detector' in cfg.model:
cfg.model = cfg.model.detector
elif cfg.get('TRAIN_REID', False):
from mmdet.apis import train_detector as train_model
from mmtrack.models import build_reid as build_model
if 'reid' in cfg.model:
cfg.model = cfg.model.reid
else:
from mmtrack.apis import train_model
from mmtrack.models import build_model
if args.cfg_options is not None:
cfg.merge_from_dict(args.cfg_options)
# set cudnn_benchmark
if cfg.get('cudnn_benchmark', False):
torch.backends.cudnn.benchmark = True
# work_dir is determined in this priority: CLI > segment in file > filename
if args.work_dir is not None:
# update configs according to CLI args if args.work_dir is not None
cfg.work_dir = args.work_dir
elif cfg.get('work_dir', None) is None:
# use config filename as default work_dir if cfg.work_dir is None
cfg.work_dir = osp.join('./work_dirs',
osp.splitext(osp.basename(args.config))[0])
if args.resume_from is not None:
cfg.resume_from = args.resume_from
if args.gpu_ids is not None:
cfg.gpu_ids = args.gpu_ids
else:
cfg.gpu_ids = range(1) if args.gpus is None else range(args.gpus)
# init distributed env first, since logger depends on the dist info.
if args.launcher == 'none':
distributed = False
else:
distributed = True
init_dist(args.launcher, **cfg.dist_params)
# create work_dir
mmcv.mkdir_or_exist(osp.abspath(cfg.work_dir))
# dump config
cfg.dump(osp.join(cfg.work_dir, osp.basename(args.config)))
# init the logger before other steps
timestamp = time.strftime('%Y%m%d_%H%M%S', time.localtime())
log_file = osp.join(cfg.work_dir, f'{timestamp}.log')
logger = get_root_logger(log_file=log_file, log_level=cfg.log_level)
# init the meta dict to record some important information such as
# environment info and seed, which will be logged
meta = dict()
# log env info
env_info_dict = collect_env()
env_info = '\n'.join([(f'{k}: {v}') for k, v in env_info_dict.items()])
dash_line = '-' * 60 + '\n'
logger.info('Environment info:\n' + dash_line + env_info + '\n' +
dash_line)
meta['env_info'] = env_info
# log some basic info
logger.info(f'Distributed training: {distributed}')
logger.info(f'Config:\n{cfg.pretty_text}')
# set random seeds
if args.seed is not None:
logger.info(f'Set random seed to {args.seed}, '
f'deterministic: {args.deterministic}')
set_random_seed(args.seed, deterministic=args.deterministic)
cfg.seed = args.seed
meta['seed'] = args.seed
if cfg.get('train_cfg', False):
model = build_model(cfg.model,
train_cfg=cfg.train_cfg,
test_cfg=cfg.test_cfg)
else:
model = build_model(cfg.model)
model.init_weights()
datasets = [build_dataset(cfg.data.train)]
if len(cfg.workflow) == 2:
val_dataset = copy.deepcopy(cfg.data.val)
val_dataset.pipeline = cfg.data.train.pipeline
datasets.append(build_dataset(val_dataset))
if cfg.checkpoint_config is not None:
# save mmtrack version, config file content and class names in
# checkpoints as meta data
cfg.checkpoint_config.meta = dict(mmtrack_version=__version__,
config=cfg.pretty_text,
CLASSES=datasets[0].CLASSES)
# add an attribute for visualization convenience
model.CLASSES = datasets[0].CLASSES
train_model(model,
datasets,
cfg,
distributed=distributed,
validate=(not args.no_validate),
timestamp=timestamp,
meta=meta)
def main():
args = parse_args()
assert args.out or args.eval or args.format_only or args.show \
or args.show_dir, \
('Please specify at least one operation (save/eval/format/show the '
'results / save the results) with the argument "--out", "--eval"'
', "--format-only", "--show" or "--show-dir"')
if args.eval and args.format_only:
raise ValueError('--eval and --format_only cannot be both specified')
if args.out is not None and not args.out.endswith(('.pkl', '.pickle')):
raise ValueError('The output file must be a pkl file.')
cfg = Config.fromfile(args.config)
if cfg.get('USE_MMDET', False):
from mmdet.apis import multi_gpu_test, single_gpu_test
from mmdet.datasets import build_dataloader
from mmdet.models import build_detector as build_model
if 'detector' in cfg.model:
cfg.model = cfg.model.detector
elif cfg.get('TRAIN_REID', False):
from mmdet.apis import multi_gpu_test, single_gpu_test
from mmdet.datasets import build_dataloader
from mmtrack.models import build_reid as build_model
if 'reid' in cfg.model:
cfg.model = cfg.model.reid
else:
from mmtrack.apis import multi_gpu_test, single_gpu_test
from mmtrack.datasets import build_dataloader
from mmtrack.models import build_model
if args.cfg_options is not None:
cfg.merge_from_dict(args.cfg_options)
# set cudnn_benchmark
if cfg.get('cudnn_benchmark', False):
torch.backends.cudnn.benchmark = True
# cfg.model.pretrains = None
if hasattr(cfg.model, 'detector'):
cfg.model.detector.pretrained = None
cfg.data.test.test_mode = True
# init distributed env first, since logger depends on the dist info.
if args.launcher == 'none':
distributed = False
else:
distributed = True
init_dist(args.launcher, **cfg.dist_params)
# build the dataloader
dataset = build_dataset(cfg.data.test)
data_loader = build_dataloader(dataset,
samples_per_gpu=1,
workers_per_gpu=cfg.data.workers_per_gpu,
dist=distributed,
shuffle=False)
# build the model and load checkpoint
if cfg.get('test_cfg', False):
model = build_model(cfg.model,
train_cfg=cfg.train_cfg,
test_cfg=cfg.test_cfg)
else:
model = build_model(cfg.model)
# We need call `init_weights()` to load pretained weights in MOT task.
model.init_weights()
fp16_cfg = cfg.get('fp16', None)
if fp16_cfg is not None:
wrap_fp16_model(model)
if args.checkpoint is not None:
checkpoint = load_checkpoint(model,
args.checkpoint,
map_location='cpu')
if 'CLASSES' in checkpoint['meta']:
model.CLASSES = checkpoint['meta']['CLASSES']
if not hasattr(model, 'CLASSES'):
model.CLASSES = dataset.CLASSES
if args.fuse_conv_bn:
model = fuse_conv_bn(model)
if not distributed:
model = MMDataParallel(model, device_ids=[0])
outputs = single_gpu_test(model,
data_loader,
args.show,
args.show_dir,
show_score_thr=args.show_score_thr)
else:
model = MMDistributedDataParallel(
model.cuda(),
device_ids=[torch.cuda.current_device()],
broadcast_buffers=False)
outputs = multi_gpu_test(model, data_loader, args.tmpdir,
args.gpu_collect)
rank, _ = get_dist_info()
if rank == 0:
if args.out:
print(f'\nwriting results to {args.out}')
mmcv.dump(outputs, args.out)
kwargs = {} if args.eval_options is None else args.eval_options
if args.format_only:
dataset.format_results(outputs, **kwargs)
if args.eval:
eval_kwargs = cfg.get('evaluation', {}).copy()
# hard-code way to remove EvalHook args
eval_hook_args = [
'interval', 'tmpdir', 'start', 'gpu_collect', 'save_best',
'rule', 'by_epoch'
]
for key in eval_hook_args:
eval_kwargs.pop(key, None)
eval_kwargs.update(dict(metric=args.eval, **kwargs))
print(dataset.evaluate(outputs, **eval_kwargs))
def main():
args = parse_args()
cfg = Config.fromfile(args.config)
# import modules from string list.
if cfg.get('custom_imports', None):
from mmcv.utils import import_modules_from_strings
import_modules_from_strings(**cfg['custom_imports'])
# set cudnn_benchmark
if cfg.get('cudnn_benchmark', False):
torch.backends.cudnn.benchmark = True
if hasattr(cfg.model, 'detector'):
cfg.model.detector.pretrained = None
cfg.data.test.test_mode = True
# build the dataloader
samples_per_gpu = cfg.data.test.pop('samples_per_gpu', 1)
if samples_per_gpu > 1:
# Replace 'ImageToTensor' to 'DefaultFormatBundle'
cfg.data.test.pipeline = replace_ImageToTensor(cfg.data.test.pipeline)
dataset = build_dataset(cfg.data.test)
data_loader = build_dataloader(dataset,
samples_per_gpu=1,
workers_per_gpu=cfg.data.workers_per_gpu,
dist=False,
shuffle=False)
# build the model and load checkpoint
model = build_model(cfg.model)
# We need call `init_weights()` to load pretained weights in MOT task.
model.init_weights()
fp16_cfg = cfg.get('fp16', None)
if fp16_cfg is not None:
wrap_fp16_model(model)
if args.checkpoint is not None:
load_checkpoint(model, args.checkpoint, map_location='cpu')
if args.fuse_conv_bn:
model = fuse_conv_bn(model)
model = MMDataParallel(model, device_ids=[0])
model.eval()
# the first several iterations may be very slow so skip them
num_warmup = 5
pure_inf_time = 0
# benchmark with 2000 image and take the average
for i, data in enumerate(data_loader):
torch.cuda.synchronize()
start_time = time.perf_counter()
with torch.no_grad():
model(return_loss=False, rescale=True, **data)
torch.cuda.synchronize()
elapsed = time.perf_counter() - start_time
if i >= num_warmup:
pure_inf_time += elapsed
if (i + 1) % args.log_interval == 0:
fps = (i + 1 - num_warmup) / pure_inf_time
print(f'Done image [{i + 1:<3}/ 2000], fps: {fps:.1f} img / s')
if (i + 1) == 2000:
pure_inf_time += elapsed
fps = (i + 1 - num_warmup) / pure_inf_time
print(f'Overall fps: {fps:.1f} img / s')
break
def main():
args = parse_args()
assert args.show or args.out_dir, \
('Please specify at least one operation (show the results '
'/ save the results) with the argument "--show" or "--out-dir"')
if not args.result_file.endswith(('.pkl', 'pickle')):
raise ValueError('The result file must be a pkl file.')
if args.out_dir is not None:
os.makedirs(args.out_dir, exist_ok=True)
print_log('This script visualizes the error for multiple object tracking. '
'By Default, the red bounding box denotes false positive, '
'the yellow bounding box denotes the false negative '
'and the blue bounding box denotes ID switch.')
cfg = Config.fromfile(args.config)
dataset = build_dataset(cfg.data.val, dict(test_mode=True))
results = mmcv.load(args.result_file)
# create index from frame_id to filename
filenames_dict = dict()
for data_info in dataset.data_infos:
video_name = data_info['filename'].split('/', 1)[0]
frame_id = int(data_info['filename'].rsplit('/', 1)[-1].split('.')[0])
if video_name not in filenames_dict:
filenames_dict[video_name] = dict()
filenames_dict[video_name][frame_id] = data_info['filename']
# format the results to txts
resfiles, video_names, tmp_dir = dataset.format_results(
results, None, ['track'])
for video_name in video_names:
print_log(f'Start processing video {video_name}')
acc, res, gt = compare_res_gts(resfiles, dataset, video_name)
frames_id_list = sorted(
list(set(acc.mot_events.index.get_level_values(0))))
for frame_id in frames_id_list:
# events in the current frame
events = acc.mot_events.xs(frame_id)
cur_res = res.loc[frame_id] if frame_id in res.index else None
cur_gt = gt.loc[frame_id] if frame_id in gt.index else None
# path of image
img = osp.join(dataset.img_prefix,
filenames_dict[video_name][frame_id])
fps = events[events.Type == 'FP']
fns = events[events.Type == 'MISS']
idsws = events[events.Type == 'SWITCH']
bboxes, ids, error_types = [], [], []
for fp_index in fps.index:
hid = events.loc[fp_index].HId
bboxes.append([
cur_res.loc[hid].X, cur_res.loc[hid].Y,
cur_res.loc[hid].X + cur_res.loc[hid].Width,
cur_res.loc[hid].Y + cur_res.loc[hid].Height,
cur_res.loc[hid].Confidence
])
ids.append(hid)
# error_type = 0 denotes false positive error
error_types.append(0)
for fn_index in fns.index:
oid = events.loc[fn_index].OId
bboxes.append([
cur_gt.loc[oid].X, cur_gt.loc[oid].Y,
cur_gt.loc[oid].X + cur_gt.loc[oid].Width,
cur_gt.loc[oid].Y + cur_gt.loc[oid].Height,
cur_gt.loc[oid].Confidence
])
ids.append(-1)
# error_type = 1 denotes false negative error
error_types.append(1)
for idsw_index in idsws.index:
hid = events.loc[idsw_index].HId
bboxes.append([
cur_res.loc[hid].X, cur_res.loc[hid].Y,
cur_res.loc[hid].X + cur_res.loc[hid].Width,
cur_res.loc[hid].Y + cur_res.loc[hid].Height,
cur_res.loc[hid].Confidence
])
ids.append(hid)
# error_type = 2 denotes id switch
error_types.append(2)
if len(bboxes) == 0:
bboxes = np.zeros((0, 5), dtype=np.float32)
else:
bboxes = np.asarray(bboxes, dtype=np.float32)
ids = np.asarray(ids, dtype=np.int32)
error_types = np.asarray(error_types, dtype=np.int32)
imshow_mot_errors(
img,
bboxes,
ids,
error_types,
show=args.show,
out_file=osp.join(args.out_dir,
f'{video_name}/{frame_id:06d}.jpg')
if args.out_dir else None,
backend=args.backend)
print_log(f'Done! Visualization images are saved in '
f'\'{args.out_dir}/{video_name}\'')
mmcv.frames2video(f'{args.out_dir}/{video_name}',
f'{args.out_dir}/{video_name}.mp4',
fps=args.fps,
fourcc='mp4v',
start=frames_id_list[0],
end=frames_id_list[-1],
show_progress=False)
print_log(
f'Done! Visualization video is saved as '
f'\'{args.out_dir}/{video_name}.mp4\' with a FPS of {args.fps}')