def test_model_voting_regression(self):
model, X = fit_regression_model(model_to_test())
model_onnx = convert_sklearn(
model, "voting regression",
[("input", FloatTensorType([None, X.shape[1]]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(X.astype(numpy.float32),
model,
model_onnx,
basename="SklearnVotingRegressor-Dec4",
allow_failure="StrictVersion("
"onnxruntime.__version__)"
"<= StrictVersion('0.2.1')",
comparable_outputs=[0])
def test_convert_svr_int(self):
model, X = fit_regression_model(SVR(), is_int=True)
model_onnx = convert_sklearn(
model,
"SVR", [("input", Int64TensorType([None, X.shape[1]]))],
target_opset=TARGET_OPSET)
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
basename="SklearnSVRInt-Dec4",
allow_failure="StrictVersion(onnxruntime.__version__)"
" <= StrictVersion('0.2.1')")
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_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_model_ransac_regressor_tree(self):
model, X = fit_regression_model(
linear_model.RANSACRegressor(
base_estimator=GradientBoostingRegressor()))
model_onnx = convert_sklearn(
model,
"ransac regressor",
[("input", FloatTensorType([None, X.shape[1]]))],
target_opset=TARGET_OPSET)
self.assertIsNotNone(model_onnx)
dump_data_and_model(X,
model,
model_onnx,
verbose=False,
basename="SklearnRANSACRegressorTree-Dec3")
def test_model_ransac_regressor_mlp(self):
model, X = fit_regression_model(
linear_model.RANSACRegressor(
base_estimator=MLPRegressor(solver='sgd', max_iter=20)))
model_onnx = convert_sklearn(
model,
"ransac regressor",
[("input", FloatTensorType([None, X.shape[1]]))],
target_opset=TARGET_OPSET)
self.assertIsNotNone(model_onnx)
dump_data_and_model(X,
model,
model_onnx,
verbose=False,
basename="SklearnRANSACRegressorMLP-Dec3")
def test_gpr_rbf_fitted_true(self):
gp = GaussianProcessRegressor(alpha=1e-5,
n_restarts_optimizer=25,
normalize_y=True)
gp, X = fit_regression_model(gp)
# return_cov=False, return_std=False
model_onnx = to_onnx(
gp, initial_types=[('X', DoubleTensorType([None, None]))],
target_opset=TARGET_OPSET)
self.assertTrue(model_onnx is not None)
dump_data_and_model(X.astype(np.float64), gp, model_onnx,
verbose=False,
basename="SklearnGaussianProcessRBFTDouble")
def test_model_linear_svr(self):
model, X = fit_regression_model(LinearSVR())
model_onnx = convert_sklearn(
model, "linear SVR",
[("input", FloatTensorType([None, X.shape[1]]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
basename="SklearnLinearSvr-Dec4",
allow_failure="StrictVersion("
"onnxruntime.__version__)"
"<= StrictVersion('0.2.1')",
)
def test_model_theilsen(self):
model, X = fit_regression_model(linear_model.TheilSenRegressor())
model_onnx = convert_sklearn(
model, "thiel-sen regressor",
[("input", FloatTensorType([None, X.shape[1]]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
basename="SklearnTheilSen-Dec4",
allow_failure="StrictVersion("
"onnxruntime.__version__)"
"<= StrictVersion('0.2.1')",
)
def test_model_mlp_regressor_identity(self):
model, X_test = fit_regression_model(MLPRegressor(
random_state=42, activation="identity"),
is_int=True)
model_onnx = convert_sklearn(
model,
"scikit-learn MLPRegressor",
[("input", Int64TensorType([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="SklearnMLPRegressorIdentityActivation-Dec4")
def test_bagging_regressor_bool(self):
model, X = fit_regression_model(
BaggingRegressor(), is_bool=True)
model_onnx = convert_sklearn(
model,
"bagging regressor",
[("input", BooleanTensorType([None, X.shape[1]]))],
target_opset=TARGET_OPSET,
)
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
basename="SklearnBaggingRegressorBool-Dec4")
def test_bagging_regressor_default(self):
model, X = fit_regression_model(
BaggingRegressor())
model_onnx = convert_sklearn(
model,
"bagging regressor",
[("input", FloatTensorType([None, X.shape[1]]))],
target_opset=TARGET_OPSET
)
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
basename="SklearnBaggingRegressorDefault-Dec4")
def test_model_voting_regression(self):
# Could not find an implementation for the node Sum:Sum(8)
model = VotingRegressor([('lr', LinearRegression()),
('dt', SGDRegressor())])
model, X = fit_regression_model(model)
model_onnx = convert_sklearn(
model,
"voting regression",
[("input", DoubleTensorType([None, X.shape[1]]))],
target_opset=TARGET_OPSET)
dump_data_and_model(X.astype(np.float64),
model,
model_onnx,
basename="SklearnVotingRegressorDouble",
comparable_outputs=[0])
def test_grid_search_gaussian_regressor_double(self):
tuned_parameters = [{'alpha': np.logspace(-4, -0.5, 4)}]
clf = GridSearchCV(GaussianProcessRegressor(), tuned_parameters, cv=3)
model, X = fit_regression_model(clf)
model_onnx = convert_sklearn(
model,
"GridSearchCV", [("input", DoubleTensorType([None, X.shape[1]]))],
target_opset=TARGET_OPSET)
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X.astype(np.float64),
model,
model_onnx,
basename="SklearnGridSearchGaussianRegressionDouble"
"-OneOffArray-Dec4")
def test_model_elastic_net_regressor_int(self):
model, X = fit_regression_model(linear_model.ElasticNet(), is_int=True)
model_onnx = convert_sklearn(
model, "elastic net regression",
[("input", Int64TensorType([None, X.shape[1]]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
basename="SklearnElasticNetRegressorInt-Dec4",
allow_failure="StrictVersion("
"onnxruntime.__version__)"
"<= StrictVersion('0.2.1')",
)
def test_model_bayesian_ridge_return_std_normalize(self):
model, X = fit_regression_model(
linear_model.BayesianRidge(normalize=True),
n_features=2, n_samples=50)
model_onnx = convert_sklearn(
model, "bayesian ridge",
[("input", FloatTensorType([None, X.shape[1]]))],
options={linear_model.BayesianRidge: {'return_std': True}})
self.assertIsNotNone(model_onnx)
sess = InferenceSession(model_onnx.SerializeToString())
outputs = sess.run(None, {'input': X})
pred, std = model.predict(X, return_std=True)
assert_almost_equal(pred, outputs[0].ravel(), decimal=4)
assert_almost_equal(std, outputs[1].ravel(), decimal=4)
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')",
)
def test_model_linear_regression64(self):
model, X = fit_regression_model(linear_model.LinearRegression())
model_onnx = convert_sklearn(model, "linear regression",
[("input", DoubleTensorType(X.shape))])
self.assertIsNotNone(model_onnx)
self.assertIn("elem_type: 11", str(model_onnx))
dump_data_and_model(
X.astype(numpy.float64),
model,
model_onnx,
basename="SklearnLinearRegression64-Dec4",
allow_failure="StrictVersion("
"onnxruntime.__version__)"
"<= StrictVersion('0.2.1')",
)
def test_model_bayesian_ridge(self):
model, X = fit_regression_model(linear_model.BayesianRidge())
model_onnx = convert_sklearn(
model, "bayesian ridge",
[("input", FloatTensorType([None, X.shape[1]]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
basename="SklearnBayesianRidge-Dec4",
allow_failure="StrictVersion("
"onnxruntime.__version__)"
"<= StrictVersion('0.2.1')",
)
def test_model_ard_regression(self):
model, X = fit_regression_model(linear_model.ARDRegression())
model_onnx = convert_sklearn(
model, "ard regression",
[("input", FloatTensorType([None, X.shape[1]]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
basename="SklearnARDRegression-Dec3",
allow_failure="StrictVersion("
"onnxruntime.__version__)"
"<= StrictVersion('0.2.1')",
)
def test_convert_nusvr_int(self):
model, X = fit_regression_model(NuSVR(), is_int=True)
model_onnx = convert_sklearn(
model,
"NuSVR",
[("input", Int64TensorType(X.shape))],
)
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
basename="SklearnNuSVRInt-Dec4",
allow_failure="StrictVersion(onnxruntime.__version__)"
" <= StrictVersion('0.2.1')")
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]]))],
)
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_regressor_int(self):
model, X = fit_regression_model(
GradientBoostingRegressor(random_state=42), is_int=True)
model_onnx = convert_sklearn(
model, "gradient boosting regression",
[("input", Int64TensorType([None, X.shape[1]]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
basename="SklearnGradientBoostingRegressionInt-Dec4",
allow_failure="StrictVersion(onnxruntime.__version__)"
" <= StrictVersion('0.2.1')"
)
def test_model_voting_regression_int(self):
model, X = fit_regression_model(model_to_test(), is_int=True)
model_onnx = convert_sklearn(
model,
"voting regression",
[("input", Int64TensorType([None, X.shape[1]]))],
target_opset=TARGET_OPSET)
self.assertIsNotNone(model_onnx)
dump_data_and_model(X,
model,
model_onnx,
basename="SklearnVotingRegressorInt-Dec4",
allow_failure="StrictVersion("
"onnxruntime.__version__)"
"<= StrictVersion('0.2.1')",
comparable_outputs=[0])
def test_model_mlpregressor_64(self):
# Could not find an implementation for the node Relu:Relu(6)
# Could not find an implementation for the node Tanh:Tanh(6)
# Could not find an implementation for the node Sigmoid:Sigmoid(6)
for activation in ['relu', 'tanh', 'logistic']:
with self.subTest(activation=activation):
model, X = fit_regression_model(
MLPRegressor(activation=activation))
model_onnx = convert_sklearn(
model, "linear regression",
[("input", DoubleTensorType([None, X.shape[1]]))],
target_opset=TARGET_OPSET)
self.assertIn("elem_type: 11", str(model_onnx))
dump_data_and_model(
X.astype(np.float64), model, model_onnx,
basename="SklearnMLPRegressorDouble%s" % activation)
def test_decision_tree_regressor_int(self):
model, X = fit_regression_model(
DecisionTreeRegressor(random_state=42), is_int=True)
model_onnx = convert_sklearn(
model,
"decision tree regression",
[("input", Int64TensorType([None, X.shape[1]]))],
)
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
basename="SklearnDecisionTreeRegressionInt",
allow_failure="StrictVersion(onnxruntime.__version__)"
" <= StrictVersion('0.2.1')")
def test_bagging_regressor_gradient_boosting(self):
model, X = fit_regression_model(
BaggingRegressor(GradientBoostingRegressor(n_estimators=10)))
model_onnx = convert_sklearn(
model,
"bagging regressor",
[("input", FloatTensorType([None, X.shape[1]]))],
target_opset=TARGET_OPSET)
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
basename="SklearnBaggingRegressorGradientBoosting-Dec4",
allow_failure="StrictVersion(onnxruntime.__version__)"
"<= StrictVersion('0.2.1')")
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]]))],
)
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
basename="SklearnExtraTreeRegressionBool-Dec4",
allow_failure="StrictVersion(onnxruntime.__version__)"
" <= StrictVersion('0.2.1')")
def test_gradient_boosting_regressor_lad_loss(self):
model, X = fit_regression_model(
GradientBoostingRegressor(n_estimators=3, loss="lad"))
model_onnx = convert_sklearn(
model,
"gradient boosting regression",
[("input", FloatTensorType(X.shape))],
)
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
basename="SklearnGradientBoostingRegressionLadLoss",
allow_failure="StrictVersion(onnxruntime.__version__)"
" <= StrictVersion('0.2.1')")
def test_random_forest_regressor_int(self):
model, X = fit_regression_model(RandomForestRegressor(n_estimators=5,
random_state=42),
is_int=True)
model_onnx = convert_sklearn(
model,
"random forest regression",
[("input", Int64TensorType([None, X.shape[1]]))],
target_opset=TARGET_OPSET)
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
basename="SklearnRandomForestRegressorInt-Dec4",
)
