def inference(model,
data_loader,
dataset_name,
device,
output_folder=None,
use_cached=False,
**kwargs):
dataset = data_loader.dataset
logger = logging.getLogger("SSD.inference")
logger.info("Evaluating {} dataset({} images):".format(
dataset_name, len(dataset)))
predictions_path = os.path.join(output_folder, 'predictions.pth')
if use_cached and os.path.exists(predictions_path):
predictions = torch.load(predictions_path, map_location='cpu')
else:
predictions = compute_on_dataset(model, data_loader, device)
synchronize()
predictions = _accumulate_predictions_from_multiple_gpus(predictions)
if not is_main_process():
return
if output_folder:
torch.save(predictions, predictions_path)
return evaluate(dataset=dataset,
predictions=predictions,
output_dir=output_folder,
**kwargs)
def do_evaluation(cfg, model, output_dir, distributed):
if isinstance(model, torch.nn.parallel.DistributedDataParallel):
model = model.module
assert isinstance(model, SSD), 'Wrong module.'
test_datasets = build_dataset(dataset_list=cfg.DATASETS.TEST, is_test=True)
device = torch.device(cfg.MODEL.DEVICE)
model.eval()
if not model.is_test:
model.is_test = True
predictor = Predictor(cfg=cfg,
model=model,
iou_threshold=cfg.TEST.NMS_THRESHOLD,
score_threshold=cfg.TEST.CONFIDENCE_THRESHOLD,
device=device)
cpu_device = torch.device("cpu")
logger = logging.getLogger("SSD.inference")
for dataset_name, test_dataset in zip(cfg.DATASETS.TEST, test_datasets):
logger.info("Test dataset {} size: {}".format(dataset_name,
len(test_dataset)))
indices = list(range(len(test_dataset)))
if distributed:
indices = indices[distributed_util.get_rank()::distributed_util.
get_world_size()]
# show progress bar only on main process.
progress_bar = tqdm if distributed_util.is_main_process() else iter
logger.info('Progress on {} 0:'.format(cfg.MODEL.DEVICE.upper()))
predictions = {}
for i in progress_bar(indices):
image = test_dataset.get_image(i)
output = predictor.predict(image)
boxes, labels, scores = [o.to(cpu_device).numpy() for o in output]
predictions[i] = (boxes, labels, scores)
distributed_util.synchronize()
predictions = _accumulate_predictions_from_multiple_gpus(predictions)
if not distributed_util.is_main_process():
return
final_output_dir = os.path.join(output_dir, dataset_name)
if not os.path.exists(final_output_dir):
os.makedirs(final_output_dir)
torch.save(predictions,
os.path.join(final_output_dir, 'predictions.pth'))
evaluate(dataset=test_dataset,
predictions=predictions,
output_dir=final_output_dir)
def inference(model, data_loader, dataset_name, output_folder: pathlib.Path,
**kwargs):
dataset = data_loader.dataset
logger = logging.getLogger("SSD.inference")
logger.info("Evaluating {} dataset({} images):".format(
dataset_name, len(dataset)))
predictions = compute_on_dataset(model, data_loader)
predictions = convert_predictions(predictions)
return evaluate(dataset=dataset,
predictions=predictions,
output_dir=output_folder,
**kwargs)
def _evaluation(cfg, dataset_name, test_dataset, predictor, distributed, output_dir):
""" Perform evaluating on one dataset
Args:
cfg:
dataset_name: dataset's name
test_dataset: Dataset object
predictor: Predictor object, used to to prediction.
distributed: whether distributed evaluating or not
output_dir: path to save prediction results
Returns:
evaluate result
"""
cpu_device = torch.device("cpu")
logger = logging.getLogger("SSD.inference")
logger.info("Evaluating {} dataset({} images):".format(dataset_name, len(test_dataset)))
indices = list(range(len(test_dataset)))
if distributed:
indices = indices[distributed_util.get_rank()::distributed_util.get_world_size()]
# show progress bar only on main process.
progress_bar = tqdm if distributed_util.is_main_process() else iter
logger.info('Progress on {} 0:'.format(cfg.MODEL.DEVICE.upper()))
predictions = {}
for i in progress_bar(indices):
image = test_dataset.get_image(i)
#print(type(image))
#image=numpy(image)
#transform=PredictionTransform(cfg.INPUT.IMAGE_SIZE, cfg.INPUT.PIXEL_MEAN)
#image=transform(image)
output = predictor.predict(image)
print('output')
boxes, labels, scores = [o.to(cpu_device).numpy() for o in output]
predictions[i] = (boxes, labels, scores)
distributed_util.synchronize()
predictions = _accumulate_predictions_from_multiple_gpus(predictions)
if not distributed_util.is_main_process():
return
final_output_dir = os.path.join(output_dir, dataset_name)
if not os.path.exists(final_output_dir):
os.makedirs(final_output_dir)
torch.save(predictions, os.path.join(final_output_dir, 'predictions.pth'))
return evaluate(dataset=test_dataset, predictions=predictions, output_dir=final_output_dir)
def inference(cfg,
model,
data_loader,
dataset_name,
device='cuda',
output_dir=None):
device = torch.device(device)
num_devices = get_world_size()
logger = logging.getLogger('ssd.inference')
dataset = data_loader.dataset
logger.info(
f'Start evaluation on {dataset_name} dataset ({len(dataset)} images)')
total_timer = Timer()
inference_timer = Timer()
total_timer.tic()
predictions = compute_on_dataset(model, data_loader, device,
inference_timer)
synchronize()
total_time = total_timer.toc()
total_time_str = get_time_str(total_time)
logger.info(
f"Total run time: {total_time_str} ({total_time * num_devices / len(dataset)} s / img per device, on {num_devices} devices)"
)
total_infer_time = get_time_str(inference_timer.total_time)
logger.info(
f"Model inference time: {total_infer_time} ({inference_timer.total_time * num_devices / len(dataset)} s / img per device, on {num_devices} devices)"
)
predictions = _accumulate_predictions_from_multiple_gpus(predictions)
if not is_main_process():
return
if output_dir:
torch.save(predictions, os.path.join(output_dir, 'predictions.pth'))
size = (cfg.INPUT.SIZE, cfg.INPUT.SIZE)
return evaluate(dataset, predictions, output_dir, size=size)
def compute_map(self):
image_ids = list(sorted(self.predictions.keys()))
predictions = [self.predictions[i] for i in image_ids]
return evaluate(dataset=self.test_dataset,
predictions=predictions,
output_dir=self.output_dir)