def main():
args = parse_args()
cfg = Config.fromfile(args.config)
# set cudnn_benchmark
if cfg.get('cudnn_benchmark', False):
torch.backends.cudnn.benchmark = True
cfg.model.backbone.pretrained = None
cfg.data.test.test_mode = True
# build the dataloader
dataset = build_dataset(cfg.data.test, dict(test_mode=True))
data_loader = build_dataloader(
dataset,
videos_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, train_cfg=None, test_cfg=cfg.get('test_cfg'))
fp16_cfg = cfg.get('fp16', None)
if fp16_cfg is not None:
wrap_fp16_model(model)
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 video 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, **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 video [{i + 1:<3}/ 2000], fps: {fps:.1f} video / s')
if (i + 1) == 200:
pure_inf_time += elapsed
fps = (i + 1 - num_warmup) / pure_inf_time
print(f'Overall fps: {fps:.1f} video / s')
break
def main(args):
# load config
cfg = mmcv.Config.fromfile(args.config)
if args.update_config is not None:
cfg.merge_from_dict(args.update_config)
cfg = update_config(cfg, args)
cfg = propagate_root_dir(cfg, args.data_dir)
if cfg.get('seed'):
print(f'Set random seed to {cfg.seed}')
set_random_seed(cfg.seed)
# build the dataset
dataset = build_dataset(cfg.data, 'test', dict(test_mode=True))
print(f'Test datasets:\n{str(dataset)}')
# build the dataloader
data_loader = build_dataloader(
dataset,
videos_per_gpu=20,
workers_per_gpu=cfg.data.workers_per_gpu,
dist=False,
shuffle=False
)
# collect results
mean_data, std_data = collect_stat(data_loader)
# filter data
mean_data, std_data = filter_stat(mean_data, std_data, min_value=1.0)
# dump stat
dump_stat(mean_data, std_data, args.out)
def get_phase_dataset(self, phase, modality_sampler):
""" Get the dataset for the specific phase. """
rgb_mode_config = getattr(Config().data.multi_modal_configs.rgb, phase)
flow_mode_config = getattr(Config().data.multi_modal_configs.flow,
phase)
audio_feature_mode_config = getattr(
Config().data.multi_modal_configs.audio_feature, phase)
rgb_mode_config = self.correct_current_config(
loaded_plato_config=rgb_mode_config,
mode=phase,
modality_name="rgb")
flow_mode_config = self.correct_current_config(
loaded_plato_config=flow_mode_config,
mode=phase,
modality_name="flow")
audio_feature_mode_config = self.correct_current_config(
loaded_plato_config=audio_feature_mode_config,
mode=phase,
modality_name="audio_feature")
# build a RawframeDataset
rgb_mode_dataset = build_dataset(rgb_mode_config)
flow_mode_dataset = build_dataset(flow_mode_config)
audio_feature_mode_dataset = build_dataset(audio_feature_mode_config)
multi_modal_mode_data = {
"rgb": rgb_mode_dataset,
"flow": flow_mode_dataset,
"audio_feature": audio_feature_mode_dataset
}
multi_modal_mode_info = {
"rgb": rgb_mode_config["ann_file"],
"flow": flow_mode_config["ann_file"],
"audio_feature": audio_feature_mode_config["ann_file"],
"categories": self.categoty_anno_file_path
}
gym_mode_dataset = GymDataset(
multimodal_data_holder=multi_modal_mode_data,
phase="train",
phase_info=multi_modal_mode_info,
modality_sampler=modality_sampler)
return gym_mode_dataset
def main(args):
assert args.model.endswith('.xml')
# load config
cfg = mmcv.Config.fromfile(args.config)
if args.update_config is not None:
cfg.merge_from_dict(args.update_config)
cfg = update_config(cfg, args)
cfg = propagate_root_dir(cfg, args.data_dir)
# Load eval_config from cfg
eval_config = cfg.get('eval_config', {})
# Overwrite eval_config from args.eval
eval_config = merge_configs(eval_config, dict(metrics=args.eval))
# Add options from args.option
eval_config = merge_configs(eval_config, args.options)
assert eval_config, 'Please specify at eval operation with the argument "--eval"'
# build the dataset
dataset = build_dataset(cfg.data, 'test', dict(test_mode=True))
assert dataset.num_datasets == 1
if cfg.get('classes'):
dataset = dataset.filter(cfg.classes)
print(f'Test datasets:\n{str(dataset)}')
# build the dataloader
data_loader = build_dataloader(
dataset,
videos_per_gpu=1,
workers_per_gpu=cfg.data.workers_per_gpu,
dist=False,
shuffle=False
)
# build class mapping between model.classes and dataset.classes
assert cfg.get('model_classes') is not None
model_classes = {k: v for k, v in enumerate(cfg.model_classes)}
class_map = build_class_map(dataset.class_maps[0], model_classes)
# load model
ie_core = load_ie_core()
model = ActionRecognizer(args.model, ie_core, class_map)
# collect results
outputs = collect_results(model, data_loader)
# get metrics
if eval_config:
eval_res = dataset.evaluate(outputs, **eval_config)
print('\nFinal metrics:')
for name, val in eval_res.items():
print(f'{name}: {val:.04f}')
def setup(self):
print("loading dataset ...");
self.system_dict["local"]["datasets"] = [build_dataset(self.system_dict["local"]["cfg"].data.train)]
print("loading_model ...");
self.system_dict["local"]["model"] = build_model(self.system_dict["local"]["cfg"].model,
train_cfg=self.system_dict["local"]["cfg"].train_cfg,
test_cfg=self.system_dict["local"]["cfg"].test_cfg)
print("creating workspace directory ...");
mmcv.mkdir_or_exist(osp.abspath(self.system_dict["local"]["cfg"].work_dir))
print("Done");
def _update_long_cycle(self, runner):
"""Before every epoch, check if long cycle shape should change. If it
should, change the pipelines accordingly.
change dataloader and model's subbn3d(split_bn)
"""
base_b, base_t, base_s = self._get_schedule(runner.epoch)
# rebuild dataset
from mmaction.datasets import build_dataset
resize_list = []
for trans in self.cfg.data.train.pipeline:
if trans['type'] == 'SampleFrames':
curr_t = trans['clip_len']
trans['clip_len'] = base_t
trans['frame_interval'] = (curr_t *
trans['frame_interval']) / base_t
elif trans['type'] == 'Resize':
resize_list.append(trans)
resize_list[-1]['scale'] = _ntuple(2)(base_s)
ds = build_dataset(self.cfg.data.train)
from mmaction.datasets import build_dataloader
dataloader = build_dataloader(
ds,
self.data_cfg.videos_per_gpu * base_b,
self.data_cfg.workers_per_gpu,
dist=True,
num_gpus=len(self.cfg.gpu_ids),
drop_last=True,
seed=self.cfg.get('seed', None),
)
runner.data_loader = dataloader
self.logger.info('Rebuild runner.data_loader')
# the self._max_epochs is changed, therefore update here
runner._max_iters = runner._max_epochs * len(runner.data_loader)
# rebuild all the sub_batch_bn layers
num_modifies = modify_subbn3d_num_splits(self.logger, runner.model,
base_b)
self.logger.info(f'{num_modifies} subbns modified to {base_b}.')
def main():
parser = argparse.ArgumentParser(description='Benchmark dataloading')
parser.add_argument('config', help='train config file path')
args = parser.parse_args()
cfg = Config.fromfile(args.config)
# init logger before other steps
logger = get_root_logger()
logger.info(f'MMAction2 Version: {__version__}')
logger.info(f'Config: {cfg.text}')
# create bench data list
ann_file_bench = 'benchlist.txt'
if not os.path.exists(ann_file_bench):
with open(cfg.ann_file_train) as f:
lines = f.readlines()[:256]
with open(ann_file_bench, 'w') as f1:
f1.writelines(lines)
cfg.data.train.ann_file = ann_file_bench
dataset = build_dataset(cfg.data.train)
data_loader = build_dataloader(dataset,
videos_per_gpu=cfg.data.videos_per_gpu,
workers_per_gpu=0,
num_gpus=1,
dist=False)
# Start progress bar after first 5 batches
prog_bar = mmcv.ProgressBar(len(dataset) - 5 * cfg.data.videos_per_gpu,
start=False)
for i, data in enumerate(data_loader):
if i == 5:
prog_bar.start()
for img in data['imgs']:
if i < 5:
continue
prog_bar.update()
def main():
args = parse_args()
cfg = Config.fromfile(args.config)
assert args.eval is not None
if args.cfg_options is not None:
cfg.merge_from_dict(args.cfg_options)
cfg.data.test.test_mode = True
dataset = build_dataset(cfg.data.test)
outputs = mmcv.load(args.results)
kwargs = {} if args.eval_options is None else args.eval_options
eval_kwargs = cfg.get('evaluation', {}).copy()
# hard-code way to remove EpochEvalHook args
for key in [
'interval', 'tmpdir', 'start', 'gpu_collect', 'save_best', 'rule',
'key_indicator'
]:
eval_kwargs.pop(key, None)
eval_kwargs.update(dict(metrics=args.eval, **kwargs))
print(dataset.evaluate(outputs, **eval_kwargs))
def main():
args = parse_args()
cfg = mmcv.Config.fromfile(args.config)
# Load output_config from cfg
output_config = cfg.get('output_config', {})
# Overwrite output_config from args.out
output_config = merge_configs(output_config, dict(out=args.out))
# Load eval_config from cfg
eval_config = cfg.get('eval_config', {})
# Overwrite eval_config from args.eval
eval_config = merge_configs(eval_config, dict(metrics=args.eval))
# Add options from args.option
eval_config = merge_configs(eval_config, args.options)
assert output_config or eval_config, \
('Please specify at least one operation (save or eval the '
'results) with the argument "--out" or "--eval"')
# set cudnn benchmark
if cfg.get('cudnn_benchmark', False):
torch.backends.cudnn.benchmark = True
cfg.data.test.test_mode = True
if cfg.test_cfg is None:
cfg.test_cfg = dict(average_clips=args.average_clips)
else:
cfg.test_cfg.average_clips = args.average_clips
# 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, dict(test_mode=True))
data_loader = build_dataloader(dataset,
videos_per_gpu=1,
workers_per_gpu=cfg.data.workers_per_gpu,
dist=distributed,
shuffle=False)
# map lable from txt to csv file
df = pd.read_csv('/data2/phap/datasets/dataset3_test.txt', header=None)
df.columns = ['full_name']
df['file_name'] = df['full_name'].apply(lambda x: x.rsplit(' ')[0])
df['true_label'] = df['full_name'].apply(lambda x: x.rsplit(' ')[-1])
# build the model and load checkpoint
model = build_model(cfg.model, train_cfg=None, test_cfg=cfg.test_cfg)
load_checkpoint(model, args.checkpoint, map_location='cpu')
if not distributed:
model = MMDataParallel(model, device_ids=[0])
outputs = single_gpu_test(model, data_loader)
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)
# convert softmax output to one hot
pred_arr = []
for i in outputs:
pred = np.argmax(i)
pred_arr.append(pred)
# import output into csv
df['pred_label_orig'] = outputs
df['pred_label'] = pred_arr
# save csv file
df.to_csv('dataset3_test_pred_w_rwf_model.csv')
print('\nSuccess, csv file saved')
rank, _ = get_dist_info()
if rank == 0:
if output_config:
out = output_config['out']
print(f'\nwriting results to {out}')
dataset.dump_results(outputs, **output_config)
if eval_config:
eval_res = dataset.evaluate(outputs, **eval_config)
for name, val in eval_res.items():
print(f'{name}: {val:.04f}')
opencv='OpenCV',
pyav='PyAV')
# read config file
cfg = Config.fromfile(args.config)
cfg.merge_from_dict(args.cfg_options)
# build dataset
dataset_type = cfg.data[args.split].type
assert dataset_type == 'VideoDataset'
cfg.data[args.split].pipeline = [
dict(type=decoder_to_pipeline_prefix[args.decoder] + 'Init'),
dict(type='RandomSampleFrames'),
dict(type=decoder_to_pipeline_prefix[args.decoder] + 'Decode')
]
dataset = build_dataset(cfg.data[args.split],
dict(test_mode=(args.split != 'train')))
# prepare for checking
if os.path.exists(args.output_file):
# remove exsiting output file
os.remove(args.output_file)
pool = Pool(args.num_processes)
lock = Manager().Lock()
worker_fn = partial(_do_check_videos, lock, dataset, args.output_file)
ids = range(len(dataset))
# start checking
prog_bar = mmcv.ProgressBar(len(dataset))
for _ in pool.imap_unordered(worker_fn, ids):
prog_bar.update()
pool.close()
def main():
# parse arguments
args = parse_args()
# load config
cfg = Config.fromfile(args.config)
if args.update_config is not None:
cfg.merge_from_dict(args.update_config)
cfg = update_config(cfg, args)
cfg = propagate_root_dir(cfg, args.data_dir)
# init distributed env first, since logger depends on the dist info.
distributed = args.launcher != 'none'
if distributed:
init_dist(args.launcher, **cfg.dist_params)
# create work_dir
mmcv.mkdir_or_exist(osp.abspath(cfg.work_dir))
# init 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: {cfg.text}')
if cfg.get('nncf_config'):
check_nncf_is_enabled()
logger.info('NNCF config: {}'.format(cfg.nncf_config))
meta.update(get_nncf_metadata())
# set random seeds
cfg.seed = args.seed
meta['seed'] = args.seed
if cfg.get('seed'):
logger.info(f'Set random seed to {cfg.seed}, deterministic: {args.deterministic}')
set_random_seed(cfg.seed, deterministic=args.deterministic)
# build datasets
datasets = [build_dataset(cfg.data, 'train', dict(logger=logger))]
logger.info(f'Train datasets:\n{str(datasets[0])}')
if len(cfg.workflow) == 2:
if not args.no_validate:
warnings.warn('val workflow is duplicated with `--validate`, '
'it is recommended to use `--validate`. see '
'https://github.com/open-mmlab/mmaction2/pull/123')
datasets.append(build_dataset(copy.deepcopy(cfg.data), 'val', dict(logger=logger)))
logger.info(f'Val datasets:\n{str(datasets[-1])}')
# filter dataset labels
if cfg.get('classes'):
datasets = [dataset.filter(cfg.classes) for dataset in datasets]
# build model
model = build_model(
cfg.model,
train_cfg=cfg.train_cfg,
test_cfg=cfg.test_cfg,
class_sizes=datasets[0].class_sizes,
class_maps=datasets[0].class_maps
)
# define ignore layers
ignore_prefixes = []
if hasattr(cfg, 'reset_layer_prefixes') and isinstance(cfg.reset_layer_prefixes, (list, tuple)):
ignore_prefixes += cfg.reset_layer_prefixes
ignore_suffixes = ['num_batches_tracked']
if hasattr(cfg, 'reset_layer_suffixes') and isinstance(cfg.reset_layer_suffixes, (list, tuple)):
ignore_suffixes += cfg.reset_layer_suffixes
# train model
train_model(
model,
datasets,
cfg,
distributed=distributed,
validate=(not args.no_validate),
timestamp=timestamp,
meta=meta,
ignore_prefixes=tuple(ignore_prefixes),
ignore_suffixes=tuple(ignore_suffixes)
)
def main():
args = parse_args()
cfg = mmcv.Config.fromfile(args.config)
if args.update_config is not None:
cfg.merge_from_dict(args.update_config)
cfg = update_config(cfg, args)
cfg = propagate_root_dir(cfg, args.data_dir)
# Load output_config from cfg
output_config = cfg.get('output_config', {})
# Overwrite output_config from args.out
output_config = merge_configs(output_config, dict(out=args.out))
# Load eval_config from cfg
eval_config = cfg.get('eval_config', {})
# Overwrite eval_config from args.eval
eval_config = merge_configs(eval_config, dict(metrics=args.eval))
# Add options from args.option
eval_config = merge_configs(eval_config, args.options)
assert output_config or eval_config, \
('Please specify at least one operation (save or eval the '
'results) with the argument "--out" or "--eval"')
# init distributed env first, since logger depends on the dist info.
distributed = args.launcher != 'none'
if distributed:
init_dist(args.launcher, **cfg.dist_params)
# get rank
rank, _ = get_dist_info()
if cfg.get('seed'):
print(f'Set random seed to {cfg.seed}')
set_random_seed(cfg.seed)
# build the dataset
dataset = build_dataset(cfg.data, 'test', dict(test_mode=True))
if cfg.get('classes'):
dataset = dataset.filter(cfg.classes)
if rank == 0:
print(f'Test datasets:\n{str(dataset)}')
# build the dataloader
data_loader = build_dataloader(
dataset,
videos_per_gpu=1,
workers_per_gpu=cfg.data.workers_per_gpu,
dist=distributed,
shuffle=False
)
# build the model and load checkpoint
model = build_model(
cfg.model,
train_cfg=None,
test_cfg=cfg.test_cfg,
class_sizes=dataset.class_sizes,
class_maps=dataset.class_maps
)
fp16_cfg = cfg.get('fp16', None)
if fp16_cfg is not None:
wrap_fp16_model(model)
# load model weights
load_checkpoint(model, args.checkpoint, map_location='cpu', force_matching=True)
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)
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)
if rank == 0:
if output_config:
out = output_config['out']
print(f'\nwriting results to {out}')
dataset.dump_results(outputs, **output_config)
if eval_config:
eval_res = dataset.evaluate(outputs, **eval_config)
print('\nFinal metrics:')
for name, val in eval_res.items():
print(f'{name}: {val:.04f}')
def main():
args = parse_args()
cfg = Config.fromfile(args.config)
cfg.merge_from_dict(args.cfg_options)
if cfg.model['test_cfg'] is None:
cfg.model['test_cfg'] = dict(feature_extraction=True)
else:
cfg.model['test_cfg']['feature_extraction'] = True
# Load output_config from cfg
output_config = cfg.get('output_config', {})
if args.out:
# Overwrite output_config from args.out
output_config = Config._merge_a_into_b(dict(out=args.out),
output_config)
assert output_config, 'Please specify output filename with --out.'
dataset_type = cfg.data.test.type
if output_config.get('out', None):
if 'output_format' in output_config:
# ugly workround to make recognition and localization the same
warnings.warn(
'Skip checking `output_format` in localization task.')
else:
out = output_config['out']
# make sure the dirname of the output path exists
mmcv.mkdir_or_exist(osp.dirname(out))
_, suffix = osp.splitext(out)
assert dataset_type == 'VideoDataset'
assert suffix[1:] in file_handlers, (
'The format of the output '
'file should be json, pickle or yaml')
# set cudnn benchmark
if cfg.get('cudnn_benchmark', False):
torch.backends.cudnn.benchmark = True
cfg.data.test.test_mode = True
cfg.data.test.data_prefix = args.video_root
# 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)
rank, _ = get_dist_info()
size = 256
fname_tensor = torch.zeros(size, dtype=torch.uint8).cuda()
if rank == 0:
videos = open(args.video_list).readlines()
videos = [x.strip() for x in videos]
timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
fake_anno = f'fake_anno_{timestamp}.txt'
with open(fake_anno, 'w') as fout:
lines = [x + ' 0' for x in videos]
fout.write('\n'.join(lines))
fname_tensor = text2tensor(fake_anno, size).cuda()
if distributed:
dist.broadcast(fname_tensor.cuda(), src=0)
fname = tensor2text(fname_tensor)
cfg.data.test.ann_file = fname
# The flag is used to register module's hooks
cfg.setdefault('module_hooks', [])
# build the dataloader
dataset = build_dataset(cfg.data.test, dict(test_mode=True))
dataloader_setting = dict(videos_per_gpu=cfg.data.get('videos_per_gpu', 1),
workers_per_gpu=cfg.data.get(
'workers_per_gpu', 1),
dist=distributed,
shuffle=False)
dataloader_setting = dict(dataloader_setting,
**cfg.data.get('test_dataloader', {}))
data_loader = build_dataloader(dataset, **dataloader_setting)
outputs = inference_pytorch(args, cfg, distributed, data_loader)
if rank == 0:
if output_config.get('out', None):
out = output_config['out']
print(f'\nwriting results to {out}')
dataset.dump_results(outputs, **output_config)
# remove the temporary file
os.remove(fake_anno)
cfg.gpu_ids = range(1)
# We can initialize the logger for training and have a look
# at the final config used for training
print(f'Config:\n{cfg.pretty_text}')
import os.path as osp
from mmaction.datasets import build_dataset
from mmaction.models import build_model
from mmaction.apis import train_model
import mmcv
# Build the dataset
datasets = [build_dataset(cfg.data.train)]
# Build the recognizer
model = build_model(cfg.model, train_cfg=cfg.train_cfg, test_cfg=cfg.test_cfg)
# Create work_dir
mmcv.mkdir_or_exist(osp.abspath(cfg.work_dir))
train_model(model, datasets, cfg, distributed=False, validate=True)
from mmaction.apis import single_gpu_test
from mmaction.datasets import build_dataloader
from mmcv.parallel import MMDataParallel
# Build a test dataloader
dataset = build_dataset(cfg.data.test, dict(test_mode=True))
data_loader = build_dataloader(dataset,
def main():
args = parse_args()
cfg = Config.fromfile(args.config)
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 > config file > default (base 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)
# The flag is used to determine whether it is omnisource training
cfg.setdefault('omnisource', False)
# The flag is used to register module's hooks
cfg.setdefault('module_hooks', [])
# 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 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: {cfg.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
meta['config_name'] = osp.basename(args.config)
meta['work_dir'] = osp.basename(cfg.work_dir.rstrip('/\\'))
model = build_model(cfg.model,
train_cfg=cfg.get('train_cfg'),
test_cfg=cfg.get('test_cfg'))
register_module_hooks(model.backbone, cfg.module_hooks)
if cfg.omnisource:
# If omnisource flag is set, cfg.data.train should be a list
assert type(cfg.data.train) is list
datasets = [build_dataset(dataset) for dataset in cfg.data.train]
else:
datasets = [build_dataset(cfg.data.train)]
if len(cfg.workflow) == 2:
# For simplicity, omnisource is not compatiable with val workflow,
# we recommend you to use `--validate`
assert not cfg.omnisource
if args.validate:
warnings.warn('val workflow is duplicated with `--validate`, '
'it is recommended to use `--validate`. see '
'https://github.com/open-mmlab/mmaction2/pull/123')
val_dataset = copy.deepcopy(cfg.data.val)
datasets.append(build_dataset(val_dataset))
if cfg.checkpoint_config is not None:
# save mmaction version, config file content and class names in
# checkpoints as meta data
cfg.checkpoint_config.meta = dict(mmaction_version=__version__ +
get_git_hash(digits=7),
config=cfg.text)
train_model(model,
datasets,
cfg,
distributed=distributed,
validate=args.validate,
timestamp=timestamp,
meta=meta)
def main():
args = parse_args()
cfg = mmcv.Config.fromfile(args.config)
# Load output_config from cfg
output_config = cfg.get('output_config', {})
# Overwrite output_config from args.out
output_config = merge_configs(output_config, dict(out=args.out))
# Load eval_config from cfg
eval_config = cfg.get('eval_config', {})
# Overwrite eval_config from args.eval
eval_config = merge_configs(eval_config, dict(metrics=args.eval))
# Add options from args.option
eval_config = merge_configs(eval_config, args.options)
assert output_config or eval_config, \
('Please specify at least one operation (save or eval the '
'results) with the argument "--out" or "--eval"')
# set cudnn benchmark
if cfg.get('cudnn_benchmark', False):
torch.backends.cudnn.benchmark = True
cfg.data.test.test_mode = True
if cfg.test_cfg is None:
cfg.test_cfg = dict(average_clips=args.average_clips)
else:
cfg.test_cfg.average_clips = args.average_clips
# 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, dict(test_mode=True))
data_loader = build_dataloader(dataset,
videos_per_gpu=1,
workers_per_gpu=cfg.data.workers_per_gpu,
dist=distributed,
shuffle=False)
if args.pred_result_path_1:
model1_preds = np.load(args.pred_result_path_1, allow_pickle=True)
print('Evaluating {} accuracy:'.format(args.pred_result_path_1))
eval_res = dataset.evaluate(model1_preds, **eval_config)
if args.pred_result_path_2:
model2_preds = np.load(args.pred_result_path_2, allow_pickle=True)
print('Evaluating {} accuracy:'.format(args.pred_result_path_2))
eval_res = dataset.evaluate(model2_preds, **eval_config)
if args.pred_result_path_3:
model3_preds = np.load(args.pred_result_path_3, allow_pickle=True)
print('Evaluating {} accuracy:'.format(args.pred_result_path_3))
eval_res = dataset.evaluate(model3_preds, **eval_config)
if args.pred_result_path_3:
all_preds = np.stack([model1_preds, model2_preds, model3_preds])
else:
all_preds = np.stack([model1_preds, model2_preds])
ensemble_preds = np.mean(all_preds, axis=0).tolist()
rank, _ = get_dist_info()
if rank == 0:
if output_config:
out = output_config['out']
print(f'\nwriting results to {out}')
dataset.dump_results(outputs, **output_config)
if eval_config:
print('Evaluating an ensemble accuracy:')
eval_res = dataset.evaluate(ensemble_preds, **eval_config)
for name, val in eval_res.items():
if 'confusion' not in name:
print(f'{name}: {val:.04f}')
elif output_config:
if 'fig' in name:
confmat_dir = os.path.dirname(output_config['out'])
val.savefig(os.path.join(confmat_dir, name + '.jpg'),
format='jpg')
def main():
args = parse_args()
cfg = mmcv.Config.fromfile(args.config)
if args.update_config is not None:
cfg.merge_from_dict(args.update_config)
cfg = update_config(cfg, args)
cfg = propagate_root_dir(cfg, args.data_dir)
# Load output_config from cfg
output_config = cfg.get('output_config', {})
# Overwrite output_config from args.out
output_config = merge_configs(output_config, dict(out=args.out))
# Load eval_config from cfg
eval_config = cfg.get('eval_config', {})
# Overwrite eval_config from args.eval
eval_config = merge_configs(eval_config, dict(metrics=args.eval))
# Add options from args.option
eval_config = merge_configs(eval_config, args.options)
assert output_config or eval_config, \
('Please specify at least one operation (save or eval the '
'results) with the argument "--out" or "--eval"')
# init distributed env first, since logger depends on the dist info.
distributed = args.launcher != 'none'
if distributed:
init_dist(args.launcher, **cfg.dist_params)
# get rank
rank, _ = get_dist_info()
if cfg.get('seed'):
print(f'Set random seed to {cfg.seed}')
set_random_seed(cfg.seed)
# build the dataset
dataset = build_dataset(cfg.data, 'test', dict(test_mode=True))
if cfg.get('classes'):
dataset = dataset.filter(cfg.classes)
if rank == 0:
print(f'Test datasets:\n{str(dataset)}')
# build the dataloader
data_loader = build_dataloader(dataset,
videos_per_gpu=1,
workers_per_gpu=cfg.data.workers_per_gpu,
dist=distributed,
shuffle=False)
# build the model and load checkpoint
model = build_model(cfg.model,
train_cfg=None,
test_cfg=cfg.test_cfg,
class_sizes=dataset.class_sizes,
class_maps=dataset.class_maps)
# nncf model wrapper
if is_checkpoint_nncf(args.checkpoint) and not cfg.get('nncf_config'):
# reading NNCF config from checkpoint
nncf_part = get_nncf_config_from_meta(args.checkpoint)
for k, v in nncf_part.items():
cfg[k] = v
if cfg.get('nncf_config'):
check_nncf_is_enabled()
if not is_checkpoint_nncf(args.checkpoint):
raise RuntimeError(
'Trying to make testing with NNCF compression a model snapshot that was NOT trained with NNCF'
)
cfg.load_from = args.checkpoint
cfg.resume_from = None
if torch.cuda.is_available():
model = model.cuda()
_, model = wrap_nncf_model(model, cfg, None, get_fake_input)
else:
fp16_cfg = cfg.get('fp16', None)
if fp16_cfg is not None:
wrap_fp16_model(model)
# load model weights
load_checkpoint(model,
args.checkpoint,
map_location='cpu',
force_matching=True)
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)
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)
if rank == 0:
if output_config:
out = output_config['out']
print(f'\nwriting results to {out}')
dataset.dump_results(outputs, **output_config)
if eval_config:
eval_res = dataset.evaluate(outputs, **eval_config)
print('\nFinal metrics:')
for name, val in eval_res.items():
if 'invalid_info' in name:
continue
if isinstance(val, float):
print(f'{name}: {val:.04f}')
elif isinstance(val, str):
print(f'{name}:\n{val}')
else:
print(f'{name}: {val}')
invalid_info = {
name: val
for name, val in eval_res.items() if 'invalid_info' in name
}
if len(invalid_info) > 0:
assert args.out_invalid is not None and args.out_invalid != ''
if os.path.exists(args.out_invalid):
shutil.rmtree(args.out_invalid)
if not os.path.exists(args.out_invalid):
os.makedirs(args.out_invalid)
for name, invalid_record in invalid_info.items():
out_invalid_dir = os.path.join(args.out_invalid, name)
item_gen = zip(invalid_record['ids'],
invalid_record['conf'],
invalid_record['pred'])
for invalid_idx, pred_conf, pred_label in item_gen:
record_info = dataset.get_info(invalid_idx)
gt_label = record_info['label']
if 'filename' in record_info:
src_data_path = record_info['filename']
in_record_name, record_extension = os.path.basename(
src_data_path).split('.')
out_record_name = f'{in_record_name}_gt{gt_label}_pred{pred_label}_conf{pred_conf:.3f}'
trg_data_path = os.path.join(
out_invalid_dir,
f'{out_record_name}.{record_extension}')
shutil.copyfile(src_data_path, trg_data_path)
else:
src_data_path = record_info['frame_dir']
in_record_name = os.path.basename(src_data_path)
out_record_name = f'{in_record_name}_gt{gt_label}_pred{pred_label}_conf{pred_conf:.3f}'
trg_data_path = os.path.join(
out_invalid_dir, out_record_name)
os.makedirs(trg_data_path)
start_frame_id = record_info[
'clip_start'] + dataset.start_index
end_frame_id = record_info[
'clip_end'] + dataset.start_index
for frame_id in range(start_frame_id,
end_frame_id):
img_name = f'{frame_id:05}.jpg'
shutil.copyfile(
os.path.join(src_data_path, img_name),
os.path.join(trg_data_path, img_name))
type='Mp4Word2VecDataset',
ann_file='/mnt/lustre/jinliwei/bili_full/bili_anno_vec_train',
data_prefix='/mnt/lustre/share_data/bilibili/sensebee_datalist_32109',
pipeline=[
dict(type='DecordInit', io_backend='memcached', **mc_cfg),
dict(type='SampleFrames', clip_len=1, frame_interval=1, num_clips=8),
dict(type='DecordDecode'),
dict(type='Resize', scale=(-1, 256), lazy=True),
dict(type='MultiScaleCrop',
input_size=224,
scales=(1, 0.875, 0.75, 0.66),
random_crop=False,
max_wh_scale_gap=1,
lazy=True),
dict(type='Resize', scale=(224, 224), keep_ratio=False, lazy=True),
dict(type='Flip', flip_ratio=0.5, lazy=True),
dict(type='Fuse'),
dict(type='Normalize', **img_norm_cfg),
dict(type='FormatShape', input_format='NCHW'),
dict(type='LoadWord2Vec'),
dict(type='Collect', keys=['imgs', 'word2vec', 'weight'],
meta_keys=[]),
dict(type='ToTensor', keys=['imgs', 'word2vec', 'weight'])
])
bili_full_dataset = build_dataset(cfg)
for i in range(10):
d = bili_full_dataset[i]
print(d)
def main():
args = parse_args()
cfg = Config.fromfile(args.config)
# set cudnn_benchmark
if cfg.get('cudnn_benchmark', False):
torch.backends.cudnn.benchmark = True
# work_dir is determined in this priority:
# CLI > config file > default (base 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 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: {cfg.text}')
# set random seeds
if args.seed is not None:
logger.info('Set random seed to {}, deterministic: {}'.format(
args.seed, args.deterministic))
set_random_seed(args.seed, deterministic=args.deterministic)
cfg.seed = args.seed
meta['seed'] = args.seed
model = build_model(cfg.model,
train_cfg=cfg.train_cfg,
test_cfg=cfg.test_cfg)
datasets = [build_dataset(cfg.data.train)]
if len(cfg.workflow) == 2:
val_dataset = copy.deepcopy(cfg.data.val)
datasets.append(build_dataset(val_dataset))
if cfg.checkpoint_config is not None:
# save mmaction version, config file content and class names in
# checkpoints as meta data
cfg.checkpoint_config.meta = dict(mmaction_version=__version__,
config=cfg.text)
train_model(model,
datasets,
cfg,
distributed=distributed,
validate=args.validate,
timestamp=timestamp,
meta=meta)
# The original learning rate (LR) is set for 8-GPU training.
# We divide it by 8 since we only use one GPU.
cfg.optimizer.lr = cfg.optimizer.lr / 8 / 16
cfg.total_epochs = 15
# We can set the checkpoint saving interval to reduce the storage cost
cfg.checkpoint_config.interval = 10
# We can set the log print interval to reduce the the times of printing log
cfg.log_config.interval = 5
# Set seed thus the results are more reproducible
cfg.seed = 0
set_random_seed(0, deterministic=False)
cfg.gpu_ids = range(1)
# We can initialize the logger for training and have a look
# at the final config used for training
print(f'Config:\n{cfg.pretty_text}')
# Build the dataset
datasets = [build_dataset(cfg.data.train)]
# Build the recognizer
model = build_model(cfg.model, train_cfg=cfg.train_cfg, test_cfg=cfg.test_cfg)
# Create work_dir
mmcv.mkdir_or_exist(osp.abspath(cfg.work_dir))
train_model(model, datasets, cfg, distributed=False, validate=True)
def main():
parser = ArgumentParser()
parser.add_argument('--config', '-c', type=str, required=True)
parser.add_argument('--checkpoint', '-w', type=str, required=True)
parser.add_argument('--dataset_name', '-n', type=str, required=True)
parser.add_argument('--data_dir', '-d', type=str, required=True)
parser.add_argument('--predictions', '-p', type=str, required=True)
parser.add_argument('--movements', '-m', type=str, required=True)
parser.add_argument('--keypoints', '-k', type=str, required=True)
parser.add_argument('--out_annotation', '-o', type=str, required=True)
args = parser.parse_args()
assert exists(args.config)
assert exists(args.weights)
assert exists(args.data_dir)
assert exists(args.predictions)
assert exists(args.movements)
assert exists(args.keypoints)
assert args.dataset_name is not None and args.dataset_name != ''
assert args.out_annotation is not None and args.out_annotation != ''
cfg = Config.fromfile(args.config)
cfg = update_config(cfg, args, trg_name=args.dataset_name)
cfg = propagate_root_dir(cfg, args.data_dir)
dataset = build_dataset(cfg.data, 'train', dict(test_mode=True))
data_pipeline = Compose(dataset.pipeline.transforms[1:])
print('{} dataset:\n'.format(args.mode) + str(dataset))
model = build_model(cfg.model, train_cfg=None, test_cfg=cfg.test_cfg)
load_checkpoint(model, args.checkpoint, strict=False)
model = MMDataParallel(model, device_ids=[0])
model.eval()
annotation_path = join(args.data_dir, cfg.data.train.sources[0],
cfg.data.train.ann_file)
records = load_annotation(annotation_path)
predictions = load_distributed_data(args.predictions,
parse_predictions_file, 'txt')
movements = load_distributed_data(args.movements, parse_movements_file,
'txt')
hand_kpts = load_distributed_data(args.keypoints, parse_kpts_file, 'json')
print('Loaded records: {}'.format(len(records)))
invalid_stat = dict()
all_candidates = []
ignore_candidates = get_ignore_candidates(records, IGNORE_LABELS)
all_candidates += ignore_candidates
static_candidates, static_invalids = get_regular_candidates(
records,
predictions,
movements,
hand_kpts,
cfg.data.output.length,
False,
STATIC_LABELS,
NEGATIVE_LABEL,
NO_MOTION_LABEL,
min_score=0.9,
min_length=4,
max_distance=1)
all_candidates += static_candidates
invalid_stat = update_stat(invalid_stat, static_invalids)
print('Static candidates: {}'.format(len(static_candidates)))
if len(invalid_stat) > 0:
print('Ignored records after static analysis:')
for ignore_label, ignore_values in invalid_stat.items():
print(' - {}: {}'.format(ignore_label.replace('_', ' '),
len(ignore_values)))
dynamic_candidates, dynamic_invalids = get_regular_candidates(
records,
predictions,
movements,
hand_kpts,
cfg.data.output.length,
True,
DYNAMIC_LABELS,
NEGATIVE_LABEL,
NO_MOTION_LABEL,
min_score=0.9,
min_length=4,
max_distance=1)
all_candidates += dynamic_candidates
invalid_stat = update_stat(invalid_stat, dynamic_invalids)
print('Dynamic candidates: {}'.format(len(dynamic_candidates)))
if len(invalid_stat) > 0:
print('Ignored records after dynamic analysis:')
for ignore_label, ignore_values in invalid_stat.items():
print(' - {}: {}'.format(ignore_label.replace('_', ' '),
len(ignore_values)))
fixed_records, fix_stat = find_best_match(all_candidates, model, dataset,
NEGATIVE_LABEL)
invalid_stat = update_stat(invalid_stat, fix_stat)
print('Final records: {}'.format(len(fixed_records)))
if len(invalid_stat) > 0:
print('Final ignored records:')
for ignore_label, ignore_values in invalid_stat.items():
print(' - {}: {}'.format(ignore_label.replace('_', ' '),
len(ignore_values)))
for ignored_record in ignore_values:
print(' - {}'.format(ignored_record.path))
dump_records(fixed_records, args.out_annotation)
print('Fixed annotation has been stored at: {}'.format(
args.out_annotation))
def main():
args = parse_args()
cfg = Config.fromfile(args.config)
cfg.merge_from_dict(args.cfg_options)
# Load output_config from cfg
output_config = cfg.get('output_config', {})
# Overwrite output_config from args.out
output_config = merge_configs(output_config, dict(out=args.out))
# Load eval_config from cfg
eval_config = cfg.get('eval_config', {})
# Overwrite eval_config from args.eval
eval_config = merge_configs(eval_config, dict(metrics=args.eval))
# Add options from args.option
eval_config = merge_configs(eval_config, args.options)
assert output_config or eval_config, \
('Please specify at least one operation (save or eval the '
'results) with the argument "--out" or "--eval"')
# set cudnn benchmark
if cfg.get('cudnn_benchmark', False):
torch.backends.cudnn.benchmark = True
cfg.data.test.test_mode = True
if cfg.test_cfg is None:
cfg.test_cfg = dict(average_clips=args.average_clips)
else:
# You can set average_clips during testing, it will override the
# original settting
if args.average_clips is not None:
cfg.test_cfg.average_clips = args.average_clips
# 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))
# build the dataloader
dataset = build_dataset(cfg.data.test, dict(test_mode=True))
dataloader_setting = dict(videos_per_gpu=cfg.data.get('videos_per_gpu', 2),
workers_per_gpu=cfg.data.get(
'workers_per_gpu', 0),
dist=distributed,
shuffle=False)
dataloader_setting = dict(dataloader_setting,
**cfg.data.get('test_dataloader', {}))
data_loader = build_dataloader(dataset, **dataloader_setting)
# build the model and load checkpoint
model = build_model(cfg.model, train_cfg=None, test_cfg=cfg.test_cfg)
fp16_cfg = cfg.get('fp16', None)
if fp16_cfg is not None:
wrap_fp16_model(model)
load_checkpoint(model, args.checkpoint, map_location='cpu')
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)
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 output_config:
out = output_config['out']
print(f'\nwriting results to {out}')
dataset.dump_results(outputs, **output_config)
if eval_config:
eval_res = dataset.evaluate(outputs, **eval_config)
for name, val in eval_res.items():
print(f'{name}: {val:.04f}')
def main():
parser = ArgumentParser()
parser.add_argument('--config',
type=str,
required=True,
help='Test config file path')
parser.add_argument('--checkpoint',
type=str,
required=True,
help='Checkpoint file')
parser.add_argument('--data_dir',
type=str,
required=True,
help='The dir with dataset')
parser.add_argument('--out_dir',
type=str,
required=True,
help='Output directory')
parser.add_argument('--dataset',
type=str,
required=True,
help='Dataset name')
parser.add_argument('--gpus',
default=1,
type=int,
help='GPU number used for annotating')
parser.add_argument('--proc_per_gpu',
default=2,
type=int,
help='Number of processes per GPU')
parser.add_argument('--mode',
choices=['train', 'val', 'test'],
default='train')
args = parser.parse_args()
assert exists(args.config)
assert exists(args.checkpoint)
assert exists(args.data_dir)
cfg = Config.fromfile(args.config)
cfg = update_config(cfg, args, trg_name=args.dataset)
cfg = propagate_root_dir(cfg, args.data_dir)
dataset = build_dataset(cfg.data, args.mode, dict(test_mode=True))
data_pipeline = Compose(dataset.pipeline.transforms[1:])
print('{} dataset:\n'.format(args.mode) + str(dataset))
tasks = prepare_tasks(dataset, cfg.input_clip_length)
print('Prepared tasks: {}'.format(sum([len(v) for v in tasks.values()])))
if not exists(args.out_dir):
makedirs(args.out_dir)
model = build_model(cfg.model, train_cfg=None, test_cfg=cfg.test_cfg)
load_checkpoint(model, args.checkpoint, strict=False)
batch_size = 4 * cfg.data.videos_per_gpu
if args.gpus == 1:
model = MMDataParallel(model, device_ids=[0])
model.eval()
process_tasks(tasks, dataset, model, args.out_dir, batch_size,
cfg.input_clip_length, data_pipeline)
else:
raise NotImplementedError
def main():
args = parse_args()
cfg = Config.fromfile(args.config)
cfg.merge_from_dict(args.cfg_options)
# Load output_config from cfg
output_config = cfg.get('output_config', {})
if args.out:
# Overwrite output_config from args.out
output_config = Config._merge_a_into_b(dict(out=args.out),
output_config)
# Load eval_config from cfg
eval_config = cfg.get('eval_config', {})
if args.eval:
# Overwrite eval_config from args.eval
eval_config = Config._merge_a_into_b(dict(metrics=args.eval),
eval_config)
if args.eval_options:
# Add options from args.eval_options
eval_config = Config._merge_a_into_b(args.eval_options, eval_config)
assert output_config or eval_config, \
('Please specify at least one operation (save or eval the '
'results) with the argument "--out" or "--eval"')
dataset_type = cfg.data.test.type
if output_config.get('out', None):
if 'output_format' in output_config:
# ugly workround to make recognition and localization the same
warnings.warn(
'Skip checking `output_format` in localization task.')
else:
out = output_config['out']
# make sure the dirname of the output path exists
mmcv.mkdir_or_exist(osp.dirname(out))
_, suffix = osp.splitext(out)
if dataset_type == 'AVADataset':
assert suffix[1:] == 'csv', ('For AVADataset, the format of '
'the output file should be csv')
else:
assert suffix[1:] in file_handlers, (
'The format of the output '
'file should be json, pickle or yaml')
# set cudnn benchmark
if cfg.get('cudnn_benchmark', False):
torch.backends.cudnn.benchmark = True
cfg.data.test.test_mode = True
if args.average_clips is not None:
# You can set average_clips during testing, it will override the
# original setting
if cfg.model.get('test_cfg') is None and cfg.get('test_cfg') is None:
cfg.model.setdefault('test_cfg',
dict(average_clips=args.average_clips))
else:
if cfg.model.get('test_cfg') is not None:
cfg.model.test_cfg.average_clips = args.average_clips
else:
cfg.test_cfg.average_clips = args.average_clips
# 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)
# The flag is used to register module's hooks
cfg.setdefault('module_hooks', [])
# build the dataloader
dataset = build_dataset(cfg.data.test, dict(test_mode=True))
dataloader_setting = dict(videos_per_gpu=cfg.data.get('videos_per_gpu', 1),
workers_per_gpu=cfg.data.get(
'workers_per_gpu', 1),
dist=distributed,
shuffle=False)
dataloader_setting = dict(dataloader_setting,
**cfg.data.get('test_dataloader', {}))
data_loader = build_dataloader(dataset, **dataloader_setting)
# remove redundant pretrain steps for testing
turn_off_pretrained(cfg.model)
# build the model and load checkpoint
model = build_model(cfg.model,
train_cfg=None,
test_cfg=cfg.get('test_cfg'))
if len(cfg.module_hooks) > 0:
register_module_hooks(model, cfg.module_hooks)
fp16_cfg = cfg.get('fp16', None)
if fp16_cfg is not None:
wrap_fp16_model(model)
load_checkpoint(model, args.checkpoint, map_location='cpu')
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)
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 output_config.get('out', None):
out = output_config['out']
print(f'\nwriting results to {out}')
#import pdb
#pdb.set_trace()
print(out[-4:])
if out[-4:] == 'json':
result_dict = {}
for result in outputs:
video_name = result['video_name']
result_dict[video_name] = result['proposal_list']
output_dict = {
'version': 'VERSION 1.3',
'results': result_dict,
'external_data': {}
}
mmcv.dump(output_dict, out)
else:
dataset.dump_results(outputs, **output_config)
if eval_config:
eval_res = dataset.evaluate(outputs, **eval_config)
for name, val in eval_res.items():
print(f'{name}: {val:.04f}')
def main():
args = parse_args()
if args.tensorrt and args.onnx:
raise ValueError(
'Cannot set onnx mode and tensorrt mode at the same time.')
cfg = Config.fromfile(args.config)
cfg.merge_from_dict(args.cfg_options)
# Load output_config from cfg
output_config = cfg.get('output_config', {})
if args.out:
# Overwrite output_config from args.out
output_config = Config._merge_a_into_b(dict(out=args.out),
output_config)
# Load eval_config from cfg
eval_config = cfg.get('eval_config', {})
if args.eval:
# Overwrite eval_config from args.eval
eval_config = Config._merge_a_into_b(dict(metrics=args.eval),
eval_config)
if args.eval_options:
# Add options from args.eval_options
eval_config = Config._merge_a_into_b(args.eval_options, eval_config)
assert output_config or eval_config, \
('Please specify at least one operation (save or eval the '
'results) with the argument "--out" or "--eval"')
dataset_type = cfg.data.test.type
if output_config.get('out', None):
if 'output_format' in output_config:
# ugly workround to make recognition and localization the same
warnings.warn(
'Skip checking `output_format` in localization task.')
else:
out = output_config['out']
# make sure the dirname of the output path exists
mmcv.mkdir_or_exist(osp.dirname(out))
_, suffix = osp.splitext(out)
if dataset_type == 'AVADataset':
assert suffix[1:] == 'csv', ('For AVADataset, the format of '
'the output file should be csv')
else:
assert suffix[1:] in file_handlers, (
'The format of the output '
'file should be json, pickle or yaml')
# set cudnn benchmark
if cfg.get('cudnn_benchmark', False):
torch.backends.cudnn.benchmark = True
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)
# The flag is used to register module's hooks
cfg.setdefault('module_hooks', [])
# build the dataloader
dataset = build_dataset(cfg.data.test, dict(test_mode=True))
dataloader_setting = dict(videos_per_gpu=cfg.data.get('videos_per_gpu', 1),
workers_per_gpu=cfg.data.get(
'workers_per_gpu', 1),
dist=distributed,
shuffle=False)
dataloader_setting = dict(dataloader_setting,
**cfg.data.get('test_dataloader', {}))
data_loader = build_dataloader(dataset, **dataloader_setting)
if args.tensorrt:
outputs = inference_tensorrt(args.checkpoint, distributed, data_loader,
dataloader_setting['videos_per_gpu'])
elif args.onnx:
outputs = inference_onnx(args.checkpoint, distributed, data_loader,
dataloader_setting['videos_per_gpu'])
else:
outputs = inference_pytorch(args, cfg, distributed, data_loader)
rank, _ = get_dist_info()
if rank == 0:
if output_config.get('out', None):
out = output_config['out']
print(f'\nwriting results to {out}')
dataset.dump_results(outputs, **output_config)
if eval_config:
eval_res = dataset.evaluate(outputs, **eval_config)
for name, val in eval_res.items():
print(f'{name}: {val:.04f}')