def test_sigmoid_expr(): expr = ast.SigmoidExpr(ast.NumVal(2.0)) expected_code = """ let private sigmoid x = let z = exp x match x with | i when i < 0.0 -> z / (1.0 + z) | _ -> 1.0 / (1.0 + exp (-x)) let score (input : double list) = sigmoid (2.0) """ interpreter = FSharpInterpreter() assert_code_equal(interpreter.interpret(expr), expected_code)
def test_sigmoid_expr(): expr = ast.SigmoidExpr(ast.NumVal(2.0)) expected_code = """ import math def sigmoid(x): if x < 0.0: z = math.exp(x) return z / (1.0 + z) return 1.0 / (1.0 + math.exp(-x)) def score(input): return sigmoid(2.0) """ interpreter = PythonInterpreter() assert_code_equal(interpreter.interpret(expr), expected_code)
def test_sigmoid_expr(): expr = ast.SigmoidExpr(ast.NumVal(2.0)) expected_code = """ sigmoid <- function(x) { if (x < 0.0) { z <- exp(x) return(z / (1.0 + z)) } return(1.0 / (1.0 + exp(-x))) } score <- function(input) { return(sigmoid(2.0)) } """ interpreter = RInterpreter() utils.assert_code_equal(interpreter.interpret(expr), expected_code)
def test_sigmoid_expr(): expr = ast.SigmoidExpr(ast.NumVal(2.0)) expected_code = """ function Score([double[]] $InputVector) { return Sigmoid $(2.0) } function Sigmoid([double] $x) { if ($x -lt 0.0) { [double] $z = [math]::Exp($x) return $z / (1.0 + $z) } return 1.0 / (1.0 + [math]::Exp(-$x)) } """ interpreter = PowershellInterpreter() utils.assert_code_equal(interpreter.interpret(expr), expected_code)
def test_sigmoid_expr(): expr = ast.SigmoidExpr(ast.NumVal(2.0)) expected_code = """ import 'dart:math'; double score(List<double> input) { return sigmoid(2.0); } double sigmoid(double x) { if (x < 0.0) { double z = exp(x); return z / (1.0 + z); } return 1.0 / (1.0 + exp(-x)); } """ interpreter = DartInterpreter() utils.assert_code_equal(interpreter.interpret(expr), expected_code)
def test_sigmoid_expr(): expr = ast.SigmoidExpr(ast.NumVal(2.0)) expected_code = r""" module Model where score :: [Double] -> Double score input = sigmoid (2.0) sigmoid :: Double -> Double sigmoid x | x < 0.0 = z / (1.0 + z) | otherwise = 1.0 / (1.0 + exp (-x)) where z = exp x """ interpreter = HaskellInterpreter() utils.assert_code_equal(interpreter.interpret(expr), expected_code)
def test_sigmoid_expr(): expr = ast.SigmoidExpr(ast.NumVal(2.0)) expected_code = """ function score(input) { return sigmoid(2.0); } function sigmoid(x) { if (x < 0.0) { let z = Math.exp(x); return z / (1.0 + z); } return 1.0 / (1.0 + Math.exp(-x)); } """ interpreter = JavascriptInterpreter() assert_code_equal(interpreter.interpret(expr), expected_code)
def test_sigmoid_expr(): expr = ast.SigmoidExpr(ast.NumVal(2.0)) expected_code = """ def score(input) sigmoid(2.0) end def sigmoid(x) if x < 0.0 z = Math.exp(x) return z / (1.0 + z) end 1.0 / (1.0 + Math.exp(-x)) end """ interpreter = RubyInterpreter() assert_code_equal(interpreter.interpret(expr), expected_code)
def test_sigmoid_expr(): expr = ast.SigmoidExpr(ast.NumVal(2.0)) expected_code = """ fn score(input: Vec<f64>) -> f64 { sigmoid(2.0_f64) } fn sigmoid(x: f64) -> f64 { if x < 0.0_f64 { let z: f64 = x.exp(); return z / (1.0_f64 + z); } 1.0_f64 / (1.0_f64 + (-x).exp()) } """ interpreter = RustInterpreter() assert_code_equal(interpreter.interpret(expr), expected_code)
def test_multi_class_sigmoid_output_transform(): estimator = lgb.LGBMClassifier(n_estimators=1, random_state=1, max_depth=1, sigmoid=0.5, objective="ovr") estimator.fit(np.array([[1], [2], [3]]), np.array([1, 2, 3])) assembler = LightGBMModelAssembler(estimator) actual = assembler.assemble() sigmoid = ast.SigmoidExpr( ast.BinNumExpr(ast.NumVal(0.5), ast.NumVal(-1.3862943611), ast.BinNumOpType.MUL)) expected = ast.VectorVal([sigmoid] * 3) assert utils.cmp_exprs(actual, expected)
def test_sigmoid_fallback_expr(): expr = ast.SigmoidExpr(ast.NumVal(2.0)) class InterpreterWithoutSigmoid(PythonInterpreter): sigmoid_function_name = NotImplemented def interpret_sigmoid_expr(self, expr, **kwargs): return super(PythonInterpreter, self).interpret_sigmoid_expr(expr, **kwargs) interpreter = InterpreterWithoutSigmoid() expected_code = """ import math def score(input): return (1.0) / ((1.0) + (math.exp((0.0) - (2.0)))) """ assert_code_equal(interpreter.interpret(expr), expected_code)
def test_sigmoid_expr(): expr = ast.SigmoidExpr(ast.NumVal(2.0)) expected_code = """ import "math" func score(input []float64) float64 { return sigmoid(2.0) } func sigmoid(x float64) float64 { if (x < 0.0) { z := math.Exp(x) return z / (1.0 + z) } return 1.0 / (1.0 + math.Exp(-x)) } """ interpreter = GoInterpreter() assert_code_equal(interpreter.interpret(expr), expected_code)
def test_sigmoid_expr(): expr = ast.SigmoidExpr(ast.NumVal(2.0)) expected_code = """ <?php function score(array $input) { return sigmoid(2.0); } function sigmoid($x) { if ($x < 0.0) { $z = exp($x); return $z / (1.0 + $z); } return 1.0 / (1.0 + exp(-$x)); } """ interpreter = PhpInterpreter() utils.assert_code_equal(interpreter.interpret(expr), expected_code)
def test_sigmoid_expr(): expr = ast.SigmoidExpr(ast.NumVal(2.0)) expected_code = """ #include <math.h> double sigmoid(double x) { if (x < 0.0) { double z = exp(x); return z / (1.0 + z); } return 1.0 / (1.0 + exp(-x)); } double score(double * input) { return sigmoid(2.0); } """ interpreter = CInterpreter() assert_code_equal(interpreter.interpret(expr), expected_code)
def test_sigmoid_expr(): expr = ast.SigmoidExpr(ast.NumVal(2.0)) interpreter = JavaInterpreter() expected_code = """ public class Model { public static double score(double[] input) { return sigmoid(2.0); } private static double sigmoid(double x) { if (x < 0.0) { double z = Math.exp(x); return z / (1.0 + z); } return 1.0 / (1.0 + Math.exp(-x)); } }""" utils.assert_code_equal(interpreter.interpret(expr), expected_code)
def test_sigmoid_expr(): expr = ast.SigmoidExpr(ast.NumVal(2.0)) expected_code = """ Module Model Function Score(ByRef inputVector() As Double) As Double Score = Sigmoid(2.0) End Function Function Sigmoid(ByVal number As Double) As Double If number < 0.0 Then Dim z As Double z = Math.Exp(number) Sigmoid = z / (1.0 + z) Exit Function End If Sigmoid = 1.0 / (1.0 + Math.Exp(-number)) End Function End Module """ interpreter = VisualBasicInterpreter() assert_code_equal(interpreter.interpret(expr), expected_code)
def test_statsmodels_glm_logit_link_func(): estimator = utils.StatsmodelsSklearnLikeWrapper( sm.GLM, dict(init=dict( family=sm.families.Binomial( sm.families.links.logit())), fit=dict(maxiter=1))) estimator = estimator.fit([[1], [2]], [0.1, 0.2]) assembler = assemblers.StatsmodelsModelAssemblerSelector(estimator) actual = assembler.assemble() expected = ast.SigmoidExpr( ast.BinNumExpr( ast.NumVal(0.0), ast.BinNumExpr( ast.FeatureRef(0), ast.NumVal(-0.8567815987), ast.BinNumOpType.MUL), ast.BinNumOpType.ADD)) assert utils.cmp_exprs(actual, expected)
def test_sigmoid_expr(): expr = ast.SigmoidExpr(ast.NumVal(2.0)) expected_code = """ using static System.Math; namespace ML { public static class Model { public static double Score(double[] input) { return Sigmoid(2.0); } private static double Sigmoid(double x) { if (x < 0.0) { double z = Exp(x); return z / (1.0 + z); } return 1.0 / (1.0 + Exp(-x)); } } } """ interpreter = CSharpInterpreter() assert_code_equal(interpreter.interpret(expr), expected_code)
def test_binary_classification(): estimator = xgb.XGBClassifier(n_estimators=2, random_state=1, max_depth=1) utils.get_binary_classification_model_trainer()(estimator) assembler = XGBoostModelAssemblerSelector(estimator) actual = assembler.assemble() sigmoid = ast.SigmoidExpr(ast.BinNumExpr( ast.IfExpr( ast.CompExpr(ast.FeatureRef(20), ast.NumVal(16.795), ast.CompOpType.GTE), ast.NumVal(-0.5178947448730469), ast.NumVal(0.4880000054836273)), ast.IfExpr( ast.CompExpr(ast.FeatureRef(27), ast.NumVal(0.142349988), ast.CompOpType.GTE), ast.NumVal(-0.4447747468948364), ast.NumVal(0.39517202973365784)), ast.BinNumOpType.ADD), to_reuse=True) expected = ast.VectorVal([ ast.BinNumExpr(ast.NumVal(1), sigmoid, ast.BinNumOpType.SUB), sigmoid ]) assert utils.cmp_exprs(actual, expected)
def test_simple_sigmoid_output_transform(): estimator = lgb.LGBMRegressor(n_estimators=2, random_state=1, max_depth=1, objective="cross_entropy") utils.get_bounded_regression_model_trainer()(estimator) assembler = LightGBMModelAssembler(estimator) actual = assembler.assemble() expected = ast.SigmoidExpr( ast.BinNumExpr( ast.IfExpr( ast.CompExpr(ast.FeatureRef(12), ast.NumVal(19.23), ast.CompOpType.GT), ast.NumVal(4.002437528537838), ast.NumVal(4.090096709787509)), ast.IfExpr( ast.CompExpr(ast.FeatureRef(12), ast.NumVal(14.895), ast.CompOpType.GT), ast.NumVal(-0.0417499606641773), ast.NumVal(0.02069953712454655)), ast.BinNumOpType.ADD)) assert utils.cmp_exprs(actual, expected)
def test_binary_classification(): estimator = lgb.LGBMClassifier(n_estimators=2, random_state=1, max_depth=1) utils.get_binary_classification_model_trainer()(estimator) assembler = LightGBMModelAssembler(estimator) actual = assembler.assemble() sigmoid = ast.SigmoidExpr(ast.BinNumExpr( ast.IfExpr( ast.CompExpr(ast.FeatureRef(20), ast.NumVal(16.795), ast.CompOpType.GT), ast.NumVal(0.27502096830384837), ast.NumVal(0.6391171126839048)), ast.IfExpr( ast.CompExpr(ast.FeatureRef(27), ast.NumVal(0.14205), ast.CompOpType.GT), ast.NumVal(-0.21340153096570616), ast.NumVal(0.11583109256834748)), ast.BinNumOpType.ADD), to_reuse=True) expected = ast.VectorVal([ ast.BinNumExpr(ast.NumVal(1), sigmoid, ast.BinNumOpType.SUB), sigmoid ]) assert utils.cmp_exprs(actual, expected)
def test_bin_class_sigmoid_output_transform(): estimator = lgb.LGBMClassifier(n_estimators=1, random_state=1, max_depth=1, sigmoid=0.5) utils.get_binary_classification_model_trainer()(estimator) assembler = LightGBMModelAssembler(estimator) actual = assembler.assemble() sigmoid = ast.SigmoidExpr(ast.BinNumExpr( ast.NumVal(0.5), ast.IfExpr( ast.CompExpr(ast.FeatureRef(20), ast.NumVal(16.795), ast.CompOpType.GT), ast.NumVal(0.5500419366076967), ast.NumVal(1.2782342253678096)), ast.BinNumOpType.MUL), to_reuse=True) expected = ast.VectorVal([ ast.BinNumExpr(ast.NumVal(1), sigmoid, ast.BinNumOpType.SUB), sigmoid ]) assert utils.cmp_exprs(actual, expected)
def _bin_class_convert_output(self, expr, to_reuse=True): return ast.SigmoidExpr(expr, to_reuse=to_reuse)
def _logit_inversed(self, ast_to_transform): return ast.SigmoidExpr(ast_to_transform)
assert ast.count_exprs( ast.BinNumExpr(ast.NumVal(1), ast.NumVal(2), ast.BinNumOpType.ADD), exclude_list={ast.BinNumExpr} ) == 2 EXPR_WITH_ALL_EXPRS = ast.BinVectorNumExpr( ast.BinVectorExpr( ast.VectorVal([ ast.AbsExpr(ast.NumVal(-2)), ast.AtanExpr(ast.NumVal(2)), ast.ExpExpr(ast.NumVal(2)), ast.LogExpr(ast.NumVal(2)), ast.Log1pExpr(ast.NumVal(2)), ast.SigmoidExpr(ast.NumVal(2)), ast.SqrtExpr(ast.NumVal(2)), ast.PowExpr(ast.NumVal(2), ast.NumVal(3)), ast.TanhExpr(ast.NumVal(1)), ast.BinNumExpr( ast.NumVal(0), ast.FeatureRef(0), ast.BinNumOpType.ADD) ]), ast.IdExpr( ast.SoftmaxExpr([ ast.NumVal(1), ast.NumVal(2), ast.NumVal(3), ast.NumVal(4), ast.NumVal(5),