def test_single_gpu_test():
if not torch.cuda.is_available():
pytest.skip('test requires GPU and torch+cuda')
cfg = _get_config_module('votenet/votenet_16x8_sunrgbd-3d-10class.py')
cfg.model.train_cfg = None
model = build_detector(cfg.model, test_cfg=cfg.get('test_cfg'))
dataset_cfg = cfg.data.test
dataset_cfg.data_root = './tests/data/sunrgbd'
dataset_cfg.ann_file = 'tests/data/sunrgbd/sunrgbd_infos.pkl'
dataset = build_dataset(dataset_cfg)
data_loader = build_dataloader(
dataset,
samples_per_gpu=1,
workers_per_gpu=cfg.data.workers_per_gpu,
dist=False,
shuffle=False)
model = MMDataParallel(model, device_ids=[0])
results = single_gpu_test(model, data_loader)
bboxes_3d = results[0]['boxes_3d']
scores_3d = results[0]['scores_3d']
labels_3d = results[0]['labels_3d']
assert bboxes_3d.tensor.shape[0] >= 0
assert bboxes_3d.tensor.shape[1] == 7
assert scores_3d.shape[0] >= 0
assert labels_3d.shape[0] >= 0
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.pretrained = None
cfg.data.test.test_mode = True
# build the dataloader
# TODO: support multiple images per gpu (only minor changes are needed)
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_detector(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_module(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 several samples 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}/ {args.samples}], '
f'fps: {fps:.1f} img / s')
if (i + 1) == args.samples:
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()
if args.out is not None and not args.out.endswith(('.pkl', '.pickle')):
raise ValueError('The output file must be a pkl file.')
cfg_start_time = time.time()
cfg = Config.fromfile(args.config)
cfg_last = time.time() - cfg_start_time
print('cfg time:', cfg_last)
# set cudnn_benchmark
if cfg.get('cudnn_benchmark', False):
torch.backends.cudnn.benchmark = True
cfg.model.pretrained = None
cfg.data.test.test_mode = True
# set random seeds
if args.seed is not None:
set_random_seed(args.seed, deterministic=args.deterministic)
# build the dataloader
samples_per_gpu = cfg.data.test.pop('samples_per_gpu', 1)
dataset_start_time = time.time()
dataset = build_dataset(cfg.data.test)
data_loader = build_dataloader(
dataset,
samples_per_gpu=samples_per_gpu,
workers_per_gpu=cfg.data.workers_per_gpu,
dist=False,
shuffle=False)
dataset_last = time.time() - dataset_start_time
print('dataset & dataloader time:', dataset_last)
# build the model and load checkpoint
model_start_time = time.time()
model = build_detector(cfg.model, train_cfg=None, test_cfg=None)
checkpoint = load_checkpoint(model, args.checkpoint, map_location='cpu')
if args.fuse_conv_bn:
model = fuse_module(model)
# old versions did not save class info in checkpoints, this walkaround is
# for backward compatibility
if 'CLASSES' in checkpoint['meta']:
model.CLASSES = checkpoint['meta']['CLASSES']
else:
model.CLASSES = dataset.CLASSES
model_time = time.time() - model_start_time
print('model time:', model_time)
model = MMDataParallel(model, device_ids=[0])
single_seg_test(model, data_loader)
def main():
args = parse_args()
epoch = int(os.path.basename(args.checkpoint)[6:-4])
print(f'Epoch [{epoch}]')
cfg_start_time = time.time()
cfg = Config.fromfile(args.config)
cfg_last = time.time() - cfg_start_time
print('cfg time:', cfg_last)
# set cudnn_benchmark
if cfg.get('cudnn_benchmark', False):
torch.backends.cudnn.benchmark = True
cfg.model.pretrained = None
# cfg.data.test.test_mode = True
# set random seeds
if args.seed is not None:
set_random_seed(args.seed, deterministic=args.deterministic)
# build the dataloader
samples_per_gpu = 1
dataset_start_time = time.time()
# dataset = build_dataset(cfg.data.test)
dataset = build_dataset(cfg.data.get(args.split))
data_loader = build_dataloader(dataset,
samples_per_gpu=samples_per_gpu,
workers_per_gpu=cfg.data.workers_per_gpu,
dist=False,
shuffle=False)
dataset_last = time.time() - dataset_start_time
print('dataset & dataloader time:', dataset_last)
# build the model and load checkpoint
model_start_time = time.time()
model = build_detector(cfg.model, train_cfg=None, test_cfg=None)
checkpoint = load_checkpoint(model, args.checkpoint, map_location='cpu')
# old versions did not save class info in checkpoints, this walkaround is
# for backward compatibility
if 'CLASSES' in checkpoint['meta']:
model.CLASSES = checkpoint['meta']['CLASSES']
else:
model.CLASSES = dataset.CLASSES
model_time = time.time() - model_start_time
print('model time:', model_time)
model = MMDataParallel(model, device_ids=[0])
seg_test_with_loss(model, data_loader)
def _init_data(self):
# build the dataloader
# TODO right config (train / val / test?)
samples_per_gpu = 1
dataset = build_dataset(self.cfg.data.test)
self.data_loader = build_dataloader(
dataset,
samples_per_gpu=samples_per_gpu,
workers_per_gpu=1,
dist=False,
shuffle=False,
)
# get class information
self.cat2id = dataset.cat2id
def _init_data(self, mode):
# build the dataloader
samples_per_gpu = 1
dataset = None
if mode == "train":
dataset = build_dataset(self.cfg.data.train)
elif mode == "test":
dataset = build_dataset(self.cfg.data.test)
elif mode == "val":
dataset = build_dataset(self.cfg.data.val)
elif mode == "easy_test":
# use the regular test config but change the ann file to the extension test set
data_root = pathlib.Path(self.cfg.data.test.ann_file).parent
easy_test_ann_file = data_root.joinpath(
"carla_infos_easy_test.pkl")
self.cfg.data.test.ann_file = str(easy_test_ann_file)
dataset = build_dataset(self.cfg.data.test)
else:
raise ValueError("unsupportet dataset type {}".format(mode))
self.data_loader = build_dataloader(
dataset,
samples_per_gpu=samples_per_gpu,
workers_per_gpu=1,
dist=False,
shuffle=False,
)
# get class information
self.cat2id = dataset.cat2id
cat2id_file = self._result_base_path.joinpath(self._cat_to_id)
with open(cat2id_file, 'w') as fp:
json.dump(self.cat2id, fp, indent=4)
def setup(self, config_file, checkpoint_file, fuse_conv):
cfg = Config.fromfile(config_file)
# set cudnn_benchmark
if cfg.get('cudnn_benchmark', False):
torch.backends.cudnn.benchmark = True
cfg.model.pretrained = None
cfg.data.test.test_mode = True
# build the dataloader
# TODO: support multiple images per gpu (only minor changes are needed)
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_detector(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, checkpoint_file, map_location='cpu')
if fuse_conv:
model = fuse_module(model)
self._fuse_conv = fuse_conv
model = MMDataParallel(model, device_ids=[0])
model.eval()
return model, data_loader, dataset
def main():
args = parse_args()
cfg = Config.fromfile(args.config)
if args.cfg_options is not None:
cfg.merge_from_dict(args.cfg_options)
# import modules from plguin/xx, registry will be updated
if hasattr(cfg, 'plugin') & cfg.plugin:
import importlib
if hasattr(cfg, 'plugin_dir'):
plugin_dir = cfg.plugin_dir
_module_dir = os.path.dirname(plugin_dir)
_module_dir = _module_dir.split('/')
_module_path = _module_dir[0]
for m in _module_dir[1:]:
_module_path = _module_path + '.' + m
print(_module_path)
plg_lib = importlib.import_module(_module_path)
else:
# import dir is the dirpath for the config file
_module_dir = os.path.dirname(args.config)
_module_dir = _module_dir.split('/')
_module_path = _module_dir[0]
for m in _module_dir[1:]:
_module_path = _module_path + '.' + m
print(_module_path)
plg_lib = importlib.import_module(_module_path)
# 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
cfg.model.pretrained = None
# in case the test dataset is concatenated
samples_per_gpu = 1
if isinstance(cfg.data.test, dict):
cfg.data.test.test_mode = True
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)
elif isinstance(cfg.data.test, list):
for ds_cfg in cfg.data.test:
ds_cfg.test_mode = True
samples_per_gpu = max(
[ds_cfg.pop('samples_per_gpu', 1) for ds_cfg in cfg.data.test])
if samples_per_gpu > 1:
for ds_cfg in cfg.data.test:
ds_cfg.pipeline = replace_ImageToTensor(ds_cfg.pipeline)
distributed = False
# set random seeds
if args.seed is not None:
set_random_seed(args.seed, deterministic=args.deterministic)
# build the dataloader
dataset = build_dataset(cfg.data.test)
data_loader = build_dataloader(
dataset,
samples_per_gpu=samples_per_gpu,
workers_per_gpu=cfg.data.workers_per_gpu,
dist=distributed,
shuffle=False)
if not os.path.exists(args.out_dir):
os.mkdir(args.out_dir)
# build the model and load checkpoint
cfg.model.train_cfg = None
model = build_detector(cfg.model, test_cfg=cfg.get('test_cfg'))
#from IPython import embed
#embed()
fp16_cfg = cfg.get('fp16', None)
if fp16_cfg is not None:
wrap_fp16_model(model)
checkpoint = 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()
output_list = []
for i, data in enumerate(data_loader):
with torch.no_grad():
data = scatter(data, [-1])[0]
for k, v in data.items():
if isinstance(v, torch.Tensor):
data[k] = v.cuda()
outputs = model.module.eval_forward(data)
output_list.append(outputs)
if i >= 100:
break
merged_output_list = []
for i, output in enumerate(output_list):
save_dir = os.path.join(args.out_dir, 'sample-{}'.format(i))
if not os.path.isdir(save_dir):
os.mkdir(save_dir)
outputs = parse_output(output, save_dir)
merged_output_list.append(outputs)
save_dir = os.path.join(args.out_dir, 'gifs')
if not os.path.isdir(save_dir):
os.mkdir(save_dir)
merge_output(merged_output_list, save_dir)
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 args.cfg_options is not None:
cfg.merge_from_dict(args.cfg_options)
# 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
cfg.model.pretrained = None
# in case the test dataset is concatenated
samples_per_gpu = 1
if isinstance(cfg.data.test, dict):
cfg.data.test.test_mode = True
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)
elif isinstance(cfg.data.test, list):
for ds_cfg in cfg.data.test:
ds_cfg.test_mode = True
samples_per_gpu = max(
[ds_cfg.pop('samples_per_gpu', 1) for ds_cfg in cfg.data.test])
if samples_per_gpu > 1:
for ds_cfg in cfg.data.test:
ds_cfg.pipeline = replace_ImageToTensor(ds_cfg.pipeline)
# 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)
# set random seeds
if args.seed is not None:
set_random_seed(args.seed, deterministic=args.deterministic)
# build the dataloader
dataset = build_dataset(cfg.data.test)
data_loader = build_dataloader(dataset,
samples_per_gpu=samples_per_gpu,
workers_per_gpu=cfg.data.workers_per_gpu,
dist=distributed,
shuffle=False)
# build the model and load checkpoint
cfg.model.train_cfg = None
model = build_detector(cfg.model, test_cfg=cfg.get('test_cfg'))
fp16_cfg = cfg.get('fp16', None)
if fp16_cfg is not None:
wrap_fp16_model(model)
checkpoint = load_checkpoint(model, args.checkpoint, map_location='cpu')
if args.fuse_conv_bn:
model = fuse_conv_bn(model)
# old versions did not save class info in checkpoints, this walkaround is
# for backward compatibility
if 'CLASSES' in checkpoint.get('meta', {}):
model.CLASSES = checkpoint['meta']['CLASSES']
else:
model.CLASSES = dataset.CLASSES
if not distributed:
model = MMDataParallel(model, device_ids=[0])
outputs = single_gpu_test(model, data_loader, args.show, args.show_dir)
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
for key in [
'interval', 'tmpdir', 'start', 'gpu_collect', 'save_best',
'rule'
]:
eval_kwargs.pop(key, None)
eval_kwargs.update(dict(metric=args.eval, **kwargs))
print(dataset.evaluate(outputs, **eval_kwargs))
def main():
args = parse_args()
assert args.out or args.eval or args.format_only or args.show, \
('Please specify at least one operation (save/eval/format/show the '
'results) with the argument "--out", "--eval", "--format_only" '
'or "--show"')
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_start_time = time.time()
cfg = Config.fromfile(args.config)
cfg_last = time.time() - cfg_start_time
print('cfg time:', cfg_last)
# set cudnn_benchmark
if cfg.get('cudnn_benchmark', False):
torch.backends.cudnn.benchmark = True
cfg.model.pretrained = None
cfg.data.test.test_mode = True
# set random seeds
if args.seed is not None:
set_random_seed(args.seed, deterministic=args.deterministic)
# build the dataloader
samples_per_gpu = cfg.data.test.pop('samples_per_gpu', 1)
dataset_start_time = time.time()
dataset = build_dataset(cfg.data.test)
data_loader = build_dataloader(dataset,
samples_per_gpu=samples_per_gpu,
workers_per_gpu=cfg.data.workers_per_gpu,
dist=False,
shuffle=False)
dataset_last = time.time() - dataset_start_time
print('dataset & dataloader time:', dataset_last)
# data_batch = iter(data_loader).next()
# print(len(data_batch['points'][0].data[0]))
# print(type(data_batch['seg_label'][0].data[0][0]))
# print(data_batch['seg_label'][0].data[0][0].shape)
# build the model and load checkpoint
model_start_time = time.time()
model = build_detector(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)
checkpoint = load_checkpoint(model, args.checkpoint, map_location='cpu')
if args.fuse_conv_bn:
model = fuse_module(model)
# old versions did not save class info in checkpoints, this walkaround is
# for backward compatibility
if 'CLASSES' in checkpoint['meta']:
model.CLASSES = checkpoint['meta']['CLASSES']
else:
model.CLASSES = dataset.CLASSES
model_time = time.time() - model_start_time
print('model time:', model_time)
model = MMDataParallel(model, device_ids=[0])
# outputs = mmda_single_gpu_test(model, data_loader, args.show, args.show_dir) # len(outputs)=len(dataset)
outputs = single_gpu_test(model, data_loader, args.show,
args.show_dir) # len(outputs)=len(dataset)
if args.out:
print(f'\nwriting results to {args.out}')
mmcv.dump(outputs, args.out)
kwargs = {} if args.options is None else args.options
if args.format_only:
dataset.format_results(outputs, **kwargs)
if args.eval:
dataset.evaluate(outputs,
args.eval,
jsonfile_prefix=args.json,
**kwargs)
def main():
args = parse_args()
cfg = Config.fromfile(args.config)
if args.cfg_options is not None:
cfg.merge_from_dict(args.cfg_options)
# import modules from plguin/xx, registry will be updated
if hasattr(cfg, 'plugin') & cfg.plugin:
import importlib
if hasattr(cfg, 'plugin_dir'):
plugin_dir = cfg.plugin_dir
_module_dir = os.path.dirname(plugin_dir)
_module_dir = _module_dir.split('/')
_module_path = _module_dir[0]
for m in _module_dir[1:]:
_module_path = _module_path + '.' + m
print(_module_path)
plg_lib = importlib.import_module(_module_path)
else:
# import dir is the dirpath for the config file
_module_dir = os.path.dirname(args.config)
_module_dir = _module_dir.split('/')
_module_path = _module_dir[0]
for m in _module_dir[1:]:
_module_path = _module_path + '.' + m
print(_module_path)
plg_lib = importlib.import_module(_module_path)
# 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
cfg.model.pretrained = None
# in case the test dataset is concatenated
samples_per_gpu = 1
if isinstance(cfg.data.test, dict):
cfg.data.test.test_mode = True
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)
elif isinstance(cfg.data.test, list):
for ds_cfg in cfg.data.test:
ds_cfg.test_mode = True
samples_per_gpu = max(
[ds_cfg.pop('samples_per_gpu', 1) for ds_cfg in cfg.data.test])
if samples_per_gpu > 1:
for ds_cfg in cfg.data.test:
ds_cfg.pipeline = replace_ImageToTensor(ds_cfg.pipeline)
# 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)
# set random seeds
if args.seed is not None:
set_random_seed(args.seed, deterministic=args.deterministic)
# build the dataloader
dataset = build_dataset(cfg.data.test)
data_loader = build_dataloader(dataset,
samples_per_gpu=samples_per_gpu,
workers_per_gpu=cfg.data.workers_per_gpu,
dist=distributed,
shuffle=False)
if not os.path.exists(args.out_dir):
os.mkdir(args.out_dir)
# build the model and load checkpoint
cfg.model.train_cfg = None
model = build_detector(cfg.model, test_cfg=cfg.get('test_cfg'))
#from IPython import embed
#embed()
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 args.fuse_conv_bn:
model = fuse_conv_bn(model)
if not distributed:
model = MMDataParallel(model, device_ids=[0])
else:
model = MMDistributedDataParallel(
model.cuda(),
device_ids=[torch.cuda.current_device()],
broadcast_buffers=False)
model.eval()
meta_json = {}
print('len of data loader: ', len(data_loader))
for i, data in tqdm(enumerate(data_loader)):
with torch.no_grad():
data = scatter(data, [-1])[0]
for k, v in data.items():
if isinstance(v, torch.Tensor):
data[k] = v.cuda()
key_img_path = data['img_metas'][0]['filename']
key_img_name = os.path.join(*key_img_path.split('/')[2:])
key_img_filename = key_img_path.split('/')[-1]
save_path = os.path.join(args.out_dir, key_img_filename)
outputs = model.module.preprocess_forward(data)
outputs = outputs.detach().cpu().numpy()
np.save(save_path, outputs)
meta_json[key_img_name] = save_path + '.npy'
with open(
os.path.join(args.out_dir,
'sf_inp_val_meta_{}.json'.format(args.local_rank)),
'w') as f:
json.dump(meta_json, f)
def main():
args = parse_args()
assert args.out or args.eval or args.format_only or args.show, \
('Please specify at least one operation (save/eval/format/show the '
'results) with the argument "--out", "--eval", "--format_only" '
'or "--show"')
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)
# set cudnn_benchmark
if cfg.get('cudnn_benchmark', False):
torch.backends.cudnn.benchmark = True
cfg.model.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)
# set random seeds
if args.seed is not None:
set_random_seed(args.seed, deterministic=args.deterministic)
# build the dataloader
# TODO: support multiple images per gpu (only minor changes are needed)
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
model = build_detector(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)
checkpoint = load_checkpoint(model, args.checkpoint, map_location='cpu')
if args.fuse_conv_bn:
model = fuse_module(model)
# old versions did not save class info in checkpoints, this walkaround is
# for backward compatibility
if 'CLASSES' in checkpoint['meta']:
model.CLASSES = checkpoint['meta']['CLASSES']
else:
model.CLASSES = dataset.CLASSES
if not distributed:
model = MMDataParallel(model, device_ids=[0])
outputs = single_gpu_test(model, data_loader, args.show, args.show_dir)
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.options is None else args.options
if args.format_only:
dataset.format_results(outputs, **kwargs)
if args.eval:
dataset.evaluate(outputs, args.eval, **kwargs)
def main():
args = parse_args()
cfg = Config.fromfile(args.config)
# import modules from plguin/xx, registry will be updated
if hasattr(cfg, 'plugin') & cfg.plugin:
import importlib
_module_dir = os.path.dirname(args.config)
_module_dir = _module_dir.split('/')
_module_path = _module_dir[0]
for m in _module_dir[1:]:
_module_path = _module_path + '.' + m
print(_module_path)
plg_lib = importlib.import_module(_module_path)
# set cudnn_benchmark
if cfg.get('cudnn_benchmark', False):
torch.backends.cudnn.benchmark = True
cfg.model.pretrained = None
cfg.data.test.test_mode = True
# build the dataloader
# TODO: support multiple images per gpu (only minor changes are needed)
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
cfg.model.train_cfg = None
model = build_detector(cfg.model, test_cfg=cfg.get('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_module(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 several samples and take the average
for i, data in enumerate(data_loader):
torch.cuda.synchronize()
start_time = time.perf_counter()
img_keys = ['img{}'.format(i) for i in range(18)]
now_depth_keys = ['depth_map{}'.format(i) for i in range(6, 12)]
now_sf_keys = ['sf_map{}'.format(i) for i in range(6, 12)]
# Imgs!
# shape [18, N, 3, H, W]
imgs = [data[tmp_key] for tmp_key in img_keys]
prev_imgs, now_imgs, next_imgs = imgs[0:6], imgs[6:12], imgs[12:]
# shape [N*6, 3, H, W]
prev_imgs = torch.cat(prev_imgs, dim=0)
now_imgs = torch.cat(now_imgs, dim=0)
next_imgs = torch.cat(next_imgs, dim=0)
now_depth = torch.cat([data[tmp_key] for tmp_key in now_depth_keys], dim=0)
now_depth = now_depth.unsqueeze(dim=1)
now_sf = torch.cat([data[tmp_key] for tmp_key in now_sf_keys], dim=0)
now_sf = now_sf.permute(0, 3, 1, 2)
all_imgs = torch.cat([prev_imgs, now_imgs, next_imgs], dim=0)
camera_intrinsic = data['cam_intrinsic']
#img_x, img_y = now_imgs.size(-2), now_imgs.size(-1)
img_x, img_y = now_imgs.size(-1), now_imgs.size(-2)
#print(now_imgs.shape)
scale_x = img_x / 1600
scale_y = img_y / 900
camera_intrinsic = scale_intrinsics(camera_intrinsic, scale_x, scale_y)
prev_cam_intrin = camera_intrinsic[:, 0:6, ...].view(-1, 3, 3)
now_cam_intrin = camera_intrinsic[:, 6:12, ...].view(-1, 3, 3)
next_cam_intrin = camera_intrinsic[:, 12:18, ...].view(-1, 3, 3)
cam_pose = data['cam_pose']
# [N, 6, 4, 4] => [N*6, 4, 4]
prev_cam_pose = cam_pose[:, 0:6, ...].view(-1, 4, 4)
now_cam_pose = cam_pose[:, 6:12, ...].view(-1, 4, 4)
next_cam_pose = cam_pose[:, 12:18, ...].view(-1, 4, 4)
B, _, H, W = now_imgs.shape
with torch.no_grad():
#fused_motion = (now2next_sf_pred - now2prev_sf_pred) / 2
real_sf = convert_res_sf_to_sf(now_cam_intrin, next_cam_intrin,
now_cam_pose, next_cam_pose, now_depth, now_sf/10.0)
def main():
args = parse_args()
assert args.out or args.eval or args.format_only or args.show, \
('Please specify at least one operation (save/eval/format/show the '
'results) with the argument "--out", "--eval", "--format_only" '
'or "--show"')
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)
# set cudnn_benchmark
if cfg.get('cudnn_benchmark', False):
torch.backends.cudnn.benchmark = True
cfg.model.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)
# set random seeds
if args.seed is not None:
set_random_seed(args.seed, deterministic=args.deterministic)
# build the dataloader
samples_per_gpu = cfg.data.test.pop('samples_per_gpu', 1)
dataset = build_dataset(cfg.data.test)
data_loader = build_dataloader(dataset,
samples_per_gpu=samples_per_gpu,
workers_per_gpu=cfg.data.workers_per_gpu,
dist=distributed,
shuffle=False)
# build the model and load checkpoint
model = build_detector(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)
checkpoint = load_checkpoint(model, args.checkpoint, map_location='cpu')
if args.fuse_conv_bn:
model = fuse_module(model)
# old versions did not save class info in checkpoints, this walkaround is
# for backward compatibility
if 'CLASSES' in checkpoint['meta']:
model.CLASSES = checkpoint['meta']['CLASSES']
else:
model.CLASSES = dataset.CLASSES
if not distributed:
model = MMDataParallel(model, device_ids=[0])
outputs = single_gpu_test(model, data_loader, args.show, args.show_dir)
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)
#pkl_saved_path = '/home/radmin/jk/code/seg/SelectiveSeg/work_dirs/20210322_pano_all_preds/results/output_pkl/results.pkl'
#outputs = mmcv.load(pkl_saved_path)
rank, _ = get_dist_info()
if rank == 0:
if args.out and args.need_pkl_res:
pkl_res_path = os.path.join(args.out, 'output_pkl')
mmcv.mkdir_or_exist(pkl_res_path)
pkl_res_path = os.path.join(pkl_res_path, 'results.pkl')
print(f'\nwriting results to {pkl_res_path}')
mmcv.dump(outputs, pkl_res_path)
if args.need_bin_res:
import torch
import numpy as np
bin_res_path = os.path.join(args.out, 'pred_label')
mmcv.mkdir_or_exist(bin_res_path)
box_res_path = os.path.join(args.out, 'box_label')
mmcv.mkdir_or_exist(box_res_path)
for i, res in enumerate(outputs):
sem_preds = res['sem_preds']
if 'ins_preds' not in res:
ins_preds = torch.zeros_like(sem_preds)
else:
ins_preds = res['ins_preds']
preds = torch.stack([sem_preds, ins_preds], dim=-1)
preds = preds.cpu().numpy()
preds = np.array(preds, dtype=np.uint8)
file_name = str(i).zfill(6)
postfix = '.bin'
preds.tofile(bin_res_path + '/' + file_name + postfix)
if 'pts_bbox' in res:
bbox_preds = res['pts_bbox']
bbox_3d = bbox_preds['boxes_3d'].tensor
dim = bbox_3d.size(1)
if dim == 3:
pseudo_size = bbox_3d.new_ones((bbox_3d.size(0), 3))
pseudo_theta = bbox_3d.new_zeros((bbox_3d.size(0), 1))
bbox_3d = torch.cat(
[bbox_3d, pseudo_size, pseudo_theta], dim=1)
else:
# check here
bbox_3d = torch.cat([
bbox_preds['boxes_3d'].gravity_center,
bbox_preds['boxes_3d'].tensor[:, 3:]
],
dim=1)
temp_label = bbox_preds['labels_3d'].view(-1, 1)
temp_score = bbox_preds['scores_3d'].view(-1, 1)
temp_id = torch.zeros_like(temp_score)
file_bbox_3d = torch.cat(
[temp_label, bbox_3d, temp_score, temp_id], dim=1)
file_bbox_3d = file_bbox_3d.numpy()
postfix = '.txt'
np.savetxt(box_res_path + '/' + file_name + postfix,
file_bbox_3d,
fmt='%.3f')
if 'seg' in args.eval:
mmcv.mkdir_or_exist(args.out)
dataset.evaluate_seg(outputs,
result_names=['sem_preds'],
out_dir=args.out)
elif 'pano' in args.eval:
import numpy as np
from selective_seg.util_tools.evaluate_panoptic import init_eval, printResults, eval_one_scan
#log_file = osp.join(args.out, f'{timestamp}.log')
log_file = os.path.join(args.out, 'pano_res.log')
logger = get_root_logger(log_file=log_file,
log_level=cfg.log_level)
gt_label_path = '/data/nuscenes_opendata/ordered_seg_label/val/seg_ins_mask'
mmcv.mkdir_or_exist(args.out)
min_points = 15 # 15 for nuscenes, 50 for semantickitti official param
evaluator = init_eval(dataset_type=cfg['dataset_type'],
min_points=min_points)
for i in range(len(outputs)):
gt_file_path = os.path.join(gt_label_path,
str(i).zfill(6) + '.bin')
gt_labels = np.fromfile(gt_file_path,
dtype=np.uint8).reshape(-1, 2)
gt_sem_labels = gt_labels[:, 0]
gt_ins_labels = gt_labels[:, 1]
pred_sem_labels = outputs[i]['sem_preds'].cpu().numpy()
pred_ins_labels = outputs[i]['ins_preds'].cpu().numpy()
eval_one_scan(evaluator, gt_sem_labels, gt_ins_labels,
pred_sem_labels, pred_ins_labels)
eval_results = printResults(evaluator, logger=logger)
'''
def main():
args = parse_args()
assert args.out or args.eval or args.format_only or args.show, (
"Please specify at least one operation (save/eval/format/show the "
'results) with the argument "--out", "--eval", "--format_only" '
'or "--show"')
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)
# set cudnn_benchmark
if cfg.get("cudnn_benchmark", False):
torch.backends.cudnn.benchmark = True
cfg.model.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)
# set random seeds
if args.seed is not None:
set_random_seed(args.seed, deterministic=args.deterministic)
# build the dataloader
samples_per_gpu = cfg.data.test.pop("samples_per_gpu", 1)
dataset = build_dataset(cfg.data.test)
data_loader = build_dataloader(
dataset,
samples_per_gpu=samples_per_gpu,
workers_per_gpu=cfg.data.workers_per_gpu,
dist=distributed,
shuffle=False,
)
# build the model and load checkpoint
cfg.model.train_cfg = None
model = build_detector(cfg.model, test_cfg=cfg.get("test_cfg"))
parameters = filter(lambda p: p.requires_grad, model.parameters())
model_engine, _, _, _ = initialize(
args=args,
model=model,
model_parameters=parameters,
)
_, client_state = model_engine.load_checkpoint(args.checkpoint, "ds")
model = model_engine.module
fp16_cfg = cfg.get("fp16", None)
if fp16_cfg is not None:
wrap_fp16_model(model)
# checkpoint = load_checkpoint(model, args.checkpoint, map_location='cpu')
if args.fuse_conv_bn:
model = fuse_module(model)
# old versions did not save class info in checkpoints, this walkaround is
# for backward compatibility
if "CLASSES" in client_state:
model.CLASSES = client_state["CLASSES"]
else:
model.CLASSES = dataset.CLASSES
if not distributed:
model = MMDataParallel(model, device_ids=[0])
outputs = single_gpu_test(model, data_loader, args.show, args.show_dir)
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.options is None else args.options
if args.format_only:
dataset.format_results(outputs, **kwargs)
if args.eval:
dataset.evaluate(outputs, args.eval, **kwargs)
def main():
args = parse_args()
cfg = Config.fromfile(args.config)
if args.cfg_options is not None:
cfg.merge_from_dict(args.cfg_options)
# import modules from plguin/xx, registry will be updated
if hasattr(cfg, 'plugin') & cfg.plugin:
import importlib
_module_dir = os.path.dirname(args.config)
_module_dir = _module_dir.split('/')
_module_path = _module_dir[0]
for m in _module_dir[1:]:
_module_path = _module_path + '.' + m
print(_module_path)
plg_lib = importlib.import_module(_module_path)
# 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
cfg.model.pretrained = None
# in case the test dataset is concatenated
samples_per_gpu = 1
if isinstance(cfg.data.test, dict):
cfg.data.test.test_mode = True
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)
elif isinstance(cfg.data.test, list):
for ds_cfg in cfg.data.test:
ds_cfg.test_mode = True
samples_per_gpu = max(
[ds_cfg.pop('samples_per_gpu', 1) for ds_cfg in cfg.data.test])
if samples_per_gpu > 1:
for ds_cfg in cfg.data.test:
ds_cfg.pipeline = replace_ImageToTensor(ds_cfg.pipeline)
# 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)
# set random seeds
if args.seed is not None:
set_random_seed(args.seed, deterministic=args.deterministic)
# build the dataloader
dataset = build_dataset(cfg.data.test)
data_loader = build_dataloader(dataset,
samples_per_gpu=samples_per_gpu,
workers_per_gpu=cfg.data.workers_per_gpu,
dist=distributed,
shuffle=False)
# build the model and load checkpoint
cfg.model.train_cfg = None
model = build_detector(cfg.model, test_cfg=cfg.get('test_cfg'))
fp16_cfg = cfg.get('fp16', None)
if fp16_cfg is not None:
wrap_fp16_model(model)
checkpoint = 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, args.show, args.show_dir)
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
for key in [
'interval', 'tmpdir', 'start', 'gpu_collect', 'save_best',
'rule'
]:
eval_kwargs.pop(key, None)
eval_kwargs.update(dict(metric=args.eval, **kwargs))
print(dataset.evaluate(outputs, **eval_kwargs))
