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),
