​ OpenVINO Runtime支持同步或异步模式下的推理。Async API的主要优点是，当设备忙于推理时，应用程序可以并行执行其他任务（例如，填充输入或调度其他请求），而不是等待当前推理首先完成。 当我们使用异步API时，第二个请求的传输与第一个推理的执行重叠，这防止了任何硬件空闲时间。

  本文章中，我们以YOLOv8模型为例，对比了OpenVINO分别使用同步推理接口以及异步推理接口的推理速度情况。其中同步推理一帧平均推理时间为43.02毫秒，而异步接口一帧平均推理时间仅为11.37毫秒，异步接口一秒钟平均可以实现87.98FPS的推理，是同步推理的3.78倍，速度快到飞起！！

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

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. 时间测试

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

API	PrePocess	Inference	PostProcess	Total	FPS
Sync	9.83 ms	33.18 ms	0.1 ms	43.02 ms	23.25
Async	11.27 ms	0.02 ms	0.08 ms	11.37 ms	87.98

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

6. 总结

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

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