【OpenVINO™】使用 OpenVINO™ C++ 异步推理接口部署YOLOv8 ——在Intel IGPU 上实现80+FPS视频推理

  下面是异步推理与同步推理对比效果演示视频：

YOLOv8在集成显卡可实现80+FPS推理——使用 OpenVINO™ C++ 异步推理接口部署YOLOv8 实现视频推理

1. OpenVINO™ 工具套件

  英特尔发行版 OpenVINO™ 工具套件基于 oneAPI 而开发，可以加快高性能计算机视觉和深度学习视觉应用开发速度工具套件，适用于从边缘到云的各种英特尔平台上，帮助用户更快地将更准确的真实世界结果部署到生产系统中。通过简化的开发工作流程，OpenVINO™ 可赋能开发者在现实世界中部署高性能应用程序和算法。

  2024年4月25日，英特尔发布了开源 OpenVINO™ 2024.1 工具包，用于在各种硬件上优化和部署人工智能推理。更新了更多的 Gen AI 覆盖范围和框架集成，以最大限度地减少代码更改。同时提供了更广泛的 LLM 模型支持和更多的模型压缩技术。通过压缩嵌入的额外优化减少了 LLM 编译时间，改进了采用英特尔®高级矩阵扩展 （Intel® AMX） 的第 4 代和第 5 代英特尔®至强®处理器上 LLM 的第 1 令牌性能。通过对英特尔®锐炫™ GPU 的 oneDNN、INT4 和 INT8 支持，实现更好的 LLM 压缩和改进的性能。最后实现了更高的可移植性和性能，可在边缘、云端或本地运行 AI。

2. OpenVINO™ 异步接口

  OpenVINO Runtime支持同步或异步模式下的推理。Async API的主要优点是，当设备忙于推理时，应用程序可以并行执行其他任务（例如，填充输入或调度其他请求），而不是等待当前推理首先完成。 在同步模式下，我们等待第一次推理的结果，然后再发送下一个请求。在发送请求时，硬件处于空闲状态。当我们使用异步API时，第二个请求的传输与第一个推理的执行重叠，这防止了任何硬件空闲时间。如下图所示，该图展示了同步推理与异步推理流程情况以及时间安排：

  可以看出，通过异步接口，我们可以实现模型推理和数据前处理以及后处理并行执行，这将会大大压缩模型推理全流程的时间。下面简单介绍一下在C++中，同步推理以及异步推理接口：

2.1 创建推断请求

  可以从以下位置创建：ov::InferRequestov::CompiledModel

auto infer_request = compiled_model.create_infer_request();

  ov::InferRequest可以运行推理，支持同步和异步模式进行推理。

2.2 同步模式

  ov::InferRequest::infer可以使用来阻止应用程序执行，以同步模式下进行模型推理。

infer_request.infer();

2.3 异步模式

  异步模式可以提高应用程序的整体帧速率，方法是使其在加速器繁忙时在主机上工作，而不是等待推理完成。要在异步模式下推断模型，需要使用ov::InferRequest::start_async接口。

infer_request.start_async();

  异步模式支持应用程序等待推理结果的两种方式：

  ov::InferRequest::wait_for：指定阻止方法的最大持续时间（以毫秒为单位）。该方法将被阻止，直到指定的时间过去，或者结果变得可用，以先到者为准。

infer_request.wait_for(std::chrono::milliseconds(10));

  ov::InferRequest::wait：等到推理结果可用

infer_request.wait();

  其中这两种等待推理结果的方法都是线程安全的。

3. 项目环境

• 推理设备：OpenVINO IGPU
• CPU: Intel Core i7-1165G7
• IGPU: Intel Iris Xe Graphics
• 推理模型: YOLOv8s
• 视频分辨率：1920×1080

4. 代码实现

4.1 定义YOLOv8数据处理方法

  首先定义了一下YOLOv8模型前后处理的方法，包括输入数据处理接口pre_process(cv::Mat* img, int length, float* factor, std::vector<float>& data)以及预测结果处理接口std::vector<DetResult> post_process(float* result, float factor, int outputLength) ，具体不做过多讲解，代码如下所示：

struct DetResult {
    cv::Rect bbox;
    float conf;
    int lable;
    DetResult() {}
    DetResult(cv::Rect bbox, float conf, int lable) :bbox(bbox), conf(conf), lable(lable) {}
};

void draw_bbox(cv::Mat& img, std::vector<DetResult>& res) {
    for (size_t j = 0; j < res.size(); j++) {
        cv::rectangle(img, res[j].bbox, cv::Scalar(255, 0, 255), 2);
        cv::putText(img, std::to_string(res[j].lable) + "-" + std::to_string(res[j].conf),
            cv::Point(res[j].bbox.x, res[j].bbox.y - 1), cv::FONT_HERSHEY_PLAIN,
            1.2, cv::Scalar(0, 0, 255), 2);
    }
}
void pre_process(cv::Mat* img, int length, float* factor, std::vector<float>& data) {
    cv::Mat mat;
    int rh = img->rows;
    int rw = img->cols;
    int rc = img->channels();
    cv::cvtColor(*img, mat, cv::COLOR_BGR2RGB);
    int max_image_length = rw > rh ? rw : rh;
    cv::Mat max_image = cv::Mat::zeros(max_image_length, max_image_length, CV_8UC3);
    max_image = max_image * 255;
    cv::Rect roi(0, 0, rw, rh);
    mat.copyTo(cv::Mat(max_image, roi));
    cv::Mat resize_img;
    cv::resize(max_image, resize_img, cv::Size(length, length), 0.0f, 0.0f, cv::INTER_LINEAR);

    *factor = (float)((float)max_image_length / (float)length);
    resize_img.convertTo(resize_img, CV_32FC3, 1 / 255.0);
    rh = resize_img.rows;
    rw = resize_img.cols;
    rc = resize_img.channels();
    for (int i = 0; i < rc; ++i) {
        cv::extractChannel(resize_img, cv::Mat(rh, rw, CV_32FC1, data.data() + i * rh * rw), i);
    }
}
std::vector<DetResult> post_process(float* result, float factor, int outputLength) {
    std::vector<cv::Rect> position_boxes;
    std::vector <int> class_ids;
    std::vector <float> confidences;
    // Preprocessing output results

    for (int i = 0; i < outputLength; i++)
    {
        for (int j = 4; j < 4 + 80; j++)
        {
            float source = result[outputLength * j + i];
            int label = j - 4;
            if (source > 0.2)
            {
                float maxSource = source;
                float cx = result[outputLength * 0 + i];
                float cy = result[outputLength * 1 + i];
                float ow = result[outputLength * 2 + i];
                float oh = result[outputLength * 3 + i];
                int x = (int)((cx - 0.5 * ow) * factor);
                int y = (int)((cy - 0.5 * oh) * factor);
                int width = (int)(ow * factor);
                int height = (int)(oh * factor);

                cv::Rect box(x, y, width, height);

                position_boxes.push_back(box);
                class_ids.push_back(label);
                confidences.push_back(maxSource);
            }
        }
    }
    std::vector<int> indices;
    cv::dnn::NMSBoxes(position_boxes, confidences, 0.2f, 0.5f, indices);
    std::vector<DetResult> re;
    for (int i = 0; i < indices.size(); i++)
    {
        int index = indices[i];
        DetResult det(position_boxes[index], confidences[index], class_ids[index]);
        re.push_back(det);
    }
    return re;
}

4.2 异步推理实现

  异步推理在实现时，需要创建两个以上的推理通道ov::InferRequest，首先读取第一帧数据并将其添加在第一个推理通道上，并开启异步推理；然后读取下一帧视频数据，并加载到另一个推理通道上；接着等待上一帧数据推理是否结束，如果结束，便会读取推理结果，进行结果处理；接着读取下一帧数据，并将推理结果加载到图里玩的通道上，依次往复，便可以实现视频数据的异步推理。

void yolov8_async_infer() {
    std::string video_path = "E:\\ModelData\\NY.mp4";
    std::string model_path = "E:\\Model\\yolo\\yolov8s.onnx";
    ov::Core core;
    auto model = core.read_model(model_path);
    auto compiled_model = core.compile_model(model, "GPU");
    std::vector<ov::InferRequest>requests = { compiled_model.create_infer_request(), compiled_model.create_infer_request() };
    cv::VideoCapture capture(video_path);
    if (!capture.isOpened()) {
        std::cerr << "ERROR: 视频无法打开" << std::endl;
        return;
    }
    float factor = 0;
    requests[0].get_input_tensor().set_shape(std::vector<size_t>{1, 3, 640, 640});
    requests[1].get_input_tensor().set_shape(std::vector<size_t>{1, 3, 640, 640});
    cv::Mat frame;
    capture.read(frame);
    std::vector<float> inputData(640 * 640 * 3);
    pre_process(&frame, 640, &factor, inputData);
    memcpy(requests[0].get_input_tensor().data<float>(), inputData.data(), 640 * 640 * 3);
    requests[0].start_async();
    while (true)
    {
        cv::Mat next_frame;
        if (!capture.read(next_frame)) {
            break;
        }
        pre_process(&next_frame, 640, &factor, inputData);
        memcpy(requests[1].get_input_tensor().data<float>(), inputData.data(), 640 * 640 * 3);
        requests[1].start_async();
        requests[0].wait();
        float* output_data = requests[0].get_output_tensor().data<float>();
        std::vector<DetResult> result = post_process(output_data, factor, 8400);
        draw_bbox(frame, result);
        imshow("读取视频", frame);
        cv::waitKey(1);	//延时30
        frame = next_frame;
        std::swap(requests[0], requests[1]);
    }
    cv::destroyAllWindows();
    return;
}

  上面已经展示了该项目实现的全部代码，如果想获取项目文件，通过下面链接进行下载：OpenVINOC++异步推理接口部署YOLOv8代码资源

5. 时间测试

写完代码后，对同步接口以及异步推理接口进行了时间测试，如下表所示：

  其中同步推理一帧平均推理时间为43.02毫秒，而异步接口一帧平均推理时间仅为11.37毫秒，异步接口一秒钟平均可以实现87.98FPS的推理，是同步推理的3.78倍，速度快到飞起！！

6. 总结

  在该项目中，我们实现了OpenVINO异步模式下的推理，并和同步推理进行了对比，异步推理速度提升了3.78倍，并且在没有进行任何优化掉前提下，使用集成显卡中便实现了视频的快速推理。

  最后如果各位开发者在使用中有任何问题，欢迎大家与我联系。