C++实战：如何高效运行YOLO算法并优化推理性能

1次阅读

共计 3048 个字符，预计需要花费 8 分钟才能阅读完成。

在 C ++ 环境中部署 YOLO 目标检测算法时，开发者常常面临以下挑战：

模型格式转换复杂：YOLO 原生模型通常为 Darknet 格式，需要转换为 C ++ 友好格式如 ONNX
推理延迟高：未经优化的单线程推理难以满足实时性需求
内存占用大：高分辨率输入和深层网络导致显存 / 内存压力显著
预处理 / 后处理瓶颈 ：图像归一化和非极大值抑制(NMS) 消耗大量 CPU 资源

主流推理框架特性对比：

框架	优点	缺点
OpenCV DNN	集成度高，预处理方便	对新型算子支持滞后，GPU 加速有限
ONNX Runtime	跨平台性强，支持量化加速	需要额外模型转换步骤
TensorRT	极致优化，延迟最低	生态绑定 NVIDIA 硬件

推荐组合方案：ONNX Runtime + OpenCV 预处理，平衡易用性与性能

使用官方工具将 YOLOv5 PyTorch 模型转 ONNX：

python export.py --weights yolov5s.pt --include onnx --imgsz 640 640

关键参数说明：
– --dynamic：如需支持动态输入需显式指定
– --opset=12：确保与 ONNX Runtime 版本兼容

#include <opencv2/opencv.hpp>
#include <onnxruntime_cxx_api.h>

// 初始化 ONNX Runtime 环境
Ort::Env env(ORT_LOGGING_LEVEL_WARNING, "YOLOv5");
Ort::SessionOptions session_options;
session_options.SetIntraOpNumThreads(4);  // 设置并行线程数

// 加载 ONNX 模型
Ort::Session session(env, "yolov5s.onnx", session_options);

// 图像预处理函数
cv::Mat preprocess(cv::Mat input) {
    cv::Mat blob;
    // 归一化到 0 - 1 范围并调整通道顺序
    input.convertTo(input, CV_32F, 1.0/255);
    cv::cvtColor(input, input, cv::COLOR_BGR2RGB);

    // 使用 OpenCV 的 blobFromImage 进行标准化处理
    cv::dnn::blobFromImage(input, blob, 1.0, 
                          cv::Size(640, 640), 
                          cv::Scalar(), true, false);
    return blob;
}

// 创建线程安全的任务队列
class InferenceQueue {
    std::queue<cv::Mat> queue;
    std::mutex mtx;
    std::condition_variable cv;

public:
    void push(cv::Mat&& frame) {std::lock_guard<std::mutex> lock(mtx);
        queue.push(std::move(frame));
        cv.notify_one();}

    cv::Mat pop() {std::unique_lock<std::mutex> lock(mtx);
        cv.wait(lock, [&]{return !queue.empty(); });
        auto frame = std::move(queue.front());
        queue.pop();
        return frame;
    }
};

// 工作线程函数
void worker(InferenceQueue& queue) {while (true) {auto input = queue.pop();
        auto blob = preprocess(input);

        // 准备 ONNX Runtime 输入张量
        Ort::MemoryInfo memory_info = Ort::MemoryInfo::CreateCpu(OrtAllocatorType::OrtArenaAllocator, OrtMemType::OrtMemTypeDefault);

        std::vector<int64_t> input_shape = {1, 3, 640, 640};
        Ort::Value input_tensor = Ort::Value::CreateTensor<float>(memory_info, blob.ptr<float>(), blob.total(), 
            input_shape.data(), input_shape.size());

        // 执行推理
        auto outputs = session.Run(Ort::RunOptions{nullptr}, 
                                 input_names.data(), &input_tensor, 1, 
                                 output_names.data(), output_names.size());
    }
}

使用 ONNX Runtime 的量化工具：

from onnxruntime.quantization import quantize_dynamic
quantize_dynamic("yolov5s.onnx", "yolov5s_quant.onnx", 
                weight_type=QuantType.QInt8)

效果对比（Tesla T4 GPU）：

模型	精度(mAP)	延迟(ms)	内存占用(MB)
FP32	0.56	15.2	1200
INT8 量化	0.54	8.7	680

// 创建自定义内存分配器
class PooledAllocator : public OrtAllocator {std::vector<std::unique_ptr<char[]>> pools;
public:
    void* Alloc(size_t size) override {pools.emplace_back(new char[size]);
        return pools.back().get();
    }
    void Free(void* p) override {/* 复用内存块 */}
};

// 在 SessionOptions 中配置
PooledAllocator allocator;
session_options.AddConfigEntry("session.use_device_allocator_for_initializers", "1");
session_options.SetCustomAllocator(&allocator);