注意
转到结尾 下载完整示例代码
GaussianProcessorRegressor 的差异：使用双精度浮点数¶
GaussianProcessRegressor 涉及许多可能需要双精度浮点数的矩阵运算。sklearn-onnx 默认情况下使用单精度浮点数，但对于此特定模型，最好使用双精度浮点数。让我们看看如何使用双精度浮点数创建 ONNX 文件。
训练模型¶
在波士顿数据集上使用 GaussianProcessRegressor 的一个非常基本的示例。
import pprint
import numpy
import sklearn
from sklearn.datasets import load_diabetes
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import DotProduct, RBF
from sklearn.model_selection import train_test_split
import onnx
import onnxruntime as rt
import skl2onnx
from skl2onnx.common.data_types import FloatTensorType, DoubleTensorType
from skl2onnx import convert_sklearn
dataset = load_diabetes()
X, y = dataset.data, dataset.target
X_train, X_test, y_train, y_test = train_test_split(X, y)
gpr = GaussianProcessRegressor(DotProduct() + RBF(), alpha=1.0)
gpr.fit(X_train, y_train)
print(gpr)
/home/xadupre/github/scikit-learn/sklearn/gaussian_process/kernels.py:419: ConvergenceWarning: The optimal value found for dimension 0 of parameter k2__length_scale is close to the specified lower bound 1e-05. Decreasing the bound and calling fit again may find a better value.
warnings.warn(
GaussianProcessRegressor(alpha=1.0,
kernel=DotProduct(sigma_0=1) + RBF(length_scale=1))
首次尝试将模型转换为 ONNX¶
文档建议以下方法将模型转换为 ONNX。
initial_type = [("X", FloatTensorType([None, X_train.shape[1]]))]
onx = convert_sklearn(gpr, initial_types=initial_type, target_opset=12)
sess = rt.InferenceSession(onx.SerializeToString(), providers=["CPUExecutionProvider"])
try:
pred_onx = sess.run(None, {"X": X_test.astype(numpy.float32)})[0]
except RuntimeError as e:
print(str(e))
第二次尝试：可变维度¶
不幸的是，即使转换成功，运行时也无法计算预测。之前的代码片段对输入施加了固定维度，因此运行时假设每个节点输出都具有固定维度的输出。而对于此模型并非如此。我们需要通过将固定维度替换为空值来禁用这些检查（见下一行）。
initial_type = [("X", FloatTensorType([None, None]))]
onx = convert_sklearn(gpr, initial_types=initial_type, target_opset=12)
sess = rt.InferenceSession(onx.SerializeToString(), providers=["CPUExecutionProvider"])
pred_onx = sess.run(None, {"X": X_test.astype(numpy.float32)})[0]
pred_skl = gpr.predict(X_test)
print(pred_skl[:10])
print(pred_onx[0, :10])
[157.67407448 142.03651212 160.8484086 135.0034477 100.48107033
171.43261057 134.12309522 167.4292642 155.90885873 201.31475888]
[155.5]
差异似乎非常重要。让我们通过查看最大的差异来确认这一点。
diff = numpy.sort(numpy.abs(numpy.squeeze(pred_skl) - numpy.squeeze(pred_onx)))[-5:]
print(diff)
print("min(Y)-max(Y):", min(y_test), max(y_test))
[2.24528426 2.36538915 2.37925239 2.38045369 2.63459276]
min(Y)-max(Y): 25.0 336.0
第三次尝试：使用双精度浮点数¶
该模型使用了一些矩阵计算，矩阵的系数具有非常不同的数量级。如果转换后的模型仍然坚持使用浮点数，则很难近似使用 scikit-learn 生成的预测。需要双精度浮点数。
之前的代码需要两个更改。第一个更改表示输入现在是 DoubleTensorType 类型。第二个更改是额外的参数 dtype=numpy.float64 告诉转换函数将所有实数常量矩阵（例如训练后的系数）都作为双精度浮点数而不是浮点数进行转储。
initial_type = [("X", DoubleTensorType([None, None]))]
onx64 = convert_sklearn(gpr, initial_types=initial_type, target_opset=12)
sess64 = rt.InferenceSession(
onx64.SerializeToString(), providers=["CPUExecutionProvider"]
)
pred_onx64 = sess64.run(None, {"X": X_test})[0]
print(pred_onx64[0, :10])
[157.67407447]
新的差异看起来好多了。
diff = numpy.sort(numpy.abs(numpy.squeeze(pred_skl) - numpy.squeeze(pred_onx64)))[-5:]
print(diff)
print("min(Y)-max(Y):", min(y_test), max(y_test))
[7.92597632e-09 8.98936037e-09 9.23387233e-09 9.66474545e-09
1.00339719e-08]
min(Y)-max(Y): 25.0 336.0
大小增加¶
结果是，ONNX 模型的大小几乎增加了一倍，因为每个系数都作为双精度浮点数而不是浮点数存储。
ONNX with floats: 29814
ONNX with doubles: 57694
return_std=True¶
GaussianProcessRegressor 是一个为预测函数定义了额外参数的模型。如果使用 return_std=True 调用，则该类将返回一个额外的结果，这需要反映到生成的 ONNX 图中。转换器需要知道需要扩展的图。这通过选项机制完成（参见 具有选项的转换器）。
initial_type = [("X", DoubleTensorType([None, None]))]
options = {GaussianProcessRegressor: {"return_std": True}}
try:
onx64_std = convert_sklearn(
gpr, initial_types=initial_type, options=options, target_opset=12
)
except RuntimeError as e:
print(e)
此错误突出显示了这样一个事实，即 scikit-learn 在第一次调用 predict 方法时计算内部变量。转换器需要通过至少调用一次 predict 方法来初始化这些变量，然后再次进行转换。
gpr.predict(X_test[:1], return_std=True)
onx64_std = convert_sklearn(
gpr, initial_types=initial_type, options=options, target_opset=12
)
sess64_std = rt.InferenceSession(
onx64_std.SerializeToString(), providers=["CPUExecutionProvider"]
)
pred_onx64_std = sess64_std.run(None, {"X": X_test[:5]})
pprint.pprint(pred_onx64_std)
[array([[157.67407447],
[142.03651212],
[160.8484086 ],
[135.0034477 ],
[100.48107033]]),
array([1.00845167, 1.0054851 , 1.0139891 , 1.00514903, 1.01019988])]
让我们与 scikit-learn 预测进行比较。
pprint.pprint(gpr.predict(X_test[:5], return_std=True))
(array([157.67407448, 142.03651212, 160.8484086 , 135.0034477 ,
100.48107033]),
array([1.00845384, 1.00548596, 1.01398906, 1.00515132, 1.01019995]))
看起来不错。让我们进行更仔细的检查。
pred_onx64_std = sess64_std.run(None, {"X": X_test})
pred_std = gpr.predict(X_test, return_std=True)
diff = numpy.sort(
numpy.abs(numpy.squeeze(pred_onx64_std[1]) - numpy.squeeze(pred_std[1]))
)[-5:]
print(diff)
[2.54371954e-06 2.56724555e-06 2.58754006e-06 2.63925354e-06
3.30249346e-06]
存在一些差异，但这似乎是合理的。
用于此示例的版本
print("numpy:", numpy.__version__)
print("scikit-learn:", sklearn.__version__)
print("onnx: ", onnx.__version__)
print("onnxruntime: ", rt.__version__)
print("skl2onnx: ", skl2onnx.__version__)
numpy: 1.23.5
scikit-learn: 1.4.dev0
onnx: 1.15.0
onnxruntime: 1.16.0+cu118
skl2onnx: 1.16.0
脚本的总运行时间：（0 分钟 3.428 秒）