C++集成TensorRT加速推理：从模型优化到部署实战

1次阅读

没有评论

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

在边缘计算和实时推理场景中，模型推理的延迟和资源占用一直是开发者面临的挑战。本文将详细介绍如何使用 TensorRT 在 C ++ 环境中实现高效的模型推理加速。

原生框架如 PyTorch 直接推理在延迟敏感场景中存在以下瓶颈：

计算资源利用率低：原生框架没有针对特定硬件进行优化，无法充分利用 GPU 的并行计算能力。
内存占用高：推理过程中内存占用较大，影响系统整体性能。
延迟不稳定：推理延迟波动较大，难以满足实时性要求。

TensorRT 与其他推理框架在 C ++ 生态中的优劣势对比：

TensorRT：
优势：高度优化的推理引擎，支持 FP16/INT8 量化，层融合等优化技术。
劣势：对 ONNX 模型的支持有限，部分算子需要自定义实现。
TFLite：
优势：轻量级，适合移动端和嵌入式设备。
劣势：优化程度不如 TensorRT，性能较低。
OpenVINO：
优势：针对 Intel 硬件优化，支持多种模型格式。
劣势：在 NVIDIA GPU 上的性能不如 TensorRT。

为了避免算子不支持的问题，导出 ONNX 模型时需注意：

使用 torch.onnx.export 时，确保所有算子都在 ONNX 的支持列表中。
使用 opset_version 参数指定合适的 ONNX 算子集版本。
避免使用动态尺寸，除非确实需要动态 shape 支持。

生成序列化引擎的命令示例：

trtexec --onnx=model.onnx --saveEngine=model.engine --fp16

以下是一个加载 TRT 引擎的代码示例，包含错误处理和资源释放：

#include <NvInfer.h>
#include <NvOnnxParser.h>
#include <iostream>
#include <fstream>
#include <vector>

using namespace nvinfer1;

class Logger : public ILogger {
public:
    void log(Severity severity, const char* msg) override {if (severity != Severity::kINFO) {std::cout << msg << std::endl;}
    }
};

std::vector<char> loadEngine(const std::string& enginePath) {std::ifstream engineFile(enginePath, std::ios::binary);
    if (!engineFile) {throw std::runtime_error("Failed to open engine file.");
    }
    engineFile.seekg(0, std::ios::end);
    size_t size = engineFile.tellg();
    engineFile.seekg(0, std::ios::beg);
    std::vector<char> engineData(size);
    engineFile.read(engineData.data(), size);
    return engineData;
}

int main() {
    Logger logger;
    std::vector<char> engineData = loadEngine("model.engine");
    IRuntime* runtime = createInferRuntime(logger);
    ICudaEngine* engine = runtime->deserializeCudaEngine(engineData.data(), engineData.size(), nullptr);
    IExecutionContext* context = engine->createExecutionContext();

    // 推理代码...

    context->destroy();
    engine->destroy();
    runtime->destroy();
    return 0;
}

FP16：推理速度提升 2 - 4 倍，精度损失可以忽略不计。
INT8：推理速度提升 4 - 8 倍，但可能引入精度损失，需进行校准。

TensorRT 支持动态 shape，但需要在构建引擎时指定最小、最优和最大尺寸：

IOptimizationProfile* profile = builder->createOptimizationProfile();
profile->setDimensions(inputName, OptProfileSelector::kMIN, Dims4(1, 3, 224, 224));
profile->setDimensions(inputName, OptProfileSelector::kOPT, Dims4(1, 3, 224, 224));
profile->setDimensions(inputName, OptProfileSelector::kMAX, Dims4(8, 3, 224, 224));
config->addOptimizationProfile(profile);

使用 valgrind 结合 NVTX 标记检测内存泄漏：

valgrind --tool=memcheck --leak-check=full --show-leak-kinds=all ./your_program

在多线程环境中，每个线程应拥有独立的 CUDA 上下文，避免竞争条件：

class ThreadContext {
public:
    ThreadContext() {cudaSetDevice(0);
        context = engine->createExecutionContext();}

    ~ThreadContext() {context->destroy();
    }

    IExecutionContext* getContext() { return context;}

private:
    IExecutionContext* context;
};

以下是一个简单的 benchmark 测试脚本，用于统计吞吐量和 P99 延迟：

#include <chrono>
#include <vector>

void benchmark(IExecutionContext* context, int iterations) {
    std::vector<float> timings;
    for (int i = 0; i < iterations; ++i) {auto start = std::chrono::high_resolution_clock::now();
        // 执行推理...
        auto end = std::chrono::high_resolution_clock::now();
        float duration = std::chrono::duration<float, std::milli>(end - start).count();
        timings.push_back(duration);
    }

    std::sort(timings.begin(), timings.end());
    float p99 = timings[static_cast<int>(iterations * 0.99)];
    float avg = std::accumulate(timings.begin(), timings.end(), 0.0f) / iterations;
    std::cout << "Average latency:" << avg << "ms" << std::endl;
    std::cout << "P99 latency:" << p99 << "ms" << std::endl;
    std::cout << "Throughput:" << (1000.0f / avg) << "FPS" << std::endl;
}

INT8 量化可以显著提升推理速度，但可能引入精度损失。如何平衡精度损失与加速比？这需要在实际应用中进行权衡，通常可以通过以下方法：