High Inference time when using CPU

[gusmcarreira]

Hi there, is it normal to have a really high inference time when using CPU? I have experimented with multiple models and they all average 2FPS. Is it normal or am I the one doing something wrong?

Thank u in advance!

[Tau-J]

Thanks for using MMPose. It depends on the model you use. For example, if you are using algorithm based on hrnet with cpu, it is normal. If you have to use cpu for inference, I suggest trying RTMPose.

[gusmcarreira]

Hi there, thank you so much for the reply!

Sadly I have tried using RTMPose and it still averages 2FPS. Am I doing anything wrong? I have even tried with the smallest of the RTM versions.

My code is as follows:

import mimetypes
import os
import time
from argparse import ArgumentParser

import cv2
import json_tricks as json
import mmcv
import mmengine
import numpy as np
import time
from tqdm import tqdm
import torch
import torch.quantization

from mmpose.apis import inference_topdown
from mmpose.apis import init_model as init_pose_estimator
from mmpose.evaluation.functional import nms
from mmpose.registry import VISUALIZERS
from mmpose.structures import merge_data_samples, split_instances
from mmpose.utils import adapt_mmdet_pipeline

try:
    from mmdet.apis import inference_detector, init_detector
    has_mmdet = True
except (ImportError, ModuleNotFoundError):
    has_mmdet = False


def process_one_frame(args, img, detector, pose_estimator):
    # ==== PREDICT BBOX ====
    start_time = time.perf_counter()  # Start the timer for detection
    det_result = inference_detector(detector, img)
    pred_instance = det_result.pred_instances.cpu().numpy()

    bboxes = np.concatenate((pred_instance.bboxes, pred_instance.scores[:, None]), axis=1)
    bboxes = bboxes[np.logical_and(pred_instance.labels == args["det_cat_id"], pred_instance.scores > args["bbox_thr"])]
    bboxes = bboxes[nms(bboxes, args["nms_thr"]), :4]
    detection_time = time.perf_counter() - start_time  # Calculate the detection time

    # ==== PREDICT KEYPOINTS ====
    start_time = time.perf_counter()  # Start the timer for estimation
    pose_results = inference_topdown(pose_estimator, img, bboxes)

    estimation_time = time.perf_counter() - start_time  # Calculate the estimation time
    data_samples = merge_data_samples(pose_results)

    # if there is no instance detected, return None
    return data_samples.get('pred_instances', None), detection_time, estimation_time


def main(args):
    # build detector
    detector = init_detector(args["det_config"], args["det_checkpoint"], device=args["device"])
    detector.cfg = adapt_mmdet_pipeline(detector.cfg)
    
    # build pose estimator
    pose_estimator = init_pose_estimator(
        args["pose_config"],
        args["pose_checkpoint"],
        device=args["device"],
        cfg_options=dict(model=dict(test_cfg=dict(output_heatmaps=args["draw_heatmap"]))))


    cap = cv2.VideoCapture(args["input"])

    start_time = time.perf_counter()
    num_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
    frame_counter = 0

    detection_times = []
    estimation_times = []

    frame_idx = 0

    with tqdm(total=num_frames) as pbar:
        while cap.isOpened():
            success, frame = cap.read()
            frame_idx += 1

            if not success:
                pbar.close()

            # topdown pose estimation
            pred_instances, detection_time, estimation_time = process_one_frame(args, frame, detector, pose_estimator)

            # Accumulate the detection and estimation times
            detection_times.append(detection_time)
            estimation_times.append(estimation_time)

            # Increment frame counter
            frame_counter += 1
            # Calculate and print the FPS every n frames (e.g., every 10 frames)
            if frame_counter % 10 == 0:
                elapsed_time = time.perf_counter() - start_time
                fps = frame_counter / elapsed_time
                print(f"FPS: {fps:.2f}")

            pbar.update(1)

    # Calculate the average detection and estimation times
    avg_detection_time = sum(detection_times) / len(detection_times)
    avg_estimation_time = sum(estimation_times) / len(estimation_times)

    # Calculate the average time per frame
    avg_time_per_frame = (avg_detection_time + avg_estimation_time) / 2

    # Calculate the FPS
    fps = 1 / avg_time_per_frame

    # Print the average times and FPS values
    print("Average Detection Time: {:.2f}s".format(avg_detection_time))
    print("Average Estimation Time: {:.2f}s".format(avg_estimation_time))
    print("FPS: {:.2f}".format(fps))

    cap.release()


if __name__ == "__main__":
    args = {
        'det_config': 'my_path/configs/det/rtdm/rtmdet_tiny_8xb32-300e_coco.py',
        'det_checkpoint': 'my_path/checkpoints/det/rtdm/rtmdet_tiny_8xb32-300e_coco_20220902_112414-78e30dcc.pth',
        'pose_config': 'my_path/configs/pose/rtdm/rtmpose-t_8xb256-420e_coco-256x192.py',
        'pose_checkpoint': 'my_path/checkpoints/pose/rtdm/rtmpose-tiny_simcc-coco_pt-aic-coco_420e-256x192-e613ba3f_20230127.pth',
        'input': 'example_video.mp4',
        'show': False,
        'output_root': 'output',
        'save_predictions': False,
        'device': 'cpu',#'cuda:0',
        'det_cat_id': 0,
        'bbox_thr': 0.3,
        'nms_thr': 0.3,
        'kpt_thr': 0.3,
        'draw_heatmap': False,
        'show_kpt_idx': False,
        'skeleton_style': 'mmpose',
        'radius': 3,
        'thickness': 1,
        'show_interval': 0,
        'alpha': 0.8,
        'draw_bbox': False
    }

    main(args)