【OpenVINO™】使用 OpenVINO™ C++ 异步推理接口部署YOLOv8 —

本文主要是介绍【OpenVINO™】使用 OpenVINO™ C++ 异步推理接口部署YOLOv8 ——在Intel IGPU 上实现80+FPS视频推理，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

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

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

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

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

1. OpenVINO™ 工具套件

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

03b06c0aec22e58235cd01fa6d9b6db4

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时，第二个请求的传输与第一个推理的执行重叠，这防止了任何硬件空闲时间。如下图所示，该图展示了同步推理与异步推理流程情况以及时间安排：

async分析

可以看出，通过异步接口，我们可以实现模型推理和数据前处理以及后处理并行执行，这将会大大压缩模型推理全流程的时间。下面简单介绍一下在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));

&emsp; 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 resultsfor (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);	//延时30frame = next_frame;std::swap(requests[0], requests[1]);}cv::destroyAllWindows();return;
}