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)