模型部署优化：ONNX与TensorRT实战——从训练到推理的完整优化链路

- 摘要
- [1. 引言：模型部署的挑战](#1. 引言：模型部署的挑战)
- - [1.1 从训练到部署的鸿沟](#1.1 从训练到部署的鸿沟)
  - [1.2 推理优化的核心目标](#1.2 推理优化的核心目标)
  - [1.3 ONNX与TensorRT的角色定位](#1.3 ONNX与TensorRT的角色定位)
- [2. ONNX介绍](#2. ONNX介绍)
- - [2.1 什么是ONNX](#2.1 什么是ONNX)
  - [2.2 ONNX架构](#2.2 ONNX架构)
  - [2.3 ONNX算子支持](#2.3 ONNX算子支持)
  - [2.4 ONNX的发展历程](#2.4 ONNX的发展历程)
- [3. TensorRT介绍](#3. TensorRT介绍)
- - [3.1 什么是TensorRT](#3.1 什么是TensorRT)
  - [3.2 TensorRT优化原理](#3.2 TensorRT优化原理)
  - [3.3 TensorRT性能对比](#3.3 TensorRT性能对比)
  - [3.4 TensorRT的适用场景](#3.4 TensorRT的适用场景)
- [4. 模型转换实战](#4. 模型转换实战)
- - [4.1 环境准备](#4.1 环境准备)
  - [4.2 PyTorch模型导出ONNX](#4.2 PyTorch模型导出ONNX)
  - [4.3 ONNX模型简化](#4.3 ONNX模型简化)
  - [4.4 ONNX转TensorRT](#4.4 ONNX转TensorRT)
- [5. 推理优化实战](#5. 推理优化实战)
- - [5.1 ONNX Runtime推理](#5.1 ONNX Runtime推理)
  - [5.2 TensorRT推理](#5.2 TensorRT推理)
  - [5.3 性能对比分析](#5.3 性能对比分析)
- [6. 量化技术详解](#6. 量化技术详解)
- - [6.1 什么是量化](#6.1 什么是量化)
  - [6.2 量化方法分类](#6.2 量化方法分类)
  - [6.3 TensorRT INT8量化](#6.3 TensorRT INT8量化)
  - [6.4 PyTorch量化感知训练](#6.4 PyTorch量化感知训练)
- [7. 剪枝技术详解](#7. 剪枝技术详解)
- - [7.1 什么是剪枝](#7.1 什么是剪枝)
  - [7.2 剪枝方法分类](#7.2 剪枝方法分类)
  - [7.3 结构化剪枝实战](#7.3 结构化剪枝实战)
  - [7.4 剪枝后微调](#7.4 剪枝后微调)
- [8. 综合优化策略](#8. 综合优化策略)
- - [8.1 优化流程](#8.1 优化流程)
  - [8.2 优化效果对比](#8.2 优化效果对比)
  - [8.3 最佳实践建议](#8.3 最佳实践建议)
- [9. 总结](#9. 总结)
- 思考题
- 参考资料

摘要

深度学习模型从实验室到生产环境的部署过程中，推理性能往往是最大的瓶颈。本文系统讲解ONNX（Open Neural Network Exchange）和TensorRT两大核心工具，详细介绍模型转换、推理优化、量化压缩、结构剪枝等关键技术。通过ResNet图像分类模型的完整实战案例，演示如何将模型推理速度提升5-10倍，同时保持精度损失在可接受范围内。读者将掌握模型部署优化的完整方法论，能够在实际项目中实现高效、低成本的模型推理服务。

1. 引言：模型部署的挑战

1.1 从训练到部署的鸿沟

深度学习模型在训练阶段和部署阶段面临截然不同的挑战：

阶段	关注点	典型需求
训练	准确率、收敛速度	大显存、高精度计算
部署	延迟、吞吐量、成本	低延迟、低功耗、小体积

训练时我们追求的是模型精度，可以使用FP32甚至FP64的高精度计算；部署时我们追求的是推理速度，需要在有限的硬件资源上实现低延迟、高吞吐。

1.2 推理优化的核心目标

模型部署优化的三大核心目标：
模型部署优化
降低延迟
提升吞吐
减少体积
量化
算子融合
批处理优化
并行推理
剪枝
知识蒸馏

降低延迟：单次推理的响应时间，直接影响用户体验。实时应用通常要求延迟低于100ms。

提升吞吐：单位时间处理的请求数量，影响服务成本。高吞吐意味着可以用更少的硬件服务更多的用户。

减少体积：模型文件大小和运行时内存占用，影响部署灵活性和边缘设备适配。

1.3 ONNX与TensorRT的角色定位

ONNX和TensorRT在模型部署链路中扮演不同角色：

工具	定位	核心能力
ONNX	中间表示格式	模型转换、跨框架互操作
TensorRT	推理优化引擎	算子融合、量化、内核自动调优

ONNX解决了框架碎片化问题，让PyTorch、TensorFlow等框架训练的模型能够统一表示；TensorRT则专注于NVIDIA GPU上的推理优化，提供极致的推理性能。

2. ONNX介绍

2.1 什么是ONNX

ONNX（Open Neural Network Exchange）是由Facebook和Microsoft联合发起的开放神经网络交换格式。其核心价值在于：

框架互操作：PyTorch模型可转换为ONNX，再转换为TensorFlow
统一推理引擎：ONNX Runtime提供跨平台高性能推理
生态系统支持：主流框架和硬件厂商广泛支持

2.2 ONNX架构

推理引擎
ONNX中间表示
训练框架
PyTorch
TensorFlow
MXNet
模型结构

Graph
算子定义

Operators
权重数据

Weights
ONNX Runtime
TensorRT
OpenVINO

ONNX采用Protobuf格式存储模型，包含计算图（Graph）、算子（Operators）和权重（Weights）三部分。计算图定义了模型的拓扑结构，算子定义了具体的计算操作，权重存储了训练好的参数。

2.3 ONNX算子支持

ONNX定义了丰富的算子集，覆盖主流神经网络结构：

算子类别	典型算子	支持情况
基础运算	Add, Mul, MatMul	完全支持
卷积类	Conv, Pool, BatchNorm	完全支持
激活函数	ReLU, Sigmoid, Softmax	完全支持
循环结构	LSTM, GRU, Loop	部分支持
自定义算子	Custom Ops	需要扩展

2.4 ONNX的发展历程

ONNX项目于2017年9月开源，最初由Facebook和Microsoft主导。2018年，NVIDIA、Intel、AMD等硬件厂商加入生态。2020年后，ONNX成为事实上的模型交换标准，支持超过100种算子，覆盖CNN、RNN、Transformer等主流架构。目前ONNX已发展到1.15版本，持续扩展算子支持和优化性能。

3. TensorRT介绍

3.1 什么是TensorRT

TensorRT是NVIDIA推出的高性能深度学习推理优化器，专为NVIDIA GPU设计。其核心能力包括：

算子融合：将多个算子合并为单个内核，减少内存访问
精度校准：INT8/FP16量化，大幅提升吞吐量
内核自动调优：针对特定GPU选择最优内核实现
动态张量内存：优化显存使用，支持更大batch size

3.2 TensorRT优化原理

原始模型
图优化
算子融合
精度优化
内核选择
引擎序列化
优化引擎

图优化：分析计算图，消除冗余操作，优化计算顺序。

算子融合：将连续的Conv-BN-ReLU等操作合并为单个内核，减少内存读写次数。

精度优化：将FP32模型转换为FP16或INT8，减少计算量和显存占用。

内核选择：针对目标GPU选择最优的内核实现，利用Tensor Core等硬件特性。

3.3 TensorRT性能对比

模型	原始PyTorch	ONNX Runtime	TensorRT FP16	TensorRT INT8
ResNet-50	45ms	28ms	8ms	5ms
BERT-Base	120ms	85ms	35ms	22ms
YOLOv5s	25ms	18ms	6ms	4ms

测试环境：NVIDIA RTX 3090，Batch Size=1

3.4 TensorRT的适用场景

场景	推荐配置	原因
实时推理	TensorRT INT8	极低延迟需求
批量推理	TensorRT FP16	平衡精度与速度
边缘部署	TensorRT + Jetson	优化功耗
云端服务	TensorRT + Triton	高吞吐场景

4. 模型转换实战

4.1 环境准备

bash 复制代码

# 创建虚拟环境
conda create -n deploy python=3.10
conda activate deploy

# 安装PyTorch
pip install torch torchvision

# 安装ONNX工具
pip install onnx onnxruntime onnx-simplifier

# 安装TensorRT（需要NVIDIA GPU）
pip install nvidia-tensorrt

# 安装其他依赖
pip install numpy pandas matplotlib

4.2 PyTorch模型导出ONNX

python 复制代码

import torch
import torchvision.models as models
import onnx

# 加载预训练模型
model = models.resnet50(pretrained=True)
model.eval()

# 创建示例输入
dummy_input = torch.randn(1, 3, 224, 224)

# 导出ONNX模型
onnx_path = "resnet50.onnx"
torch.onnx.export(
    model,
    dummy_input,
    onnx_path,
    export_params=True,
    opset_version=14,
    do_constant_folding=True,
    input_names=['input'],
    output_names=['output'],
    dynamic_axes={
        'input': {0: 'batch_size'},
        'output': {0: 'batch_size'}
    }
)

# 验证ONNX模型
onnx_model = onnx.load(onnx_path)
onnx.checker.check_model(onnx_model)
print(f"ONNX模型导出成功: {onnx_path}")
print(f"模型输入: {onnx_model.graph.input[0].name}")
print(f"模型输出: {onnx_model.graph.output[0].name}")

上述代码将PyTorch的ResNet-50模型导出为ONNX格式。dynamic_axes参数支持动态batch size，opset_version指定算子版本。导出后使用onnx.checker验证模型合法性。

4.3 ONNX模型简化

python 复制代码

import onnxsim

# 简化ONNX模型
simplified_onnx_path = "resnet50_sim.onnx"
onnx_model_simplified, check = onnxsim.simplify(
    onnx_path,
    input_shapes={'input': [1, 3, 224, 224]}
)

# 保存简化后的模型
onnx.save(onnx_model_simplified, simplified_onnx_path)
print(f"ONNX模型简化完成: {simplified_onnx_path}")
print(f"原始节点数: {len(onnx_model.graph.node)}")
print(f"简化后节点数: {len(onnx_model_simplified.graph.node)}")

onnx-simplifier工具可以消除ONNX模型中的冗余操作，如常量折叠、死代码消除等。简化后的模型更小、推理更快。

4.4 ONNX转TensorRT

python 复制代码

import tensorrt as trt

# 创建TensorRT日志记录器
TRT_LOGGER = trt.Logger(trt.Logger.WARNING)

def build_engine(onnx_file_path, engine_file_path, precision='fp16'):
    """
    将ONNX模型转换为TensorRT引擎
    """
    builder = trt.Builder(TRT_LOGGER)
    network = builder.create_network(1 << int(trt.NetworkDefinitionCreationFlag.EXPLICIT_BATCH))
    parser = trt.OnnxParser(network, TRT_LOGGER)
    
    # 解析ONNX模型
    with open(onnx_file_path, 'rb') as model:
        if not parser.parse(model.read()):
            print('ERROR: Failed to parse the ONNX file.')
            for error in range(parser.num_errors):
                print(parser.get_error(error))
            return None
    
    # 配置构建器
    config = builder.create_builder_config()
    config.max_workspace_size = 4 << 30  # 4GB
    
    # 设置精度
    if precision == 'fp16':
        config.set_flag(trt.BuilderFlag.FP16)
    elif precision == 'int8':
        config.set_flag(trt.BuilderFlag.INT8)
        # INT8需要校准数据集，这里简化处理
    
    # 构建引擎
    engine = builder.build_engine(network, config)
    
    # 序列化保存
    with open(engine_file_path, 'wb') as f:
        f.write(engine.serialize())
    
    print(f"TensorRT引擎构建完成: {engine_file_path}")
    return engine

# 转换模型
engine = build_engine(
    "resnet50_sim.onnx",
    "resnet50_fp16.engine",
    precision='fp16'
)

上述代码将ONNX模型转换为TensorRT引擎。TensorRT在构建阶段会进行算子融合、内核选择等优化，生成的引擎文件可直接用于推理。

5. 推理优化实战

5.1 ONNX Runtime推理

python 复制代码

import onnxruntime as ort
import numpy as np
import time

# 创建ONNX Runtime会话
sess_options = ort.SessionOptions()
sess_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL

session = ort.InferenceSession(
    "resnet50_sim.onnx",
    sess_options,
    providers=['CUDAExecutionProvider', 'CPUExecutionProvider']
)

# 获取输入输出信息
input_name = session.get_inputs()[0].name
output_name = session.get_outputs()[0].name
input_shape = session.get_inputs()[0].shape
print(f"输入: {input_name}, 形状: {input_shape}")
print(f"输出: {output_name}")

# 准备输入数据
input_data = np.random.randn(1, 3, 224, 224).astype(np.float32)

# 预热
for _ in range(10):
    session.run([output_name], {input_name: input_data})

# 性能测试
start_time = time.time()
iterations = 100
for _ in range(iterations):
    outputs = session.run([output_name], {input_name: input_data})
end_time = time.time()

avg_latency = (end_time - start_time) / iterations * 1000
print(f"ONNX Runtime平均延迟: {avg_latency:.2f}ms")
print(f"输出形状: {outputs[0].shape}")

ONNX Runtime提供了跨平台的高性能推理能力，支持CPU和GPU后端。graph_optimization_level参数控制图优化级别，ORT_ENABLE_ALL启用所有优化。

5.2 TensorRT推理

python 复制代码

import pycuda.driver as cuda
import pycuda.autoinit
import tensorrt as trt

class TensorRTInference:
    def __init__(self, engine_path):
        self.logger = trt.Logger(trt.Logger.WARNING)
        
        # 加载引擎
        with open(engine_path, 'rb') as f:
            self.engine = trt.Runtime(self.logger).deserialize_cuda_engine(f.read())
        
        self.context = self.engine.create_execution_context()
        
        # 分配内存
        self.inputs = []
        self.outputs = []
        self.bindings = []
        self.stream = cuda.Stream()
        
        for i in range(self.engine.num_bindings):
            binding = self.engine[i]
            shape = self.engine.get_binding_shape(binding)
            size = trt.volume(shape)
            dtype = trt.nptype(self.engine.get_binding_dtype(binding))
            
            # 分配主机和设备内存
            host_mem = cuda.pagelocked_empty(size, dtype)
            device_mem = cuda.mem_alloc(host_mem.nbytes)
            
            self.bindings.append(int(device_mem))
            
            if self.engine.binding_is_input(binding):
                self.inputs.append({'host': host_mem, 'device': device_mem, 'shape': shape})
            else:
                self.outputs.append({'host': host_mem, 'device': device_mem, 'shape': shape})
    
    def infer(self, input_data):
        """执行推理"""
        # 复制输入数据
        np.copyto(self.inputs[0]['host'], input_data.ravel())
        
        # 传输到GPU
        for inp in self.inputs:
            cuda.memcpy_htod_async(inp['device'], inp['host'], self.stream)
        
        # 执行推理
        self.context.execute_async_v2(bindings=self.bindings, stream_handle=self.stream.handle)
        
        # 传输回CPU
        for out in self.outputs:
            cuda.memcpy_dtoh_async(out['host'], out['device'], self.stream)
        
        # 同步
        self.stream.synchronize()
        
        return self.outputs[0]['host'].reshape(self.outputs[0]['shape'])

# 创建推理器
trt_inference = TensorRTInference("resnet50_fp16.engine")

# 准备输入
input_data = np.random.randn(1, 3, 224, 224).astype(np.float32)

# 预热
for _ in range(10):
    trt_inference.infer(input_data)

# 性能测试
start_time = time.time()
iterations = 100
for _ in range(iterations):
    output = trt_inference.infer(input_data)
end_time = time.time()

avg_latency = (end_time - start_time) / iterations * 1000
print(f"TensorRT FP16平均延迟: {avg_latency:.2f}ms")
print(f"输出形状: {output.shape}")

TensorRT推理需要手动管理GPU内存，但性能显著优于ONNX Runtime。上述代码封装了完整的推理流程，支持异步执行和批处理。

5.3 性能对比分析

python 复制代码

import matplotlib.pyplot as plt

# 性能数据
methods = ['PyTorch\nFP32', 'ONNX Runtime\nFP32', 'TensorRT\nFP16', 'TensorRT\nINT8']
latencies = [45, 28, 8, 5]
throughputs = [1000/45, 1000/28, 1000/8, 1000/5]

# 创建图表
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 5))

# 延迟对比
colors = ['#ef4444', '#f59e0b', '#22c55e', '#4f46e5']
bars1 = ax1.bar(methods, latencies, color=colors)
ax1.set_ylabel('延迟 (ms)', fontsize=12)
ax1.set_title('推理延迟对比', fontsize=14)
ax1.set_ylim(0, 55)

for bar, latency in zip(bars1, latencies):
    ax1.annotate(f'{latency}ms', xy=(bar.get_x() + bar.get_width()/2, bar.get_height()),
                 xytext=(0, 3), textcoords="offset points", ha='center', va='bottom', fontsize=11)

# 吞吐对比
bars2 = ax2.bar(methods, throughputs, color=colors)
ax2.set_ylabel('吞吐量 (QPS)', fontsize=12)
ax2.set_title('推理吞吐对比', fontsize=14)

for bar, throughput in zip(bars2, throughputs):
    ax2.annotate(f'{throughput:.0f}', xy=(bar.get_x() + bar.get_width()/2, bar.get_height()),
                 xytext=(0, 3), textcoords="offset points", ha='center', va='bottom', fontsize=11)

plt.tight_layout()
plt.savefig('performance_comparison.png', dpi=150)
plt.show()

6. 量化技术详解

6.1 什么是量化

量化是将模型从高精度表示（FP32）转换为低精度表示（FP16/INT8）的过程。其核心思想是：用更少的比特表示数值，牺牲少量精度换取大幅性能提升。

精度	比特数	数值范围	相对误差
FP32	32	±3.4×10³⁸	基准
FP16	16	±65504	~0.1%
INT8	8	-128~127	~1%

6.2 量化方法分类

量化方法
训练后量化PTQ
量化感知训练QAT
动态量化
静态量化
校准量化
伪量化训练

训练后量化（PTQ）：在模型训练完成后进行量化，无需重新训练，实现简单但精度损失较大。

量化感知训练（QAT）：在训练过程中模拟量化效果，精度损失小但需要重新训练。

6.3 TensorRT INT8量化

python 复制代码

import tensorrt as trt
import pycuda.driver as cuda
import pycuda.autoinit

class Calibrator(trt.IInt8EntropyCalibrator2):
    """INT8校准器"""
    
    def __init__(self, calibration_data, batch_size=1):
        trt.IInt8EntropyCalibrator2.__init__(self)
        self.calibration_data = calibration_data
        self.batch_size = batch_size
        self.current_index = 0
        
        # 分配GPU内存
        self.device_input = cuda.mem_alloc(
            calibration_data[0].nbytes * batch_size
        )
    
    def get_batch_size(self):
        return self.batch_size
    
    def get_batch(self, names):
        if self.current_index >= len(self.calibration_data):
            return None
        
        batch = self.calibration_data[
            self.current_index:self.current_index + self.batch_size
        ]
        self.current_index += self.batch_size
        
        cuda.memcpy_htod(self.device_input, batch)
        return [int(self.device_input)]
    
    def read_calibration_cache(self):
        return None
    
    def write_calibration_cache(self, cache):
        with open('calibration.cache', 'wb') as f:
            f.write(cache)

def build_int8_engine(onnx_path, calibration_data):
    """构建INT8引擎"""
    logger = trt.Logger(trt.Logger.WARNING)
    builder = trt.Builder(logger)
    network = builder.create_network(1 << int(trt.NetworkDefinitionCreationFlag.EXPLICIT_BATCH))
    parser = trt.OnnxParser(network, logger)
    
    with open(onnx_path, 'rb') as f:
        parser.parse(f.read())
    
    config = builder.create_builder_config()
    config.max_workspace_size = 4 << 30
    config.set_flag(trt.BuilderFlag.INT8)
    
    # 设置校准器
    calibrator = Calibrator(calibration_data)
    config.int8_calibrator = calibrator
    
    engine = builder.build_engine(network, config)
    
    with open('resnet50_int8.engine', 'wb') as f:
        f.write(engine.serialize())
    
    return engine

# 准备校准数据
calibration_data = np.random.randn(500, 3, 224, 224).astype(np.float32)

# 构建INT8引擎
engine = build_int8_engine("resnet50_sim.onnx", calibration_data)
print("INT8引擎构建完成")

INT8量化需要校准数据集来确定量化参数。校准器遍历校准数据，统计每层的激活分布，计算最优的量化参数。校准完成后，量化参数被缓存，后续推理直接使用。

6.4 PyTorch量化感知训练

python 复制代码

import torch.quantization as quant

# 准备模型
model = models.resnet50(pretrained=True)
model.eval()

# 融合BN层
model = torch.quantization.fuse_modules(model, [['conv1', 'bn1', 'relu']])

# 设置量化配置
model.qconfig = quant.get_default_qat_qconfig('fbgemm')

# 准备量化感知训练
quant.prepare_qat(model, inplace=True)

# 微调训练（简化示例）
optimizer = torch.optim.SGD(model.parameters(), lr=0.0001)
criterion = torch.nn.CrossEntropyLoss()

for epoch in range(5):
    for batch_idx, (data, target) in enumerate(train_loader):
        optimizer.zero_grad()
        output = model(data)
        loss = criterion(output, target)
        loss.backward()
        optimizer.step()

# 转换为量化模型
model_int8 = quant.convert(model)

# 保存量化模型
torch.save(model_int8.state_dict(), 'resnet50_qat.pth')
print("量化感知训练完成")

量化感知训练在训练过程中插入伪量化节点，模拟量化带来的精度损失，让模型学习适应量化误差。训练完成后，伪量化节点被移除，模型转换为真正的INT8模型。

7. 剪枝技术详解

7.1 什么是剪枝

剪枝是通过移除模型中不重要的参数来减少模型大小和计算量的技术。其核心思想是：神经网络存在大量冗余参数，移除它们对精度影响很小。
原始模型
评估参数重要性
移除不重要参数
微调恢复精度
剪枝后模型

7.2 剪枝方法分类

方法	剪枝粒度	优点	缺点
非结构化剪枝	单个权重	压缩率高	难以加速
结构化剪枝	通道/层	易于加速	精度损失大
全局剪枝	全局统一阈值	简单	可能过度剪枝
局部剪枝	每层独立阈值	灵活	需要调参

7.3 结构化剪枝实战

python 复制代码

import torch.nn.utils.prune as prune

def apply_structured_pruning(model, amount=0.3):
    """应用结构化剪枝"""
    for name, module in model.named_modules():
        if isinstance(module, torch.nn.Conv2d):
            # 对卷积层进行结构化剪枝
            prune.ln_structured(module, name='weight', amount=amount, n=2, dim=0)
            prune.remove(module, 'weight')
            print(f"剪枝层: {name}, 剪枝比例: {amount}")
    
    return model

# 应用剪枝
model = models.resnet50(pretrained=True)
pruned_model = apply_structured_pruning(model, amount=0.3)

# 统计参数量
total_params = sum(p.numel() for p in model.parameters())
pruned_params = sum(p.numel() for p in pruned_model.parameters())
print(f"原始参数量: {total_params:,}")
print(f"剪枝后参数量: {pruned_params:,}")
print(f"压缩比: {total_params/pruned_params:.2f}x")

结构化剪枝移除完整的通道或滤波器，生成的稀疏模型可以直接在标准硬件上加速。上述代码对ResNet-50的所有卷积层进行LN结构化剪枝，剪枝比例为30%。

7.4 剪枝后微调

python 复制代码

def finetune_pruned_model(model, train_loader, epochs=10):
    """剪枝后微调恢复精度"""
    model.train()
    optimizer = torch.optim.SGD(model.parameters(), lr=0.001, momentum=0.9)
    criterion = torch.nn.CrossEntropyLoss()
    
    for epoch in range(epochs):
        running_loss = 0.0
        correct = 0
        total = 0
        
        for batch_idx, (data, target) in enumerate(train_loader):
            optimizer.zero_grad()
            output = model(data)
            loss = criterion(output, target)
            loss.backward()
            optimizer.step()
            
            running_loss += loss.item()
            _, predicted = output.max(1)
            total += target.size(0)
            correct += predicted.eq(target).sum().item()
        
        accuracy = 100. * correct / total
        print(f"Epoch {epoch+1}/{epochs}, Loss: {running_loss/len(train_loader):.4f}, Acc: {accuracy:.2f}%")
    
    return model

# 微调剪枝后的模型
finetuned_model = finetune_pruned_model(pruned_model, train_loader, epochs=10)

剪枝会破坏模型的结构，导致精度下降。微调训练可以让剩余参数重新学习，恢复大部分精度。通常微调5-10个epoch即可恢复90%以上的精度。

8. 综合优化策略

8.1 优化流程

否
是
否
是
否
是
训练好的模型
模型大小合适?
剪枝压缩
推理速度满足?
量化加速
部署
精度损失可接受?
量化感知训练

8.2 优化效果对比

优化方案	模型大小	推理延迟	精度损失	适用场景
原始FP32	100MB	45ms	0%	基准
FP16量化	50MB	8ms	<0.1%	通用场景
INT8量化	25MB	5ms	~1%	高吞吐场景
剪枝+INT8	15MB	4ms	~2%	边缘设备
QAT+剪枝	15MB	4ms	<1%	高精度需求

8.3 最佳实践建议

场景	推荐方案	原因
云端高吞吐	TensorRT INT8	极致性能
边缘设备	剪枝 + INT8	小体积低功耗
精度敏感	QAT + FP16	平衡精度与速度
快速部署	ONNX Runtime FP16	跨平台兼容

9. 总结

本文系统讲解了模型部署优化的核心技术，重点介绍了ONNX模型转换和TensorRT推理优化。核心要点如下：

ONNX模型转换：作为中间表示格式，实现了跨框架互操作。使用onnx-simplifier可进一步优化模型结构。
TensorRT推理优化：通过算子融合、精度校准、内核自动调优等技术，可将推理速度提升5-10倍。
量化技术：INT8量化是最有效的加速手段，PTQ实现简单，QAT精度更高。TensorRT的校准机制可自动确定量化参数。
剪枝技术：结构化剪枝可直接加速推理，配合微调可恢复大部分精度。与量化结合可实现更高压缩率。
综合策略：根据部署场景选择合适的优化方案，云端优先INT8量化，边缘设备需要剪枝+量化组合。

模型部署优化是一个系统工程，需要在精度、速度、体积之间权衡。掌握ONNX和TensorRT这两大工具，能够应对绝大多数部署场景。

思考题

在你的项目中，推理延迟的瓶颈在哪里？如何针对性优化？
INT8量化会带来精度损失，如何评估和缓解这种损失？
剪枝和量化应该先做哪个？为什么？

模型部署优化：ONNX与TensorRT实战——从训练到推理的完整优化链路

目录

摘要

1. 引言：模型部署的挑战

1.1 从训练到部署的鸿沟

1.2 推理优化的核心目标

1.3 ONNX与TensorRT的角色定位

2. ONNX介绍

2.1 什么是ONNX

2.2 ONNX架构

2.3 ONNX算子支持

2.4 ONNX的发展历程

3. TensorRT介绍

3.1 什么是TensorRT

3.2 TensorRT优化原理

3.3 TensorRT性能对比

3.4 TensorRT的适用场景

4. 模型转换实战

4.1 环境准备

4.2 PyTorch模型导出ONNX

4.3 ONNX模型简化

4.4 ONNX转TensorRT

5. 推理优化实战

5.1 ONNX Runtime推理

5.2 TensorRT推理

5.3 性能对比分析

6. 量化技术详解

6.1 什么是量化

6.2 量化方法分类

6.3 TensorRT INT8量化

6.4 PyTorch量化感知训练

7. 剪枝技术详解

7.1 什么是剪枝

7.2 剪枝方法分类

7.3 结构化剪枝实战

7.4 剪枝后微调

8. 综合优化策略

8.1 优化流程

8.2 优化效果对比

8.3 最佳实践建议

9. 总结

思考题

参考资料