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
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

use crate::{
    decision_tree::{self, RegressorModel},
    trainer_builders::*,
    FloatTarget, Trainset,
};

use serde::{Deserialize, Serialize};

/// A regression tree.
/// # Training
/// The [Trainer] implements [CommonTrainerBuilder]. Default training parameters:
/// ```text
/// max_depth: usize::MAX,
/// max_features: NumFeatures::NUMBER(usize::MAX),
/// seed: 42,
/// min_samples_leaf: 1,
/// min_samples_split: 2,
/// sample_weights: empty (1.0 for each sample)
///```
///
/// # Example
/// ```
/// use rafor::dt;
/// let dataset = [0.7, 0.0, 0.8, 1.0, 0.7, 0.0];
/// let targets = [1.0, 0.5, 0.2];
/// let predictor = dt::Regressor::trainer().train(&dataset, &targets);
/// let predictions = predictor.predict(&dataset);
/// println!("Predictions: {:?}", predictions);
/// ```
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Regressor {
    regressor: RegressorModel,
}

/// Trainer for tree regressor.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct Trainer {
    pub config: decision_tree::TrainConfig,
}

impl TrainConfigProvider for Trainer {
    fn train_config(&mut self) -> &mut decision_tree::TrainConfig {
        &mut self.config
    }
}

impl CommonTrainerBuilder for Trainer {}
//impl RegressorConfigBuilder for Trainer {}

impl Trainer {
    /// Trains a regression tree with dataset given by a slice of length divisible by targets.len().
    pub fn train(&self, data: &[f32], targets: &[FloatTarget]) -> Regressor {
        let trainset = Trainset::with_transposed(data, &targets);

        Regressor {
            regressor: RegressorModel::train(&trainset, &self.config),
        }
    }
}

impl Regressor {
    /// Predicts regression values for a set of samples.
    /// Dataset is a vector of floats with length multiple of num_features().
    pub fn predict(&self, dataset: &[f32]) -> Vec<FloatTarget> {
        //let view = DatasetView::new(dataset, self.regressor.num_features());
        self.regressor.predict(dataset)
    }

    /// Predicts regression value for a single sample given by a slice of length num_features().
    pub fn predict_one(&self, sample: &[f32]) -> FloatTarget {
        self.regressor.predict_one(sample)
    }

    /// Provides trainer for training a regressor tree.
    pub fn trainer() -> Trainer {
        Trainer::default()
    }

    /// Returns a number of features for a trained tree.
    pub fn num_features(&self) -> usize {
        self.regressor.num_features()
    }
}