def test_statsmodels_glm_inverse_squared_link_func(): estimator = utils.StatsmodelsSklearnLikeWrapper( sm.GLM, dict(init=dict( family=sm.families.Tweedie( sm.families.links.Power(-2))), fit=dict(maxiter=1))) estimator = estimator.fit([[1], [2]], [0.1, 0.2]) assembler = assemblers.StatsmodelsModelAssemblerSelector(estimator) actual = assembler.assemble() expected = ast.BinNumExpr( ast.NumVal(1.0), ast.SqrtExpr( ast.BinNumExpr( ast.NumVal(0.0), ast.BinNumExpr( ast.FeatureRef(0), ast.NumVal(15.1237331741), ast.BinNumOpType.MUL), ast.BinNumOpType.ADD)), ast.BinNumOpType.DIV) assert utils.cmp_exprs(actual, expected)
def test_count_all_exprs_types(): expr = ast.BinVectorNumExpr( ast.BinVectorExpr( ast.VectorVal([ ast.ExpExpr(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.VectorVal([ ast.NumVal(1), ast.NumVal(2), ast.NumVal(3), ast.NumVal(4), ast.FeatureRef(1) ]), ast.BinNumOpType.SUB), ast.IfExpr( ast.CompExpr(ast.NumVal(2), ast.NumVal(0), ast.CompOpType.GT), ast.NumVal(3), ast.NumVal(4), ), ast.BinNumOpType.MUL) assert ast.count_exprs(expr) == 27
def test_sqrt_expr(): expr = ast.SqrtExpr(ast.NumVal(2.0)) expected_code = """ let score (input : double list) = sqrt (2.0) """ interpreter = FSharpInterpreter() assert_code_equal(interpreter.interpret(expr), expected_code)
def test_sqrt_expr(): expr = ast.SqrtExpr(ast.NumVal(2.0)) expected_code = """ score <- function(input) { return(sqrt(2.0)) } """ interpreter = RInterpreter() utils.assert_code_equal(interpreter.interpret(expr), expected_code)
def test_sqrt_expr(): expr = ast.SqrtExpr(ast.NumVal(2.0)) expected_code = """ def score(input) Math.sqrt(2.0) end """ interpreter = RubyInterpreter() assert_code_equal(interpreter.interpret(expr), expected_code)
def test_sqrt_expr(): expr = ast.SqrtExpr(ast.NumVal(2.0)) expected_code = """ function Score([double[]] $InputVector) { return [math]::Sqrt(2.0) } """ interpreter = PowershellInterpreter() utils.assert_code_equal(interpreter.interpret(expr), expected_code)
def test_sqrt_expr(): expr = ast.SqrtExpr(ast.NumVal(2.0)) expected_code = """ function score(input) { return Math.sqrt(2.0); } """ interpreter = JavascriptInterpreter() assert_code_equal(interpreter.interpret(expr), expected_code)
def test_sqrt_expr(): expr = ast.SqrtExpr(ast.NumVal(2.0)) expected_code = """ fn score(input: Vec<f64>) -> f64 { f64::sqrt(2.0_f64) } """ interpreter = RustInterpreter() assert_code_equal(interpreter.interpret(expr), expected_code)
def kernel_ast(sup_vec_value): feature_norm = ast.SqrtExpr(ast.BinNumExpr(ast.FeatureRef(0), ast.FeatureRef(0), ast.BinNumOpType.MUL), to_reuse=True) return ast.BinNumExpr( ast.BinNumExpr(ast.NumVal(sup_vec_value), ast.FeatureRef(0), ast.BinNumOpType.MUL), ast.IfExpr( ast.CompExpr(feature_norm, ast.NumVal(0.0), ast.CompOpType.EQ), ast.NumVal(1.0), feature_norm), ast.BinNumOpType.DIV)
def test_sqrt_expr(): expr = ast.SqrtExpr(ast.NumVal(2.0)) expected_code = """ import math def score(input): return math.sqrt(2.0) """ interpreter = PythonInterpreter() assert_code_equal(interpreter.interpret(expr), expected_code)
def test_sqrt_expr(): expr = ast.SqrtExpr(ast.NumVal(2.0)) expected_code = """ module Model where score :: [Double] -> Double score input = sqrt (2.0) """ interpreter = HaskellInterpreter() utils.assert_code_equal(interpreter.interpret(expr), expected_code)
def test_sqrt_expr(): expr = ast.SqrtExpr(ast.NumVal(2.0)) interpreter = interpreters.CInterpreter() expected_code = """ #include <math.h> double score(double * input) { return sqrt(2.0); }""" utils.assert_code_equal(interpreter.interpret(expr), expected_code)
def test_sqrt_expr(): expr = ast.SqrtExpr(ast.NumVal(2.0)) interpreter = GoInterpreter() expected_code = """ import "math" func score(input []float64) float64 { return math.Sqrt(2.0) }""" utils.assert_code_equal(interpreter.interpret(expr), expected_code)
def test_sqrt_expr(): expr = ast.SqrtExpr(ast.NumVal(2.0)) expected_code = """ <?php function score(array $input) { return sqrt(2.0); } """ interpreter = PhpInterpreter() utils.assert_code_equal(interpreter.interpret(expr), expected_code)
def test_sqrt_expr(): expr = ast.SqrtExpr(ast.NumVal(2.0)) expected_code = """ import 'dart:math'; double score(List<double> input) { return sqrt(2.0); } """ interpreter = DartInterpreter() utils.assert_code_equal(interpreter.interpret(expr), expected_code)
def test_sqrt_expr(): expr = ast.SqrtExpr(ast.NumVal(2.0)) expected_code = """ Module Model Function Score(ByRef inputVector() As Double) As Double Score = (2.0) ^ (0.5) End Function End Module """ interpreter = VisualBasicInterpreter() utils.assert_code_equal(interpreter.interpret(expr), expected_code)
def test_sqrt_fallback_expr(): expr = ast.SqrtExpr(ast.NumVal(2.0)) interpreter = PythonInterpreter() interpreter.sqrt_function_name = NotImplemented expected_code = """ import math def score(input): return math.pow(2.0, 0.5) """ assert_code_equal(interpreter.interpret(expr), expected_code)
def test_sqrt_expr(): expr = ast.SqrtExpr(ast.NumVal(2.0)) interpreter = JavaInterpreter() expected_code = """ public class Model { public static double score(double[] input) { return Math.sqrt(2.0); } }""" utils.assert_code_equal(interpreter.interpret(expr), expected_code)
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_sqrt_expr(): expr = ast.SqrtExpr(ast.NumVal(2.0)) expected_code = """ using static System.Math; namespace ML { public static class Model { public static double Score(double[] input) { return Sqrt(2.0); } } } """ interpreter = CSharpInterpreter() assert_code_equal(interpreter.interpret(expr), expected_code)
def _power_inversed(self, ast_to_transform): power = self._get_power() if power == 1: return self._identity_inversed(ast_to_transform) elif power == -1: return self._inverse_power_inversed(ast_to_transform) elif power == 2: return ast.SqrtExpr(ast_to_transform) elif power == -2: return self._inverse_squared_inversed(ast_to_transform) elif power < 0: # some languages may not support negative exponent return utils.div( ast.NumVal(1.0), ast.PowExpr(ast_to_transform, ast.NumVal(1 / -power))) else: return ast.PowExpr(ast_to_transform, ast.NumVal(1 / power))
def _inverse_squared_inversed(self, ast_to_transform): return utils.div(ast.NumVal(1.0), ast.SqrtExpr(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), ast.NumVal(6),