def test_random_forest_classifier_fit2_string(self):
res = fit_classification_model(ExtraTreesClassifier(),
n_classes=2,
label_string=True)
self.assertEqual(len(res), 2)
self.assertIsInstance(res[0], ExtraTreesClassifier)
self.assertIsInstance(res[1], numpy.ndarray)
def test_model_bernoulli_nb_binary_classification(self):
model, X = fit_classification_model(BernoulliNB(), 2)
model_onnx = convert_sklearn(
model,
"bernoulli naive bayes",
[("input", FloatTensorType([None, X.shape[1]]))],
target_opset=TARGET_OPSET)
dump_data_and_model(X, model, model_onnx, "SklearnBinBernoulliNB")
def test_model_gaussian_nb_binary_classification_int(self):
model, X = fit_classification_model(GaussianNB(), 2, is_int=True)
model_onnx = convert_sklearn(
model,
"gaussian naive bayes",
[("input", Int64TensorType([None, X.shape[1]]))],
target_opset=TARGET_OPSET)
dump_data_and_model(X,
model,
model_onnx,
basename="SklearnBinGaussianNBInt")
def test_model_bernoulli_nb_multiclass_int(self):
model, X = fit_classification_model(BernoulliNB(), 4, is_int=True)
model_onnx = convert_sklearn(
model,
"bernoulli naive bayes",
[("input", Int64TensorType([None, X.shape[1]]))],
target_opset=TARGET_OPSET)
dump_data_and_model(X,
model,
model_onnx,
basename="SklearnMclBernoulliNBInt-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_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_stacking_classifier(self):
model, X = fit_classification_model(
model_to_test_cl(), n_classes=2)
model_onnx = convert_sklearn(
model, "stacking classifier",
[("input", FloatTensorType([None, X.shape[1]]))],
target_opset=TARGET_OPSET)
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X, model, model_onnx,
basename="SklearnStackingClassifier",
comparable_outputs=[0])
def test_model_bernoulli_nb_multiclass_params(self):
model, X = fit_classification_model(
BernoulliNB(alpha=0, binarize=1.0, fit_prior=False), 4)
model_onnx = convert_sklearn(
model,
"bernoulli naive bayes",
[("input", FloatTensorType([None, X.shape[1]]))],
target_opset=TARGET_OPSET)
dump_data_and_model(X,
model,
model_onnx,
basename="SklearnMclBernoulliNBParams")
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_multinomial_nb_multiclass(self):
model, X = fit_classification_model(MultinomialNB(),
5,
pos_features=True)
model_onnx = convert_sklearn(
model,
"multinomial naive bayes",
[("input", FloatTensorType([None, X.shape[1]]))],
target_opset=TARGET_OPSET)
dump_data_and_model(X,
model,
model_onnx,
basename="SklearnMclMultinomialNB-Dec4")
def test_model_complement_nb_binary_classification(self):
model, X = fit_classification_model(ComplementNB(),
2,
pos_features=True)
model_onnx = convert_sklearn(
model,
"complement naive bayes",
[("input", FloatTensorType([None, X.shape[1]]))],
target_opset=TARGET_OPSET)
dump_data_and_model(X,
model,
model_onnx,
basename="SklearnBinComplementNB-Dec4")
def test_model_multinomial_nb_binary_classification(self):
model, X = fit_classification_model(MultinomialNB(),
2,
pos_features=True)
model_onnx = convert_sklearn(
model,
"multinomial naive bayes",
[("input", FloatTensorType([None, X.shape[1]]))],
target_opset=TARGET_OPSET)
dump_data_and_model(X.astype(numpy.float32),
model,
model_onnx,
basename="SklearnBinMultinomialNB-Dec4",
verbose=False)
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_model_categorical_nb(self):
model, X = fit_classification_model(CategoricalNB(),
3,
is_int=True,
pos_features=True)
model_onnx = convert_sklearn(
model,
"categorical naive bayes",
[("input", Int64TensorType([None, X.shape[1]]))],
target_opset=TARGET_OPSET)
dump_data_and_model(X[10:13],
model,
model_onnx,
basename="SklearnCategoricalNB")
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_column_transformer_drop(self):
model, X = fit_classification_model(ColumnTransformer(
[('pca', PCA(n_components=5), slice(0, 10)),
('svd', TruncatedSVD(n_components=5), slice(80, 100))],
remainder='drop'),
3,
n_features=100)
model_onnx = convert_sklearn(
model, "column transformer drop",
[("input", FloatTensorType([None, X.shape[1]]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(X,
model,
model_onnx,
basename="SklearnColumnTransformerDrop")
def test_ada_boost_classifier_samme_r_logreg(self):
model, X_test = fit_classification_model(
AdaBoostClassifier(
n_estimators=5,
algorithm="SAMME.R",
base_estimator=LogisticRegression(solver='liblinear')), 4)
model_onnx = convert_sklearn(
model,
"AdaBoost classification",
[("input", FloatTensorType((None, X_test.shape[1])))],
target_opset=10)
self.assertIsNotNone(model_onnx)
dump_data_and_model(X_test,
model,
model_onnx,
basename="SklearnAdaBoostClassifierSAMMERLogReg")
def test_ada_boost_classifier_samme(self):
model, X_test = fit_classification_model(
AdaBoostClassifier(n_estimators=5,
algorithm="SAMME",
random_state=42,
base_estimator=DecisionTreeClassifier(
max_depth=6, random_state=42)), 2)
model_onnx = convert_sklearn(
model,
"AdaBoostClSamme",
[("input", FloatTensorType((None, X_test.shape[1])))],
target_opset=10)
self.assertIsNotNone(model_onnx)
dump_data_and_model(X_test,
model,
model_onnx,
basename="SklearnAdaBoostClassifierSAMMEDT")
def test_ada_boost_classifier_samme_r(self):
model, X_test = fit_classification_model(
AdaBoostClassifier(n_estimators=10,
algorithm="SAMME.R",
random_state=42,
base_estimator=DecisionTreeClassifier(
max_depth=2, random_state=42)), 3)
model_onnx = convert_sklearn(
model,
"AdaBoost classification",
[("input", FloatTensorType((None, X_test.shape[1])))],
target_opset=10)
self.assertIsNotNone(model_onnx)
self.assertNotIn("noop_with_empty_axes", str(model_onnx))
dump_data_and_model(X_test,
model,
model_onnx,
basename="SklearnAdaBoostClassifierSAMMER")
def test_column_transformer_weights(self):
model, X = fit_classification_model(ColumnTransformer(
[('pca', PCA(n_components=5), slice(0, 10)),
('svd', TruncatedSVD(n_components=5), slice(10, 100))],
transformer_weights={
'pca': 2,
'svd': 3
}),
3,
n_features=100)
model_onnx = convert_sklearn(
model, "column transformer weights",
[("input", FloatTensorType([None, X.shape[1]]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(X,
model,
model_onnx,
basename="SklearnColumnTransformerWeights-Dec4")
def test_model_gaussian_nb_multi_class_nocl(self):
model, X = fit_classification_model(GaussianNB(), 2, label_string=True)
model_onnx = convert_sklearn(
model,
"GaussianNB multi-class nocl",
[("input", FloatTensorType([None, X.shape[1]]))],
options={id(model): {
'nocl': True
}},
target_opset=TARGET_OPSET)
sonx = str(model_onnx)
assert 'classlabels_strings' not in sonx
assert 'cl0' not in sonx
dump_data_and_model(X,
model,
model_onnx,
classes=model.classes_,
basename="SklearnGaussianNBMultiNoCl")
def test_model_multinomial_nb_multiclass_params(self):
model, X = fit_classification_model(MultinomialNB(alpha=0.5,
fit_prior=False),
5,
pos_features=True)
model_onnx = convert_sklearn(
model,
"multinomial naive bayes",
[("input", FloatTensorType([None, X.shape[1]]))],
target_opset=TARGET_OPSET)
pp = model.predict_proba(X)
col = pp.shape[1]
pps = numpy.sort(pp, axis=1)
diff = pps[:, col - 1] - pps[:, col - 2]
ind = diff >= 1e-4
dump_data_and_model(X[ind],
model,
model_onnx,
basename="SklearnMclMultinomialNBParams-Dec4")
def test_ada_boost_classifier_samme_decision_function(self):
model, X_test = fit_classification_model(
AdaBoostClassifier(n_estimators=5,
algorithm="SAMME",
random_state=42,
base_estimator=DecisionTreeClassifier(
max_depth=6, random_state=42)), 2)
options = {id(model): {'raw_scores': True}}
model_onnx = convert_sklearn(
model,
"AdaBoostClSamme",
[("input", FloatTensorType((None, X_test.shape[1])))],
target_opset=10,
options=options)
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X_test,
model,
model_onnx,
basename="SklearnAdaBoostClassifierSAMMEDTDecisionFunction",
methods=['predict', 'decision_function_binary'])
