ONNX Runtime Python 推理性能优化：8 个低延迟工程实践

在深度学习落地过程中，有一个常见的误区：一旦推理速度不达标，大家的第一反应往往是拿着模型开到，比如：做剪枝、搞蒸馏、甚至牺牲精度换小模型。

实际上生产环境中的 Python 推理链路隐藏着巨大的“工程红利”。很多时候你的模型本身并不慢，慢的是低效的数据搬运、混乱的线程争用以及不合理的 Runtime 默认配置。在不改变模型精度的情况下，仅靠ONNX Runtime (ORT) 的工程特性，往往就能从现有技术栈中“抠”出惊人的性能提升。

以下是 8 个经过实战验证的低延迟优化策略，专治各种“莫名其妙的慢”。

1、 明确指定 Execution Provider 及其顺序

ORT 会严格按照你传入的

providers

列表顺序进行尝试。把最快的放在第一位，并且尽量避免它静默回退（Fallback）到 CPU。如果不显式指定，ORT 有时候会“犹豫”，这都会消耗时间。

 import onnxruntime as ort  

providers = [  
    ("TensorrtExecutionProvider", {"trt_fp16_enable": True}),  # if supported  
    "CUDAExecutionProvider",  
    "CPUExecutionProvider",  
]  

sess = ort.InferenceSession("model.onnx", providers=providers)  
print(sess.get_providers())  # verify what you actually got

Fallback 是有成本的，如果环境里有 TensorRT 就优先用，没有就降级到 CUDA，最后才是 CPU。把这个路径写死。另外在边缘设备上，OpenVINO 或者 CoreML 的性能通常吊打普通 CPU 推理；如果是 Windows 平台带集显DirectML 也是个容易被忽视的加速选项。

2.、像做手术一样控制线程数（不要超配）

线程配置有两个核心参数：intra-op（算子内并行）和 inter-op（算子间并行）。这两个参数的设置必须参考机器的物理核心数以及你的负载特性。

 import os, multiprocessing as mp, onnxruntime as ort  

cores = mp.cpu_count() // 2 or 1  # conservative default  
so = ort.SessionOptions()  
so.intra_op_num_threads = cores  
so.inter_op_num_threads = 1  # start low for consistent latency  
so.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL  

sess = ort.InferenceSession("model.onnx", sess_options=so, providers=["CPUExecutionProvider"])

默认的线程策略经常会跟 NumPy、BLAS 库甚至你的 Web Server 抢占资源，导致严重的线程争用和长尾延迟。建议把

inter_op

设为 1（通常能获得更稳定的延迟），然后遍历测试

intra_op

（从 1 到物理核数），盯着 p50 和 p95 指标找最佳平衡点，不要光看平均速度。

3、使用 IO Binding 规避内存拷贝（GPU 必选项）

如果在 GPU 上跑推理，却每次

run()

都把张量从 Device 拷回 Host再拷回 Device，利用 IO Binding 将输入/输出直接绑定在显存上，复用这块内存。

 import onnxruntime as ort  
import numpy as np  

sess = ort.InferenceSession("model.onnx", providers=["CUDAExecutionProvider"])  
io = sess.io_binding()  

# Example: preallocate on device via OrtValue (CUDA)  
import onnxruntime as ort  
x = np.random.rand(1, 3, 224, 224).astype(np.float32)  
x_ort = ort.OrtValue.ortvalue_from_numpy(x, device_type="cuda", device_id=0)  

io.bind_input(name=sess.get_inputs()[0].name, device_type="cuda", device_id=0, element_type=np.float32, shape=x.shape, buffer_ptr=x_ort.data_ptr())  
io.bind_output(name=sess.get_outputs()[0].name, device_type="cuda", device_id=0)  

sess.run_with_iobinding(io)  
y_ort = io.get_outputs()[0]  # still on device

这对于高频请求特别重要，哪怕单次拷贝只耗费几毫秒，累积起来也是巨大的开销，所以让热数据留在它该在的地方。

4、锁定 Shape 或采用分桶策略

动态 Shape 看起来很灵活，但它会阻碍 ORT 进行激进的算子融合和 Kernel 优选。在导出 ONNX 时能固定 Shape 就尽量固定。

如果业务场景确实需要变长输入，可以采用分桶（Bucketing）策略：

 # pseudo: choose session by input shape  
 def get_session_for_shape(h, w):  
     if h <= 256 and w <= 256: return sess_256  
     if h <= 384 and w <= 384: return sess_384  
     return sess_fallback

比如在视觉任务中，把输入限定在 224、256、384 这几档，创建对应的 Session。哪怕只分两三个桶，性能表现也比完全动态 Shape 强得多。

5、开启全图优化并验证

这一步很简单但容易被忽略。开启

ORT_ENABLE_ALL

，让 ORT 帮你做算子融合、常量折叠和内存规划。

 import onnxruntime as ort  

so = ort.SessionOptions()  
so.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL  
# optional: serialize the optimized model for inspection  
so.optimized_model_filepath = "model.optimized.onnx"  

sess = ort.InferenceSession("model.onnx", sess_options=so, providers=["CPUExecutionProvider"])

更少的算子意味着更少的 Kernel Launch 开销和内存带宽压力。建议导出一个

optimized_model_filepath

，用 Netron 打开看看，确认 Conv+BN+ReLU 这种经典组合是不是真的被融合成一个节点了，如果没融那就是优化链路上有问题。

6、CPU 推理？直接上量化

如果只能用 CPU，INT8 量化或者动态量化是提速神器。配合 CPU 的向量指令集能极大减少矩阵乘法的开销。

 from onnxruntime.quantization import quantize_dynamic, QuantType  

quantize_dynamic(  
    model_input="model.onnx",  
    model_output="model.int8.onnx",  
    weight_type=QuantType.QInt8,   # try QInt8 or QUInt8  
    extra_options={"MatMulConstBOnly": True}  
)

然后加载量化后的模型：

 import onnxruntime as ort  
 sess = ort.InferenceSession("model.int8.onnx", providers=["CPUExecutionProvider"])

对于 Transformer 类模型，动态量化通常能带来 1.5 到 3 倍的加速且精度损失很小。不过需要先在真实数据上验证，如果精度掉得厉害尝试 Per-channel 量化或者只量化计算最密集的算子。

7、预热、复用与 Micro-Batching

InferenceSession

的初始化开销很大，属于重资源对象。务必全局只创建一次，并且需要启动后先跑几次 Dummy Data 做预热，把 Kernel Cache 和内存池填好。

 # app startup  
 sess=ort.InferenceSession("model.onnx", providers=["CUDAExecutionProvider"])  
 dummy= {sess.get_inputs()[0].name: np.zeros((1, 3, 224, 224), np.float32)}  
 for_inrange(3):  
     sess.run(None, dummy)  # warms kernels, caches, memory arenas

如果是高并发场景不要一个个请求单独跑，攒一个 Micro-batch（比如 2 到 8 个样本）一起送进去，能显著提高 GPU 利用率（Occupancy）。

 definfer_batch(batch):  
     inputs=np.stack(batch, axis=0).astype(np.float32, copy=False)  
     returnsess.run(None, {sess.get_inputs()[0].name: inputs})[0]

调整 Batch Size 的时候，盯着 p95 延迟和吞吐量看，找到那个甜点。

8、优化前后处理：拒绝 Python 循环

很多时候大家抱怨模型慢，其实瓶颈在预处理和后处理。Python 的

for

循环处理像素或 logits 是绝对的性能杀手。所以保持数组内存连续，避免不必要的

astype

转换尽量全部向量化。

 import numpy as np  

# Bad: repeated copies/conversions  
# x = np.array(img).astype(np.float32)  # realloc every time  

# Better: reuse buffers and normalize in-place  
buf = np.empty((1, 3, 224, 224), dtype=np.float32)  

def preprocess(img, out=buf):  
    # assume img is already CHW float32 normalized upstream  
    np.copyto(out, img, casting="no")   # no implicit cast  
    return out  

# Post-process with NumPy ops, not Python loops  
def topk(logits, k=5):  
    idx = np.argpartition(logits, -k, axis=1)[:, -k:]  
    vals = np.take_along_axis(logits, idx, axis=1)  
    order = np.argsort(-vals, axis=1)  
    return np.take_along_axis(idx, order, axis=1), np.take_along_axis(vals, order, axis=1)

几个多余的

.astype()

就能吃掉好几毫秒，这点在低延迟场景下非常致命。

基准测试模板

这是一个简单的 Benchmarking 脚本，改改就能用，别靠感觉优化要用数据来进行对比：

 import time, statistics as stats  
import numpy as np, onnxruntime as ort  

def bench(sess, x, iters=100, warmup=5):  
    name = sess.get_inputs()[0].name  
    for _ in range(warmup):  
        sess.run(None, {name: x})  
    times = []  
    for _ in range(iters):  
        t0 = time.perf_counter()  
        sess.run(None, {name: x})  
        times.append((time.perf_counter() - t0) * 1e3)  
    return {  
        "p50_ms": stats.median(times),  
        "p95_ms": sorted(times)[int(0.95 * len(times)) - 1],  
        "min_ms": min(times),  
        "max_ms": max(times)  
    }  

# Example usage  
providers = ["CUDAExecutionProvider", "CPUExecutionProvider"]  
so = ort.SessionOptions(); so.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL  
sess = ort.InferenceSession("model.onnx", sess_options=so, providers=providers)  

x = np.random.rand(1, 3, 224, 224).astype(np.float32)  
print(bench(sess, x))

总结

做低延迟推理没有什么黑科技，全是细节。选对 Provider，别乱开线程，减少内存拷贝，固定 Shape，激进地做图融合，最后把 Python 代码洗干净。哪怕只落实其中两三点，性能提升也是肉眼可见的。

https://avoid.overfit.cn/post/aa489c6b429641b9b1a1a3e4a3e4ce1d

作者：Modexa