def test_rf_classifier_decision_path_leaf(self):
     model = RandomForestClassifier(n_estimators=3, max_depth=3)
     X, y = make_classification(3, n_features=4, random_state=42)
     X = X[:, :2]
     model.fit(X, y)
     initial_types = [('input', FloatTensorType((None, X.shape[1])))]
     model_onnx = convert_sklearn(model,
                                  initial_types=initial_types,
                                  options={
                                      id(model): {
                                          'decision_leaf': True,
                                          'decision_path': True,
                                          'zipmap': False
                                      }
                                  },
                                  target_opset=TARGET_OPSET)
     sess = InferenceSession(model_onnx.SerializeToString())
     res = sess.run(None, {'input': X.astype(numpy.float32)})
     pred = model.predict(X)
     assert_almost_equal(pred, res[0].ravel())
     dec = model.decision_path(X)
     exp_leaf = path_to_leaf(model.estimators_, dec[0].todense(), dec[1])
     exp_path = binary_array_to_string(dec[0].todense())
     got_path = numpy.array([''.join(row) for row in res[2]])
     assert exp_path == got_path.ravel().tolist()
     assert exp_leaf.tolist() == res[3].tolist()
Example #2
0
    def test_decisiontree_classifier_decision_path_leaf(self):
        model = DecisionTreeClassifier(max_depth=2)
        X, y = make_classification(10, n_features=4, random_state=42)
        X = X[:, :2]
        model.fit(X, y)
        initial_types = [('input', FloatTensorType((None, X.shape[1])))]
        model_onnx = convert_sklearn(model,
                                     initial_types=initial_types,
                                     options={
                                         id(model): {
                                             'decision_leaf': True,
                                             'decision_path': True,
                                             'zipmap': False
                                         }
                                     },
                                     target_opset=TARGET_OPSET)
        sess = InferenceSession(model_onnx.SerializeToString())
        res = sess.run(None, {'input': X.astype(np.float32)})
        pred = model.predict(X)
        assert_almost_equal(pred, res[0].ravel())
        prob = model.predict_proba(X)
        assert_almost_equal(prob, res[1])

        dec = model.decision_path(X)

        exp_path = binary_array_to_string(dec.todense())
        exp_leaf = path_to_leaf(model.tree_, dec.todense())
        assert exp_path == res[2].ravel().tolist()
        assert exp_leaf.tolist() == res[3].ravel().tolist()
 def test_decisiontree_regressor_decision_path(self):
     model = DecisionTreeRegressor(max_depth=2)
     X, y = make_classification(10, n_features=4, random_state=42)
     X = X[:, :2]
     model.fit(X, y)
     initial_types = [('input', FloatTensorType((None, X.shape[1])))]
     model_onnx = convert_sklearn(
         model, initial_types=initial_types,
         options={id(model): {'decision_path': True}})
     sess = InferenceSession(model_onnx.SerializeToString())
     res = sess.run(None, {'input': X.astype(np.float32)})
     pred = model.predict(X)
     assert_almost_equal(pred, res[0].ravel())
     dec = model.decision_path(X)
     exp = binary_array_to_string(dec.todense())
     assert exp == res[1].ravel().tolist()
 def test_extratreesregressor_decision_path(self):
     model = ExtraTreesRegressor(max_depth=2, n_estimators=2)
     X, y = make_classification(10, n_features=4, random_state=42)
     X = X[:, :2]
     model.fit(X, y)
     initial_types = [('input', FloatTensorType((None, X.shape[1])))]
     model_onnx = convert_sklearn(
         model,
         initial_types=initial_types,
         options={id(model): {
                      'decision_path': True
                  }},
         target_opset=TARGET_OPSET)
     sess = InferenceSession(model_onnx.SerializeToString())
     res = sess.run(None, {'input': X.astype(numpy.float32)})
     pred = model.predict(X)
     assert_almost_equal(pred, res[0].ravel())
     dec = model.decision_path(X)
     exp = binary_array_to_string(dec[0].todense())
     got = numpy.array([''.join(row) for row in res[1]])
     assert exp == got.ravel().tolist()
Example #5
0
 def test_randomforestclassifier_decision_path(self):
     model = RandomForestClassifier(max_depth=2, n_estimators=2)
     X, y = make_classification(10, n_features=4, random_state=42)
     X = X[:, :2]
     model.fit(X, y)
     initial_types = [('input', FloatTensorType((None, X.shape[1])))]
     model_onnx = convert_sklearn(
         model,
         initial_types=initial_types,
         options={id(model): {
                      'decision_path': True,
                      'zipmap': False
                  }})
     sess = InferenceSession(model_onnx.SerializeToString())
     res = sess.run(None, {'input': X.astype(numpy.float32)})
     pred = model.predict(X)
     assert_almost_equal(pred, res[0].ravel())
     prob = model.predict_proba(X)
     assert_almost_equal(prob, res[1])
     dec = model.decision_path(X)
     exp = binary_array_to_string(dec[0].todense())
     got = numpy.array([''.join(row) for row in res[2]])
     assert exp == got.ravel().tolist()