rafor 0.3.0

Fast Random Forest library.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

use super::{splitter::MseSplitter, trainer, DecisionTree, TrainConfig};

use crate::{FloatTarget, SampleWeight, Trainset};

use serde::{Deserialize, Serialize};

#[derive(Default, Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct RegressorModel {
    tree: DecisionTree,
}

#[derive(Default)]
struct Aggregator {}

impl RegressorModel {
    pub fn predict(&self, dataset: &[f32]) -> Vec<f32> {
        assert!(dataset.len() % self.tree.num_features() == 0);
        dataset
            .chunks_exact(self.tree.num_features())
            .map(|s| self.predict_one(s))
            .collect()
    }

    #[inline(always)]
    pub fn num_features(&self) -> usize {
        self.tree.num_features()
    }

    #[inline(always)]
    pub fn predict_one(&self, sample: &[f32]) -> f32 {
        f32::from_bits(self.tree.predict(sample))
    }

    pub fn train(ts: &Trainset<FloatTarget>, config: &TrainConfig) -> RegressorModel {
        let mut aggregator = Aggregator::default();
        let tree = trainer::train(
            ts,
            config.clone(),
            MseSplitter::new(config.min_samples_leaf),
            &mut aggregator,
        );

        RegressorModel { tree }
    }
}

impl trainer::Aggregator<FloatTarget> for Aggregator {
    fn aggregate(&mut self, leaf_items: &[(FloatTarget, SampleWeight)]) -> u32 {
        let mut s: f64 = 0.;
        let mut total_weight: f64 = 0.;
        for &(x, w) in leaf_items.iter() {
            s += (x * w) as f64;
            total_weight += w as f64;
        }
        let value = (s / total_weight) as f32;
        value.to_bits()
    }
}