def test_softmax_expr(): expr = ast.SoftmaxExpr([ast.NumVal(2.0), ast.NumVal(3.0)]) expected_code = """ import "math" func score(input []float64) []float64 { return softmax([]float64{2.0, 3.0}) } func softmax(x []float64) []float64 { size := len(x) result := make([]float64, size) max := x[0] for _, v := range x { if (v > max) { max = v } } sum := 0.0 for i := 0; i < size; i++ { result[i] = math.Exp(x[i] - max) sum += result[i] } for i := 0; i < size; i++ { result[i] /= sum } return result } """ interpreter = GoInterpreter() 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.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 = GoInterpreter() utils.assert_code_equal(interpreter.interpret(expr), expected_code)
def test_bin_vector_num_expr(): expr = ast.BinVectorNumExpr(ast.VectorVal([ast.NumVal(1), ast.NumVal(2)]), ast.NumVal(1), ast.BinNumOpType.MUL) interpreter = GoInterpreter() expected_code = """ func addVectors(v1, v2 []float64) []float64 { result := make([]float64, len(v1)) for i := 0; i < len(v1); i++ { result[i] = v1[i] + v2[i] } return result } func mulVectorNumber(v1 []float64, num float64) []float64 { result := make([]float64, len(v1)) for i := 0; i < len(v1); i++ { result[i] = v1[i] * num } return result } func score(input []float64) []float64 { return mulVectorNumber([]float64{1.0, 2.0}, 1.0) }""" utils.assert_code_equal(interpreter.interpret(expr), expected_code)
def test_raw_array(): expr = ast.VectorVal([ast.NumVal(3), ast.NumVal(4)]) expected_code = """ func score(input []float64) []float64 { return []float64{3.0, 4.0} }""" interpreter = GoInterpreter() utils.assert_code_equal(interpreter.interpret(expr), expected_code)
def __init__(self, model): self.model_name = "score" self.model = model self.interpreter = GoInterpreter() assembler_cls = get_assembler_cls(model) self.model_ast = assembler_cls(model).assemble() self.exec_path = None
def test_atan_expr(): expr = ast.AtanExpr(ast.NumVal(2.0)) interpreter = GoInterpreter() expected_code = """ import "math" func score(input []float64) float64 { return math.Atan(2.0) }""" utils.assert_code_equal(interpreter.interpret(expr), expected_code)
def test_log1p_expr(): expr = ast.Log1pExpr(ast.NumVal(2.0)) expected_code = """ import "math" func score(input []float64) float64 { return math.Log1p(2.0) } """ interpreter = GoInterpreter() assert_code_equal(interpreter.interpret(expr), expected_code)
def test_pow_expr(): expr = ast.PowExpr(ast.NumVal(2.0), ast.NumVal(3.0)) expected_code = """ import "math" func score(input []float64) float64 { return math.Pow(2.0, 3.0) } """ interpreter = GoInterpreter() assert_code_equal(interpreter.interpret(expr), expected_code)
def test_bin_num_expr(): expr = ast.BinNumExpr( ast.BinNumExpr(ast.FeatureRef(0), ast.NumVal(-2), ast.BinNumOpType.DIV), ast.NumVal(2), ast.BinNumOpType.MUL) interpreter = GoInterpreter() expected_code = """ func score(input []float64) float64 { return ((input[0]) / (-2.0)) * (2.0) }""" utils.assert_code_equal(interpreter.interpret(expr), expected_code)
def test_reused_expr(): reused_expr = ast.ExpExpr(ast.NumVal(1.0), to_reuse=True) expr = ast.BinNumExpr(reused_expr, reused_expr, ast.BinNumOpType.DIV) interpreter = GoInterpreter() expected_code = """ import "math" func score(input []float64) float64 { var var0 float64 var0 = math.Exp(1.0) return (var0) / (var0) }""" utils.assert_code_equal(interpreter.interpret(expr), expected_code)
def test_if_expr(): expr = ast.IfExpr( ast.CompExpr(ast.NumVal(1), ast.FeatureRef(0), ast.CompOpType.EQ), ast.NumVal(2), ast.NumVal(3)) interpreter = GoInterpreter() expected_code = """ func score(input []float64) float64 { var var0 float64 if (1.0) == (input[0]) { var0 = 2.0 } else { var0 = 3.0 } return var0 }""" utils.assert_code_equal(interpreter.interpret(expr), expected_code)
def test_multi_output(): expr = ast.IfExpr( ast.CompExpr(ast.NumVal(1), ast.NumVal(1), ast.CompOpType.EQ), ast.VectorVal([ast.NumVal(1), ast.NumVal(2)]), ast.VectorVal([ast.NumVal(3), ast.NumVal(4)])) expected_code = """ func score(input []float64) []float64 { var var0 []float64 if (1.0) == (1.0) { var0 = []float64{1.0, 2.0} } else { var0 = []float64{3.0, 4.0} } return var0 }""" interpreter = GoInterpreter() utils.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_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 = """ func score(input []float64) float64 { var var0 float64 var var1 float64 if (1.0) == (1.0) { var1 = 1.0 } else { var1 = 2.0 } if (1.0) == ((var1) + (2.0)) { var var2 float64 if (1.0) == (1.0) { var2 = 1.0 } else { var2 = 2.0 } if (1.0) == ((var2) + (2.0)) { var0 = input[2] } else { var0 = 2.0 } } else { var0 = 2.0 } return var0 }""" interpreter = GoInterpreter() utils.assert_code_equal(interpreter.interpret(expr), expected_code)
class GoExecutor(BaseExecutor): def __init__(self, model): self.model_name = "score" self.model = model self.interpreter = GoInterpreter() assembler_cls = get_assembler_cls(model) self.model_ast = assembler_cls(model).assemble() self.exec_path = None def predict(self, X): exec_args = [str(self.exec_path), *map(utils.format_arg, X)] return utils.predict_from_commandline(exec_args) def prepare(self): if self.model_ast.output_size > 1: print_code = EXECUTE_AND_PRINT_VECTOR else: print_code = EXECUTE_AND_PRINT_SCALAR executor_code = EXECUTOR_CODE_TPL.format( model_code=self.interpreter.interpret(self.model_ast), print_code=print_code) file_name = self._resource_tmp_dir / f"{self.model_name}.go" utils.write_content_to_file(executor_code, file_name) self.exec_path = self._resource_tmp_dir / self.model_name subprocess.call([ "go", "build", "-o", str(self.exec_path), str(file_name) ])