def __init__(self, model, dataset, norm):
BenchPerfTest.__init__(self)
self.model_name = model
self.dataset_name = dataset
self.datas = common_datasets[dataset]
skl_model = get_model(model)
if norm:
if 'NB' in model:
self.model = make_pipeline(MinMaxScaler(), skl_model)
else:
self.model = make_pipeline(StandardScaler(), skl_model)
else:
self.model = skl_model
self.model.fit(self.datas[0], self.datas[2])
self.data_test = self.datas[1]
if '-cdist' in model:
options = {id(skl_model): {'optim': 'cdist'}}
else:
options = None
self.onx = to_onnx(self.model,
self.datas[0].astype(numpy.float32),
options=options,
target_opset=__max_supported_opset__)
self.onx.ir_version = get_ir_version(__max_supported_opset__)
logger = getLogger("skl2onnx")
logger.propagate = False
logger.disabled = True
self.ort = InferenceSession(self.onx.SerializeToString())
self.oinf = OnnxInference(self.onx, runtime='python')
self.oinfc = OnnxInference(self.onx, runtime='python_compiled')
self.output_name = self.oinf.output_names[-1]
self.input_name = self.ort.get_inputs()[0].name
self.model_info = analyze_model(self.model)
def test_onnxt_runtime_empty(self):
idi = numpy.identity(2, dtype=numpy.float32)
onx = OnnxAdd('X', idi, output_names=['Y'], op_version=TARGET_OPSET)
model_def = onx.to_onnx({'X': idi.astype(numpy.float32)})
model_def.ir_version = get_ir_version(TARGET_OPSET)
oinf = OnnxInference(model_def, runtime='empty')
self.assertNotEmpty(oinf)
def test_kernel_ker2_def_ort(self):
ker = Sum(
CK(0.1, (1e-3, 1e3)) * RBF(length_scale=10,
length_scale_bounds=(1e-3, 1e3)),
CK(0.1, (1e-3, 1e3)) * RBF(length_scale=1,
length_scale_bounds=(1e-3, 1e3)))
onx = convert_kernel(ker, 'X', output_names=['Y'], dtype=numpy.float32,
op_version=TARGET_OPSET)
model_onnx = onx.to_onnx(
inputs=[('X', FloatTensorType([None, None]))],
outputs=[('Y', FloatTensorType([None, None]))],
target_opset=TARGET_OPSET)
model_onnx.ir_version = get_ir_version(TARGET_OPSET)
sess = _capture_output(
lambda: OnnxInference(model_onnx.SerializeToString(),
runtime="onnxruntime2"), 'c')[0]
try:
res = sess.run({'X': Xtest_.astype(numpy.float32)})
except RuntimeError as e:
if "Got invalid dimensions for input" in str(e):
# probable bug somewhere
return
raise e
m1 = res['Y']
m2 = ker(Xtest_)
self.assertEqualArray(m1, m2, decimal=5)
def test_onnxt_runtime_add1(self):
idi = numpy.identity(2, dtype=numpy.float32)
onx = OnnxAdd('X', idi, output_names=['Y3'],
op_version=TARGET_OPSET)
model_def = onx.to_onnx({'X': idi.astype(numpy.float32)})
X = numpy.array([[1, 2], [3, 4]], dtype=numpy.float32)
model_def.ir_version = get_ir_version(TARGET_OPSET)
oinf = OnnxInference(model_def, runtime='onnxruntime1')
got = oinf.run({'X': X})
self.assertEqual(list(sorted(got)), ['Y3'])
self.assertEqualArray(idi + X, got['Y3'], decimal=6)
def test_code_add_except(self):
idi = numpy.identity(2, dtype=numpy.float32)
onx = OnnxAdd('X', idi, output_names=['Y'], op_version=TARGET_OPSET)
model_def = onx.to_onnx({'X': idi.astype(numpy.float32)},
target_opset=TARGET_OPSET)
model_def.ir_version = get_ir_version(TARGET_OPSET)
oinf = OnnxInference(model_def, runtime='onnxruntime1')
try:
oinf.to_python()
except ValueError:
pass
def test_onnxt_runtime_array_feature_extractor_cmp(self):
X = numpy.array([3.3626876, 2.204158, 2.267245, 1.297554, 0.97023404],
dtype=numpy.float32)
indices = numpy.array([[
4,
2,
0,
1,
3,
], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [3, 4, 2, 0, 1], [0, 2, 3, 4, 1]],
dtype=numpy.int64)
onx = OnnxArrayFeatureExtractor('X', indices, output_names=['Y'])
model_def = onx.to_onnx({'X': X.astype(numpy.float32)},
outputs=[('Y', FloatTensorType([2]))])
model_def.ir_version = get_ir_version(TARGET_OPSET)
oinf = OnnxInference(model_def)
got = oinf.run({'X': X})['Y']
model_def.ir_version = get_ir_version(TARGET_OPSET)
oinf2 = OnnxInference(model_def, runtime="onnxruntime2")
got2 = oinf2.run({'X': X})['Y']
self.assertEqualArray(got, got2)
def test_onnxt_runtime_array_feature_extractor_cmp4(self):
X = numpy.random.randn(38, 5).astype( # pylint: disable=E1101
numpy.float32) # pylint: disable=E1101
indices = numpy.ones((38, 1), dtype=numpy.int64)
onx = OnnxArrayFeatureExtractor('X', indices, output_names=['Y'])
model_def = onx.to_onnx({'X': X.astype(numpy.float32)},
outputs=[('Y', FloatTensorType([2]))])
oinf = OnnxInference(model_def)
got = oinf.run({'X': X})['Y']
model_def.ir_version = get_ir_version(TARGET_OPSET)
oinf2 = OnnxInference(model_def, runtime="onnxruntime2")
got2 = oinf2.run({'X': X})['Y']
self.assertEqualArray(got, got2)
def test_model_bernoulli_nb_bc_onnxruntime1(self):
model, X = self.fit_classification_model(BernoulliNB(), 2)
model_onnx = convert_sklearn(
model,
"?", [("input", FloatTensorType([None, X.shape[1]]))],
target_opset=TARGET_OPSET)
exp1 = model.predict(X)
exp = model.predict_proba(X)
model_onnx.ir_version = get_ir_version(TARGET_OPSET)
oinf = _capture_output(
lambda: OnnxInference(model_onnx, runtime='onnxruntime1'), 'c')[0]
got = oinf.run({'input': X})
self.assertEqualArray(exp1, got['output_label'])
got2 = DataFrame(got['output_probability']).values
self.assertEqualArray(exp, got2, decimal=4)
def test_kernel_exp_sine_squared(self):
from skl2onnx.operator_converters.gaussian_process import convert_kernel
ker = ExpSineSquared()
onx = convert_kernel(ker,
'X',
output_names=['Y'],
dtype=numpy.float32,
op_version=10)
model_onnx = onx.to_onnx(inputs=[('X', FloatTensorType([None, None]))])
model_onnx.ir_version = get_ir_version(TARGET_OPSET)
sess = OnnxInference(model_onnx, runtime='onnxruntime1')
Xtest_ = numpy.arange(6).reshape((3, 2))
res = sess.run({'X': Xtest_.astype(numpy.float32)})
m1 = res['Y']
m2 = ker(Xtest_)
self.assertEqualArray(m1, m2, decimal=5)
def test_kernel_rbf1(self):
from skl2onnx.operator_converters.gaussian_process import convert_kernel
ker = RBF(length_scale=1, length_scale_bounds=(1e-3, 1e3))
onx = convert_kernel(ker,
'X',
output_names=['Y'],
dtype=numpy.float32,
op_version=10)
model_onnx = onx.to_onnx(inputs=[('X', FloatTensorType([None, None]))])
model_onnx.ir_version = get_ir_version(TARGET_OPSET)
sess = OnnxInference(model_onnx, runtime='onnxruntime1')
Xtest_ = numpy.arange(6).reshape((3, 2))
res = sess.run({'X': Xtest_.astype(numpy.float32)})
m1 = res['Y']
m2 = ker(Xtest_)
self.assertEqualArray(m1, m2)
def __init__(self, model, dataset, norm):
BenchPerfTest.__init__(self)
self.model_name = model
self.dataset_name = dataset
self.datas = common_datasets[dataset]
skl_model = get_model(model)
if norm:
if 'NB' in model:
self.model = make_pipeline(MinMaxScaler(), skl_model)
else:
self.model = make_pipeline(StandardScaler(), skl_model)
else:
self.model = skl_model
self.model.fit(self.datas[0], self.datas[2])
self.data_test = self.datas[1]
if '-cdist' in model:
options = {id(skl_model): {'optim': 'cdist'}}
elif "-ZM" in model:
options = {id(skl_model): {'zipmap': False}}
else:
options = None
try:
self.onx = to_onnx(self.model,
self.datas[0].astype(numpy.float32),
options=options,
target_opset=__max_supported_opsets__)
self.onx.ir_version = get_ir_version(__max_supported_opset__)
except (RuntimeError, NameError) as e:
raise RuntimeError("Unable to convert model {}.".format(
self.model)) from e
logger = getLogger("skl2onnx")
logger.propagate = False
logger.disabled = True
self.oinf = OnnxInference(self.onx, runtime='python')
self.oinfc = OnnxInference(self.onx, runtime='python_compiled')
try:
self.ort = InferenceSession(self.onx.SerializeToString())
except OrtFail as e:
raise RuntimeError(
"Unable to load model {}\n--SUMMARY--\n{}".format(
self.model, self.oinfc)) from e
self.output_name = self.oinf.output_names[-1]
self.input_name = self.ort.get_inputs()[0].name
self.model_info = analyze_model(self.model)
def generate_onnx_graph(dim, nbnode, input_name='X1'):
"""Generates a series of consecutive scalers."""
matrices = []
scale = list(numpy.ones((1, dim)).ravel())
i1 = input_name
for i in range(nbnode - 1):
i2 = list(-random_binary_classification(1, dim)[0].ravel())
matrices.append(i2)
node = OnnxScaler(i1, offset=i2, scale=scale)
i1 = node
i2 = list(-random_binary_classification(1, dim)[0].ravel())
matrices.append(i2)
node = OnnxScaler(i1, offset=i2, scale=scale, output_names=['Y'])
onx = node.to_onnx([(input_name, FloatTensorType((None, dim)))],
outputs=[('Y', FloatTensorType((None, dim)))])
onx.ir_version = get_ir_version(__max_supported_opset__)
return onx, matrices
def _create_onnx_inference(self, onx, runtime):
if 'onnxruntime' in runtime:
old = onx.ir_version
onx.ir_version = get_ir_version(__max_supported_opset__)
else:
old = None
try:
res = OnnxInference(onx,
runtime=runtime,
runtime_options=dict(log_severity_level=3))
except RuntimeError as e: # pragma: no cover
if "[ONNXRuntimeError]" in str(e):
return RuntimeError("onnxruntime fails due to {}".format(
str(e)))
raise e
if old is not None:
onx.ir_version = old
return res
def generate_onnx_graph(dim, nbnode, input_name='X1'):
"""Generates a series of consecutive additions."""
matrices = []
i1 = input_name
for i in range(nbnode - 1):
i2 = random_binary_classification(1, dim)[0].astype(numpy.float32)
matrices.append(i2)
node = OnnxAdd(i1, i2, op_version=__max_supported_opset__)
i1 = node
i2 = random_binary_classification(1, dim)[0].astype(numpy.float32)
matrices.append(i2)
node = OnnxAdd(i1,
i2,
output_names=['Y'],
op_version=__max_supported_opset__)
onx = node.to_onnx([(input_name, FloatTensorType((None, dim)))],
outputs=[('Y', FloatTensorType((None, dim)))])
onx.ir_version = get_ir_version(__max_supported_opset__)
return onx, matrices
def test_onnx_helper_load_save(self):
model = make_pipeline(StandardScaler(), Binarizer(threshold=0.5))
X = numpy.array([[0.1, 1.1], [0.2, 2.2]])
model.fit(X)
model_onnx = convert_sklearn(
model, 'binarizer', [('input', FloatTensorType([None, 2]))])
model_onnx.ir_version = get_ir_version(TARGET_OPSET)
filename = "temp_onnx_helper_load_save.onnx"
save_onnx_model(model_onnx, filename)
model = load_onnx_model(filename)
list(enumerate_model_node_outputs(model))
new_model = select_model_inputs_outputs(model, 'variable')
self.assertTrue(new_model.graph is not None) # pylint: disable=E1101
tr1 = self.get_model(model)
tr2 = self.get_model(new_model)
X = X.astype(numpy.float32)
X1 = tr1(X)
X2 = tr2(X)
self.assertEqual(X1.shape, (2, 2))
self.assertEqual(X2.shape, (2, 2))
def test_onnxrt_python_one_class_svm(self):
X = numpy.array([[0, 1, 2], [44, 36, 18],
[-4, -7, -5]], dtype=numpy.float32)
with self.subTest(dtype='float64'):
for kernel in ['linear', 'sigmoid', 'rbf', 'poly']:
model = OneClassSVM(kernel=kernel).fit(X)
X64 = X.astype(numpy.float64)
model_onnx = to_onnx(model, X64)
model.decision_function(X64)
self.assertIn("SVMRegressorDouble", str(model_onnx))
oinf = OnnxInference(model_onnx, runtime='python')
res = oinf.run({'X': X64})
scores = res['scores']
dec = model.decision_function(X64)
self.assertEqualArray(scores, dec, decimal=5)
# print("64", kernel + ("-" * (7 - len(kernel))), scores - dec, "skl", dec)
with self.subTest(dtype='floa32'):
for kernel in ['linear', 'sigmoid', 'rbf', 'poly']:
model = OneClassSVM(kernel=kernel).fit(X)
X32 = X.astype(numpy.float32)
model_onnx = to_onnx(model, X32)
oinf = OnnxInference(model_onnx, runtime='python')
res = oinf.run({'X': X32})
scores = res['scores']
dec = model.decision_function(X32)
self.assertEqualArray(scores, dec, decimal=4)
# print("32", kernel + ("-" * (7 - len(kernel))), scores - dec, "skl", dec)
model_onnx.ir_version = get_ir_version(TARGET_OPSET)
oinf = OnnxInference(model_onnx, runtime='onnxruntime1')
res = oinf.run({'X': X32})
scores = res['scores']
dec = model.decision_function(X32)
self.assertEqualArray(scores.ravel(), dec.ravel(), decimal=4)
def onnx_test_knn_single_classreg(self,
dtype,
n_targets=1,
debug=False,
add_noise=False,
runtime='python',
target_opset=None,
optim=None,
kind='reg',
level=1,
largest0=True,
metric_params=None,
**kwargs):
iris = load_iris()
X, y = iris.data, iris.target
if add_noise:
X += numpy.random.randn(X.shape[0], X.shape[1]) * 10
if kind == 'reg':
y = y.astype(dtype)
elif kind == 'bin':
y = (y % 2).astype(numpy.int64)
elif kind == 'mcl':
y = y.astype(numpy.int64)
else:
raise AssertionError("unknown '{}'".format(kind))
if n_targets != 1:
yn = numpy.empty((y.shape[0], n_targets), dtype=dtype)
for i in range(n_targets):
yn[:, i] = y + i
y = yn
X_train, X_test, y_train, _ = train_test_split(X, y, random_state=11)
X_test = X_test.astype(dtype)
if kind in ('bin', 'mcl'):
clr = KNeighborsClassifier(metric_params=metric_params, **kwargs)
elif kind == 'reg':
clr = KNeighborsRegressor(metric_params=metric_params, **kwargs)
else:
raise NotImplementedError(kind)
clr.fit(X_train, y_train)
if optim is None:
options = None
else:
options = {clr.__class__: {'optim': 'cdist'}}
if not largest0:
if options is None:
options = {}
if clr.__class__ not in options:
options[clr.__class__] = {}
options[clr.__class__].update({'largest0': False})
if target_opset is None:
opsets = list(
sorted(set([9, 10, 11, 12, 13, 14, 15,
TARGET_OPSET]))) # opset=13, 14, ...
else:
opsets = [target_opset]
for ops in opsets:
if ops is None:
raise AssertionError("Cannot happen: {}.".format(opsets))
with self.subTest(target_opset=ops):
try:
model_def = to_onnx(clr,
X_train.astype(dtype),
rewrite_ops=True,
target_opset=ops,
options=options)
except NameError as e:
if "Option 'largest0' not in" in str(e):
continue
if 'onnxruntime' in runtime:
model_def.ir_version = get_ir_version(ops)
try:
if runtime == 'onnxruntime2':
oinf = _capture_output(
lambda: OnnxInference(model_def, runtime=runtime), # pylint: disable=W0640
'c')[0]
else:
oinf = OnnxInference(model_def, runtime=runtime)
except (RuntimeError, TypeError, OrtInvalidArgument) as e:
if "No Op registered for Identity with domain_version of 12" in str(
e):
continue
if debug:
raise AssertionError(
"Unable to create a model for target_opset={}\n----\n{}\n----"
.format(ops,
str(model_def)[:100])) from e
if "Unknown model file format version." in str(e):
continue
raise AssertionError(
"Unable to create model for opset={} and runtime='{}'\n{}"
"".format(ops, runtime,
str(model_def)[:100])) from e
if debug:
y = oinf.run({'X': X_test}, verbose=level, fLOG=print)
else:
y = oinf.run({'X': X_test})
lexp = clr.predict(X_test)
if kind == 'reg':
self.assertEqual(list(sorted(y)), ['variable'])
if dtype == numpy.float32:
self.assertEqualArray(lexp,
y['variable'],
decimal=5,
squeeze=True)
else:
self.assertEqualArray(lexp,
y['variable'],
squeeze=True)
else:
self.assertEqual(list(sorted(y)),
['output_label', 'output_probability'])
self.assertEqualArray(lexp, y['output_label'])
lprob = clr.predict_proba(X_test)
self.assertEqualArray(lprob,
DataFrame(
y['output_probability']).values,
decimal=5)
def test_onnxrt_python_lightgbm_categorical_iris_dataframe(self):
from lightgbm import Dataset, train as lgb_train
iris = load_iris()
X, y = iris.data, iris.target
X = (X * 10).astype(numpy.int32)
X_train, X_test, y_train, _ = train_test_split(
X, y, random_state=11)
other_x = numpy.random.randint(
0, high=10, size=(1500, X_train.shape[1]))
X_train = numpy.vstack([X_train, other_x]).astype(dtype=numpy.int32)
y_train = numpy.hstack(
[y_train, numpy.zeros(500) + 3, numpy.zeros(500) + 4,
numpy.zeros(500) + 5]).astype(dtype=numpy.int32)
self.assertEqual(y_train.shape, (X_train.shape[0], ))
y_train = y_train % 2
df_train = pandas.DataFrame(X_train)
df_train.columns = ['c1', 'c2', 'c3', 'c4']
df_train['c1'] = df_train['c1'].astype('category')
df_train['c2'] = df_train['c2'].astype('category')
df_train['c3'] = df_train['c3'].astype('category')
df_train['c4'] = df_train['c4'].astype('category')
df_test = pandas.DataFrame(X_test)
df_test.columns = ['c1', 'c2', 'c3', 'c4']
df_test['c1'] = df_test['c1'].astype('category')
df_test['c2'] = df_test['c2'].astype('category')
df_test['c3'] = df_test['c3'].astype('category')
df_test['c4'] = df_test['c4'].astype('category')
# categorical_feature=[0, 1]
train_data = Dataset(
df_train, label=y_train)
params = {
"boosting_type": "gbdt", "learning_rate": 0.05,
"n_estimators": 2, "objective": "binary",
"max_bin": 5, "min_child_samples": 100,
'verbose': -1}
booster = lgb_train(params, train_data)
exp = booster.predict(X_test)
onx = to_onnx(booster, df_train, target_opset=TARGET_OPSET)
self.assertIn('ZipMap', str(onx))
oif = OnnxInference(onx)
got = oif.run(df_test)
values = pandas.DataFrame(got['output_probability']).values
self.assertEqualArray(exp, values[:, 1], decimal=5)
onx.ir_version = get_ir_version(TARGET_OPSET)
oif = OnnxInference(onx, runtime='onnxruntime1')
got = oif.run(df_test)
values = pandas.DataFrame(got['output_probability']).values
self.assertEqualArray(exp, values[:, 1], decimal=5)
onx = to_onnx(booster, df_train,
options={booster.__class__: {'cast': True}},
target_opset=TARGET_OPSET)
self.assertIn('op_type: "Cast"', str(onx))
oif = OnnxInference(onx)
got = oif.run(df_test)
values = pandas.DataFrame(got['output_probability']).values
self.assertEqualArray(exp, values[:, 1], decimal=5)
def test_gradient_boosting_regressor_pipeline(self):
fLOG(__file__,
self._testMethodName,
OutputPrint=__name__ == "__main__")
random_seed = 123
df = load_audit()
train, test = train_test_split(df,
test_size=0.2,
random_state=random_seed)
target_feature = 'TARGET_Adjusted'
y_train = train[target_feature]
x_train = train.drop(target_feature, axis=1, inplace=False)
y_test = test[target_feature]
x_test = test.drop(target_feature, axis=1, inplace=False)
cols = list(x_train.columns)
numerical_cols = list(x_train._get_numeric_data().columns) # pylint: disable=W0212
categorical_cols = list(set(cols) - set(numerical_cols))
n_trees = 50
max_depth = 10
predictor = Pipeline([
('prep',
ColumnTransformer([('num_prep', StandardScaler(), numerical_cols),
('cat_prep',
OneHotEncoder(handle_unknown='ignore'),
categorical_cols)])),
('model',
GradientBoostingClassifier(learning_rate=0.01,
random_state=random_seed,
n_estimators=n_trees,
max_depth=max_depth))
])
predictor.fit(x_train, y_train)
fLOG('accuracy: ' + str(predictor.score(x_test, y_test)))
sklearn_predictions = DataFrame(predictor.predict(x_test),
columns=['sklearn_prediction'])
def convert_dataframe_schema(df, drop=None):
inputs = []
for k, v in zip(df.columns, df.dtypes):
if drop is not None and k in drop:
continue
# also ints treated as floats otherwise onnx exception "all columns must be equal" is raised.
if v in ('int64', 'float64'):
t = FloatTensorType([None, 1])
else:
t = StringTensorType([None, 1])
inputs.append((k, t))
return inputs
model_name = 'gbt_audit'
inputs = convert_dataframe_schema(x_train)
try:
model_onnx = convert_sklearn(predictor, model_name, inputs)
except Exception as e:
raise AssertionError("Unable to convert model %r (version=%r)." %
(predictor, skl2onnx_version)) from e
data = {
col[0]: x_test[col[0]].values.reshape(x_test.shape[0], 1)
for col in inputs
}
for col in numerical_cols:
data[col] = data[col].astype(numpy.float32)
for runtime in [
'python', 'python_compiled', 'onnxruntime1', 'onnxruntime2'
]:
if runtime == 'onnxruntime2':
# Type for text column are guessed wrong
# (Float instead of text).
continue
if 'onnxruntime' in runtime:
model_onnx.ir_version = get_ir_version(__max_supported_opset__)
sess = OnnxInference(model_onnx, runtime=runtime)
onnx_predictions = sess.run(data)
onnx_predictions = DataFrame(
{'onnx_prediction': onnx_predictions['output_label']})
fLOG('Model accuracy in SKlearn = ' +
str(accuracy_score(y_test, sklearn_predictions.values)))
fLOG('Model accuracy in ONNX = ' +
str(accuracy_score(y_test, onnx_predictions)))
fLOG()
fLOG('predicted class distribution from SKLearn')
fLOG(sklearn_predictions['sklearn_prediction'].value_counts())
fLOG()
fLOG('predicted class distribution from ONNX')
fLOG(onnx_predictions['onnx_prediction'].value_counts())
fLOG()
df = concat([sklearn_predictions, onnx_predictions], axis=1)
df["diff"] = df["sklearn_prediction"] - df["onnx_prediction"]
df["diff_abs"] = numpy.abs(df["diff"])
total = df.sum()
sum_diff = total["diff_abs"]
if sum_diff != 0:
raise AssertionError(
"Runtime: '{}', discrepencies: sum_diff={}"
"".format(runtime, sum_diff))
def test_kernel_ker2_def_python(self):
ker = Sum(
CK(0.1, (1e-3, 1e3)) * RBF(length_scale=10,
length_scale_bounds=(1e-3, 1e3)),
CK(0.1, (1e-3, 1e3)) * RBF(length_scale=1,
length_scale_bounds=(1e-3, 1e3))
)
onx = convert_kernel(ker, 'X', output_names=['Y'], dtype=numpy.float32,
op_version=TARGET_OPSET)
model_onnx = onx.to_onnx(
inputs=[('X', FloatTensorType([None, None]))],
outputs=[('Y', FloatTensorType([None, None]))],
target_opset=TARGET_OPSET)
model_onnx.ir_version = get_ir_version(TARGET_OPSET)
sess = OnnxInference(model_onnx.SerializeToString(),
runtime="python", inplace=False)
rows = []
def myprint(*args, **kwargs):
rows.append(" ".join(map(str, args)))
res = sess.run({'X': Xtest_.astype(numpy.float32)},
intermediate=True, verbose=1, fLOG=myprint)
self.assertGreater(len(rows), 2)
m1 = res['Y']
self.assertNotEmpty(m1)
self.assertGreater(len(res), 2)
# m2 = ker(Xtest_)
# self.assertEqualArray(m1, m2, decimal=5)
cpu = OnnxInference(model_onnx.SerializeToString())
self.assertRaise(
lambda: side_by_side_by_values(
[cpu, sess], inputs={'X': Xtest_.astype(numpy.float32)}),
ValueError)
cpu = OnnxInference(model_onnx.SerializeToString(), inplace=False)
sbs = side_by_side_by_values(
[cpu, sess], inputs={'X': Xtest_.astype(numpy.float32)})
self.assertGreater(len(sbs), 2)
self.assertIsInstance(sbs, list)
self.assertIsInstance(sbs[0], dict)
self.assertIn('step', sbs[0])
self.assertIn('step', sbs[1])
self.assertIn('metric', sbs[0])
self.assertIn('metric', sbs[1])
self.assertIn('cmp', sbs[0])
self.assertIn('cmp', sbs[1])
self.assertIn('order[0]', sbs[1])
self.assertEqual(sbs[1]['order[0]'], 0)
sess3 = _capture_output(
lambda: OnnxInference(
model_onnx.SerializeToString(), runtime="onnxruntime2",
inplace=False), 'c')[0]
try:
sbs = side_by_side_by_values(
[cpu, sess, sess3], inputs={'X': Xtest_.astype(numpy.float32)})
except RuntimeError as e:
if "Got invalid dimensions for input" in str(e):
# probable bug somewhere
return
raise e
self.assertNotEmpty(sbs)
inputs = {'X': Xtest_.astype(numpy.float32)}
sbs = side_by_side_by_values(
[(cpu, inputs), (sess, inputs), (sess3, inputs)])
self.assertNotEmpty(sbs)
sbs, res = side_by_side_by_values(
[(cpu, inputs), (sess, inputs), (sess3, inputs)], return_results=True)
self.assertNotEmpty(sbs)
self.assertNotEmpty(res)
self.assertIsInstance(res, list)
self.assertEqual(len(res), 3)
self.assertIsInstance(res[0], list)
self.assertIsInstance(res[0][0], tuple)
def onnx_test_svm_single_classreg(self,
dtype,
n_targets=1,
debug=False,
add_noise=False,
runtime='python',
target_opset=None,
kind='reg',
level=1,
**kwargs):
iris = load_iris()
X, y = iris.data, iris.target
if add_noise:
X += numpy.random.randn(X.shape[0], X.shape[1]) * 10
if kind == 'reg':
y = y.astype(dtype)
elif kind == 'bin':
y = (y % 2).astype(numpy.int64)
elif kind == 'mcl':
y = y.astype(numpy.int64)
else:
raise AssertionError("unknown '{}'".format(kind))
if n_targets != 1:
yn = numpy.empty((y.shape[0], n_targets), dtype=dtype)
for i in range(n_targets):
yn[:, i] = y + i
y = yn
X_train, X_test, y_train, _ = train_test_split(X, y, random_state=11)
X_test = X_test.astype(dtype)
if kind in ('bin', 'mcl'):
clr = SVC(**kwargs)
elif kind == 'reg':
clr = SVR(**kwargs)
clr.fit(X_train, y_train)
model_def = to_onnx(clr,
X_train.astype(dtype),
rewrite_ops=True,
target_opset=target_opset)
if 'onnxruntime' in runtime:
model_def.ir_version = get_ir_version(target_opset)
try:
oinf = OnnxInference(model_def, runtime=runtime)
except RuntimeError as e:
if debug:
raise RuntimeError(
"Unable to create a model\n{}".format(model_def)) from e
raise e
if debug:
y = oinf.run({'X': X_test}, verbose=level, fLOG=print)
else:
y = oinf.run({'X': X_test})
lexp = clr.predict(X_test)
if kind == 'reg':
self.assertEqual(list(sorted(y)), ['variable'])
if dtype == numpy.float32:
self.assertEqualArray(lexp.ravel(),
y['variable'].ravel(),
decimal=5)
else:
self.assertEqualArray(lexp, y['variable'], decimal=5)
else:
self.assertEqual(list(sorted(y)),
['output_label', 'output_probability'])
self.assertEqualArray(lexp, y['output_label'])
lprob = clr.predict_proba(X_test)
self.assertEqualArray(lprob,
DataFrame(y['output_probability']).values,
decimal=5)
