#![allow(clippy::ptr_arg)]
#![allow(clippy::type_complexity)]
#![cfg_attr(all(feature = "mesalock_sgx",
not(target_env = "sgx")), no_std)]
#![cfg_attr(all(target_env = "sgx", target_vendor = "mesalock"), feature(rustc_private))]
#[cfg(all(feature = "mesalock_sgx", not(target_env = "sgx")))]
#[macro_use]
extern crate sgx_tstd as std;
pub mod binary_tree;
pub mod config;
pub mod decision_tree;
pub mod fitness;
pub mod gradient_boost;
#[cfg(feature = "input")]
#[macro_use]
extern crate cfg_if;
#[cfg(feature = "input")]
pub mod input;
#[cfg(test)]
mod tests {
#[test]
fn walk_tree() {
use crate::binary_tree::*;
let mut tree: BinaryTree<f32> = BinaryTree::new();
let root = BinaryTreeNode::new(10.0);
let root_index = tree.add_root(root);
let n1 = BinaryTreeNode::new(5.0);
let n2 = BinaryTreeNode::new(6.0);
let n1_index = tree.add_left_node(root_index, n1);
let n2_index = tree.add_right_node(root_index, n2);
let n3 = BinaryTreeNode::new(7.0);
let n4 = BinaryTreeNode::new(8.0);
tree.add_left_node(n2_index, n3);
tree.add_right_node(n2_index, n4);
let n5 = BinaryTreeNode::new(9.0);
tree.add_left_node(n1_index, n5);
tree.print();
}
#[test]
fn decision_tree() {
use crate::config::Loss;
use crate::decision_tree::*;
let mut tree = DecisionTree::new();
tree.set_feature_size(3);
tree.set_max_depth(2);
tree.set_min_leaf_size(1);
tree.set_loss(Loss::SquaredError);
let data1 = Data {
feature: vec![1.0, 2.0, 3.0],
target: 2.0,
weight: 1.0,
label: 1.0,
residual: 1.0,
initial_guess: 1.0,
};
let data2 = Data {
feature: vec![1.1, 2.1, 3.1],
target: 1.0,
weight: 1.0,
label: 1.0,
residual: 1.0,
initial_guess: 1.0,
};
let data3 = Data {
feature: vec![2.0, 2.0, 1.0],
target: 0.5,
weight: 1.0,
label: 2.0,
residual: 2.0,
initial_guess: 2.0,
};
let data4 = Data {
feature: vec![2.0, 2.3, 1.2],
target: 3.0,
weight: 1.0,
label: 0.0,
residual: 0.0,
initial_guess: 1.0,
};
let mut dv = Vec::new();
dv.push(data1.clone());
dv.push(data2.clone());
dv.push(data3.clone());
dv.push(data4.clone());
let mut cache = TrainingCache::get_cache(3, &dv, 3);
tree.fit(&dv, &mut cache);
tree.print();
let mut dv = Vec::new();
dv.push(data1.clone());
dv.push(data2.clone());
dv.push(data3.clone());
dv.push(data4.clone());
println!("{:?}", tree.predict(&dv));
}
#[test]
fn build_decision_tree() {
use crate::decision_tree::DecisionTree;
let _ = DecisionTree::new();
}
#[test]
fn config_express() {
use crate::config::Config;
let c = Config::new();
println!("{}", c.to_string());
}
#[test]
fn loss_type() {
use crate::config::{loss2string, string2loss, Loss};
assert_eq!(string2loss("SquaredError"), Loss::SquaredError);
assert_eq!(string2loss("LogLikelyhood"), Loss::LogLikelyhood);
assert_eq!(string2loss("LAD"), Loss::LAD);
assert_eq!(loss2string(&Loss::SquaredError), "SquaredError");
assert_eq!(loss2string(&Loss::LogLikelyhood), "LogLikelyhood");
assert_eq!(loss2string(&Loss::LAD), "LAD");
}
#[test]
fn fitness() {
use crate::decision_tree::*;
let mut dv: DataVec = Vec::new();
dv.push(Data {
feature: Vec::new(),
target: 1.0,
weight: 0.1,
label: 1.0,
residual: 0.5,
initial_guess: VALUE_TYPE_UNKNOWN,
});
dv.push(Data {
feature: Vec::new(),
target: 1.0,
weight: 0.2,
label: 0.0,
residual: 0.5,
initial_guess: VALUE_TYPE_UNKNOWN,
});
dv.push(Data {
feature: Vec::new(),
target: 0.0,
weight: 0.3,
label: 1.0,
residual: 0.5,
initial_guess: VALUE_TYPE_UNKNOWN,
});
dv.push(Data {
feature: Vec::new(),
target: 0.0,
weight: 0.4,
label: 0.0,
residual: 0.5,
initial_guess: VALUE_TYPE_UNKNOWN,
});
use crate::fitness::{
almost_equal, average, label_average, same, weighted_label_median,
weighted_residual_median,
};
assert_eq!(true, almost_equal(0.1, 0.100000000001));
assert_eq!(false, same(&dv, dv.len()));
assert!(almost_equal(0.3, average(&dv, dv.len())));
assert!(almost_equal(0.4, label_average(&dv, dv.len())));
assert!(almost_equal(0.0, weighted_label_median(&dv, dv.len())));
assert!(almost_equal(0.5, weighted_residual_median(&dv, dv.len())));
}
}