def test_validate_sklearn_operators_all_onnxruntime(self):
fLOG(__file__, self._testMethodName, OutputPrint=__name__ == "__main__")
logger = getLogger('skl2onnx')
logger.disabled = True
verbose = 1 if __name__ == "__main__" else 0
temp = get_temp_folder(
__file__, "temp_validate_sklearn_operators_all_onnxruntime2")
if False: # pylint: disable=W0125
rows = list(enumerate_validated_operator_opsets(
verbose, models={"LogisticRegression"},
fLOG=fLOG,
runtime='onnxruntime2', debug=True))
else:
rows = []
for row in enumerate_validated_operator_opsets(
verbose, debug=None, fLOG=fLOG, runtime='onnxruntime2',
benchmark=False, dump_folder=temp,
filter_exp=lambda m, s: m not in {AdaBoostRegressor,
GaussianProcessClassifier}):
rows.append(row)
if len(rows) > 30:
break
self.assertGreater(len(rows), 1)
df = DataFrame(rows)
self.assertGreater(df.shape[1], 1)
fLOG("output results")
df.to_csv(os.path.join(temp, "sklearn_opsets_report.csv"), index=False)
df.to_excel(os.path.join(
temp, "sklearn_opsets_report.xlsx"), index=False)
piv = summary_report(df)
piv.to_excel(os.path.join(
temp, "sklearn_opsets_summary.xlsx"), index=False)
def test_validate_sklearn_operators_all(self):
fLOG(__file__,
self._testMethodName,
OutputPrint=__name__ == "__main__")
logger = getLogger('skl2onnx')
logger.disabled = True
verbose = 1 if __name__ == "__main__" else 0
temp = get_temp_folder(__file__, "temp_validate_sklearn_operators_all")
if False: # pylint: disable=W0125
rows = list(
enumerate_validated_operator_opsets(verbose,
models={"RFE"},
opset_min=10,
debug=True,
fLOG=fLOG))
else:
rows = list(
enumerate_validated_operator_opsets(verbose,
debug=None,
fLOG=fLOG,
dump_folder=temp))
self.assertGreater(len(rows), 1)
df = DataFrame(rows)
self.assertGreater(df.shape[1], 1)
fLOG("output results")
df.to_csv(os.path.join(temp, "sklearn_opsets_report.csv"), index=False)
df.to_excel(os.path.join(temp, "sklearn_opsets_report.xlsx"),
index=False)
def test_validate_sklearn_operators_all(self):
fLOG(__file__,
self._testMethodName,
OutputPrint=__name__ == "__main__")
logger = getLogger('skl2onnx')
logger.disabled = True
verbose = 1 if __name__ == "__main__" else 0
temp = get_temp_folder(__file__, "temp_validate_sklearn_operators_all")
if False: # pylint: disable=W0125
rows = list(
enumerate_validated_operator_opsets(
verbose,
models={"DecisionTreeClassifier"},
filter_exp=lambda m, p: '64' not in p,
debug=True,
fLOG=fLOG))
else:
rows = list(
enumerate_validated_operator_opsets(
verbose,
debug=None,
fLOG=fLOG,
dump_folder=temp,
time_kwargs={TARGET_OPSET: dict(number=2, repeat=2)},
models={"DecisionTreeClassifier", "LinearRegression"},
n_features=[None]))
self.assertGreater(len(rows), 1)
df = DataFrame(rows)
self.assertGreater(df.shape[1], 1)
fLOG("output results")
df.to_csv(os.path.join(temp, "sklearn_opsets_report.csv"), index=False)
df.to_excel(os.path.join(temp, "sklearn_opsets_report.xlsx"),
index=False)
def common_test_rt_knn_regressor(self, prob='b-reg', classifier=False, debug=True):
fLOG(__file__, self._testMethodName, OutputPrint=__name__ == "__main__")
logger = getLogger('skl2onnx')
logger.disabled = True
verbose = 2 if __name__ == "__main__" else 0
buffer = []
def myprint(*args, **kwargs):
buffer.append(" ".join(map(str, args)))
def fil(m, p, s, e, o):
if o == [{}] or o == {}: # pylint: disable=R1714
return False
if "kdt_" in s:
return False
if "-64" not in p and prob in p:
return True
return False
model = "KNeighborsClassifier" if classifier else "KNeighborsRegressor"
try:
rows = list(enumerate_validated_operator_opsets(
verbose, models={model},
fLOG=myprint, fail_bad_results=False,
runtime='python', debug=debug, extended_list=True,
store_models=True, opset_min=11, opset_max=11,
filter_scenario=lambda m, p, s, e, o: fil(m, p, s, e, o)))
except RuntimeBadResultsError as e:
obs = e.obs
exp = obs['lambda-skl'][0](obs['lambda-skl'][1])
got = obs['lambda-batch'][0](obs['lambda-batch'][1])
diff = numpy.abs(exp - got['variable'])
best = numpy.argmax(diff)
f1 = obs['lambda-skl'][1][best:best + 1]
f2 = obs['lambda-batch'][1][best:best + 1]
exp = obs['lambda-skl'][0](f1)
got = obs['lambda-batch'][0](f2)
model = obs['MODEL']
oinf = obs['OINF']
got = oinf.run({'X': f2}, verbose=3, fLOG=print)
exp = model.predict(f1.astype(numpy.float32))
rows = [str(f1), str(f2), str(got), str(exp)]
raise RuntimeError("\n-----\n".join(rows)) from e
except RuntimeError:
list(enumerate_validated_operator_opsets(
1, models={model},
fLOG=print, fail_bad_results=False,
runtime='python', debug=debug, extended_list=True,
store_models=True, opset_min=11, opset_max=11,
filter_scenario=lambda m, p, s, e, o: fil(m, p, s, e, o)))
self.assertGreater(len(rows), 1)
self.assertGreater(len(buffer), 1 if debug else 0)
def test_rt_OneVsRestClassifier_python(self):
fLOG(__file__, self._testMethodName, OutputPrint=__name__ == "__main__")
logger = getLogger('skl2onnx')
logger.disabled = True
verbose = 1 if __name__ == "__main__" else 0
debug = False
buffer = []
def myprint(*args, **kwargs):
buffer.append(" ".join(map(str, args)))
rows = list(enumerate_validated_operator_opsets(
verbose, models={"OneVsRestClassifier"}, opset_min=9,
opset_max=11, fLOG=myprint, benchmark=True,
runtime='python', debug=debug,
filter_exp=lambda m, p: True or 'm-cl' in p))
self.assertGreater(len(rows), 1)
self.assertIn('skl_nop', rows[0])
self.assertIn('onx_size', rows[-1])
piv = summary_report(DataFrame(rows))
self.assertGreater(piv.shape[0], 1)
self.assertGreater(piv.shape[0], 2)
common, subsets = split_columns_subsets(piv)
rst = df2rst(piv, number_format=2,
replacements={'nan': '', 'ERR: 4convert': ''},
split_row=lambda index, dp=piv: build_key_split(
dp.loc[index, "name"], index),
split_col_common=common,
split_col_subsets=subsets,
filter_rows=filter_rows,
column_size={'problem': 25},
label_pattern=".. _lpy-{section}:")
self.assertIn("opset9 | RT/SKL-N=1", rst)
def test_rt_select_python(self):
fLOG(__file__,
self._testMethodName,
OutputPrint=__name__ == "__main__")
logger = getLogger('skl2onnx')
logger.disabled = True
verbose = 1 if __name__ == "__main__" else 0
debug = True
buffer = []
def myprint(*args, **kwargs):
buffer.append(" ".join(map(str, args)))
rows = list(
enumerate_validated_operator_opsets(
verbose,
models={
"SelectPercentile",
"SelectKBest",
"SelectFwe",
"SelectFdr",
"SelectFpr",
"SelectFromModel",
},
fLOG=myprint,
runtime='python',
debug=debug,
filter_exp=lambda m, p: '-64' not in p))
self.assertGreater(len(rows), 1)
self.assertGreater(len(buffer), 1 if debug else 0)
def test_rt_svr_python_rbf(self):
fLOG(__file__,
self._testMethodName,
OutputPrint=__name__ == "__main__")
logger = getLogger('skl2onnx')
logger.disabled = True
verbose = 1 if __name__ == "__main__" else 0
buffer = []
def myprint(*args, **kwargs):
buffer.append(" ".join(map(str, args)))
debug = True
rows = list(
enumerate_validated_operator_opsets(
verbose,
models={"SVR"},
fLOG=myprint,
benchmark=False,
n_features=[45],
runtime='python',
debug=debug,
filter_exp=lambda m, p: "64" not in p,
filter_scenario=lambda m, p, s, e, t: "rbf" in str(e)))
self.assertGreater(len(rows), 1)
self.assertGreater(len(buffer), 1 if debug else 0)
def test_benchmark_replay_onnxruntime(self):
temp = get_temp_folder(__file__, "temp_bct_ort")
self.assertRaise(
lambda: list(
enumerate_benchmark_replay(temp, runtime='onnxruntime1')),
FileNotFoundError)
res = list(
enumerate_validated_operator_opsets(
0,
fLOG=None,
models={"LogisticRegression"},
opset_min=11,
opset_max=11,
benchmark=False,
store_models=True,
dump_all=True,
dump_folder=temp,
filter_exp=lambda m, p:
("64" not in p and "b-cl" in p and "dec" not in p)))
self.assertNotEmpty(res)
res.clear()
rows = list(
enumerate_benchmark_replay(temp, runtime='onnxruntime', verbose=0))
df = pandas.DataFrame(rows)
self.assertEqual(df.shape, (4, 39))
self.assertIn('1000-skl-details', df.columns)
self.assertIn('1000-skl', df.columns)
def test_rt_HistGradientBoostingRegressor_python64_compiled(self):
fLOG(__file__,
self._testMethodName,
OutputPrint=__name__ == "__main__")
logger = getLogger('skl2onnx')
logger.disabled = True
verbose = 2 if __name__ == "__main__" else 0
debug = True
buffer = []
pps = []
def pp(p):
pps.append(p)
return p
def myprint(*args, **kwargs):
buffer.append(" ".join(map(str, args)))
rows = list(
enumerate_validated_operator_opsets(
verbose,
models={"HistGradientBoostingRegressor"},
opset_min=-1,
fLOG=myprint,
runtime='python_compiled',
debug=debug,
filter_exp=lambda m, p: pp(p) == '~b-reg-64'))
if len(rows) == 0:
raise AssertionError("Empty rows: {}".format(pps))
def test_rt_CalibratedClassifierCV_onnxruntime(self):
fLOG(__file__,
self._testMethodName,
OutputPrint=__name__ == "__main__")
logger = getLogger('skl2onnx')
logger.disabled = True
verbose = 1 if __name__ == "__main__" else 0
buffer = []
def myprint(*args, **kwargs):
buffer.append(" ".join(map(str, args)))
rows = list(
enumerate_validated_operator_opsets(
verbose,
models={"CalibratedClassifierCV"},
opset_min=11,
fLOG=myprint,
runtime='python',
debug=True,
filter_scenario=lambda m, p, sc, ex, ex2: 'sgd' in sc))
self.assertGreater(len(rows), 1)
self.assertGreater(len(buffer), 1)
maxv = max(row['max_rel_diff_batch'] for row in rows)
self.assertLesser(maxv, 1e-5)
def test_validate_pyrt_ort2(self):
fLOG(__file__,
self._testMethodName,
OutputPrint=__name__ == "__main__")
logger = getLogger('skl2onnx')
logger.disabled = True
verbose = 0 if __name__ == "__main__" else 0
rows = list(
enumerate_validated_operator_opsets(
verbose,
models={"LinearRegression"},
fLOG=fLOG,
runtime=['python', 'onnxruntime1'],
debug=False,
filter_exp=lambda m, p: '-64' not in p,
benchmark=True,
n_features=[None, 10]))
df = DataFrame(rows)
piv = summary_report(df)
import matplotlib.pyplot as plt
fig, ax = plot_validate_benchmark(piv)
if __name__ == "__main__":
plt.show()
plt.clf()
self.assertNotEmpty(fig)
self.assertNotEmpty(ax)
def test_validate_sklearn_one_hot_encoder(self):
fLOG(__file__,
self._testMethodName,
OutputPrint=__name__ == "__main__")
logger = getLogger('skl2onnx')
logger.disabled = True
verbose = 1 if __name__ == "__main__" else 0
temp = get_temp_folder(__file__, "temp_validate_one_hot_encoder")
rows = list(
enumerate_validated_operator_opsets(verbose,
models={"OneHotEncoder"},
filter_exp=lambda m, p: True,
debug=False,
fLOG=fLOG,
dump_folder=temp,
benchmark=True))
self.assertGreater(len(rows), 1)
df = DataFrame(rows)
self.assertGreater(df.shape[1], 1)
fLOG("output results")
data = os.path.join(temp, "sklearn_opsets_report.csv")
df.to_csv(data, index=False)
df = read_csv(data)
piv = summary_report(df)
self.assertGreater(piv.shape[0], 1)
self.assertGreater(piv.shape[1], 10)
self.assertIn('OneHotEncoder', set(piv['name']))
piv.to_csv(os.path.join(temp, "sklearn_opsets_summary.csv"),
index=False)
piv.to_excel(os.path.join(temp, "sklearn_opsets_summary.xlsx"),
index=False)
def test_validate_Voting(self):
fLOG(__file__,
self._testMethodName,
OutputPrint=__name__ == "__main__")
logger = getLogger('skl2onnx')
logger.disabled = True
verbose = 1 if __name__ == "__main__" else 0
rows = list(
enumerate_validated_operator_opsets(verbose,
models={
"VotingRegressor",
"VotingClassifier",
'LinearRegression'
},
opset_min=9,
fLOG=fLOG,
runtime='python',
debug=False))
self.assertGreater(len(rows), 4)
df = DataFrame(rows)
piv = summary_report(df)
reg = piv[piv.name == 'VotingRegressor']
self.assertGreater(reg.shape[0], 1)
nonan = reg['opset10'].dropna()
self.assertEqual(nonan.shape[0], reg.shape[0])
def test_rt_DecisionTreeRegressor_python_100(self):
fLOG(__file__,
self._testMethodName,
OutputPrint=__name__ == "__main__")
logger = getLogger('skl2onnx')
logger.disabled = True
verbose = 2 if __name__ == "__main__" else 0
debug = True
buffer = []
def myprint(*args, **kwargs):
buffer.append(" ".join(map(str, args)))
rows = list(
enumerate_validated_operator_opsets(
verbose,
models={"DecisionTreeRegressor"},
fLOG=myprint,
runtime='python',
debug=debug,
store_models=True,
filter_exp=lambda m, p: '-f100' in p))
self.assertGreater(len(buffer), 1 if debug else 0)
row = rows[0]
init = row['init_types'][0][1]
self.assertEqual(init.shape, (1, 100))
def test_rt_DecisionTreeRegressor_python(self):
fLOG(__file__,
self._testMethodName,
OutputPrint=__name__ == "__main__")
logger = getLogger('skl2onnx')
logger.disabled = True
verbose = 1 if __name__ == "__main__" else 0
debug = False
buffer = []
def myprint(*args, **kwargs):
buffer.append(" ".join(map(str, args)))
rows = list(
enumerate_validated_operator_opsets(
verbose,
models={"Perceptron"},
opset_min=11,
fLOG=myprint,
runtime='python',
debug=debug,
filter_exp=lambda m, p: '-64' not in p))
self.assertGreater(len(rows), 1)
self.assertGreater(len(buffer), 1 if debug else 0)
def test_rt_dict_vectorizer(self):
fLOG(__file__,
self._testMethodName,
OutputPrint=__name__ == "__main__")
logger = getLogger('skl2onnx')
logger.disabled = True
verbose = 1 if __name__ == "__main__" else 0
buffer = []
def myprint(*args, **kwargs):
buffer.append(" ".join(map(str, args)))
debug = True
rows = list(
enumerate_validated_operator_opsets(
verbose,
models={"DictVectorizer"},
opset_min=11,
fLOG=myprint,
runtime='python',
debug=debug,
benchmark=True,
filter_exp=lambda m, p: "64" not in p))
self.assertGreater(len(rows), 1)
self.assertGreater(len(buffer), 1 if debug else 0)
def test_rt_KMeans_python(self):
fLOG(__file__, self._testMethodName, OutputPrint=__name__ == "__main__")
logger = getLogger('skl2onnx')
logger.disabled = True
verbose = 2 if __name__ == "__main__" else 0
debug = False
buffer = []
def myprint(*args, **kwargs):
buffer.append(" ".join(map(str, args)))
rows = list(enumerate_validated_operator_opsets(
verbose, models={"KMeans"}, opset_min=11,
opset_max=11, fLOG=myprint,
runtime='python', debug=debug))
self.assertGreater(len(rows), 1)
self.assertIn('skl_nop', rows[-1])
keys = set()
for row in rows:
keys.update(set(row))
self.assertIn('onx_size', keys)
piv = summary_report(DataFrame(rows))
opset = [c for c in piv.columns if 'opset' in c]
self.assertTrue('opset11' in opset or 'opset10' in opset)
self.assertGreater(len(buffer), 1 if debug else 0)
common, subsets = split_columns_subsets(piv)
try:
conv = df2rst(piv, split_col_common=common, # pylint: disable=E1123
split_col_subsets=subsets)
self.assertIn('| KMeans |', conv)
except TypeError as e:
if "got an unexpected keyword argument 'split_col_common'" in str(e):
return
raise e
def test_validate_pyrt_ort(self):
fLOG(__file__,
self._testMethodName,
OutputPrint=__name__ == "__main__")
logger = getLogger('skl2onnx')
logger.disabled = True
verbose = 1 if __name__ == "__main__" else 0
temp = get_temp_folder(__file__, "temp_validate_pyrt_ort")
rows = list(
enumerate_validated_operator_opsets(
verbose,
models={"LinearRegression"},
fLOG=fLOG,
runtime=['python', 'onnxruntime1'],
debug=False,
filter_exp=lambda m, p: '-64' not in p,
benchmark=True,
n_features=[None, 10]))
self.assertGreater(len(rows), 1)
df = DataFrame(rows)
self.assertGreater(df.shape[1], 1)
fLOG("output results")
df.to_csv(os.path.join(temp, "sklearn_opsets_report.csv"), index=False)
df.to_excel(os.path.join(temp, "sklearn_opsets_report.xlsx"),
index=False)
piv = summary_report(df)
piv.to_excel(os.path.join(temp, "sklearn_opsets_summary.xlsx"),
index=False)
rts = set(piv['runtime'])
self.assertEqual(rts, {'python', 'onnxruntime1'})
nfs = set(piv['n_features'])
self.assertEqual(nfs, {4, 10})
def test_rt_lightgbm_classifier64(self):
fLOG(__file__,
self._testMethodName,
OutputPrint=__name__ == "__main__")
logger = getLogger('skl2onnx')
logger.disabled = True
verbose = 1 if __name__ == "__main__" else 0
debug = True
buffer = []
def myprint(*args, **kwargs):
buffer.append(" ".join(map(str, args)))
try:
rows = list(
enumerate_validated_operator_opsets(
verbose,
models={"LGBMClassifier"},
fLOG=myprint,
runtime='python',
debug=debug,
extended_list=True,
filter_exp=lambda m, p: "-64" in p))
except json.decoder.JSONDecodeError:
# weird
return
self.assertGreater(len(rows), 1)
self.assertGreater(len(buffer), 1 if debug else 0)
def test_rt_lightgbm_regressor64(self):
fLOG(__file__,
self._testMethodName,
OutputPrint=__name__ == "__main__")
logger = getLogger('skl2onnx')
logger.disabled = True
verbose = 1 if __name__ == "__main__" else 0
debug = True
buffer = []
def myprint(*args, **kwargs):
buffer.append(" ".join(map(str, args)))
rows = list(
enumerate_validated_operator_opsets(
verbose,
models={"LGBMRegressor"},
opset_min=11,
fLOG=myprint,
runtime='python',
debug=debug,
extended_list=True,
filter_exp=lambda m, p: "-64" in p))
self.assertGreater(len(rows), 1)
self.assertGreater(len(buffer), 1 if debug else 0)
def test_rt_GaussianProcessRegressor_python_nofit(self):
fLOG(__file__,
self._testMethodName,
OutputPrint=__name__ == "__main__")
logger = getLogger('skl2onnx')
logger.disabled = True
verbose = 1 if __name__ == "__main__" else 0
buffer = []
def myprint(*args, **kwargs):
buffer.append(" ".join(map(str, args)))
debug = False
rows = list(
enumerate_validated_operator_opsets(
verbose,
models={"GaussianProcessRegressor"},
opset_min=11,
fLOG=myprint,
runtime='python',
debug=debug,
filter_exp=lambda m, s: "NF" in s))
self.assertGreater(len(rows), 6)
self.assertGreater(len(buffer), 1 if debug else 0)
def test_rt_GaussianProcessRegressor_debug_std(self):
fLOG(__file__, self._testMethodName, OutputPrint=__name__ == "__main__")
logger = getLogger('skl2onnx')
logger.disabled = True
verbose = 4
buffer = []
def myprint(*args, **kwargs):
buffer.append(" ".join(map(str, args)))
def filter_scenario(a, b, c, d, e):
if isinstance(e, dict) and GaussianProcessRegressor in e:
opt = e[GaussianProcessRegressor]
if opt.get('optim', '') == 'cdist':
return False
return True
debug = True
rows = list(enumerate_validated_operator_opsets(
verbose, models={"GaussianProcessRegressor"},
fLOG=myprint,
runtime='onnxruntime1', debug=debug,
filter_exp=lambda m, s: "b-reg-std-NSV" in s,
filter_scenario=filter_scenario))
self.assertGreater(len(rows), 1)
self.assertGreater(len(buffer), 1 if debug else 0)
def test_rt_LinearClassifier_python_feat20(self):
fLOG(__file__,
self._testMethodName,
OutputPrint=__name__ == "__main__")
logger = getLogger('skl2onnx')
logger.disabled = True
verbose = 1 if __name__ == "__main__" else 0
debug = False
buffer = []
def myprint(*args, **kwargs):
buffer.append(" ".join(map(str, args)))
rows = list(
enumerate_validated_operator_opsets(
verbose,
models={"LogisticRegression"},
fLOG=myprint,
runtime='python',
debug=debug,
n_features=20,
filter_exp=lambda m, p: '-64' not in p))
self.assertGreater(len(rows), 1)
self.assertGreater(len(buffer), 1 if debug else 0)
for row in rows:
lb = row['lambda-batch']
m = lb[1]
self.assertEqual(m.shape[1], 20)
def test_rt_tfidftransformer_onnxruntime1(self):
fLOG(__file__,
self._testMethodName,
OutputPrint=__name__ == "__main__")
logger = getLogger('skl2onnx')
logger.disabled = True
verbose = 1 if __name__ == "__main__" else 0
debug = False
buffer = []
def myprint(*args, **kwargs):
buffer.append(" ".join(map(str, args)))
rows = list(
enumerate_validated_operator_opsets(verbose,
models={"TfidfTransformer"},
fLOG=myprint,
runtime='onnxruntime1',
debug=debug,
filter_exp=lambda m, p: True))
self.assertGreater(len(rows), 1)
self.assertIn('skl_nop', rows[0])
self.assertIn('onx_size', rows[-1])
piv = summary_report(DataFrame(rows))
self.assertGreater(piv.shape[0], 1)
def test_validate_sklearn_operators_onnxruntime_KMeans(self):
fLOG(__file__,
self._testMethodName,
OutputPrint=__name__ == "__main__")
logger = getLogger('skl2onnx')
logger.disabled = True
verbose = 1 if __name__ == "__main__" else 0
buffer = []
def myprint(*args, **kwargs):
buffer.append(" ".join(map(str, args)))
op = TARGET_OPSET
rows = list(
enumerate_validated_operator_opsets(
verbose,
models={"KMeans"},
fLOG=myprint,
runtime='onnxruntime2',
debug=True,
filter_exp=lambda m, p: '-64' not in p,
opset_min=op,
opset_max=op))
self.assertGreater(len(rows), 1)
def test_rt_DecisionTreeRegressor_python_64(self):
fLOG(__file__,
self._testMethodName,
OutputPrint=__name__ == "__main__")
logger = getLogger('skl2onnx')
logger.disabled = True
verbose = 2 if __name__ == "__main__" else 0
debug = True
buffer = []
def myprint(*args, **kwargs):
buffer.append(" ".join(map(str, args)))
rows = list(
enumerate_validated_operator_opsets(
verbose,
models={"DecisionTreeRegressor"},
fLOG=myprint,
runtime='python',
debug=debug,
store_models=True,
filter_exp=lambda m, p: '-64' in p))
rows = [row for row in rows if 'OK' not in row['available']]
available = [row['available'] for row in rows]
if len(available) > 0:
import pprint
raise AssertionError(
"The runtime did have an issue with double\n{}".format(
pprint.pformat(rows)))
self.assertGreater(len(buffer), 1 if debug else 0)
def test_validate_sklearn_operators_benchmark(self):
fLOG(__file__,
self._testMethodName,
OutputPrint=__name__ == "__main__")
logger = getLogger('skl2onnx')
logger.disabled = True
verbose = 1 if __name__ == "__main__" else 0
temp = get_temp_folder(__file__,
"temp_validate_sklearn_operators_benchmark")
rows = list(
enumerate_validated_operator_opsets(verbose,
models={"LinearRegression"},
opset_min=10,
benchmark=True,
fLOG=fLOG))
self.assertGreater(len(rows), 1)
df = DataFrame(rows)
for col in ['skl', 'batch']:
self.assertIn('lambda-' + col, df.columns)
for col in ['1', '10']:
self.assertIn('time-ratio-N=' + col, df.columns)
self.assertGreater(df.shape[1], 1)
self.assertGreater(df.loc[0, "tostring_time"], 0)
piv = summary_report(df)
self.assertGreater(piv.shape[1], 1)
self.assertIn('RT/SKL-N=1', piv.columns)
self.assertNotIn('RT/SKL-N=10', piv.columns)
self.assertIn('N=10', piv.columns)
fLOG("output results")
df.to_excel(os.path.join(temp, "sklearn_opsets_report.xlsx"),
index=False)
piv.to_excel(os.path.join(temp, "sklearn_opsets_summary.xlsx"),
index=False)
def test_validate_sklearn_operators_dump_all(self):
fLOG(__file__,
self._testMethodName,
OutputPrint=__name__ == "__main__")
logger = getLogger('skl2onnx')
logger.disabled = True
verbose = 1 if __name__ == "__main__" else 0
temp = get_temp_folder(__file__,
"temp_validate_sklearn_operators_dump_all")
self.assertRaise(
lambda: list(
enumerate_validated_operator_opsets(
verbose,
models={"DecisionTreeClassifier"},
filter_exp=lambda m, p: '64' not in p,
fLOG=fLOG,
dump_all=True)), ValueError)
rows = list(
enumerate_validated_operator_opsets(
verbose,
models={"DecisionTreeClassifier"},
filter_exp=lambda m, p: '64' not in p,
fLOG=fLOG,
dump_all=True,
dump_folder=temp))
self.assertGreater(len(rows), 1)
df = DataFrame(rows)
self.assertGreater(df.shape[1], 1)
fLOG("output results")
df.to_csv(os.path.join(temp, "sklearn_opsets_report.csv"), index=False)
df.to_excel(os.path.join(temp, "sklearn_opsets_report.xlsx"),
index=False)
stored = os.path.join(
temp,
("dump-i-python-DecisionTreeClassifier-default-b-cl-tree._classes."
"DecisionTreeClassifierzipmapFalse-op%d-nf4.pkl" %
get_opset_number_from_onnx()))
with open(stored, "rb") as f:
obj = pickle.load(f)
self.assertIn('onnx_bytes', obj)
self.assertIn('skl_model', obj)
self.assertIn('X_test', obj)
self.assertIn('Xort_test', obj)
def test_validate_sklearn_operators_node_time(self):
fLOG(__file__, self._testMethodName, OutputPrint=__name__ == "__main__")
logger = getLogger('skl2onnx')
logger.disabled = True
verbose = 1 if __name__ == "__main__" else 0
rows = list(enumerate_validated_operator_opsets(
verbose, models={"LogisticRegression"}, opset_min=10,
debug=False, node_time=True, fLOG=fLOG))
self.assertNotEmpty(rows)
for row in rows:
self.assertIn('bench-batch', row)
self.assertIsInstance(row['bench-batch'], list)
self.assertNotEmpty(row['bench-batch'])
def test_rt_PowerTransformer(self):
debug = True
buffer = []
def myprint(*args, **kwargs):
buffer.append(" ".join(map(str, args)))
rows = list(
enumerate_validated_operator_opsets(verbose=0,
models={"PowerTransformer"},
fLOG=myprint,
runtime='python',
debug=debug))
self.assertGreater(len(rows), 1)
self.assertGreater(len(buffer), 1 if debug else 0)