C++与TensorRT加速推理实战：从模型优化到性能调优

1次阅读

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

在深度学习推理场景中，性能优化一直是开发者关注的重点。原生框架如 PyTorch 或 TensorFlow 虽然提供了便捷的模型训练和推理接口，但在生产环境中往往面临性能瓶颈。本文将详细介绍如何利用 C ++ 结合 TensorRT 实现高性能推理，从模型优化到性能调优的全流程。

原生深度学习框架在推理时存在几个明显的性能瓶颈：

计算冗余：框架默认的算子实现可能未针对特定硬件优化，导致计算效率低下。
内存占用高：原生框架的运行时开销较大，尤其是在处理大模型时，内存占用成为瓶颈。
延迟不稳定：动态图执行和未优化的计算图可能导致推理延迟波动较大。

这些痛点在高吞吐、低延迟的生产环境中尤为突出，亟需一种高效的解决方案。

常见的推理加速方案包括：

TensorRT：NVIDIA 推出的高性能推理优化器，支持层融合、精度校准和动态形状优化。
ONNX Runtime：支持跨平台部署，但对 NVIDIA 硬件的优化不如 TensorRT 深入。
TVM：专注于编译优化，适合多硬件平台，但学习曲线较陡。

TensorRT 凭借其针对 NVIDIA 硬件的深度优化和易用性，成为多数场景下的首选。

首先，将训练好的模型转换为 TensorRT 支持的格式（如 ONNX）：

import torch
import torch.onnx

model = torch.load("model.pth")
dummy_input = torch.randn(1, 3, 224, 224)
torch.onnx.export(model, dummy_input, "model.onnx", opset_version=11)

使用 TensorRT 的优化器对模型进行优化，生成序列化后的引擎文件：

#include <NvInfer.h>
#include <NvOnnxParser.h>

using namespace nvinfer1;

// 创建 Builder
IBuilder* builder = createInferBuilder(logger);

// 创建 Network
INetworkDefinition* network = builder->createNetworkV2(0U);

// 解析 ONNX 模型
nvonnxparser::IParser* parser = nvonnxparser::createParser(*network, logger);
parser->parseFromFile("model.onnx", static_cast<int>(ILogger::Severity::kWARNING));

// 配置 Builder
IBuilderConfig* config = builder->createBuilderConfig();
config->setMaxWorkspaceSize(1 << 30); // 1GB

// 构建引擎
ICudaEngine* engine = builder->buildEngineWithConfig(*network, *config);

// 序列化引擎
IHostMemory* serializedEngine = engine->serialize();
std::ofstream engineFile("model.engine", std::ios::binary);
engineFile.write(static_cast<const char*>(serializedEngine->data()), serializedEngine->size());

// 释放资源
serializedEngine->destroy();
engine->destroy();
config->destroy();
parser->destroy();
network->destroy();
builder->destroy();

加载优化后的引擎文件并执行推理：

#include <NvInferRuntimeCommon.h>

// 加载引擎文件
std::ifstream engineFile("model.engine", std::ios::binary);
engineFile.seekg(0, std::ios::end);
size_t engineSize = engineFile.tellg();
engineFile.seekg(0, std::ios::beg);
std::vector<char> engineData(engineSize);
engineFile.read(engineData.data(), engineSize);

// 创建运行时
IRuntime* runtime = createInferRuntime(logger);
ICudaEngine* engine = runtime->deserializeCudaEngine(engineData.data(), engineSize, nullptr);
IExecutionContext* context = engine->createExecutionContext();

// 准备输入输出缓冲区
void* buffers[engine->getNbBindings()];
for (int i = 0; i < engine->getNbBindings(); ++i) {Dims dims = engine->getBindingDimensions(i);
    size_t size = volume(dims) * sizeof(float);
    cudaMalloc(&buffers[i], size);
}

// 执行推理
context->executeV2(buffers);

// 释放资源
for (int i = 0; i < engine->getNbBindings(); ++i) {cudaFree(buffers[i]);
}
context->destroy();
engine->destroy();
runtime->destroy();

优化前后的性能对比数据如下（测试环境：NVIDIA T4 GPU）：

指标	原生框架	TensorRT 优化	提升幅度
吞吐量 (FPS)	120	450	275%
延迟 (ms)	8.3	2.2	73%
内存占用 (MB)	1024	512	50%

TensorRT 的对象生命周期管理需要特别注意，尤其是 create 和destroy的配对使用。建议使用 RAII 封装：

class TrtUniquePtr {
public:
    TrtUniquePtr(void* ptr, std::function<void(void*)> deleter) : ptr_(ptr), deleter_(deleter) {}
    ~TrtUniquePtr() { if (ptr_) deleter_(ptr_); }
private:
    void* ptr_;
    std::function<void(void*)> deleter_;
};

TensorRT 的 IExecutionContext 不是线程安全的，每个线程应独占一个上下文实例。可以通过线程池管理多个上下文：

std::vector<IExecutionContext*> contexts;
for (int i = 0; i < numThreads; ++i) {contexts.push_back(engine->createExecutionContext());
}

TensorRT 支持 INT8 量化，可进一步降低计算和内存开销。量化流程包括：

收集校准数据
生成校准表
构建 INT8 引擎

对于输入尺寸变化的场景，可以启用动态形状支持：

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

通过本文的介绍，相信大家对如何使用 C ++ 和 TensorRT 优化深度学习推理有了更深入的理解。TensorRT 的强大优化能力可以显著提升推理性能，但同时也需要注意其使用细节和潜在问题。希望本文能帮助开发者在实际项目中更好地应用这一技术，实现高效的模型部署。

正文完