def test_multi_class():
estimator = ensemble.RandomForestClassifier(n_estimators=2,
random_state=13)
estimator.fit([[1], [2], [3]], [1, -1, 1])
assembler = assemblers.RandomForestModelAssembler(estimator)
actual = assembler.assemble()
expected = ast.BinVectorExpr(
ast.BinVectorNumExpr(
ast.SubroutineExpr(
ast.IfExpr(
ast.CompExpr(ast.FeatureRef(0), ast.NumVal(1.5),
ast.CompOpType.LTE),
ast.VectorVal([ast.NumVal(0.0),
ast.NumVal(1.0)]),
ast.VectorVal([ast.NumVal(1.0),
ast.NumVal(0.0)]))), ast.NumVal(0.5),
ast.BinNumOpType.MUL),
ast.BinVectorNumExpr(
ast.SubroutineExpr(
ast.IfExpr(
ast.CompExpr(ast.FeatureRef(0), ast.NumVal(2.5),
ast.CompOpType.LTE),
ast.VectorVal([ast.NumVal(1.0),
ast.NumVal(0.0)]),
ast.VectorVal([ast.NumVal(0.0),
ast.NumVal(1.0)]))), ast.NumVal(0.5),
ast.BinNumOpType.MUL), ast.BinNumOpType.ADD)
assert utils.cmp_exprs(actual, expected)
def test_bin_vector_num_expr():
expr = ast.BinVectorNumExpr(ast.VectorVal([ast.NumVal(1),
ast.NumVal(2)]), ast.NumVal(1),
ast.BinNumOpType.MUL)
expected_code = """
namespace ML {
public static class Model {
public static double[] Score(double[] input) {
return MulVectorNumber(new double[2] {1.0, 2.0}, 1.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;
}
}
}
"""
interpreter = CSharpInterpreter()
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)
expected_code = """
function Add-Vectors([double[]] $v1, [double[]] $v2) {
[int] $length = $v1.Length
[double[]] $result = @(0) * $length
for ([int] $i = 0; $i -lt $length; ++$i) {
$result[$i] = $v1[$i] + $v2[$i]
}
return $result
}
function Mul-Vector-Number([double[]] $v1, [double] $num) {
[int] $length = $v1.Length
[double[]] $result = @(0) * $length
for ([int] $i = 0; $i -lt $length; ++$i) {
$result[$i] = $v1[$i] * $num
}
return $result
}
function Score([double[]] $InputVector) {
return Mul-Vector-Number $(@($(1), $(2))) $(1)
}
"""
interpreter = PowershellInterpreter()
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)
expected_code = """
<?php
function addVectors(array $v1, array $v2) {
$result = array();
for ($i = 0; $i < count($v1); ++$i) {
$result[] = $v1[$i] + $v2[$i];
}
return $result;
}
function mulVectorNumber(array $v1, $num) {
$result = array();
for ($i = 0; $i < count($v1); ++$i) {
$result[] = $v1[$i] * $num;
}
return $result;
}
function score(array $input) {
return mulVectorNumber(array(1, 2), 1);
}
"""
interpreter = PhpInterpreter()
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 = interpreters.JavascriptInterpreter()
expected_code = """
function score(input) {
return mulVectorNumber([1, 2], 1);
}
function addVectors(v1, v2) {
let result = new Array(v1.length);
for (let i = 0; i < v1.length; i++) {
result[i] = v1[i] + v2[i];
}
return result;
}
function mulVectorNumber(v1, num) {
let result = new Array(v1.length);
for (let i = 0; i < v1.length; i++) {
result[i] = v1[i] * num;
}
return result;
}
"""
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 = JavaInterpreter()
expected_code = """
public class Model {
public static double[] score(double[] input) {
return mulVectorNumber(new double[] {1.0, 2.0}, 1.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;
}
}"""
utils.assert_code_equal(interpreter.interpret(expr), expected_code)
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_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_bin_vector_num_expr():
expr = ast.BinVectorNumExpr(ast.VectorVal([ast.NumVal(1),
ast.NumVal(2)]), ast.NumVal(1),
ast.BinNumOpType.MUL)
interpreter = interpreters.CInterpreter()
expected_code = """
void assign_array(double source[], double *target, int size) {
for(int i = 0; i < size; ++i)
target[i] = source[i];
}
void add_vectors(double *v1, double *v2, int size, double *result) {
for(int i = 0; i < size; ++i)
result[i] = v1[i] + v2[i];
}
void mul_vector_number(double *v1, double num, int size, double *result) {
for(int i = 0; i < size; ++i)
result[i] = v1[i] * num;
}
void score(double * input, double * output) {
double var0[2];
mul_vector_number((double[]){1, 2}, 1, 2, var0);
assign_array(var0, output, 2);
}"""
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)
expected_code = """
List<double> score(List<double> input) {
return mulVectorNumber([1.0, 2.0], 1.0);
}
List<double> addVectors(List<double> v1, List<double> v2) {
List<double> result = new List<double>(v1.length);
for (int i = 0; i < v1.length; i++) {
result[i] = v1[i] + v2[i];
}
return result;
}
List<double> mulVectorNumber(List<double> v1, double num) {
List<double> result = new List<double>(v1.length);
for (int i = 0; i < v1.length; i++) {
result[i] = v1[i] * num;
}
return result;
}
"""
interpreter = DartInterpreter()
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)
expected_code = """
score <- function(input) {
return((c(1.0, 2.0)) * (1.0))
}
"""
interpreter = RInterpreter()
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 = interpreters.PythonInterpreter()
expected_code = """
import numpy as np
def score(input):
return (np.asarray([1, 2])) * (1)
"""
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)
expected_code = """
let private addVectors v1 v2 = List.map2 (+) v1 v2
let private mulVectorNumber v1 num = List.map (fun i -> i * num) v1
let score (input : double list) =
mulVectorNumber ([1.0; 2.0]) (1.0)
"""
interpreter = FSharpInterpreter()
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)
expected_code = """
def add_vectors(v1, v2):
return [sum(i) for i in zip(v1, v2)]
def mul_vector_number(v1, num):
return [i * num for i in v1]
def score(input):
return mul_vector_number([1.0, 2.0], 1.0)
"""
interpreter = PythonInterpreter()
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)
expected_code = """
Module Model
Function AddVectors(ByRef v1() As Double, ByRef v2() As Double) As Double()
Dim resLength As Integer
resLength = UBound(v1) - LBound(v1)
Dim result() As Double
ReDim result(resLength)
Dim i As Integer
For i = LBound(v1) To UBound(v1)
result(i) = v1(i) + v2(i)
Next i
AddVectors = result
End Function
Function MulVectorNumber(ByRef v1() As Double, ByVal num As Double) As Double()
Dim resLength As Integer
resLength = UBound(v1) - LBound(v1)
Dim result() As Double
ReDim result(resLength)
Dim i As Integer
For i = LBound(v1) To UBound(v1)
result(i) = v1(i) * num
Next i
MulVectorNumber = result
End Function
Function Score(ByRef inputVector() As Double) As Double()
Dim var0(1) As Double
var0(0) = 1.0
var0(1) = 2.0
Score = MulVectorNumber(var0, 1.0)
End Function
End Module
"""
interpreter = VisualBasicInterpreter()
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)
expected_code = """
module Model where
addVectors :: [Double] -> [Double] -> [Double]
addVectors v1 v2 = zipWith (+) v1 v2
mulVectorNumber :: [Double] -> Double -> [Double]
mulVectorNumber v1 num = [i * num | i <- v1]
score :: [Double] -> [Double]
score input =
mulVectorNumber ([1, 2]) (1)
"""
interpreter = HaskellInterpreter()
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)
expected_code = """
def score(input)
mul_vector_number([1.0, 2.0], 1.0)
end
def add_vectors(v1, v2)
v1.zip(v2).map { |x, y| x + y }
end
def mul_vector_number(v1, num)
v1.map { |i| i * num }
end
"""
interpreter = RubyInterpreter()
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)
expected_code = """
fn score(input: Vec<f64>) -> Vec<f64> {
mul_vector_number(vec![1.0_f64, 2.0_f64], 1.0_f64)
}
fn add_vectors(v1: Vec<f64>, v2: Vec<f64>) -> Vec<f64> {
v1.iter().zip(v2.iter()).map(|(&x, &y)| x + y).collect::<Vec<f64>>()
}
fn mul_vector_number(v1: Vec<f64>, num: f64) -> Vec<f64> {
v1.iter().map(|&i| i * num).collect::<Vec<f64>>()
}
"""
interpreter = RustInterpreter()
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 = interpreters.CInterpreter()
expected_code = """
#include <string.h>
void add_vectors(double *v1, double *v2, int size, double *result) {
for(int i = 0; i < size; ++i)
result[i] = v1[i] + v2[i];
}
void mul_vector_number(double *v1, double num, int size, double *result) {
for(int i = 0; i < size; ++i)
result[i] = v1[i] * num;
}
void score(double * input, double * output) {
double var0[2];
mul_vector_number((double[]){1, 2}, 1, 2, var0);
memcpy(output, var0, 2 * sizeof(double));
}"""
utils.assert_code_equal(interpreter.interpret(expr), expected_code)
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),
ast.NumVal(7),
ast.NumVal(8),
ast.NumVal(9),
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)
