YOLOv8模型C++部署实战：从PyTorch到TensorRT引擎的完整流程与性能优化

1. 项目概述与核心价值

最近在搞一个边缘计算的项目，需要在NVIDIA Jetson这类嵌入式设备上跑目标检测。PyTorch训练好的YOLOv8模型，直接部署上去，推理速度慢得让人抓狂。这时候，TensorRT就成了救命稻草。但整个流程，从PyTorch到ONNX，再到TensorRT的engine，中间坑不少，尤其是在C++环境下。网上教程要么太零散，要么就是Python版的，C++这块的完整实践，特别是针对YOLOv8最新版本的，还真不多见。所以，我把自己趟过的路，从环境准备、模型转换、C++推理代码编写到性能调优，整个流程梳理了一遍。如果你也面临在C++应用中部署YOLOv8并追求极致性能的需求，这篇内容应该能帮你省下不少折腾的时间。

简单说，这个流程就是：用Ultralytics官方工具把训练好的.pt模型导出为.onnx格式，然后用TensorRT的trtexec工具或C++ API将其转换为高度优化的TensorRT引擎（.engine文件），最后用C++编写推理代码加载这个引擎，实现高速的目标检测。整个过程的核心价值在于，通过TensorRT的层融合、精度校准、内核自动调优等技术，能在NVIDIA GPU上获得数倍甚至数十倍于原始框架的推理加速，同时保持高精度，特别适合对实时性要求高的生产环境。

2. 环境准备与工具链搭建

在开始模型转换和C++开发之前，一个稳定、版本匹配的环境是成功的一半。这里的环境主要分为三块：Python训练/导出环境、TensorRT转换环境、C++编译运行环境。

2.1 Python侧环境配置

模型训练和ONNX导出通常在Python环境下完成。你需要一个安装了PyTorch和Ultralytics YOLOv8库的环境。

# 创建并激活一个conda环境（推荐） conda create -n yolov8_export python=3.8 conda activate yolov8_export # 安装PyTorch（请根据你的CUDA版本到官网选择对应命令） # 例如，CUDA 11.8 pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118 # 安装ultralytics pip install ultralytics # 安装onnx和onnxsim（用于简化ONNX模型） pip install onnx onnxsim onnxruntime

注意：PyTorch、CUDA、TensorRT的版本有严格的兼容性要求。一个常见的“黄金组合”是：PyTorch 1.13+， CUDA 11.8， TensorRT 8.5.x。在开始前，最好先确定你的目标部署平台（如Jetson Orin， RTX 4090）支持的CUDA和TensorRT版本，然后倒推选择PyTorch版本。

2.2 TensorRT环境安装

TensorRT的安装方式取决于你的平台。对于x86_64的Linux服务器或工作站，可以从NVIDIA官网下载对应CUDA版本的Tar包或Deb包。

1. 下载TensorRT：访问NVIDIA TensorRT下载页面，选择与你的CUDA版本匹配的Tar包。例如，对于CUDA 11.8，可以下载TensorRT-8.6.1.6.Linux.x86_64-gnu.cuda-11.8.tar.gz。
2. 解压并设置环境变量：

   tar -xzvf TensorRT-8.6.1.6.Linux.x86_64-gnu.cuda-11.8.tar.gz export TRT_PATH=/path/to/your/TensorRT-8.6.1.6 export LD_LIBRARY_PATH=$TRT_PATH/lib:$LD_LIBRARY_PATH export PATH=$TRT_PATH/bin:$PATH

   将以上环境变量添加到你的~/.bashrc中以便永久生效。
3. 安装Python包（可选，用于在Python中测试转换）：

   cd $TRT_PATH/python pip install tensorrt-*-cp38-none-linux_x86_64.whl # 注意匹配你的Python版本（cp38表示Python3.8）

4. 验证安装：运行trtexec --version，如果能输出版本信息，说明命令行工具安装成功。

对于Jetson等嵌入式平台，TensorRT通常已经预装在JetPack SDK中，无需单独安装，但需要注意JetPack版本与CUDA、cuDNN的对应关系。

2.3 C++开发环境搭建

C++推理程序需要链接TensorRT、CUDA、cuDNN以及OpenCV（用于图像预处理和后处理）等库。

1. 安装系统依赖：

   sudo apt-get update sudo apt-get install build-essential cmake git libopencv-dev

2. 准备TensorRT C++库：上一步解压的TensorRT目录下的include/和lib/文件夹就是我们需要的头文件和库文件。
3. 创建CMake项目：这是管理C++项目依赖和编译的最佳实践。一个典型的CMakeLists.txt骨架如下：

   cmake_minimum_required(VERSION 3.10) project(YOLOv8_TensorRT_Inference) set(CMAKE_CXX_STANDARD 17) # 查找必要的包 find_package(OpenCV REQUIRED) find_package(CUDA REQUIRED) # 设置TensorRT路径（假设通过环境变量或直接指定） set(TENSORRT_DIR $ENV{TRT_PATH}) set(TENSORRT_INCLUDE_DIR ${TENSORRT_DIR}/include) set(TENSORRT_LIBRARY_DIR ${TENSORRT_DIR}/lib) # 包含头文件目录 include_directories( ${OpenCV_INCLUDE_DIRS} ${CUDA_INCLUDE_DIRS} ${TENSORRT_INCLUDE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/src ) # 添加可执行文件 add_executable(yolov8_inference src/main.cpp src/yolov8_trt.cpp src/preprocess.cu src/postprocess.cu) # 链接库 target_link_libraries(yolov8_inference ${OpenCV_LIBS} ${CUDA_LIBRARIES} cudart nvinfer nvinfer_plugin nvonnxparser ${TENSORRT_LIBRARY_DIR}/libnvinfer.so ${TENSORRT_LIBRARY_DIR}/libnvinfer_plugin.so ${TENSORRT_LIBRARY_DIR}/libnvonnxparser.so ) # 为CUDA文件设置编译规则 set_source_files_properties(src/preprocess.cu src/postprocess.cu PROPERTIES CUDA_SOURCE_PROPERTY_FORMAT OBJ) enable_language(CUDA)

   这个CMake配置指明了需要找到OpenCV和CUDA，手动指定了TensorRT的路径，并将主程序、C++逻辑文件以及两个CUDA内核文件（用于GPU上的预处理和后处理）编译成一个可执行文件，同时链接所有必要的库。

实操心得：环境配置是最大的拦路虎之一。强烈建议使用Docker容器来隔离环境，特别是团队协作时。NVIDIA官方提供了包含PyTorch、TensorRT等全套工具的NGC容器，例如nvcr.io/nvidia/pytorch:23.12-py3，可以极大减少环境冲突。对于C++项目，可以将所有依赖库（TensorRT, OpenCV静态库等）打包到一个third_party目录中，使项目更容易移植。

3. YOLOv8模型导出为ONNX格式

有了YOLOv8训练好的权重文件（比如yolov8n.pt），第一步是将其转换为ONNX这个开放的模型交换格式。ONNX定义了一个通用的计算图表示，使得模型可以在不同框架间迁移。

3.1 使用Ultralytics官方导出

这是最简单也是最推荐的方法。Ultralytics库提供了高度封装的导出函数。

from ultralytics import YOLO # 加载训练好的模型 model = YOLO('yolov8n.pt') # 可以是你的自定义模型路径 # 导出模型为ONNX格式 # imgsz: 输入图像尺寸，必须与推理时一致 # simplify: 使用onnx-simplifier简化模型，去除冗余算子，非常重要！ # opset: ONNX算子集版本，12是一个广泛兼容的稳定版本 # dynamic: 是否启用动态轴。对于批量推理，建议将批次维度设为动态，如{'images': {0: 'batch'}} success = model.export(format='onnx', imgsz=640, simplify=True, opset=12, dynamic={'images': {0: 'batch'}})

执行成功后，会在模型同级目录下生成一个yolov8n.onnx文件。

关键参数解析：

• imgsz=640: YOLOv8默认输入尺寸是640x640。如果你的训练或应用尺寸不同，这里必须修改。不一致会导致推理错误或精度下降。
• simplify=True:务必开启。它会调用onnxsim工具对计算图进行优化，合并连续的Reshape、Transpose等操作，生成一个更干净、更高效的图，能显著减少TensorRT转换时可能遇到的“不支持算子”错误。
• opset=12: ONNX算子集版本。版本越高，支持的算子越多，但也要考虑TensorRT的兼容性。TensorRT 8.x 对 Opset 12 和 13 支持良好。
• dynamic={'images': {0: 'batch'}}: 这将输入张量images的第0维（批次维度）标记为动态，命名为'batch'。这意味着生成的TensorRT引擎可以接受任意批次的输入（在最大批次限制内），灵活性大大增强。你也可以将高度和宽度维度设为动态，以支持多尺度推理，但这会增加引擎构建的复杂度和时间。

3.2 导出后的模型检查

导出后，不要急着进行下一步。先用netron工具打开生成的.onnx文件可视化一下。

pip install netron # 然后在Python中运行 import netron netron.start('yolov8n.onnx')

你需要重点检查以下几点：

1. 输入输出节点：输入名应为images，形状为[batch, 3, height, width]。输出节点可能不止一个（对于分割或姿态模型），对于检测模型，通常是一个形状为[batch, num_boxes, 85]的输出（COCO 80类 + 4坐标 + 1置信度）。
2. 算子类型：留意是否有TensorRT不直接支持的算子，比如ScatterND（在早期YOLOv8 ONNX中可能出现）。simplify过程通常会处理掉这些。如果还有，可能需要自定义插件（TensorRT Plugin）或修改模型结构。
3. 动态维度：检查输入维度是否按预期被标记为动态。

踩坑记录：我曾经遇到过导出时没开simplify，导致ONNX模型中包含大量Reshape和Transpose算子链。在TensorRT转换时虽然没报错，但构建的引擎推理结果全是乱码。开启simplify后，这些算子被合并，问题消失。所以，这个选项至关重要。

4. ONNX模型转换为TensorRT引擎

这是核心步骤，将中间格式的ONNX模型编译、优化为在特定GPU上运行效率最高的TensorRT引擎（.engine文件）。有两种主流方式：使用命令行工具trtexec或编写C++代码调用TensorRT API。

4.1 使用trtexec命令行工具（快速验证）

trtexec是TensorRT自带的多功能工具，非常适合快速测试和基准测试。

trtexec --onnx=yolov8n.onnx \ --saveEngine=yolov8n_fp16.engine \ --fp16 \ --workspace=4096 \ --minShapes=images:1x3x640x640 \ --optShapes=images:4x3x640x640 \ --maxShapes=images:8x3x640x640 \ --shapes=images:1x3x640x640

参数详解：

• --onnx: 指定输入ONNX模型路径。
• --saveEngine: 指定输出的TensorRT引擎文件路径。
• --fp16: 启用FP16（半精度）模式。这能大幅减少显存占用并提升推理速度，通常精度损失很小，是性价比最高的优化。还可以使用--int8进行INT8量化，但需要校准数据集，过程更复杂。
• --workspace: 设置GPU工作空间大小（单位MB）。TensorRT在优化过程中需要临时显存。如果遇到“out of memory”错误，可以适当增大此值，但不要超过GPU可用显存。
• --minShapes/optShapes/maxShapes: 当模型有动态维度时，必须指定。这定义了动态维度（这里是批次batch）的最小、最优和最大值。TensorRT会根据这些信息为不同形状的输入生成优化后的内核。
  • minShapes: 引擎支持的最小输入形状。
  • optShapes: 最常使用的、期望性能最优的输入形状。TensorRT会为此形状做重点优化。
  • maxShapes: 引擎支持的最大输入形状。
• --shapes: 指定构建引擎时用于测试和性能分析的具体形状。

运行命令后，trtexec会显示引擎构建的详细日志，包括每一层的优化信息、推断时间，并最终在指定路径生成.engine文件。

4.2 使用C++ API进行转换（集成到应用）

对于需要将转换流程集成到C++应用程序中的场景（例如，根据用户选择动态生成引擎），就需要使用TensorRT的C++ API。这个过程比trtexec复杂，但提供了更精细的控制。

主要步骤包括：

1. 创建构建器（IBuilder）和网络定义（INetworkDefinition）：这是TensorRT抽象计算图的起点。
2. 使用ONNX解析器（nvonnxparser）：将ONNX模型解析到TensorRT的网络定义中。
3. 配置构建配置（IBuilderConfig）：这是设置优化参数的关键，包括精度模式（FP32/FP16/INT8）、工作空间大小、动态形状配置文件等。
4. 构建引擎（buildSerializedNetwork）：执行优化过程，生成序列化的引擎数据。
5. 保存引擎：将序列化数据写入文件。

下面是一个简化的代码片段，展示核心逻辑：

#include <NvInfer.h> #include <NvOnnxParser.h> #include <fstream> // 1. 创建Logger、Builder、Network auto logger = SampleUniquePtr<nvinfer1::ILogger>(new Logger()); auto builder = SampleUniquePtr<nvinfer1::IBuilder>(nvinfer1::createInferBuilder(*logger)); const auto explicitBatch = 1U << static_cast<uint32_t>(nvinfer1::NetworkDefinitionCreationFlag::kEXPLICIT_BATCH); auto network = SampleUniquePtr<nvinfer1::INetworkDefinition>(builder->createNetworkV2(explicitBatch)); // 2. 创建ONNX解析器并解析模型 auto parser = SampleUniquePtr<nvonnxparser::IParser>(nvonnxparser::createParser(*network, *logger)); bool parsed = parser->parseFromFile(onnxModelPath.c_str(), static_cast<int>(nvinfer1::ILogger::Severity::kWARNING)); // 3. 配置BuilderConfig auto config = SampleUniquePtr<nvinfer1::IBuilderConfig>(builder->createBuilderConfig()); config->setMemoryPoolLimit(nvinfer1::MemoryPoolType::kWORKSPACE, workspaceSize * (1ULL << 30)); // 设置工作空间 if (useFP16) { config->setFlag(nvinfer1::BuilderFlag::kFP16); } // 4. 设置动态形状配置文件（Profile） auto profile = builder->createOptimizationProfile(); // 假设输入名为“images”，格式为NCHW profile->setDimensions("images", nvinfer1::OptProfileSelector::kMIN, nvinfer1::Dims4{1, 3, height, width}); profile->setDimensions("images", nvinfer1::OptProfileSelector::kOPT, nvinfer1::Dims4{4, 3, height, width}); // 最优批次设为4 profile->setDimensions("images", nvinfer1::OptProfileSelector::kMAX, nvinfer1::Dims4{maxBatch, 3, height, width}); config->addOptimizationProfile(profile); // 5. 构建序列化引擎 auto serializedEngine = SampleUniquePtr<nvinfer1::IHostMemory>(builder->buildSerializedNetwork(*network, *config)); // 6. 保存引擎到文件 std::ofstream engineFile(enginePath, std::ios::binary); engineFile.write(static_cast<const char*>(serializedEngine->data()), serializedEngine->size());

注意事项：动态形状配置（IOptimizationProfile）是支持可变批次推理的关键。你必须为每个动态输入维度设置最小、最优、最大值。TensorRT会为这个范围内的每个可能形状生成优化内核，但这也意味着构建时间会变长，引擎文件会变大。optShapes是你期望最常用的形状，引擎会优先保证这个形状下的性能。

5. C++加载TensorRT引擎并进行推理

生成.engine文件后，就可以在C++应用中加载并执行推理了。这个过程同样通过TensorRT的C++ API完成。

5.1 引擎的加载与反序列化

引擎文件是序列化的优化网络，需要先加载到内存并反序列化，创建运行时（IRuntime）和执行上下文（IExecutionContext）。

// 1. 从文件读取引擎数据 std::ifstream engineFile(enginePath, 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); // 2. 创建Runtime并反序列化引擎 auto runtime = SampleUniquePtr<nvinfer1::IRuntime>(nvinfer1::createInferRuntime(logger)); auto engine = SampleUniquePtr<nvinfer1::ICudaEngine>(runtime->deserializeCudaEngine(engineData.data(), engineSize)); // 3. 创建执行上下文 auto context = SampleUniquePtr<nvinfer1::IExecutionContext>(engine->createExecutionContext());

5.2 GPU内存管理与绑定

TensorRT推理需要在GPU上分配输入和输出缓冲区。我们需要获取引擎的输入/输出张量信息，然后在GPU上分配相应大小的内存。

// 获取输入和输出的索引及维度信息 int inputIndex = engine->getBindingIndex("images"); // 输入名需与ONNX模型一致 int outputIndex = engine->getBindingIndex("output0"); // 输出名，用netron查看 nvinfer1::Dims inputDims = engine->getBindingDimensions(inputIndex); nvinfer1::Dims outputDims = engine->getBindingDimensions(outputIndex); // 计算输入输出数据的大小（字节） size_t inputSize = batchSize * 3 * height * width * sizeof(float); size_t outputSize = batchSize * numBoxes * numClasses * sizeof(float); // 根据实际输出形状计算 // 在GPU上分配内存 void* d_input = nullptr; void* d_output = nullptr; cudaMalloc(&d_input, inputSize); cudaMalloc(&d_output, outputSize); // 创建绑定数组（一个void*数组，按绑定索引顺序存放GPU地址） void* bindings[] = {d_input, d_output};

5.3 图像预处理与后处理

这是影响最终性能和精度的关键环节。预处理（CPU/GPU）将原始图像（如OpenCV的cv::Mat）转换为模型需要的输入张量（归一化、调整大小、转换为NCHW格式等）。后处理（CPU/GPU）将模型的原始输出（一堆检测框）解码为最终的边界框、类别和置信度。

预处理（CUDA内核示例）： 为了极致性能，预处理应在GPU上完成。这通常涉及将BGR图像转换为RGB，归一化像素值（如除以255，减去均值除以标准差），并从HWC布局转换为模型需要的CHW布局。

// 一个简化的CUDA核函数，用于将BGR uint8图像转换为RGB float并归一化 __global__ void preprocess_kernel(const uchar3* src, float* dst, int width, int height, float scale, float* mean, float* std) { int x = blockIdx.x * blockDim.x + threadIdx.x; int y = blockIdx.y * blockDim.y + threadIdx.y; if (x >= width || y >= height) return; int src_idx = y * width + x; int dst_idx_r = y * width + x; // R通道 int dst_idx_g = dst_idx_r + width * height; // G通道 int dst_idx_b = dst_idx_g + width * height; // B通道 uchar3 pixel = src[src_idx]; dst[dst_idx_r] = (pixel.z * scale - mean[0]) / std[0]; // BGR -> RGB, 注意OpenCV是BGR顺序 dst[dst_idx_g] = (pixel.y * scale - mean[1]) / std[1]; dst[dst_idx_b] = (pixel.x * scale - mean[2]) / std[2]; }

在主程序中，你需要将OpenCV的cv::Mat数据拷贝到GPU，启动这个核函数，处理后的数据就在d_input指向的GPU内存中了。

后处理： YOLOv8的输出通常是[batch, num_boxes, 85]。后处理包括：

1. 解码边界框：将模型预测的偏移量（通常是中心点、宽高相对于锚框或网格的偏移）转换为图像上的绝对坐标。
2. 应用置信度阈值：过滤掉置信度过低的预测框。
3. 非极大值抑制（NMS）：去除重叠度高的冗余框。

后处理同样可以在GPU上并行化以提升速度，但逻辑比预处理复杂。许多开源项目（如TensorRTx、tensorrt-cpp-api）提供了高效的CUDA NMS实现可供参考。

5.4 执行推理与数据流转

准备好输入数据后，就可以执行推理了。

// 设置输入形状（对于动态批次，每次推理前可能需要设置） context->setBindingDimensions(inputIndex, nvinfer1::Dims4{batchSize, 3, height, width}); // 执行异步推理 bool success = context->enqueueV2(bindings, stream, nullptr); cudaStreamSynchronize(stream); // 等待推理完成 // 将输出数据从GPU拷贝回CPU std::vector<float> cpu_output(outputSize / sizeof(float)); cudaMemcpyAsync(cpu_output.data(), d_output, outputSize, cudaMemcpyDeviceToHost, stream); cudaStreamSynchronize(stream);

enqueueV2是异步执行的，它接受绑定数组、CUDA流和可选的输入就绪事件。在流上同步后，推理完成，输出数据就存在于d_output指向的GPU内存中，然后可以将其拷贝回CPU进行后处理。

6. 性能优化与调试技巧

将模型跑起来只是第一步，让它跑得又快又稳才是目标。以下是一些关键的优化和调试点。

6.1 精度模式选择：FP32 vs FP16 vs INT8

• FP32（单精度）：默认模式，精度最高，速度最慢，显存占用最大。通常用于精度验证或对精度损失零容忍的场景。
• FP16（半精度）：绝大多数场景的推荐选择。推理速度可提升1.5-3倍，显存占用减半，而精度损失通常小于1% mAP，人眼几乎无法察觉。在支持Tensor Core的GPU（Volta架构及以后）上加速效果尤其明显。
• INT8（8位整型）：速度最快，显存占用仅为FP32的1/4。但需要提供一个有代表性的校准数据集（几百张图片即可）来统计每一层激活值的分布，进行量化校准。精度损失可能稍大（1-3% mAP），且校准过程增加复杂度。适合对速度有极致要求且能接受一定精度损失的场景。

使用trtexec时，只需加上--fp16或--int8标志。在C++ API中，则通过config->setFlag(nvinfer1::BuilderFlag::kFP16)来设置。

6.2 动态形状与批次处理优化

如果你的应用场景输入图像尺寸固定，那么使用静态形状能获得最好的性能。但如果需要处理不同分辨率或进行批量推理，动态形状是必须的。

• 构建时间：动态形状引擎的构建时间远长于静态引擎，因为TensorRT需要为多个潜在形状生成优化内核。
• 引擎大小：动态引擎文件也更大。
• 推理性能：对于在optShapes中指定的最优形状，性能接近静态引擎。对于其他形状，性能可能有所下降。
• 最佳实践：合理设置minShapes、optShapes、maxShapes。optShapes应设置为最频繁出现的输入形状。避免将maxShapes设得过大，这会不必要地增加构建时间和引擎大小。

6.3 层融合与内核自动调优

TensorRT在构建引擎时会自动执行一系列图优化，其中最重要的是层融合。例如，它将卷积（Convolution）、偏置（Bias）和激活函数（如ReLU）融合成一个单一的“CBR”层，这减少了内核启动开销和内存访问次数，是性能提升的主要来源。

我们无需手动干预此过程，但可以通过查看构建日志来确认优化是否发生。在trtexec输出或设置ILogger为VERBOSE级别时，可以看到[I] [TRT] Layer ... fused这样的信息。

6.4 常见错误排查

1. “Unsupported ONNX op: ...”：TensorRT不支持该ONNX算子。

   • 解决：首先确保使用了onnx-simplifier。如果问题依旧，该算子可能确实不被支持。可以尝试更新到更高版本的TensorRT。如果还不行，可能需要编写自定义插件（Plugin）来实现该算子，或者考虑修改原始模型结构，用一组支持的算子来替代它。

2. “Could not create optimization profile ...”或“Binding ... has dynamic shape ...”：

   • 解决：这通常是因为在构建动态引擎时，没有正确设置优化配置文件（IOptimizationProfile）。确保在IBuilderConfig中添加了profile，并且min/opt/max形状设置正确。

3. 推理结果全为零或NaN：

   • 解决：
     • 检查预处理：确保图像数据在传入GPU前已正确转换为float，并进行了正确的归一化（除以255.0）。RGB顺序是否正确（OpenCV是BGR）。
     • 检查输入输出绑定：确保bindings数组中的GPU指针顺序与引擎的绑定索引一致。
     • 检查动态形状：如果用了动态批次，是否在每次推理前都通过setBindingDimensions正确设置了当前输入的维度？
     • 精度问题：尝试使用FP32模式运行，如果FP32正常而FP16异常，可能是模型某些层对低精度敏感。可以尝试在导出ONNX时，在model.export中设置half=False导出FP32的ONNX，然后用FP32模式构建TensorRT引擎。

4. 性能未达预期：

   • 解决：
     • 使用trtexec --loadEngine=... --shapes=...进行基准测试，获取理论最优性能。
     • 在C++代码中，使用CUDA事件（cudaEvent_t）精确测量预处理、推理、后处理各阶段耗时，定位瓶颈。
     • 确保在GPU上执行了预处理和后处理。
     • 使用nvprof或 Nsight Systems 进行性能剖析，查看内核执行时间、内存拷贝开销等。

实操心得：调试TensorRT应用，一个非常有效的方法是“对比法”。先用ONNX Runtime（CPU或GPU版）加载同一个ONNX模型，用相同的输入数据推理，得到一组基准输出。然后用TensorRT引擎推理，对比两者的输出。如果差异巨大，问题很可能出在预处理、绑定或引擎构建上。如果只有微小差异，那可能是FP16精度带来的正常波动。另外，将构建日志级别设为VERBOSE，能获得大量有用的内部信息，是排查问题的第一手资料。