miniboosts 0.3.6

MiniBoosts: A collection of boosting algorithms written in Rust 🦀
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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

use polars::prelude::*;

use crate::weak_learner::*;

use crate::{
    Classifier,
};


/// The union of weak learners.
/// One can use unify multiple weak learners by this struct.
/// 
/// See also:
/// - [`DTree`](crate::weak_learner::DTree)
/// 
/// # Example
/// ```no_run
/// use polars::prelude::*;
/// use miniboosts::prelude::*;
/// 
/// // Read the training data from the CSV file.
/// let mut data = CsvReader::from_path(path_to_csv_file)
///     .unwrap()
///     .has_header(true)
///     .finish()
///     .unwrap();
/// 
/// // Split the column corresponding to labels.
/// let target = data.drop_in_place(class_column_name).unwrap();
/// 
/// 
/// let t1 = DTree::init(&data, &target)
///     .max_depth(1)
///     .criterion(Criterion::Edge);
/// let t2 = DTree::init(&data, &target)
///     .max_depth(2)
///     .criterion(Criterion::Edge);
/// 
/// let weak_learner = WLUnion::new()
///     .union(Box::new(t1))
///     .union(Box::new(t2));
/// ```
pub struct WLUnion<F> {
    weak_learners: Vec<Box<dyn WeakLearner<Hypothesis = F>>>,
}

impl<F> WLUnion<F> {
    /// Generates an empty instance of `WLUnion`.
    pub fn new() -> Self {
        let weak_learners = Vec::new();
        Self { weak_learners }
    }


    /// Append a weak learner to the union.
    pub fn union(
        mut self,
        weak_learner: Box<dyn WeakLearner<Hypothesis = F>>
    ) -> Self
    {
        self.weak_learners.push(weak_learner);
        self
    }
}


impl<F> WeakLearner for WLUnion<F>
    where F: Classifier + 'static
{
    type Hypothesis = Box<dyn Classifier>;


    fn name(&self) -> &str {
        "Union of WLs"
    }


    /// Output a boxed hypothesis which maximizes the edge
    /// among the hypotheses returned by weak learners.
    fn produce(
        &self,
        data: &DataFrame,
        target: &Series,
        dist: &[f64],
    ) -> Self::Hypothesis
    {
        self.weak_learners.iter()
            .map(|wl| {
                let h = wl.produce(data, target, dist);
                let edge = target.i64()
                    .expect("The target class is not a dtype i64")
                    .into_iter()
                    .zip(dist)
                    .enumerate()
                    .map(|(i, (y, d))| {
                        let y = y.unwrap() as f64;
                        let p = h.predict(data, i) as f64;

                        d * y * p
                    })
                    .sum::<f64>();
                (edge, Box::new(h))
            })
            .max_by(|(e1, _), (e2, _)| e1.partial_cmp(&e2).unwrap())
            .unwrap().1
    }
}