def test_model_ridge_bool(self):
model, X = fit_regression_model(Ridge(), is_bool=True)
model_onnx = convert_sklearn(
model, "ridge regression",
[("input", BooleanTensorType([None, X.shape[1]]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(X, model, model_onnx, basename="SklearnRidgeBool")
def test_onnxrt_python_lightgbm_categorical(self):
X = pandas.DataFrame({
"A":
numpy.random.permutation(['a', 'b', 'c', 'd'] * 75), # str
# int
"B":
numpy.random.permutation([1, 2, 3] * 100),
# float
"C":
numpy.random.permutation([0.1, 0.2, -0.1, -0.1, 0.2] * 60),
# bool
"D":
numpy.random.permutation([True, False] * 150),
"E":
pandas.Categorical(numpy.random.permutation(
['z', 'y', 'x', 'w', 'v'] * 60),
ordered=True)
}) # str and ordered categorical
y = numpy.random.permutation([0, 1] * 150)
X_test = pandas.DataFrame({
"A":
numpy.random.permutation(['a', 'b', 'e'] * 20), # unseen category
"B":
numpy.random.permutation([1, 3] * 30),
"C":
numpy.random.permutation([0.1, -0.1, 0.2, 0.2] * 15),
"D":
numpy.random.permutation([True, False] * 30),
"E":
pandas.Categorical(numpy.random.permutation(['z', 'y'] * 30),
ordered=True)
})
cat_cols_actual = ["A", "B", "C", "D"]
X[cat_cols_actual] = X[cat_cols_actual].astype('category')
X_test[cat_cols_actual] = X_test[cat_cols_actual].astype('category')
gbm0 = LGBMClassifier().fit(X, y)
exp = gbm0.predict(X_test, raw_scores=False)
self.assertNotEmpty(exp)
init_types = [('A', StringTensorType()), ('B', Int64TensorType()),
('C', FloatTensorType()), ('D', BooleanTensorType()),
('E', StringTensorType())]
self.assertRaise(lambda: to_onnx(gbm0, initial_types=init_types),
RuntimeError, "at most 1 input(s) is(are) supported")
X = X[['C']].values.astype(numpy.float32)
X_test = X_test[['C']].values.astype(numpy.float32)
gbm0 = LGBMClassifier().fit(X, y, categorical_feature=[0])
exp = gbm0.predict_proba(X_test, raw_scores=False)
model_def = to_onnx(gbm0, X)
self.assertIn('ZipMap', str(model_def))
oinf = OnnxInference(model_def)
y = oinf.run({'X': X_test})
self.assertEqual(list(sorted(y)),
['output_label', 'output_probability'])
df = pandas.DataFrame(y['output_probability'])
self.assertEqual(df.shape, (X_test.shape[0], 2))
self.assertEqual(exp.shape, (X_test.shape[0], 2))
def test_convert_nusvr_bool(self):
model, X = fit_regression_model(NuSVR(), is_bool=True)
model_onnx = convert_sklearn(
model,
"NuSVR", [("input", BooleanTensorType([None, X.shape[1]]))],
target_opset=TARGET_OPSET)
self.assertIsNotNone(model_onnx)
dump_data_and_model(X, model, model_onnx, basename="SklearnNuSVRBool")
def build_ort_where(op_version=12):
node = OnnxWhere('cond', 'x', 'y', op_version=op_version,
output_names=['z'])
onx = node.to_onnx(inputs=[('cond', BooleanTensorType()),
('x', FloatTensorType()),
('y', FloatTensorType())],
target_opset=op_version)
sess = InferenceSession(onx.SerializeToString())
return lambda cond, x, y: sess.run(None, {'cond': cond, 'x': x, 'y': y})
def test_model_lasso_lars_bool(self):
model, X = fit_regression_model(LassoLars(), is_bool=True)
model_onnx = convert_sklearn(
model, "lasso lars",
[("input", BooleanTensorType([None, X.shape[1]]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(X,
model,
model_onnx,
basename="SklearnLassoLarsBool")
def test_model_elastic_net_regressor_bool(self):
model, X = fit_regression_model(ElasticNet(), is_bool=True)
model_onnx = convert_sklearn(
model, "elastic net regression",
[("input", BooleanTensorType([None, X.shape[1]]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(X,
model,
model_onnx,
basename="SklearnElasticNetRegressorBool")
def test_model_sgd_regressor_bool(self):
model, X = fit_regression_model(SGDRegressor(), is_bool=True)
model_onnx = convert_sklearn(
model, "SGD regression",
[("input", BooleanTensorType([None, X.shape[1]]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(X,
model,
model_onnx,
basename="SklearnSGDRegressorBool-Dec4")
def test_gradient_boosting_bool(self):
model, X = fit_classification_model(
GradientBoostingClassifier(n_estimators=4), 5, is_bool=True)
model_onnx = convert_sklearn(
model, "gradient boosting classifier",
[("input", BooleanTensorType([None, X.shape[1]]))],
target_opset=TARGET_OPSET)
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X, model, model_onnx,
basename="SklearnGradientBoostingBool")
def test_model_logistic_regression_cv_bool(self):
model, X = fit_classification_model(
linear_model.LogisticRegressionCV(max_iter=100), 3, is_bool=True)
model_onnx = convert_sklearn(
model, "logistic regression cv",
[("input", BooleanTensorType([None, X.shape[1]]))],
target_opset=TARGET_OPSET)
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X, model, model_onnx,
basename="SklearnLogitisticRegressionCVBool")
def test_gradient_boosting_regressor_bool(self):
model, X = fit_regression_model(
GradientBoostingRegressor(random_state=42), is_bool=True)
model_onnx = convert_sklearn(
model, "gradient boosting regressor",
[("input", BooleanTensorType([None, X.shape[1]]))],
target_opset=TARGET_OPSET)
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X, model, model_onnx,
basename="SklearnGradientBoostingRegressorBool-Dec4")
def test_model_gaussian_nb_multiclass_bool(self):
model, X = fit_classification_model(GaussianNB(), 5, is_bool=True)
model_onnx = convert_sklearn(
model,
"gaussian naive bayes",
[("input", BooleanTensorType([None, X.shape[1]]))],
target_opset=TARGET_OPSET)
dump_data_and_model(X,
model,
model_onnx,
basename="SklearnMclGaussianNBBool-Dec4")
def test_model_bernoulli_nb_binary_classification_bool(self):
model, X = fit_classification_model(BernoulliNB(), 2, is_bool=True)
model_onnx = convert_sklearn(
model,
"bernoulli naive bayes",
[("input", BooleanTensorType([None, X.shape[1]]))],
target_opset=TARGET_OPSET)
dump_data_and_model(X,
model,
model_onnx,
basename="SklearnBinBernoulliNBBool")
def test_model_voting_regression_bool(self):
model, X = fit_regression_model(model_to_test(), is_bool=True)
model_onnx = convert_sklearn(
model, "voting regression",
[("input", BooleanTensorType([None, X.shape[1]]))],
target_opset=TARGET_OPSET)
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X, model, model_onnx,
basename="SklearnVotingRegressorBool",
comparable_outputs=[0])
def test_model_ridge_classifier_cv_bool(self):
model, X = fit_classification_model(
linear_model.RidgeClassifierCV(), 2, is_bool=True)
model_onnx = convert_sklearn(
model, "binary ridge classifier cv",
[("input", BooleanTensorType([None, X.shape[1]]))],
target_opset=TARGET_OPSET)
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X, model, model_onnx,
basename="SklearnRidgeClassifierCVBool")
def test_model_linear_svc_bool(self):
model, X = fit_classification_model(
LinearSVC(max_iter=100), 5, is_bool=True)
model_onnx = convert_sklearn(
model, "multi-class linear SVC",
[("input", BooleanTensorType([None, X.shape[1]]))],
target_opset=TARGET_OPSET)
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X, model, model_onnx,
basename="SklearnLinearSVCBool")
def type_for_column(column: pd.Series):
if column.dtype in ['float64', 'float32']:
return FloatTensorType([None, 1])
if column.dtype in ['int64']:
return Int64TensorType([None, 1])
if column.dtype in ['bool']:
return BooleanTensorType([None, 1])
if column.dtype in ['O']:
return StringTensorType([None, 1])
raise ValueError(
'Unexpected column dtype for {column.name}:{column.dtype}'.format(
column=column))
def test_gradient_boosting_regressor_bool(self):
model, X = fit_regression_model(
GradientBoostingRegressor(random_state=42), is_bool=True)
model_onnx = convert_sklearn(
model, "gradient boosting regressor",
[("input", BooleanTensorType([None, X.shape[1]]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X, model, model_onnx,
basename="SklearnGradientBoostingRegressorBool-Dec4",
allow_failure="StrictVersion(onnxruntime.__version__)"
" <= StrictVersion('0.2.1')")
def test_ada_boost_classifier_bool(self):
model, X_test = fit_classification_model(
AdaBoostClassifier(random_state=42), 3, is_bool=True)
model_onnx = convert_sklearn(
model,
"AdaBoost classification",
[("input", BooleanTensorType((None, X_test.shape[1])))],
target_opset=10)
self.assertIsNotNone(model_onnx)
dump_data_and_model(X_test,
model,
model_onnx,
basename="SklearnAdaBoostClassifierBool")
def test_model_mlp_regressor_bool(self):
model, X_test = fit_regression_model(MLPRegressor(random_state=42),
is_bool=True)
model_onnx = convert_sklearn(
model,
"scikit-learn MLPRegressor",
[("input", BooleanTensorType([None, X_test.shape[1]]))],
target_opset=TARGET_OPSET)
self.assertTrue(model_onnx is not None)
dump_data_and_model(X_test,
model,
model_onnx,
basename="SklearnMLPRegressorBool")
def test_extra_tree_regressor_bool(self):
model, X = fit_regression_model(ExtraTreeRegressor(random_state=42),
is_bool=True)
model_onnx = convert_sklearn(
model,
"extra tree regressor",
[("input", BooleanTensorType([None, X.shape[1]]))],
target_opset=TARGET_OPSET)
self.assertIsNotNone(model_onnx)
dump_data_and_model(X,
model,
model_onnx,
basename="SklearnExtraTreeRegressionBool-Dec4")
def test_model_linear_regression_bool(self):
model, X = fit_regression_model(linear_model.LinearRegression(),
is_bool=True)
model_onnx = convert_sklearn(
model,
"linear regression",
[("input", BooleanTensorType([None, X.shape[1]]))],
target_opset=TARGET_OPSET)
self.assertIsNotNone(model_onnx)
dump_data_and_model(X,
model,
model_onnx,
basename="SklearnLinearRegressionBool")
def test_model_voting_regression_bool(self):
model, X = fit_regression_model(model_to_test(), is_bool=True)
model_onnx = convert_sklearn(
model, "voting regression",
[("input", BooleanTensorType([None, X.shape[1]]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(X,
model,
model_onnx,
basename="SklearnVotingRegressorBool",
allow_failure="StrictVersion("
"onnxruntime.__version__)"
"<= StrictVersion('0.2.1')",
comparable_outputs=[0])
def test_model_multinomial_nb_binary_classification_bool(self):
model, X = fit_classification_model(MultinomialNB(),
2,
is_bool=True,
pos_features=True)
model_onnx = convert_sklearn(
model,
"multinomial naive bayes",
[("input", BooleanTensorType([None, X.shape[1]]))],
target_opset=TARGET_OPSET)
dump_data_and_model(X,
model,
model_onnx,
basename="SklearnBinMultinomialNBBool-Dec4")
def test_random_forest_regressor_bool(self):
model, X = fit_regression_model(RandomForestRegressor(n_estimators=5,
random_state=42),
is_bool=True)
model_onnx = convert_sklearn(
model,
"random forest regression",
[("input", BooleanTensorType([None, X.shape[1]]))],
target_opset=TARGET_OPSET)
self.assertIsNotNone(model_onnx)
dump_data_and_model(X,
model,
model_onnx,
basename="SklearnRandomForestRegressorBool-Dec4")
def test_model_complement_nb_multiclass_bool(self):
model, X = fit_classification_model(ComplementNB(),
5,
is_bool=True,
pos_features=True)
model_onnx = convert_sklearn(
model,
"complement naive bayes",
[("input", BooleanTensorType([None, X.shape[1]]))],
target_opset=TARGET_OPSET)
dump_data_and_model(X,
model,
model_onnx,
basename="SklearnMclComplementNBBool-Dec4")
def test_convert_nusvr_bool(self):
model, X = fit_regression_model(NuSVR(), is_bool=True)
model_onnx = convert_sklearn(
model,
"NuSVR", [("input", BooleanTensorType([None, X.shape[1]]))],
target_opset=TARGET_OPSET)
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
basename="SklearnNuSVRBool",
allow_failure="StrictVersion(onnxruntime.__version__)"
" <= StrictVersion('0.2.1')")
def test_gradient_boosting_bool(self):
model, X = fit_classification_model(
GradientBoostingClassifier(n_estimators=4), 5, is_bool=True)
model_onnx = convert_sklearn(
model, "gradient boosting classifier",
[("input", BooleanTensorType([None, X.shape[1]]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
basename="SklearnGradientBoostingBool",
allow_failure="StrictVersion(onnxruntime.__version__)"
"<= StrictVersion('0.2.1')",
)
def test_ada_boost_regressor_bool(self):
model, X = fit_regression_model(AdaBoostRegressor(learning_rate=0.5,
random_state=42),
is_bool=True)
model_onnx = convert_sklearn(
model,
"AdaBoost regression",
[("input", BooleanTensorType([None, X.shape[1]]))],
target_opset=10,
)
self.assertIsNotNone(model_onnx)
dump_data_and_model(X,
model,
model_onnx,
basename="SklearnAdaBoostRegressorBool")
def test_extra_trees_classifier_bool(self):
model, X = fit_classification_model(ExtraTreesClassifier(
n_estimators=5, random_state=42),
2,
is_bool=True)
model_onnx = convert_sklearn(
model,
"extra trees regression",
[("input", BooleanTensorType([None, X.shape[1]]))],
target_opset=TARGET_OPSET)
self.assertIsNotNone(model_onnx)
dump_data_and_model(X,
model,
model_onnx,
basename="SklearnExtraTreesClassifierBool")
def test_model_lasso_lars_bool(self):
model, X = fit_regression_model(linear_model.LassoLars(), is_bool=True)
model_onnx = convert_sklearn(
model, "lasso lars",
[("input", BooleanTensorType([None, X.shape[1]]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
basename="SklearnLassoLarsBool",
allow_failure="StrictVersion("
"onnxruntime.__version__)"
"<= StrictVersion('0.2.1')",
)
