如何评估TensorRT加速效果？

你想知道如何科学、全面地评估TensorRT对模型的加速效果，这是落地过程中验证优化价值的关键步骤------不能只看"推理快了多少"，还要兼顾精度损失、资源占用、稳定性，确保加速的同时不影响业务指标。

一、核心评估维度（缺一不可）

评估TensorRT加速效果需覆盖4个维度，避免只关注速度而忽略其他关键指标：

评估维度	核心指标	业务意义
推理性能	单样本延迟、吞吐量、批处理延迟	决定系统响应速度、并发能力（核心加速指标）
精度损失	准确率/召回率/F1、mAP、MAE/RMSE	验证加速后模型是否满足业务精度要求
资源占用	GPU显存、CPU使用率、GPU利用率	评估部署成本（尤其边缘设备/多模型场景）
稳定性	推理耗时抖动、异常率、长时间运行表现	保证线上服务可靠，避免偶发超时/报错

二、量化评估指标与计算方法

1. 推理性能指标（核心）

（1）单样本延迟（Latency）

• 定义：单张图片/单条文本从输入模型到输出结果的总耗时，单位：毫秒（ms）或微秒（μs）；

• 计算方式：多次测试取平均延迟 （避免偶然值），同时记录P50/P90/P99延迟（反映长尾耗时）；

  import time
  import numpy as np
  
  def test_latency(model, test_input, repeat=100):
      """
      测试单样本推理延迟
      :param model: 推理模型（原生TF/TF-TRT/TensorRT引擎）
      :param test_input: 单样本输入张量 (1, 224, 224, 3)
      :param repeat: 测试次数（建议≥100）
      :return: 平均延迟、P50/P90/P99延迟（ms）
      """
      latencies = []
      # 预热（排除首次推理的初始化耗时）
      for _ in range(10):
          _ = model(test_input)
      # 正式测试
      for _ in range(repeat):
          start = time.perf_counter()
          _ = model(test_input)
          end = time.perf_counter()
          latency = (end - start) * 1000  # 转ms
          latencies.append(latency)
      # 计算统计值
      latencies = np.array(latencies)
      avg_latency = np.mean(latencies)
      p50 = np.percentile(latencies, 50)
      p90 = np.percentile(latencies, 90)
      p99 = np.percentile(latencies, 99)
      return {
          "avg_latency": avg_latency,
          "p50": p50,
          "p90": p90,
          "p99": p99
      }

（2）吞吐量（Throughput）

• 定义：单位时间内模型能处理的样本数，单位：样本/秒（samples/s）或FPS（帧/秒，图像场景）；

• 计算方式：

  def test_throughput(model, test_input_batch, repeat=50):
      """
      测试吞吐量（批处理场景）
      :param test_input_batch: 批处理输入 (batch_size, 224, 224, 3)
      :param repeat: 测试轮数
      :return: 吞吐量（samples/s）
      """
      batch_size = test_input_batch.shape[0]
      # 预热
      for _ in range(10):
          _ = model(test_input_batch)
      # 正式测试
      start = time.perf_counter()
      for _ in range(repeat):
          _ = model(test_input_batch)
      end = time.perf_counter()
      total_time = end - start
      total_samples = batch_size * repeat
      throughput = total_samples / total_time  # samples/s
      return throughput

（3）加速比（Speedup）

• 定义：TensorRT加速后的性能提升倍数，核心对比指标；

• 计算公式：

  延迟加速比 = 原生TF推理延迟 / TensorRT推理延迟
  吞吐量加速比 = TensorRT吞吐量 / 原生TF吞吐量

  例：原生TF延迟8ms，TensorRT延迟2ms → 延迟加速比=4倍；原生吞吐量125 samples/s，TensorRT 500 samples/s → 吞吐量加速比=4倍。

2. 精度损失指标

加速（尤其是INT8量化）可能导致精度下降，需对比加速前后的核心业务指标：

from sklearn.metrics import accuracy_score, precision_recall_fscore_support

def test_accuracy(model, test_ds, is_trt_engine=False):
    """
    测试模型精度（分类任务）
    :param test_ds: 测试数据集 (x_test, y_test) 或tf.data.Dataset
    :param is_trt_engine: 是否为TensorRT引擎（需适配推理逻辑）
    :return: 准确率、精确率、召回率、F1-score
    """
    x_test, y_test = test_ds
    y_pred = []
    for i in range(len(x_test)):
        input_data = x_test[i:i+1].astype(np.float32)
        if is_trt_engine:
            # TensorRT引擎推理逻辑（适配前文的do_inference函数）
            pred = do_inference(context, inputs, outputs, bindings, stream, input_data)
        else:
            # 原生TF/TF-TRT推理
            pred = model(input_data).numpy()
        y_pred.append(np.argmax(pred))
    # 计算指标
    y_pred = np.array(y_pred)
    y_true = np.argmax(y_test, axis=1)  # 若为独热编码标签
    acc = accuracy_score(y_true, y_pred)
    precision, recall, f1, _ = precision_recall_fscore_support(y_true, y_pred, average='macro')
    return {
        "accuracy": acc,
        "precision": precision,
        "recall": recall,
        "f1": f1
    }

3. 资源占用指标

通过NVIDIA工具或Python库监控GPU/CPU资源：

（1）GPU显存/利用率（nvidia-smi）

# 实时监控GPU状态（每秒刷新）
nvidia-smi --loop=1 --query-gpu=timestamp,utilization.gpu,memory.used --format=csv

（2）Python代码监控（需安装pynvml）

import pynvml

def monitor_gpu():
    """监控GPU显存和利用率"""
    pynvml.nvmlInit()
    handle = pynvml.nvmlDeviceGetHandleByIndex(0)  # 第0块GPU
    # 显存占用（MB）
    mem_info = pynvml.nvmlDeviceGetMemoryInfo(handle)
    used_mem = mem_info.used / 1024 / 1024
    # GPU利用率（%）
    util = pynvml.nvmlDeviceGetUtilizationRates(handle).gpu
    pynvml.nvmlShutdown()
    return {"used_mem_mb": used_mem, "gpu_util": util}

4. 稳定性指标

• 推理耗时抖动：计算延迟的标准差（越小越稳定）；

• 长时间运行测试：连续推理1小时，记录异常次数、平均延迟变化；

  def test_stability(model, test_input, duration=3600):
      """测试长时间运行稳定性（duration单位：秒）"""
      start_time = time.perf_counter()
      latencies = []
      error_count = 0
      while time.perf_counter() - start_time < duration:
          try:
              s = time.perf_counter()
              _ = model(test_input)
              latencies.append((time.perf_counter() - s)*1000)
          except Exception as e:
              error_count += 1
              print(f"推理异常：{e}")
      # 计算抖动（标准差）
      latency_std = np.std(latencies)
      return {
          "error_count": error_count,
          "latency_std": latency_std,
          "avg_latency": np.mean(latencies)
      }

三、完整评估流程（实操步骤）

以"MobileNetV2图像分类模型"为例，完整评估TensorRT加速效果：

步骤1：准备测试环境和数据

• 硬件：NVIDIA T4 GPU（或Jetson Xavier）；
• 测试数据：1000张测试图片（x_test）+ 标签（y_test），批处理大小设为32；
• 模型版本：
  • 基准模型：TensorFlow原生SavedModel（FP32）；
  • 优化模型1：TF-TRT（FP16）；
  • 优化模型2：TensorRT引擎（INT8）。

步骤2：逐一测试各模型

# 1. 加载模型
# 原生TF模型
tf_model = tf.saved_model.load("saved_model")
tf_infer = tf_model.signatures["serving_default"]
tf_model_wrapper = lambda x: tf_infer(tf.constant(x))[list(tf_infer.structured_outputs.keys())[0]]

# TF-TRT模型
trt_tf_model = tf.saved_model.load("trt_saved_model")
trt_tf_infer = trt_tf_model.signatures["serving_default"]
trt_tf_wrapper = lambda x: trt_tf_infer(tf.constant(x))[list(trt_tf_infer.structured_outputs.keys())[0]]

# TensorRT引擎（需提前加载context/inputs等）
trt_engine_wrapper = lambda x: do_inference(context, inputs, outputs, bindings, stream, x)

# 2. 测试单样本延迟
test_input = np.random.rand(1, 224, 224, 3).astype(np.float32)
tf_latency = test_latency(tf_model_wrapper, test_input)
trt_tf_latency = test_latency(trt_tf_wrapper, test_input)
trt_engine_latency = test_latency(trt_engine_wrapper, test_input)

# 3. 测试吞吐量
test_batch = np.random.rand(32, 224, 224, 3).astype(np.float32)
tf_throughput = test_throughput(tf_model_wrapper, test_batch)
trt_tf_throughput = test_throughput(trt_tf_wrapper, test_batch)
trt_engine_throughput = test_throughput(trt_engine_wrapper, test_batch)

# 4. 测试精度
test_ds = (x_test, y_test)
tf_acc = test_accuracy(tf_model_wrapper, test_ds)
trt_tf_acc = test_accuracy(trt_tf_wrapper, test_ds)
trt_engine_acc = test_accuracy(trt_engine_wrapper, test_ds, is_trt_engine=True)

# 5. 测试资源占用
tf_mem = monitor_gpu()  # 测试原生TF时监控
trt_mem = monitor_gpu()  # 测试TensorRT时监控

步骤3：整理评估结果（对比模板）

模型版本	平均延迟（ms）	P99延迟（ms）	吞吐量（samples/s）	准确率（%）	GPU显存（MB）	加速比（延迟）	精度损失（%）
TensorFlow原生	8.0	10.2	125	95.2	800	1x	0
TF-TRT（FP16）	2.0	2.5	500	95.1	400	4x	0.1
TensorRT引擎（INT8）	0.8	1.0	1250	94.8	200	10x	0.4

四、结果分析与决策

评估后需根据业务需求判断是否接受加速方案：

1. 优先保证精度 （如医疗、工业质检）：
   • 精度损失≤0.5%可接受，优先选FP16（几乎无精度损失）；
   • 若INT8精度损失＞1%，需优化校准数据集（增加样本数）或退回FP16。
2. 优先保证性能 （如实时视频分析）：
   • 即使精度损失1%，只要满足业务验收标准（如准确率≥94%），可选用INT8；
   • 若延迟仍不满足，可进一步优化（如减小输入尺寸、用更轻量的模型）。
3. 资源受限场景 （如边缘设备Jetson Nano）：
   • 优先关注显存占用，INT8可大幅降低显存，是边缘部署的首选。