def test_nested_condition():
left = ast.BinNumExpr(
ast.IfExpr(
ast.CompExpr(ast.NumVal(1), ast.NumVal(1), ast.CompOpType.EQ),
ast.NumVal(1), ast.NumVal(2)), ast.NumVal(2), ast.BinNumOpType.ADD)
bool_test = ast.CompExpr(ast.NumVal(1), left, ast.CompOpType.EQ)
expr_nested = ast.IfExpr(bool_test, ast.FeatureRef(2), ast.NumVal(2))
expr = ast.IfExpr(bool_test, expr_nested, ast.NumVal(2))
expected_code = """
let score (input : double list) =
let func0 =
if ((1.0) = (1.0)) then
1.0
else
2.0
let func1 =
if ((1.0) = ((func0) + (2.0))) then
if ((1.0) = ((func0) + (2.0))) then
input.[2]
else
2.0
else
2.0
func1
"""
interpreter = FSharpInterpreter()
utils.assert_code_equal(interpreter.interpret(expr), expected_code)
def _assemble_tree(self, tree):
if "leaf_value" in tree:
return ast.NumVal(tree["leaf_value"])
threshold = ast.NumVal(tree["threshold"])
feature_ref = ast.FeatureRef(tree["split_feature"])
op = ast.CompOpType.from_str_op(tree["decision_type"])
assert op == ast.CompOpType.LTE, "Unexpected comparison op"
missing_type = tree['missing_type']
if missing_type not in {"NaN", "None"}:
raise ValueError(f"Unknown missing_type: {missing_type}")
reverse_condition = missing_type == "NaN" and tree["default_left"]
reverse_condition |= missing_type == "None" and tree["threshold"] >= 0
if reverse_condition:
op = ast.CompOpType.GT
true_child = tree["right_child"]
false_child = tree["left_child"]
else:
true_child = tree["left_child"]
false_child = tree["right_child"]
return ast.IfExpr(ast.CompExpr(feature_ref, threshold, op),
self._assemble_tree(true_child),
self._assemble_tree(false_child))
def test_dependable_condition():
left = ast.BinNumExpr(
ast.IfExpr(
ast.CompExpr(ast.NumVal(1), ast.NumVal(1), ast.CompOpType.EQ),
ast.NumVal(1), ast.NumVal(2)), ast.NumVal(2), ast.BinNumOpType.ADD)
right = ast.BinNumExpr(ast.NumVal(1), ast.NumVal(2), ast.BinNumOpType.DIV)
bool_test = ast.CompExpr(left, right, ast.CompOpType.GTE)
expr = ast.IfExpr(bool_test, ast.NumVal(1), ast.FeatureRef(0))
expected_code = """
let score (input : double list) =
let func0 =
if ((1.0) = (1.0)) then
1.0
else
2.0
let func1 =
if (((func0) + (2.0)) >= ((1.0) / (2.0))) then
1.0
else
input.[0]
func1
"""
interpreter = FSharpInterpreter()
utils.assert_code_equal(interpreter.interpret(expr), expected_code)
def test_dependable_condition():
left = ast.BinNumExpr(
ast.IfExpr(
ast.CompExpr(ast.NumVal(1), ast.NumVal(1), ast.CompOpType.EQ),
ast.NumVal(1), ast.NumVal(2)), ast.NumVal(2), ast.BinNumOpType.ADD)
right = ast.BinNumExpr(ast.NumVal(1), ast.NumVal(2), ast.BinNumOpType.DIV)
bool_test = ast.CompExpr(left, right, ast.CompOpType.GTE)
expr = ast.IfExpr(bool_test, ast.NumVal(1), ast.FeatureRef(0))
expected_code = """
score <- function(input) {
if ((1) == (1)) {
var1 <- 1
} else {
var1 <- 2
}
if (((var1) + (2)) >= ((1) / (2))) {
var0 <- 1
} else {
var0 <- input[1]
}
return(var0)
}
"""
interpreter = RInterpreter()
utils.assert_code_equal(interpreter.interpret(expr), expected_code)
def test_statsmodels_glm_negativebinomial_link_func():
estimator = utils.StatsmodelsSklearnLikeWrapper(
sm.GLM,
dict(init=dict(
family=sm.families.NegativeBinomial(sm.families.links.nbinom())),
fit=dict(maxiter=1)))
estimator = estimator.fit([[1], [2]], [0.1, 0.2])
assembler = assemblers.StatsmodelsGLMModelAssembler(estimator)
actual = assembler.assemble()
expected = ast.BinNumExpr(
ast.NumVal(-1.0),
ast.BinNumExpr(
ast.NumVal(1.0),
ast.BinNumExpr(
ast.NumVal(1.0),
ast.ExpExpr(
ast.BinNumExpr(
ast.NumVal(0.0),
ast.BinNumExpr(
ast.NumVal(0.0),
ast.BinNumExpr(ast.FeatureRef(0),
ast.NumVal(-1.1079583217),
ast.BinNumOpType.MUL),
ast.BinNumOpType.ADD), ast.BinNumOpType.SUB)),
ast.BinNumOpType.SUB), ast.BinNumOpType.MUL),
ast.BinNumOpType.DIV)
assert utils.cmp_exprs(actual, expected)
def test_dependable_condition():
left = ast.BinNumExpr(
ast.IfExpr(
ast.CompExpr(ast.NumVal(1), ast.NumVal(1), ast.CompOpType.EQ),
ast.NumVal(1), ast.NumVal(2)), ast.NumVal(2), ast.BinNumOpType.ADD)
right = ast.BinNumExpr(ast.NumVal(1), ast.NumVal(2), ast.BinNumOpType.DIV)
bool_test = ast.CompExpr(left, right, ast.CompOpType.GTE)
expr = ast.IfExpr(bool_test, ast.NumVal(1), ast.FeatureRef(0))
expected_code = """
double score(double * input) {
double var0;
double var1;
if ((1.0) == (1.0)) {
var1 = 1.0;
} else {
var1 = 2.0;
}
if (((var1) + (2.0)) >= ((1.0) / (2.0))) {
var0 = 1.0;
} else {
var0 = input[0];
}
return var0;
}"""
interpreter = CInterpreter()
utils.assert_code_equal(interpreter.interpret(expr), expected_code)
def test_dependable_condition():
left = ast.BinNumExpr(
ast.IfExpr(
ast.CompExpr(ast.NumVal(1), ast.NumVal(1), ast.CompOpType.EQ),
ast.NumVal(1), ast.NumVal(2)), ast.NumVal(2), ast.BinNumOpType.ADD)
right = ast.BinNumExpr(ast.NumVal(1), ast.NumVal(2), ast.BinNumOpType.DIV)
bool_test = ast.CompExpr(left, right, ast.CompOpType.GTE)
expr = ast.IfExpr(bool_test, ast.NumVal(1), ast.FeatureRef(0))
expected_code = """
func score(input []float64) float64 {
var var0 float64
var var1 float64
if (1) == (1) {
var1 = 1
} else {
var1 = 2
}
if ((var1) + (2)) >= ((1) / (2)) {
var0 = 1
} else {
var0 = input[0]
}
return var0
}"""
interpreter = interpreters.GoInterpreter()
utils.assert_code_equal(interpreter.interpret(expr), expected_code)
def test_dependable_condition():
left = ast.BinNumExpr(
ast.IfExpr(
ast.CompExpr(ast.NumVal(1), ast.NumVal(1), ast.CompOpType.EQ),
ast.NumVal(1), ast.NumVal(2)), ast.NumVal(2), ast.BinNumOpType.ADD)
right = ast.BinNumExpr(ast.NumVal(1), ast.NumVal(2), ast.BinNumOpType.DIV)
bool_test = ast.CompExpr(left, right, ast.CompOpType.GTE)
expr = ast.IfExpr(bool_test, ast.NumVal(1), ast.FeatureRef(0))
expected_code = """
def score(input)
if (1.0) == (1.0)
var1 = 1.0
else
var1 = 2.0
end
if ((var1) + (2.0)) >= ((1.0).fdiv(2.0))
var0 = 1.0
else
var0 = input[0]
end
var0
end
"""
interpreter = RubyInterpreter()
utils.assert_code_equal(interpreter.interpret(expr), expected_code)
def test_bin_class_sigmoid_output_transform():
estimator = lightgbm.LGBMClassifier(n_estimators=1, random_state=1,
max_depth=1, sigmoid=0.5)
utils.get_binary_classification_model_trainer()(estimator)
assembler = assemblers.LightGBMModelAssembler(estimator)
actual = assembler.assemble()
sigmoid = ast.BinNumExpr(
ast.NumVal(1),
ast.BinNumExpr(
ast.NumVal(1),
ast.ExpExpr(
ast.BinNumExpr(
ast.NumVal(0),
ast.BinNumExpr(
ast.NumVal(0.5),
ast.IfExpr(
ast.CompExpr(
ast.FeatureRef(23),
ast.NumVal(868.2),
ast.CompOpType.GT),
ast.NumVal(0.5197386243),
ast.NumVal(1.2474356828)),
ast.BinNumOpType.MUL),
ast.BinNumOpType.SUB)),
ast.BinNumOpType.ADD),
ast.BinNumOpType.DIV,
to_reuse=True)
expected = ast.VectorVal([
ast.BinNumExpr(ast.NumVal(1), sigmoid, ast.BinNumOpType.SUB),
sigmoid])
assert utils.cmp_exprs(actual, expected)
def test_dependable_condition():
left = ast.BinNumExpr(
ast.IfExpr(
ast.CompExpr(ast.NumVal(1), ast.NumVal(1), ast.CompOpType.EQ),
ast.NumVal(1), ast.NumVal(2)), ast.NumVal(2), ast.BinNumOpType.ADD)
right = ast.BinNumExpr(ast.NumVal(1), ast.NumVal(2), ast.BinNumOpType.DIV)
bool_test = ast.CompExpr(left, right, ast.CompOpType.GTE)
expr = ast.IfExpr(bool_test, ast.NumVal(1), ast.FeatureRef(0))
expected_code = """
<?php
function score(array $input) {
$var0 = null;
$var1 = null;
if ((1.0) === (1.0)) {
$var1 = 1.0;
} else {
$var1 = 2.0;
}
if ((($var1) + (2.0)) >= ((1.0) / (2.0))) {
$var0 = 1.0;
} else {
$var0 = $input[0];
}
return $var0;
}
"""
interpreter = PhpInterpreter()
assert_code_equal(interpreter.interpret(expr), expected_code)
def test_dependable_condition():
left = ast.BinNumExpr(
ast.IfExpr(
ast.CompExpr(ast.NumVal(1), ast.NumVal(1), ast.CompOpType.EQ),
ast.NumVal(1), ast.NumVal(2)), ast.NumVal(2), ast.BinNumOpType.ADD)
right = ast.BinNumExpr(ast.NumVal(1), ast.NumVal(2), ast.BinNumOpType.DIV)
bool_test = ast.CompExpr(left, right, ast.CompOpType.GTE)
expr = ast.IfExpr(bool_test, ast.NumVal(1), ast.FeatureRef(0))
expected_code = """
def score(input):
if (1) == (1):
var1 = 1
else:
var1 = 2
if ((var1) + (2)) >= ((1) / (2)):
var0 = 1
else:
var0 = input[0]
return var0
"""
interpreter = interpreters.PythonInterpreter()
utils.assert_code_equal(interpreter.interpret(expr), expected_code)
def test_contains_expr():
expected_code = """
using static System.Collections.Generic;
namespace ML {
public static class Model {
public static double Score(double[] input) {
return Contains(var_1, input[0]);
}
private static double[] AddVectors(double[] v1, double[] v2) {
double[] result = new double[v1.Length];
for (int i = 0; i < v1.Length; ++i) {
result[i] = v1[i] + v2[i];
}
return result;
}
private static double[] MulVectorNumber(double[] v1, double num) {
double[] result = new double[v1.Length];
for (int i = 0; i < v1.Length; ++i) {
result[i] = v1[i] * num;
}
return result;
}
private static bool Contains(HashSet<int> v1, double featureRef) {
return v1.Contains((int) featureRef);
}
static HashSet<int> var_1 = new HashSet<int>() { 0 };
}
}
"""
expr = ast.ContainsIntExpr([0], ast.FeatureRef(0))
interpreter = CSharpInterpreter()
r = interpreter.interpret(expr)
print(r)
def test_nested_condition():
left = ast.BinNumExpr(
ast.IfExpr(
ast.CompExpr(ast.NumVal(1), ast.NumVal(1), ast.CompOpType.EQ),
ast.NumVal(1), ast.NumVal(2)), ast.NumVal(2), ast.BinNumOpType.ADD)
bool_test = ast.CompExpr(ast.NumVal(1), left, ast.CompOpType.EQ)
expr_nested = ast.IfExpr(bool_test, ast.FeatureRef(2), ast.NumVal(2))
expr = ast.IfExpr(bool_test, expr_nested, ast.NumVal(2))
expected_code = """
def score(input):
if (1) == (1):
var1 = 1
else:
var1 = 2
if (1) == ((var1) + (2)):
if (1) == (1):
var2 = 1
else:
var2 = 2
if (1) == ((var2) + (2)):
var0 = input[2]
else:
var0 = 2
else:
var0 = 2
return var0
"""
interpreter = interpreters.PythonInterpreter()
utils.assert_code_equal(interpreter.interpret(expr), expected_code)
def test_dependable_condition():
left = ast.BinNumExpr(
ast.IfExpr(
ast.CompExpr(ast.NumVal(1), ast.NumVal(1), ast.CompOpType.EQ),
ast.NumVal(1), ast.NumVal(2)), ast.NumVal(2), ast.BinNumOpType.ADD)
right = ast.BinNumExpr(ast.NumVal(1), ast.NumVal(2), ast.BinNumOpType.DIV)
bool_test = ast.CompExpr(left, right, ast.CompOpType.GTE)
expr = ast.IfExpr(bool_test, ast.NumVal(1), ast.FeatureRef(0))
expected_code = """
Module Model
Function score(ByRef input_vector() As Double) As Double
Dim var0 As Double
Dim var1 As Double
If (1) == (1) Then
var1 = 1
Else
var1 = 2
End If
If ((var1) + (2)) >= ((1) / (2)) Then
var0 = 1
Else
var0 = input_vector(0)
End If
score = var0
End Function
End Module
"""
interpreter = VisualBasicInterpreter()
utils.assert_code_equal(interpreter.interpret(expr), expected_code)
def test_dependable_condition():
left = ast.BinNumExpr(
ast.IfExpr(
ast.CompExpr(ast.NumVal(1),
ast.NumVal(1),
ast.CompOpType.EQ),
ast.NumVal(1),
ast.NumVal(2)),
ast.NumVal(2),
ast.BinNumOpType.ADD)
right = ast.BinNumExpr(ast.NumVal(1), ast.NumVal(2), ast.BinNumOpType.DIV)
bool_test = ast.CompExpr(left, right, ast.CompOpType.GTE)
expr = ast.IfExpr(bool_test, ast.NumVal(1), ast.FeatureRef(0))
expected_code = """
fn score(input: Vec<f64>) -> f64 {
let var0: f64;
let var1: f64;
if (1.0_f64) == (1.0_f64) {
var1 = 1.0_f64;
} else {
var1 = 2.0_f64;
}
if ((var1) + (2.0_f64)) >= ((1.0_f64) / (2.0_f64)) {
var0 = 1.0_f64;
} else {
var0 = input[0];
}
var0
}
"""
interpreter = RustInterpreter()
assert_code_equal(interpreter.interpret(expr), expected_code)
def test_dependable_condition():
left = ast.BinNumExpr(
ast.IfExpr(
ast.CompExpr(ast.NumVal(1), ast.NumVal(1), ast.CompOpType.EQ),
ast.NumVal(1), ast.NumVal(2)), ast.NumVal(2), ast.BinNumOpType.ADD)
right = ast.BinNumExpr(ast.NumVal(1), ast.NumVal(2), ast.BinNumOpType.DIV)
bool_test = ast.CompExpr(left, right, ast.CompOpType.GTE)
expr = ast.IfExpr(bool_test, ast.NumVal(1), ast.FeatureRef(0))
expected_code = """
module Model where
score :: [Double] -> Double
score input =
func1
where
func0 =
if ((1.0) == (1.0)) then
1.0
else
2.0
func1 =
if (((func0) + (2.0)) >= ((1.0) / (2.0))) then
1.0
else
(input) !! (0)
"""
interpreter = HaskellInterpreter()
actual_code = interpreter.interpret(expr)
utils.assert_code_equal(actual_code, expected_code)
def _assemble_tree(self, tree):
if "leaf" in tree:
return ast.NumVal(tree["leaf"])
threshold = ast.NumVal(tree["split_condition"], dtype=np.float32)
split = tree["split"]
feature_idx = self._feature_name_to_idx.get(split, split)
feature_ref = ast.FeatureRef(feature_idx)
# Since comparison with NaN (missing) value always returns false we
# should make sure that the node ID specified in the "missing" field
# always ends up in the "else" branch of the ast.IfExpr.
use_lt_comp = tree["missing"] == tree["no"]
if use_lt_comp:
comp_op = ast.CompOpType.LT
true_child_id = tree["yes"]
false_child_id = tree["no"]
else:
comp_op = ast.CompOpType.GTE
true_child_id = tree["no"]
false_child_id = tree["yes"]
return ast.IfExpr(ast.CompExpr(feature_ref, threshold, comp_op),
self._assemble_child_tree(tree, true_child_id),
self._assemble_child_tree(tree, false_child_id))
def test_dependable_condition():
left = ast.BinNumExpr(
ast.IfExpr(
ast.CompExpr(ast.NumVal(1), ast.NumVal(1), ast.CompOpType.EQ),
ast.NumVal(1), ast.NumVal(2)), ast.NumVal(2), ast.BinNumOpType.ADD)
right = ast.BinNumExpr(ast.NumVal(1), ast.NumVal(2), ast.BinNumOpType.DIV)
bool_test = ast.CompExpr(left, right, ast.CompOpType.GTE)
expr = ast.IfExpr(bool_test, ast.NumVal(1), ast.FeatureRef(0))
expected_code = """
function Score([double[]] $InputVector) {
[double]$var0 = 0
[double]$var1 = 0
if ((1) -eq (1)) {
$var1 = 1
} else {
$var1 = 2
}
if ((($var1) + (2)) -ge ((1) / (2))) {
$var0 = 1
} else {
$var0 = $InputVector[0]
}
return $var0
}
"""
interpreter = PowershellInterpreter()
utils.assert_code_equal(interpreter.interpret(expr), expected_code)
def test_binary_classification():
estimator = lightgbm.LGBMClassifier(n_estimators=2, random_state=1,
max_depth=1)
utils.train_model_classification_binary(estimator)
assembler = assemblers.LightGBMModelAssembler(estimator)
actual = assembler.assemble()
sigmoid = ast.BinNumExpr(
ast.NumVal(1),
ast.BinNumExpr(
ast.NumVal(1),
ast.ExpExpr(
ast.BinNumExpr(
ast.NumVal(0),
ast.SubroutineExpr(
ast.BinNumExpr(
ast.BinNumExpr(
ast.NumVal(0),
ast.SubroutineExpr(
ast.IfExpr(
ast.CompExpr(
ast.FeatureRef(23),
ast.NumVal(868.2000000000002),
ast.CompOpType.GT),
ast.NumVal(0.25986931215073095),
ast.NumVal(0.6237178414050242))),
ast.BinNumOpType.ADD),
ast.SubroutineExpr(
ast.IfExpr(
ast.CompExpr(
ast.FeatureRef(7),
ast.NumVal(0.05142),
ast.CompOpType.GT),
ast.NumVal(-0.1909605544006228),
ast.NumVal(0.1293965108676673))),
ast.BinNumOpType.ADD)),
ast.BinNumOpType.SUB)),
ast.BinNumOpType.ADD),
ast.BinNumOpType.DIV,
to_reuse=True)
expected = ast.VectorVal([
ast.BinNumExpr(ast.NumVal(1), sigmoid, ast.BinNumOpType.SUB),
sigmoid])
assert utils.cmp_exprs(actual, expected)
def test_two_features():
estimator = linear_model.LinearRegression()
estimator.coef_ = [1, 2]
estimator.intercept_ = 3
assembler = assemblers.SklearnLinearModelAssembler(estimator)
actual = assembler.assemble()
expected = ast.BinNumExpr(
ast.BinNumExpr(
ast.NumVal(3),
ast.BinNumExpr(ast.FeatureRef(0), ast.NumVal(1),
ast.BinNumOpType.MUL), ast.BinNumOpType.ADD),
ast.BinNumExpr(ast.FeatureRef(1), ast.NumVal(2), ast.BinNumOpType.MUL),
ast.BinNumOpType.ADD)
assert utils.cmp_exprs(actual, expected)
def _rbf_kernel_ast(estimator, sup_vec_value, to_reuse=False):
return ast.ExpExpr(ast.BinNumExpr(
ast.NumVal(-estimator.gamma),
ast.PowExpr(
ast.BinNumExpr(ast.NumVal(sup_vec_value),
ast.FeatureRef(0), ast.BinNumOpType.SUB),
ast.NumVal(2)), ast.BinNumOpType.MUL),
to_reuse=to_reuse)
def test_binary_class():
estimator = linear_model.LogisticRegression()
estimator.coef_ = np.array([[1, 2]])
estimator.intercept_ = np.array([3])
assembler = assemblers.SklearnLinearModelAssembler(estimator)
actual = assembler.assemble()
expected = ast.BinNumExpr(
ast.BinNumExpr(
ast.NumVal(3),
ast.BinNumExpr(ast.FeatureRef(0), ast.NumVal(1),
ast.BinNumOpType.MUL), ast.BinNumOpType.ADD),
ast.BinNumExpr(ast.FeatureRef(1), ast.NumVal(2), ast.BinNumOpType.MUL),
ast.BinNumOpType.ADD)
assert utils.cmp_exprs(actual, expected)
def _linear_to_ast(coef, intercept):
feature_weight_mul_ops = [
utils.mul(ast.FeatureRef(index), ast.NumVal(value))
for index, value in enumerate(coef)
]
return utils.apply_op_to_expressions(ast.BinNumOpType.ADD,
ast.NumVal(intercept),
*feature_weight_mul_ops)
def test_leaves_cutoff_threshold():
estimator = xgboost.XGBClassifier(n_estimators=2,
random_state=1,
max_depth=1)
utils.train_model_classification_binary(estimator)
assembler = assemblers.XGBoostModelAssembler(estimator,
leaves_cutoff_threshold=1)
actual = assembler.assemble()
sigmoid = ast.BinNumExpr(
ast.NumVal(1),
ast.BinNumExpr(
ast.NumVal(1),
ast.ExpExpr(
ast.BinNumExpr(
ast.NumVal(0),
ast.SubroutineExpr(
ast.BinNumExpr(
ast.BinNumExpr(
ast.NumVal(-0.0),
ast.SubroutineExpr(
ast.IfExpr(
ast.CompExpr(ast.FeatureRef(20),
ast.NumVal(16.7950001),
ast.CompOpType.GTE),
ast.NumVal(-0.17062147),
ast.NumVal(0.1638484))),
ast.BinNumOpType.ADD),
ast.SubroutineExpr(
ast.IfExpr(
ast.CompExpr(ast.FeatureRef(27),
ast.NumVal(0.142349988),
ast.CompOpType.GTE),
ast.NumVal(-0.16087772),
ast.NumVal(0.149866998))),
ast.BinNumOpType.ADD)), ast.BinNumOpType.SUB)),
ast.BinNumOpType.ADD),
ast.BinNumOpType.DIV,
to_reuse=True)
expected = ast.VectorVal([
ast.BinNumExpr(ast.NumVal(1), sigmoid, ast.BinNumOpType.SUB), sigmoid
])
assert utils.cmp_exprs(actual, expected)
def _cosine_kernel(self, support_vector):
support_vector_norm = np.linalg.norm(support_vector)
if support_vector_norm == 0.0:
support_vector_norm = 1.0
feature_norm = ast.SqrtExpr(
utils.apply_op_to_expressions(
ast.BinNumOpType.ADD,
*[utils.mul(ast.FeatureRef(i), ast.FeatureRef(i))
for i in range(len(support_vector))]),
to_reuse=True)
safe_feature_norm = ast.IfExpr(
utils.eq(feature_norm, ast.NumVal(0.0)),
ast.NumVal(1.0),
feature_norm)
kernel = self._linear_kernel(support_vector / support_vector_norm)
kernel = utils.div(kernel, safe_feature_norm)
return kernel
def test_two_conditions():
estimator = tree.DecisionTreeRegressor()
estimator.fit([[1], [2], [3]], [1, 2, 3])
assembler = assemblers.TreeModelAssembler(estimator)
actual = assembler.assemble()
expected = ast.IfExpr(
ast.CompExpr(ast.FeatureRef(0), ast.NumVal(1.5), ast.CompOpType.LTE),
ast.NumVal(1.0),
ast.IfExpr(
ast.CompExpr(ast.FeatureRef(0),
ast.NumVal(2.5), ast.CompOpType.LTE), ast.NumVal(2.0),
ast.NumVal(3.0)))
assert utils.cmp_exprs(actual, expected)
def test_binary_classification():
estimator = xgboost.XGBClassifier(n_estimators=2,
random_state=1,
max_depth=1)
utils.train_model_classification_binary(estimator)
assembler = assemblers.XGBoostModelAssembler(estimator)
actual = assembler.assemble()
sigmoid = ast.BinNumExpr(
ast.NumVal(1),
ast.BinNumExpr(
ast.NumVal(1),
ast.ExpExpr(
ast.BinNumExpr(
ast.NumVal(0),
ast.SubroutineExpr(
ast.BinNumExpr(
ast.BinNumExpr(
ast.NumVal(-0.0),
ast.SubroutineExpr(
ast.IfExpr(
ast.CompExpr(ast.FeatureRef(20),
ast.NumVal(16.7950001),
ast.CompOpType.GTE),
ast.NumVal(-0.173057005),
ast.NumVal(0.163440868))),
ast.BinNumOpType.ADD),
ast.SubroutineExpr(
ast.IfExpr(
ast.CompExpr(ast.FeatureRef(27),
ast.NumVal(0.142349988),
ast.CompOpType.GTE),
ast.NumVal(-0.161026895),
ast.NumVal(0.149405137))),
ast.BinNumOpType.ADD)), ast.BinNumOpType.SUB)),
ast.BinNumOpType.ADD),
ast.BinNumOpType.DIV,
to_reuse=True)
expected = ast.VectorVal([
ast.BinNumExpr(ast.NumVal(1), sigmoid, ast.BinNumOpType.SUB), sigmoid
])
assert utils.cmp_exprs(actual, expected)
def test_binary_classification():
estimator = lightgbm.LGBMClassifier(n_estimators=2, random_state=1,
max_depth=1)
utils.train_model_classification_binary(estimator)
assembler = assemblers.LightGBMModelAssembler(estimator)
actual = assembler.assemble()
sigmoid = ast.BinNumExpr(
ast.NumVal(1),
ast.BinNumExpr(
ast.NumVal(1),
ast.ExpExpr(
ast.BinNumExpr(
ast.NumVal(0),
ast.SubroutineExpr(
ast.BinNumExpr(
ast.BinNumExpr(
ast.NumVal(0),
ast.IfExpr(
ast.CompExpr(
ast.FeatureRef(23),
ast.NumVal(868.2000000000002),
ast.CompOpType.GT),
ast.NumVal(0.2762557140263451),
ast.NumVal(0.6399134166614473)),
ast.BinNumOpType.ADD),
ast.IfExpr(
ast.CompExpr(
ast.FeatureRef(27),
ast.NumVal(0.14205000000000004),
ast.CompOpType.GT),
ast.NumVal(-0.2139321843285849),
ast.NumVal(0.1151466338793227)),
ast.BinNumOpType.ADD)),
ast.BinNumOpType.SUB)),
ast.BinNumOpType.ADD),
ast.BinNumOpType.DIV,
to_reuse=True)
expected = ast.VectorVal([
ast.BinNumExpr(ast.NumVal(1), sigmoid, ast.BinNumOpType.SUB),
sigmoid])
assert utils.cmp_exprs(actual, expected)
def test_regression():
estimator = lgb.LGBMRegressor(n_estimators=2, random_state=1, max_depth=1)
utils.get_regression_model_trainer()(estimator)
assembler = LightGBMModelAssembler(estimator)
actual = assembler.assemble()
expected = ast.BinNumExpr(
ast.IfExpr(
ast.CompExpr(ast.FeatureRef(12), ast.NumVal(9.725),
ast.CompOpType.GT), ast.NumVal(22.030283219508686),
ast.NumVal(23.27840740210207)),
ast.IfExpr(
ast.CompExpr(ast.FeatureRef(5), ast.NumVal(6.8375),
ast.CompOpType.GT), ast.NumVal(1.2777791671888081),
ast.NumVal(-0.2686772850549309)), ast.BinNumOpType.ADD)
assert utils.cmp_exprs(actual, expected)
def kernel_ast(sup_vec_value):
return ast.PowExpr(
ast.BinNumExpr(
ast.BinNumExpr(
ast.NumVal(estimator.gamma),
ast.BinNumExpr(ast.NumVal(sup_vec_value),
ast.FeatureRef(0), ast.BinNumOpType.MUL),
ast.BinNumOpType.MUL), ast.NumVal(0.0),
ast.BinNumOpType.ADD), ast.NumVal(estimator.degree))
