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™ 可赋能开发者在现实世界中部署高性能应用程序和算法。
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
cpp
auto infer_request = compiled_model.create_infer_request();
ov::InferRequest
可以运行推理,支持同步和异步模式进行推理。
2.2 同步模式
ov::InferRequest::infer
可以使用来阻止应用程序执行,以同步模式下进行模型推理。
cpp
infer_request.infer();
2.3 异步模式
异步模式可以提高应用程序的整体帧速率,方法是使其在加速器繁忙时在主机上工作,而不是等待推理完成。要在异步模式下推断模型,需要使用ov::InferRequest::start_async
接口。
cpp
infer_request.start_async();
异步模式支持应用程序等待推理结果的两种方式:
ov::InferRequest::wait_for
:指定阻止方法的最大持续时间(以毫秒为单位)。该方法将被阻止,直到指定的时间过去,或者结果变得可用,以先到者为准。
cpp
infer_request.wait_for(std::chrono::milliseconds(10));
  ov::InferRequest::wait
:等到推理结果可用
cpp
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)
,具体不做过多讲解,代码如下所示:
cpp
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
,首先读取第一帧数据并将其添加在第一个推理通道上,并开启异步推理;然后读取下一帧视频数据,并加载到另一个推理通道上;接着等待上一帧数据推理是否结束,如果结束,便会读取推理结果,进行结果处理;接着读取下一帧数据,并将推理结果加载到图里玩的通道上,依次往复,便可以实现视频数据的异步推理。
cpp
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倍,并且在没有进行任何优化掉前提下,使用集成显卡中便实现了视频的快速推理。
最后如果各位开发者在使用中有任何问题,欢迎大家与我联系。