一、先搞懂你踩的坑:FP16推理为啥会出问题?
咱们先从最实际的场景说起:你好不容易把模型转成TensorRT的FP16模式,跑起来速度快了一倍,结果测的时候发现输出结果和原来的FP32模型差得离谱,甚至还蹦出个NaN(非数字,简单说就是“无效数”),客户那边的验收都卡了。这到底是为啥?
先给你掰明白FP16和FP32的区别,不用讲复杂的IEEE标准,就拿咱们平时算钱举例子:FP32就像你手里的精确计算器,能算到小数点后7位,还能处理特别大或者特别小的数;FP16就像个便宜的计算器,只能算到小数点后3位,而且能算的数的范围比FP32小很多——比如它能处理的最大正数大概是65504,最小正数大概是6e-5。要是你算的数超过这个范围,要么直接变成无穷大,要么直接变成0,中间算着算着就出NaN了。
举个最常见的例子:假设模型里有个步骤是算“100000的平方”,用FP32算的话结果是1e10,没问题;但用FP16算的话,1e10比FP16能表示的最大数65504大太多,直接变成无穷大,后面再做别的运算,比如除以这个无穷大,结果就变成NaN了。
1.1 为啥要选FP16?又为啥会出问题?
FP16的好处很直接:内存占用是FP32的一半,跑的时候速度快,对硬件的要求也低——现在大部分GPU(比如英伟达的RTX系列、A系列)都专门优化了FP16的运算,速度能比FP32快2-4倍。但问题就出在“精度不够”和“数值范围太窄”,尤其是模型里有一些对数值敏感的算子(就是模型里的运算步骤),用FP16算就容易出问题。
二、TensorRT里必须保留FP32的算子有哪些?
TensorRT为了保证精度,对很多算子做了专门的优化,但有些算子天生就不适合用FP16,必须强制保留FP32精度。咱们把这些算子分成几类,给你列得明明白白,每类都给你举个实际的例子。
2.1 归一化类算子:怕数值太小出问题
归一化算子的作用是把模型中间的数值调整到一个合适的范围,比如常见的LayerNorm、BatchNorm、InstanceNorm。这些算子的计算过程里,会涉及到“除以标准差”——而标准差本身可能很小(比如1e-4),要是用FP16算,1e-4已经接近FP16能表示的最小正数了,除以它的时候很容易得到一个特别大的数,超出FP16的范围,直接变成无穷大,然后出NaN。
举个具体的例子,技术栈统一用PyTorch转TensorRT的场景,先给你写个简单的LayerNorm示例:
# 技术栈:PyTorch 2.0 + TensorRT 8.6
import torch
import torch.nn as nn
# 定义一个带LayerNorm的简单模型
class TestModel(nn.Module):
def __init__(self):
super().__init__()
# 输入维度是1024的LayerNorm
self.ln = nn.LayerNorm(1024)
def forward(self, x):
return self.ln(x)
# 生成测试输入:假设某层的输出数值很小,接近FP16的最小表示范围
x = torch.randn(1, 1024) * 1e-5 # 输入数值的量级是1e-5
model = TestModel()
model.eval()
# 先测FP32的结果
with torch.no_grad():
fp32_out = model(x)
print("FP32输出的最大值:", fp32_out.max().item()) # 正常输出,比如可能是1.2左右
# 转成FP16的模型再测
model_fp16 = model.half()
x_fp16 = x.half()
with torch.no_grad():
fp16_out = model_fp16(x_fp16)
print("FP16输出的最大值:", fp16_out.max().item()) # 可能输出inf(无穷大)或者NaN
这个例子里,输入x的数值很小,LayerNorm计算标准差的时候,结果可能是1e-4量级,用FP16算的话,除以这个标准差就容易出问题。
2.2 数值敏感类算子:对精度要求极高
这类算子的计算结果差一点,最后整个模型的输出就会差很多,比如Softmax、LogSoftmax、指数运算(exp)、除法运算。
先说Softmax,它的作用是把一组数转成概率(加起来等于1),计算过程是先对每个数做exp(指数),再除以所有exp的和。要是用FP16算,要是输入的数很大(比如10),exp(10)是22026,已经接近FP16的最大范围;要是输入的数是15,exp(15)是3269017,远远超过FP16的最大范围,直接变成无穷大,最后Softmax的结果就全是NaN了。
再举个exp的示例:
# 技术栈:PyTorch 2.0 + TensorRT 8.6
import torch
# 测试FP16和FP32下exp的计算
x = torch.tensor(15.0) # 输入数值15
# FP32下的结果
print("FP32 exp(15):", torch.exp(x).item()) # 输出3269017.3387,正常
# FP16下的结果
print("FP16 exp(15):", torch.exp(x.half()).item()) # 输出inf(无穷大)
这个例子很直观,15的指数运算在FP16下直接溢出,变成无穷大。
2.3 累积类算子:容易出现误差累积
这类算子会把很多小的误差加起来,最后导致结果偏差很大,比如求和(sum)、均值(mean)、点积(dot product)。
举个求和的例子:假设你有10000个数,每个数都是1e-5,用FP32求和的话,结果是0.1,没问题;但用FP16求和的话,FP16的精度只有3位小数,加1e-5的时候,1e-5比FP16的精度小太多,加10000次之后,结果可能还是0,和FP32的0.1差得很远。
三、TensorRT的精度回退策略:怎么自动避免问题?
TensorRT很聪明,它自带了一套精度回退的机制,能自动把必须用FP32的算子改成FP32精度,不用你手动改。咱们来看看这套策略是怎么工作的,以及你怎么配置它。
3.1 自动回退的原理
TensorRT在构建引擎(就是把模型转成TensorRT格式的过程)的时候,会对每个算子做一次“精度检查”:它会先给算子喂一些测试数据,用FP16算一遍,再用FP32算一遍,要是两次结果的误差超过了你设置的阈值,就自动把这个算子改成FP32精度。
3.2 怎么配置回退策略?
你只需要在构建TensorRT引擎的时候,设置几个参数就行,下面给你一个完整的构建示例:
# 技术栈:PyTorch 2.0 + TensorRT 8.6
import torch
import torch.nn as nn
import tensorrt as trt
import pycuda.driver as cuda
import pycuda.autoinit
import numpy as np
# 1. 先定义一个带问题算子的模型(比如带Softmax和LayerNorm的分类模型)
class TestModel(nn.Module):
def __init__(self):
super().__init__()
self.fc = nn.Linear(1024, 1000) # 全连接层,输出1000个类别
self.ln = nn.LayerNorm(1000) # 归一化层
self.softmax = nn.Softmax(dim=-1) # Softmax层
def forward(self, x):
x = self.fc(x)
x = self.ln(x)
x = self.softmax(x)
return x
# 2. 把PyTorch模型转成ONNX格式(TensorRT需要先转成ONNX)
model = TestModel()
model.eval()
x = torch.randn(1, 1024)
torch.onnx.export(
model, x, "test_model.onnx",
input_names=["input"], output_names=["output"],
dynamic_axes={"input": {0: "batch_size"}, "output": {0: "batch_size"}}
)
# 3. 用TensorRT构建引擎,配置精度回退策略
TRT_LOGGER = trt.Logger(trt.Logger.WARNING)
builder = trt.Builder(TRT_LOGGER)
network = builder.create_network(1 << int(trt.NetworkDefinitionCreationFlag.EXPLICIT_BATCH))
parser = trt.OnnxParser(network, TRT_LOGGER)
# 解析ONNX模型
with open("test_model.onnx", "rb") as f:
parser.parse(f.read())
# 配置构建参数
config = builder.create_builder_config()
# 设置最大工作空间(内存),单位是字节,这里设为1GB
config.max_workspace_size = 1 << 30
# 开启FP16模式,同时配置精度回退
config.set_flag(trt.BuilderFlag.FP16)
# 设置精度回退的阈值:误差超过1e-3就回退到FP32
config.set_flag(trt.BuilderFlag.STRICT_TYPES) # 开启严格类型检查
config.set_flag(trt.BuilderFlag.SAFETY_MODE) # 开启安全模式,自动回退敏感算子
# 构建引擎
engine = builder.build_engine(network, config)
# 保存引擎到文件,方便下次直接用
with open("test_model.engine", "wb") as f:
f.write(engine.serialize())
这个配置里,STRICT_TYPES和SAFETY_MODE是关键:STRICT_TYPES会让TensorRT严格按照你设置的精度检查每个算子,SAFETY_MODE会自动把Softmax、LayerNorm这类敏感算子改成FP32。
3.3 手动回退的情况:自动回退不够用怎么办?
有时候TensorRT的自动回退可能没覆盖到你模型里的某个特殊算子,或者你想自己控制哪个算子用FP32,这时候就需要手动回退。
手动回退的方法是在ONNX模型里给算子加一个属性,告诉TensorRT这个算子必须用FP32。举个例子,假设你模型里有个自定义的除法算子,你想让它用FP32,就可以这么做:
# 技术栈:PyTorch 2.0 + TensorRT 8.6
import onnx
from onnx import helper, TensorProto
# 加载之前的ONNX模型
model = onnx.load("test_model.onnx")
# 找到你要手动回退的算子(比如找Softmax算子)
for node in model.graph.node:
if node.op_type == "Softmax":
# 给算子加一个属性:precision=32,告诉TensorRT用FP32
node.attribute.append(helper.make_attribute("precision", 32))
# 保存修改后的ONNX模型
onnx.save(model, "test_model_fp32_softmax.onnx")
这样TensorRT在解析这个ONNX模型的时候,就会强制把Softmax算子改成FP32精度。
四、生产环境上线前的定位分析实操指南
就算你配置了回退策略,上线前还是得仔细测,万一漏了某个算子,上线后出问题就麻烦了。咱们来一步步说怎么定位问题。
4.1 第一步:先对比FP32和FP16的输出
首先你得先确认问题是不是出在FP16上。方法很简单:先跑一遍FP32的模型,得到一组基准输出;再跑一遍FP16的TensorRT引擎,得到另一组输出;然后对比两组输出的误差。
给你写一个对比的脚本:
# 技术栈:PyTorch 2.0 + TensorRT 8.6
import torch
import numpy as np
import tensorrt as trt
import pycuda.driver as cuda
import pycuda.autoinit
# 1. 加载FP32的PyTorch模型,得到基准输出
model = TestModel() # 就是之前定义的TestModel
model.eval()
x = torch.randn(10, 1024) # 10个测试样本
with torch.no_grad():
fp32_out = model(x).numpy() # 基准输出,转成numpy数组方便对比
# 2. 加载FP16的TensorRT引擎,得到输出
def load_engine(engine_path):
with open(engine_path, "rb") as f:
return trt.Runtime(trt.Logger(trt.Logger.WARNING)).deserialize_cuda_engine(f.read())
engine = load_engine("test_model.engine")
context = engine.create_execution_context()
# 分配输入输出的内存
input_shape = (10, 1024)
output_shape = (10, 1000)
input_size = trt.volume(input_shape) * engine.max_batch_size * np.dtype(np.float32).itemsize
output_size = trt.volume(output_shape) * engine.max_batch_size * np.dtype(np.float32).itemsize
d_input = cuda.mem_alloc(input_size)
d_output = cuda.mem_alloc(output_size)
# 把输入数据传到GPU
x_np = x.numpy().astype(np.float32)
cuda.memcpy_htod(d_input, x_np)
# 执行推理
context.execute(batch_size=10, bindings=[int(d_input), int(d_output)])
# 把输出数据从GPU传回来
fp16_out = np.empty(output_shape, dtype=np.float32)
cuda.memcpy_dtoh(fp16_out, d_output)
# 3. 对比误差
max_error = np.max(np.abs(fp32_out - fp16_out))
mean_error = np.mean(np.abs(fp32_out - fp16_out))
print("最大误差:", max_error)
print("平均误差:", mean_error)
# 要是误差超过1e-3,就说明有问题
if max_error > 1e-3:
print("FP16推理存在精度问题,需要进一步定位")
要是输出的最大误差超过1e-3,甚至出现NaN,就说明有算子的精度有问题,接下来就要定位是哪个算子。
4.2 第二步:定位出问题的算子
定位算子的方法是“分块测试”:把模型拆成一个个小的部分,分别测试每个部分的FP16和FP32输出的误差,找到误差最大的那个部分,就是出问题的算子。
举个例子,假设你的模型是“输入→全连接层→LayerNorm→Softmax→输出”,你可以分别测试全连接层、LayerNorm、Softmax的误差:
# 技术栈:PyTorch 2.0 + TensorRT 8.6
import torch
import torch.nn as nn
import numpy as np
# 定义每个小模块的模型
class FcModel(nn.Module):
def __init__(self):
super().__init__()
self.fc = nn.Linear(1024, 1000)
def forward(self, x):
return self.fc(x)
class LnModel(nn.Module):
def __init__(self):
super().__init__()
self.ln = nn.LayerNorm(1000)
def forward(self, x):
return self.ln(x)
class SoftmaxModel(nn.Module):
def __init__(self):
super().__init__()
self.softmax = nn.Softmax(dim=-1)
def forward(self, x):
return self.softmax(x)
# 测试每个模块的误差
def test_module(module, x):
# FP32输出
with torch.no_grad():
fp32_out = module(x).numpy()
# FP16输出
module_fp16 = module.half()
x_fp16 = x.half()
with torch.no_grad():
fp16_out = module_fp16(x_fp16).numpy()
# 计算误差
max_error = np.max(np.abs(fp32_out - fp16_out))
return max_error
# 生成测试输入
x = torch.randn(10, 1024)
fc_x = torch.randn(10, 1000) # 给LayerNorm和Softmax的输入
# 测试每个模块
fc_error = test_module(FcModel(), x)
ln_error = test_module(LnModel(), fc_x)
softmax_error = test_module(SoftmaxModel(), fc_x)
print("全连接层最大误差:", fc_error)
print("LayerNorm最大误差:", ln_error)
print("Softmax最大误差:", softmax_error)
假设测试结果是Softmax的最大误差是100,LayerNorm的是10,全连接层的是0.001,那出问题的就是Softmax算子,接下来就可以手动把Softmax改成FP32精度。
4.3 第三步:验证修复效果
找到出问题的算子并改成FP32之后,你得再重新跑一遍对比脚本,确认误差已经降到合理范围(一般分类模型的误差小于1e-3就没问题,检测模型的误差可以稍微大一点,但也要符合业务要求)。
五、应用场景、优缺点和注意事项
5.1 应用场景
FP16推理主要用在对速度要求高、对精度要求不是极端苛刻的场景:比如在线推荐系统(要快速给用户推荐内容)、实时视频分析(比如直播里的人脸检测)、边缘设备上的模型部署(比如手机、摄像头,这些设备的GPU性能有限,用FP16能提升速度)。
5.2 技术优缺点
优点:1. 速度快:比FP32快2-4倍,适合实时场景;2. 内存占用小:是FP32的一半,能在内存有限的设备上部署更大的模型;3. 功耗低:运算量少,GPU的功耗也会降低,适合边缘设备。 缺点:1. 精度可能下降:对数值敏感的算子容易出问题;2. 数值范围窄:容易溢出变成无穷大或者NaN;3. 兼容性问题:有些旧的GPU不支持FP16运算。
5.3 注意事项
- 不是所有模型都适合FP16:比如医疗影像模型(对精度要求极高,差一点可能误诊)、金融风控模型(差一点可能导致错误的风险评估),这些场景尽量用FP32,或者只对非敏感算子用FP16;
- 上线前必须做充分的测试:一定要对比FP32和FP16的输出误差,不能只看速度;
- 合理配置回退策略:不要为了速度把所有算子都改成FP16,该用FP32的一定要用;
- 注意输入数据的量级:要是你的模型输入数值特别大或者特别小,提前做归一化,避免FP16溢出。
六、文章总结
FP16推理是提升TensorRT模型速度的有效方法,但也容易出现精度偏差甚至NaN的问题,核心原因是FP16的精度和数值范围有限。TensorRT里的归一化类、数值敏感类、累积类算子必须保留FP32精度,你可以通过TensorRT的自动回退策略或者手动回退来保证这些算子的精度。上线前一定要通过对比输出、分块测试的方法定位问题,确保模型的精度符合业务要求。
评论
围绕“FP16半精度推理输出莫名偏差甚至出现NaN?TensorRT中哪些算子必须保留FP32、精度回退策略与生产环境上线前的定位分析实操指南”参与讨论