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

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

在上一篇文章中我们已经实现了使用OpenVINO™ C++ 异步API接口部署YOLOv8 实现视频快速推理，得到了大家的一致肯定。一些C#开发者也想在使用OpenVINO™在C#中实现异步推理，那么该如何实现呢？那么他来了，下面我们将会演示如何使用OpenVINO™异步接口在C#中部署YOLOv8 实现视频快速推理。首先我们看一下两种不同的推理方式其效果差异：

异步推理效果	同步推理效果

1. OpenVINO™ C# API

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

OpenVINO™ C# API 是一个 OpenVINO™ 的 .Net wrapper，应用最新的 OpenVINO™ 库开发，通过 OpenVINO™ C API 实现 .Net 对 OpenVINO™ Runtime 调用，使用习惯与 OpenVINO™ C++ API 一致。OpenVINO™ C# API 由于是基于 OpenVINO™ 开发，所支持的平台与 OpenVINO™ 完全一致，具体信息可以参考 OpenVINO™。通过使用 OpenVINO™ C# API，可以在 .NET、.NET Framework等框架下使用 C# 语言实现深度学习模型在指定平台推理加速。

2. OpenVINO™ C# 异步接口

2.1 创建推断请求

可以从以下位置创建：InferRequest

var infer_request = compiled_model.create_infer_request();

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

2.2 同步模式

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

infer_request.infer();

2.3 异步模式

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

infer_request.start_async();

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

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

infer_request.wait_for(long timeout);

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) ，具体不做过多讲解，代码如下所示：

public static float[] preprocess(Mat img, out float factor)
{
    Mat mat = new Mat();
    Cv2.CvtColor(img, mat, ColorConversionCodes.BGR2RGB);
    mat = Resize.letterbox_img(mat, 640, out factor);
    mat = Normalize.run(mat, true);
    return Permute.run(mat);
}

public static DetResult postprocess(float[] result, float factor)
{
    // Storage results list
    List<Rect> positionBoxes = new List<Rect>();
    List<int> classIds = new List<int>();
    List<float> confidences = new List<float>();
    // Preprocessing output results
    for (int i = 0; i < 8400; i++)
    {
        for (int j = 4; j < 84; j++)
        {
            float source = result[8400 * j + i];
            int label = j - 4;
            if (source > 0.2)
            {
                float maxSource = source;
                float cx = result[8400 * 0 + i];
                float cy = result[8400 * 1 + i];
                float ow = result[8400 * 2 + i];
                float oh = result[8400 * 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);
                Rect box = new Rect(x, y, width, height);
                positionBoxes.Add(box);
                classIds.Add(label);
                confidences.Add(maxSource);
            }
        }
    }
    DetResult re = new DetResult();
    int[] indexes = new int[positionBoxes.Count];
    CvDnn.NMSBoxes(positionBoxes, confidences, 0.2f, 0.5f, out indexes);
    for (int i = 0; i < indexes.Length; i++)
    {
        int index = indexes[i];
        re.add(classIds[index], confidences[index], positionBoxes[index]);
    }
    return re;
}

4.2 异步推理实现

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

static void yolov8_async_det()
{
    string video_path = "E:\\ModelData\\NY.mp4";
    string model_path = "E:\\Model\\yolo\\yolov8s.onnx";
    Core core = new Core();
    Model model = core.read_model(model_path);
    CompiledModel compiled_model = core.compile_model(model, "GPU");
    VideoCapture capture = new VideoCapture(video_path);
    if (!capture.IsOpened())
    {
        Console.WriteLine("ERROR: 视频无法打开");
        return;
    }
    List<InferRequest> requests = new List<InferRequest> { compiled_model.create_infer_request(), compiled_model.create_infer_request() };
    Mat frame = new Mat();
    capture.Read(frame);
    float factor = 0f;
    float[] input_data = preprocess(frame, out factor);
    requests[0].get_input_tensor().set_data(input_data);
    requests[0].start_async();
    Stopwatch sw = new Stopwatch();
    float[] total_infs = new float[3];

    while (true)
    {
        Mat next_frame = new Mat();
        if (!capture.Read(next_frame))
        {
            break;
        }
        sw.Restart();
        input_data = preprocess(frame, out factor);
        requests[1].get_input_tensor().set_data(input_data);
        sw.Stop();
        total_infs[0] = sw.ElapsedMilliseconds;
        sw.Restart();
        requests[1].start_async();
        requests[0].wait();
        sw.Stop();
        total_infs[1] = sw.ElapsedMilliseconds;
        sw.Restart();
        float[] output_data = requests[0].get_output_tensor().get_data<float>(8400 * 84);
        DetResult result = postprocess(output_data, factor);
        sw.Stop();
        total_infs[2] = sw.ElapsedMilliseconds;

        Cv2.PutText(frame, "PreProcess: " + (1000.0 / total_infs[0]).ToString("0.00") + "FPS  " + (total_infs[0]).ToString("0.00") + "ms",
            new Point(20, 40), HersheyFonts.HersheyPlain, 2, new Scalar(255, 0, 255), 2);
        Cv2.PutText(frame, "Inference: " + (1000.0 / total_infs[1]).ToString("0.00") + "FPS  " + (total_infs[1]).ToString("0.00") + "ms",
            new Point(20, 70), HersheyFonts.HersheyPlain, 2, new Scalar(255, 0, 255), 2);
        Cv2.PutText(frame, "PostProcess: " + (1000.0 / total_infs[2]).ToString("0.00") + "FPS  " + (total_infs[2]).ToString("0.00") + "ms",
            new Point(20, 100), HersheyFonts.HersheyPlain, 2, new Scalar(255, 0, 255), 2);
        Cv2.PutText(frame, "Total: " + (1000.0 / (total_infs[0] + total_infs[1] + total_infs[2])).ToString("0.00")
            + "FPS   " + ((total_infs[0] + total_infs[1] + total_infs[2])).ToString("0.00") + "ms",
            new Point(20, 130), HersheyFonts.HersheyPlain, 2, new Scalar(255, 0, 255), 2);
        Mat res_mat = Visualize.draw_det_result(result, frame);
        Cv2.ImShow("Result", res_mat);
        Cv2.WaitKey(10);
        swap(requests);
        frame = next_frame;
    }
}

上面已经展示了该项目实现的全部代码，如果想获取项目文件，通过下面链接进行下载：

ttps://download.csdn.net/download/Grape_yan/89460175

5. 时间测试

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

API	PrePocess	Inference	PostProcess	Total	FPS
Sync	11.97 ms	34.68 ms	1.58 ms	48.23 ms	20.73
Async	14.26 ms	0.01 ms	1.22 ms	15.49 ms	64.56

其中同步推理一帧平均推理时间为48.23毫秒，而异步接口一帧平均推理时间仅为15.49毫秒，异步接口一秒钟平均可以实现64.56FPS的推理，是同步推理的3.11倍，速度快到飞起！！之前我们已经测试过C++异步推理时间，如下表所示：

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

6. 总结

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

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

个人账号 - 2