Discrepencies with ONNX#
Links: notebook, html, PDF, python, slides, GitHub
The notebook shows one example where the conversion leads with discrepencies if default options are used. It converts a pipeline with two steps, a scaler followed by a tree.
The bug this notebook is tracking does not always appear, it has a better chance to happen with integer features but that’s not always the case. The notebook must be run again in that case.
from jyquickhelper import add_notebook_menu
add_notebook_menu()
%matplotlib inline
Data and first model#
We take a random datasets with mostly integers.
import math
import numpy
from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split
X, y = make_regression(10000, 10)
X_train, X_test, y_train, y_test = train_test_split(X, y)
Xi_train, yi_train = X_train.copy(), y_train.copy()
Xi_test, yi_test = X_test.copy(), y_test.copy()
for i in range(X.shape[1]):
Xi_train[:, i] = (Xi_train[:, i] * math.pi * 2 ** i).astype(numpy.int64)
Xi_test[:, i] = (Xi_test[:, i] * math.pi * 2 ** i).astype(numpy.int64)
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.tree import DecisionTreeRegressor
max_depth = 10
model = Pipeline([
('scaler', StandardScaler()),
('dt', DecisionTreeRegressor(max_depth=max_depth))
])
model.fit(Xi_train, yi_train)
Pipeline(steps=[('scaler', StandardScaler()),
('dt', DecisionTreeRegressor(max_depth=10))])
model.predict(Xi_test[:5])
array([-283.03708629, 263.17931397, -160.34784206, -126.59514441,
-150.1963714 ])
Other models:
model2 = Pipeline([
('scaler', StandardScaler()),
('dt', DecisionTreeRegressor(max_depth=max_depth))
])
model3 = Pipeline([
('scaler', StandardScaler()),
('dt', DecisionTreeRegressor(max_depth=3))
])
models = [
('bug', Xi_test.astype(numpy.float32), model),
('no scaler', Xi_test.astype(numpy.float32),
DecisionTreeRegressor(max_depth=max_depth).fit(Xi_train, yi_train)),
('float', X_test.astype(numpy.float32),
model2.fit(X_train, y_train)),
('max_depth=3', X_test.astype(numpy.float32),
model3.fit(X_train, y_train))
]
Conversion to ONNX#
import numpy
from mlprodict.onnx_conv import to_onnx
onx = to_onnx(model, X_train[:1].astype(numpy.float32))
from mlprodict.onnxrt import OnnxInference
oinfpy = OnnxInference(onx, runtime="python_compiled")
print(oinfpy)
OnnxInference(...)
def compiled_run(dict_inputs):
# inputs
X = dict_inputs['X']
(variable1, ) = n0_scaler(X)
(variable, ) = n1_treeensembleregressor(variable1)
return {
'variable': variable,
}
import pandas
X32 = Xi_test.astype(numpy.float32)
y_skl = model.predict(X32)
obs = [dict(runtime='sklearn', diff=0)]
for runtime in ['python', 'python_compiled', 'onnxruntime1']:
oinf = OnnxInference(onx, runtime=runtime)
y_onx = oinf.run({'X': X32})['variable']
delta = numpy.abs(y_skl - y_onx.ravel())
am = delta.argmax()
obs.append(dict(runtime=runtime, diff=delta.max()))
obs[-1]['v[%d]' % am] = y_onx.ravel()[am]
obs[0]['v[%d]' % am] = y_skl.ravel()[am]
pandas.DataFrame(obs)
| runtime | diff | v[1583] | |
|---|---|---|---|
| 0 | sklearn | 0.000000 | -439.590635 |
| 1 | python | 133.641599 | -305.949036 |
| 2 | python_compiled | 133.641599 | -305.949036 |
| 3 | onnxruntime1 | 133.641599 | -305.949036 |
The pipeline shows huge discrepencies. They appear for a pipeline StandardScaler + DecisionTreeRegressor applied in integer features. They disappear if floats are used, or if the scaler is removed. The bug also disappear if the tree is not big enough (max_depth=4 instread of 5).
obs = [dict(runtime='sklearn', diff=0, name='sklearn')]
for name, x32, mod in models:
for runtime in ['python', 'python_compiled', 'onnxruntime1']:
lonx = to_onnx(mod, x32[:1])
loinf = OnnxInference(lonx, runtime=runtime)
y_skl = mod.predict(X32)
y_onx = loinf.run({'X': X32})['variable']
delta = numpy.abs(y_skl - y_onx.ravel())
am = delta.argmax()
obs.append(dict(runtime=runtime, diff=delta.max(), name=name))
obs[-1]['v[%d]' % am] = y_onx.ravel()[am]
obs[0]['v[%d]' % am] = y_skl.ravel()[am]
df = pandas.DataFrame(obs)
df
| runtime | diff | name | v[1583] | v[1109] | v[19] | v[4] | |
|---|---|---|---|---|---|---|---|
| 0 | sklearn | 0.000000 | sklearn | -439.590635 | 516.084502 | -549.753386 | -97.726497 |
| 1 | python | 133.641599 | bug | -305.949036 | NaN | NaN | NaN |
| 2 | python_compiled | 133.641599 | bug | -305.949036 | NaN | NaN | NaN |
| 3 | onnxruntime1 | 133.641599 | bug | -305.949036 | NaN | NaN | NaN |
| 4 | python | 0.000029 | no scaler | NaN | 516.084473 | NaN | NaN |
| 5 | python_compiled | 0.000029 | no scaler | NaN | 516.084473 | NaN | NaN |
| 6 | onnxruntime1 | 0.000029 | no scaler | NaN | 516.084473 | NaN | NaN |
| 7 | python | 0.000029 | float | NaN | NaN | -549.753357 | NaN |
| 8 | python_compiled | 0.000029 | float | NaN | NaN | -549.753357 | NaN |
| 9 | onnxruntime1 | 0.000029 | float | NaN | NaN | -549.753357 | NaN |
| 10 | python | 0.000003 | max_depth=3 | NaN | NaN | NaN | -97.726494 |
| 11 | python_compiled | 0.000003 | max_depth=3 | NaN | NaN | NaN | -97.726494 |
| 12 | onnxruntime1 | 0.000003 | max_depth=3 | NaN | NaN | NaN | -97.726494 |
df.pivot("runtime", "name", "diff")
| name | bug | float | max_depth=3 | no scaler | sklearn |
|---|---|---|---|---|---|
| runtime | |||||
| onnxruntime1 | 133.641599 | 0.000029 | 0.000003 | 0.000029 | NaN |
| python | 133.641599 | 0.000029 | 0.000003 | 0.000029 | NaN |
| python_compiled | 133.641599 | 0.000029 | 0.000003 | 0.000029 | NaN |
| sklearn | NaN | NaN | NaN | NaN | 0.0 |
Other way to convert#
ONNX does not support double for TreeEnsembleRegressor but that a new operator TreeEnsembleRegressorDouble was implemented into mlprodict. We need to update the conversion.
%load_ext mlprodict
onx32 = to_onnx(model, X_train[:1].astype(numpy.float32))
onx64 = to_onnx(model, X_train[:1].astype(numpy.float64),
rewrite_ops=True)
%onnxview onx64
X32 = Xi_test.astype(numpy.float32)
X64 = Xi_test.astype(numpy.float64)
obs = [dict(runtime='sklearn', diff=0)]
for runtime in ['python', 'python_compiled', 'onnxruntime1']:
for name, onx, xr in [('float', onx32, X32), ('double', onx64, X64)]:
try:
oinf = OnnxInference(onx, runtime=runtime)
except Exception as e:
obs.append(dict(runtime=runtime, error=str(e), real=name))
continue
y_skl = model.predict(xr)
y_onx = oinf.run({'X': xr})['variable']
delta = numpy.abs(y_skl - y_onx.ravel())
am = delta.argmax()
obs.append(dict(runtime=runtime, diff=delta.max(), real=name))
obs[-1]['v[%d]' % am] = y_onx.ravel()[am]
obs[0]['v[%d]' % am] = y_skl.ravel()[am]
pandas.DataFrame(obs)
| runtime | diff | v[1583] | v[0] | real | error | |
|---|---|---|---|---|---|---|
| 0 | sklearn | 0.000000 | -439.590635 | -283.037086 | NaN | NaN |
| 1 | python | 133.641599 | -305.949036 | NaN | float | NaN |
| 2 | python | 0.000000 | NaN | -283.037086 | double | NaN |
| 3 | python_compiled | 133.641599 | -305.949036 | NaN | float | NaN |
| 4 | python_compiled | 0.000000 | NaN | -283.037086 | double | NaN |
| 5 | onnxruntime1 | 133.641599 | -305.949036 | NaN | float | NaN |
| 6 | onnxruntime1 | NaN | NaN | NaN | double | Unable to create InferenceSession due to '[ONN... |
We see that the use of double removes the discrepencies.
OnnxPipeline#
Another way to reduce the number of discrepencies is to use a pipeline which converts every steps into ONNX before training the next one. That way, every steps is either trained on the inputs, either trained on the outputs produced by ONNX. Let’s see how it works.
from mlprodict.sklapi import OnnxPipeline
model_onx = OnnxPipeline([
('scaler', StandardScaler()),
('dt', DecisionTreeRegressor(max_depth=max_depth))
])
model_onx.fit(Xi_train, yi_train)
C:xavierdupre__home_github_forkscikit-learnsklearnbase.py:209: FutureWarning: From version 0.24, get_params will raise an AttributeError if a parameter cannot be retrieved as an instance attribute. Previously it would return None. FutureWarning)
OnnxPipeline(steps=[('scaler',
OnnxTransformer(onnx_bytes=b'x08x06x12x08skl2onnxx1ax081.7.1076"x07ai.onnx(x002x00:xf6x01nxa6x01nx01Xx12x08variablex1ax06Scaler"x06Scaler*=nx06offset=>xc3.;=+=xc0;=|xf2xb0<=xcd`xf9>=x89xad3xbd=RLxabxbf=Vxc4Vxbe=6<x9dxc0=B>xa0@=xbbx93xea@xa0x01x06*<nx05scale=ikxb7>=xe8x17,>=)xb5xa9==xa7xd5#==Qx9exa1<=xf5)$<=x90<xa2;=(D%;=axa8xa1:= x9f$:xa0x01x06:nai.onnx.mlx12x1emlprodict_ONNX(StandardScaler)Zx11nx01Xx12x0cnnx08x01x12x06nx00nx02x08nbx18nx08variablex12x0cnnx08x01x12x06nx00nx02x08nBx0ennai.onnx.mlx10x01')),
('dt', DecisionTreeRegressor(max_depth=10))])
We see that the first steps was replaced by an object OnnxTransformer which wraps an ONNX file into a transformer following the scikit-learn API. The initial steps are still available.
model_onx.raw_steps_
[('scaler', StandardScaler()), ('dt', DecisionTreeRegressor(max_depth=10))]
models = [
('bug', Xi_test.astype(numpy.float32), model),
('OnnxPipeline', Xi_test.astype(numpy.float32), model_onx),
]
obs = [dict(runtime='sklearn', diff=0, name='sklearn')]
for name, x32, mod in models:
for runtime in ['python', 'python_compiled', 'onnxruntime1']:
lonx = to_onnx(mod, x32[:1])
loinf = OnnxInference(lonx, runtime=runtime)
y_skl = model_onx.predict(X32) # model_onx is the new baseline
y_onx = loinf.run({'X': X32})['variable']
delta = numpy.abs(y_skl - y_onx.ravel())
am = delta.argmax()
obs.append(dict(runtime=runtime, diff=delta.max(), name=name))
obs[-1]['v[%d]' % am] = y_onx.ravel()[am]
obs[0]['v[%d]' % am] = y_skl.ravel()[am]
df = pandas.DataFrame(obs)
df
| runtime | diff | name | v[2276] | v[1109] | |
|---|---|---|---|---|---|
| 0 | sklearn | 0.000000 | sklearn | 272.784708 | 516.084502 |
| 1 | python | 234.930666 | bug | 37.854042 | NaN |
| 2 | python_compiled | 234.930666 | bug | 37.854042 | NaN |
| 3 | onnxruntime1 | 234.930666 | bug | 37.854042 | NaN |
| 4 | python | 0.000029 | OnnxPipeline | NaN | 516.084473 |
| 5 | python_compiled | 0.000029 | OnnxPipeline | NaN | 516.084473 |
| 6 | onnxruntime1 | 0.000029 | OnnxPipeline | NaN | 516.084473 |
Training the next steps based on ONNX outputs is better. This is not completely satisfactory… Let’s check the accuracy.
model.score(Xi_test, yi_test), model_onx.score(Xi_test, yi_test)
(0.6492778377907853, 0.6536515451871481)
Pretty close.
Final explanation: StandardScalerFloat#
We proposed two ways to have an ONNX pipeline which produces the same
prediction as scikit-learn. Let’s now replace the StandardScaler by a
new one which outputs float and not double. It turns out that class
StandardScaler computes X /= self.scale_ but ONNX does
X *= self.scale_inv_. We need to implement this exact same operator
with float32 to remove all discrepencies.
class StandardScalerFloat(StandardScaler):
def __init__(self, with_mean=True, with_std=True):
StandardScaler.__init__(self, with_mean=with_mean, with_std=with_std)
def fit(self, X, y=None):
StandardScaler.fit(self, X, y)
if self.scale_ is not None:
self.scale_inv_ = (1. / self.scale_).astype(numpy.float32)
return self
def transform(self, X):
X = X.copy()
if self.with_mean:
X -= self.mean_
if self.with_std:
X *= self.scale_inv_
return X
model_float = Pipeline([
('scaler', StandardScalerFloat()),
('dt', DecisionTreeRegressor(max_depth=max_depth))
])
model_float.fit(Xi_train.astype(numpy.float32), yi_train.astype(numpy.float32))
Pipeline(steps=[('scaler', StandardScalerFloat()),
('dt', DecisionTreeRegressor(max_depth=10))])
try:
onx_float = to_onnx(model_float, Xi_test[:1].astype(numpy.float))
except RuntimeError as e:
print(e)
Unable to find a shape calculator for type '<class '__main__.StandardScalerFloat'>'.
It usually means the pipeline being converted contains a
transformer or a predictor with no corresponding converter
implemented in sklearn-onnx. If the converted is implemented
in another library, you need to register
the converted so that it can be used by sklearn-onnx (function
update_registered_converter). If the model is not yet covered
by sklearn-onnx, you may raise an issue to
https://github.com/onnx/sklearn-onnx/issues
to get the converter implemented or even contribute to the
project. If the model is a custom model, a new converter must
be implemented. Examples can be found in the gallery.
We need to register a new converter so that sklearn-onnx knows how to convert the new scaler. We reuse the existing converters.
from skl2onnx import update_registered_converter
from skl2onnx.operator_converters.scaler_op import convert_sklearn_scaler
from skl2onnx.shape_calculators.scaler import calculate_sklearn_scaler_output_shapes
update_registered_converter(
StandardScalerFloat, "SklearnStandardScalerFloat",
calculate_sklearn_scaler_output_shapes,
convert_sklearn_scaler,
options={'div': ['std', 'div', 'div_cast']})
models = [
('bug', Xi_test.astype(numpy.float32), model),
('FloatPipeline', Xi_test.astype(numpy.float32), model_float),
]
obs = [dict(runtime='sklearn', diff=0, name='sklearn')]
for name, x32, mod in models:
for runtime in ['python', 'python_compiled', 'onnxruntime1']:
lonx = to_onnx(mod, x32[:1])
loinf = OnnxInference(lonx, runtime=runtime)
y_skl = model_float.predict(X32) # we use model_float as a baseline
y_onx = loinf.run({'X': X32})['variable']
delta = numpy.abs(y_skl - y_onx.ravel())
am = delta.argmax()
obs.append(dict(runtime=runtime, diff=delta.max(), name=name))
obs[-1]['v[%d]' % am] = y_onx.ravel()[am]
obs[0]['v[%d]' % am] = y_skl.ravel()[am]
df = pandas.DataFrame(obs)
df
| runtime | diff | name | v[1489] | v[1109] | |
|---|---|---|---|---|---|
| 0 | sklearn | 0.000000 | sklearn | 378.038116 | 516.084493 |
| 1 | python | 273.322334 | bug | 104.715782 | NaN |
| 2 | python_compiled | 273.322334 | bug | 104.715782 | NaN |
| 3 | onnxruntime1 | 273.322334 | bug | 104.715782 | NaN |
| 4 | python | 0.000020 | FloatPipeline | NaN | 516.084473 |
| 5 | python_compiled | 0.000020 | FloatPipeline | NaN | 516.084473 |
| 6 | onnxruntime1 | 0.000020 | FloatPipeline | NaN | 516.084473 |
That means than the differences between float32(X / Y) and
float32(X) * float32(1 / Y) are big enough to select a different
path in the decision tree. float32(X) / float32(Y) and
float32(X) * float32(1 / Y) are also different enough to trigger a
different path. Let’s illustrate that on example:
a1 = numpy.random.randn(100, 2) * 10
a2 = a1.copy()
a2[:, 1] *= 1000
a3 = a1.copy()
a3[:, 0] *= 1000
for i, a in enumerate([a1, a2, a3]):
a = a.astype(numpy.float32)
max_diff32 = numpy.max([
numpy.abs(numpy.float32(x[0]) / numpy.float32(x[1]) -
numpy.float32(x[0]) * (numpy.float32(1) / numpy.float32(x[1])))
for x in a])
max_diff64 = numpy.max([
numpy.abs(numpy.float64(x[0]) / numpy.float64(x[1]) -
numpy.float64(x[0]) * (numpy.float64(1) / numpy.float64(x[1])))
for x in a])
print(i, max_diff32, max_diff64)
0 1.9073486e-06 7.105427357601002e-15
1 3.7252903e-09 3.469446951953614e-18
2 0.00390625 7.275957614183426e-12
The last random set shows very big differences, obviously big enough to trigger a different path in the graph. The difference for double could probably be significant in some cases, not enough on this example.
Change the conversion with option div#
Option 'div' was added to the converter for StandardScaler to
change the way the scaler is converted.
model = Pipeline([
('scaler', StandardScaler()),
('dt', DecisionTreeRegressor(max_depth=max_depth))
])
model.fit(Xi_train, yi_train)
Pipeline(steps=[('scaler', StandardScaler()),
('dt', DecisionTreeRegressor(max_depth=10))])
onx_std = to_onnx(model, Xi_train[:1].astype(numpy.float32))
%onnxview onx_std
onx_div = to_onnx(model, Xi_train[:1].astype(numpy.float32),
options={StandardScaler: {'div': 'div'}})
%onnxview onx_div
onx_div_cast = to_onnx(model, Xi_train[:1].astype(numpy.float32),
options={StandardScaler: {'div': 'div_cast'}})
%onnxview onx_div_cast
The ONNX graph is different and using division. Let’s measure the discrepencies.
X32 = Xi_test.astype(numpy.float32)
X64 = Xi_test.astype(numpy.float64)
models = [('bug', model, onx_std),
('div', model, onx_div),
('div_cast', model, onx_div_cast),]
obs = [dict(runtime='sklearn', diff=0, name='sklearn')]
for name, mod, onx in models:
for runtime in ['python', 'python_compiled', 'onnxruntime1']:
oinf = OnnxInference(onx, runtime=runtime)
y_skl32 = mod.predict(X32)
y_skl64 = mod.predict(X64)
y_onx = oinf.run({'X': X32})['variable']
delta32 = numpy.abs(y_skl32 - y_onx.ravel())
am32 = delta32.argmax()
delta64 = numpy.abs(y_skl64 - y_onx.ravel())
am64 = delta64.argmax()
obs.append(dict(runtime=runtime, diff32=delta32.max(),
diff64=delta64.max(), name=name))
obs[0]['v32[%d]' % am32] = y_skl32.ravel()[am32]
obs[0]['v64[%d]' % am64] = y_skl64.ravel()[am64]
obs[-1]['v32[%d]' % am32] = y_onx.ravel()[am32]
obs[-1]['v64[%d]' % am64] = y_onx.ravel()[am64]
df = pandas.DataFrame(obs)
df
| runtime | diff | name | v32[1583] | v64[1246] | v32[1246] | v64[2080] | v64[1109] | diff32 | diff64 | |
|---|---|---|---|---|---|---|---|---|---|---|
| 0 | sklearn | 0.0 | sklearn | -439.590635 | -364.555875 | -203.438616 | 171.604023 | 516.084502 | NaN | NaN |
| 1 | python | NaN | bug | -305.949036 | -203.438614 | NaN | NaN | NaN | 133.641599 | 161.117261 |
| 2 | python_compiled | NaN | bug | -305.949036 | -203.438614 | NaN | NaN | NaN | 133.641599 | 161.117261 |
| 3 | onnxruntime1 | NaN | bug | -305.949036 | -203.438614 | NaN | NaN | NaN | 133.641599 | 161.117261 |
| 4 | python | NaN | div | NaN | NaN | -364.555878 | 329.592377 | NaN | 161.117261 | 157.988354 |
| 5 | python_compiled | NaN | div | NaN | NaN | -364.555878 | 329.592377 | NaN | 161.117261 | 157.988354 |
| 6 | onnxruntime1 | NaN | div | NaN | NaN | -364.555878 | 329.592377 | NaN | 161.117261 | 157.988354 |
| 7 | python | NaN | div_cast | NaN | NaN | -364.555878 | NaN | 516.084473 | 161.117261 | 0.000029 |
| 8 | python_compiled | NaN | div_cast | NaN | NaN | -364.555878 | NaN | 516.084473 | 161.117261 | 0.000029 |
| 9 | onnxruntime1 | NaN | div_cast | NaN | NaN | -364.555878 | NaN | 516.084473 | 161.117261 | 0.000029 |
The only combination which works is the model converted with option div_cast (use of division in double precision), float input for ONNX, double input for scikit-learn.
Explanation in practice#
Based on previous sections, the following example buids a case where discreprencies are significant.
std = StandardScaler()
std.fit(Xi_train)
xt32 = Xi_test.astype(numpy.float32)
xt64 = Xi_test.astype(numpy.float64)
pred = std.transform(xt32)
from onnxruntime import InferenceSession
onx32 = to_onnx(std, Xi_train[:1].astype(numpy.float32))
sess32 = InferenceSession(onx32.SerializeToString())
got32 = sess32.run(0, {'X': xt32})[0]
d32 = numpy.max(numpy.abs(pred.ravel() - got32.ravel()))
d32
2.3841858e-07
oinf32 = OnnxInference(onx32.SerializeToString())
gotpy32 = oinf32.run({'X': xt32})['variable']
dpy32 = numpy.max(numpy.abs(pred.ravel() - gotpy32.ravel()))
dpy32
2.3841858e-07
We tried to cast float into double before applying the normalisation and to cast back into single float. It does not help much.
onx64 = to_onnx(std, Xi_train[:1].astype(numpy.float32),
options={id(std): {'div': 'div'}})
sess64 = InferenceSession(onx64.SerializeToString())
got64 = sess64.run(0, {'X': xt32})[0]
d64 = numpy.max(numpy.abs(pred.ravel() - got64.ravel()))
d64
2.3841858e-07
Last experiment, we try to use double all along.
from onnxruntime.capi.onnxruntime_pybind11_state import InvalidGraph
onx64_2 = to_onnx(std, Xi_train[:1].astype(numpy.float64))
try:
sess64_2 = InferenceSession(onx64_2.SerializeToString())
except InvalidGraph as e:
print(e)
[ONNXRuntimeError] : 10 : INVALID_GRAPH : This is an invalid model. Error in Node:Scaler : Mismatched attribute type in 'Scaler : offset'
onnxruntime does not support this. Let’s switch to mlprodict.
onx64_2 = to_onnx(std, Xi_train[:1].astype(numpy.float64))
sess64_2 = OnnxInference(onx64_2, runtime="python")
pred64 = std.transform(xt64)
got64_2 = sess64_2.run({'X': xt64})['variable']
d64_2 = numpy.max(numpy.abs(pred64.ravel() - got64_2.ravel()))
d64_2
4.440892098500626e-16
Differences are lower if every operator is done with double.
Conclusion#
Maybe the best option is just to introduce a transform which just cast inputs into floats.
model1 = Pipeline([
('scaler', StandardScaler()),
('dt', DecisionTreeRegressor(max_depth=max_depth))
])
model1.fit(Xi_train, yi_train)
Pipeline(steps=[('scaler', StandardScaler()),
('dt', DecisionTreeRegressor(max_depth=10))])
from skl2onnx.sklapi import CastTransformer
model2 = Pipeline([
('cast64', CastTransformer(dtype=numpy.float64)),
('scaler', StandardScaler()),
('cast', CastTransformer()),
('dt', DecisionTreeRegressor(max_depth=max_depth))
])
model2.fit(Xi_train, yi_train)
Pipeline(steps=[('cast64', CastTransformer(dtype=<class 'numpy.float64'>)),
('scaler', StandardScaler()), ('cast', CastTransformer()),
('dt', DecisionTreeRegressor(max_depth=10))])
X32 = Xi_test.astype(numpy.float32)
models = [('model1', model1, X32), ('model2', model2, X32)]
options = [('-', None),
('div_cast', {StandardScaler: {'div': 'div_cast'}})]
obs = [dict(runtime='sklearn', diff=0, name='model1'),
dict(runtime='sklearn', diff=0, name='model2')]
for name, mod, x32 in models:
for no, opts in options:
onx = to_onnx(mod, Xi_train[:1].astype(numpy.float32),
options=opts)
for runtime in ['python', 'python_compiled', 'onnxruntime1']:
try:
oinf = OnnxInference(onx, runtime=runtime)
except Exception as e:
obs.append(dict(runtime=runtime, err=str(e),
name=name, options=no))
continue
y_skl = mod.predict(x32)
try:
y_onx = oinf.run({'X': x32})['variable']
except Exception as e:
obs.append(dict(runtime=runtime, err=str(e),
name=name, options=no))
continue
delta = numpy.abs(y_skl - y_onx.ravel())
am = delta.argmax()
obs.append(dict(runtime=runtime, diff=delta.max(),
name=name, options=no))
obs[-1]['v[%d]' % am] = y_onx.ravel()[am]
if name == 'model1':
obs[0]['v[%d]' % am] = y_skl.ravel()[am]
obs[1]['v[%d]' % am] = model2.predict(Xi_test).ravel()[am]
elif name == 'model2':
obs[0]['v[%d]' % am] = model1.predict(Xi_test).ravel()[am]
obs[1]['v[%d]' % am] = y_skl.ravel()[am]
df = pandas.DataFrame(obs)
df
| runtime | diff | name | v[1583] | v[1246] | v[1109] | options | err | |
|---|---|---|---|---|---|---|---|---|
| 0 | sklearn | 0.000000 | model1 | -439.590635 | -162.952888 | 516.084502 | NaN | NaN |
| 1 | sklearn | 0.000000 | model2 | -439.590635 | -364.555875 | 516.084502 | NaN | NaN |
| 2 | python | 133.641599 | model1 | -305.949036 | NaN | NaN | - | NaN |
| 3 | python_compiled | 133.641599 | model1 | -305.949036 | NaN | NaN | - | NaN |
| 4 | onnxruntime1 | 133.641599 | model1 | -305.949036 | NaN | NaN | - | NaN |
| 5 | python | 201.602989 | model1 | NaN | -364.555878 | NaN | div_cast | NaN |
| 6 | python_compiled | 201.602989 | model1 | NaN | -364.555878 | NaN | div_cast | NaN |
| 7 | onnxruntime1 | 201.602989 | model1 | NaN | -364.555878 | NaN | div_cast | NaN |
| 8 | python | 0.000029 | model2 | NaN | NaN | 516.084473 | - | NaN |
| 9 | python_compiled | 0.000029 | model2 | NaN | NaN | 516.084473 | - | NaN |
| 10 | onnxruntime1 | NaN | model2 | NaN | NaN | NaN | - | Unable to create InferenceSession due to '[ONN... |
| 11 | python | 0.000029 | model2 | NaN | NaN | 516.084473 | div_cast | NaN |
| 12 | python_compiled | 0.000029 | model2 | NaN | NaN | 516.084473 | div_cast | NaN |
| 13 | onnxruntime1 | 0.000029 | model2 | NaN | NaN | 516.084473 | div_cast | NaN |
It seems to work that way.