Add boilerplate code for mondrian forest

Cargo.toml

@@ -29,6 +29,10 @@ opt-level = 3
 name = "credit_card"
 path = "examples/anomaly_detection/credit_card.rs"
 
+[[example]]
+name = "credit_card_clf"
+path = "examples/classification/credit_card.rs"
+
 [[bench]]
 name = "hst"
 harness = false

examples/classification/credit_card.rs

@@ -0,0 +1,57 @@
+use light_river::classification::mondrian_tree::MondrianTree;
+use light_river::common::ClassifierOutput;
+use light_river::common::ClassifierTarget;
+use light_river::datasets::credit_card::CreditCard;
+use light_river::metrics::rocauc::ROCAUC;
+use light_river::metrics::traits::ClassificationMetric;
+use light_river::stream::data_stream::DataStream;
+use light_river::stream::iter_csv::IterCsv;
+use std::fs::File;
+use std::time::Instant;
+
+fn main() {
+    let now = Instant::now();
+
+    let window_size: usize = 1000;
+    let n_trees: usize = 1;
+    let height: usize = 4;
+
+    // TODO: Check if still need for classification or it was useful only in anomany detection
+    let pos_val_metric = ClassifierTarget::from("1".to_string());
+    let pos_val_tree = pos_val_metric.clone();
+
+    let features = vec!["F1".to_string(), "F2".to_string(), "F3".to_string()];
+
+    // INITIALIZATION
+    let mut mt: MondrianTree<f32> =
+        MondrianTree::new(window_size, n_trees, height, features, pos_val_tree);
+
+    // DEBUG: remove it
+    let mut counter = 0;
+
+    // LOOP
+    let transactions: IterCsv<f32, File> = CreditCard::load_credit_card_transactions().unwrap();
+    for transaction in transactions {
+        let data = transaction.unwrap();
+        // println!("Data: {data}");
+        let observation = data.get_observation();
+        // println!("Observation: {:?}", observation);
+        let label = data.to_classifier_target("Class").unwrap();
+        // let score = mt.update(&observation, true, true).unwrap();
+
+        // Label: No idea why we it
+        // println!("Label: {:?}", label);
+        // println!("Score: {:?}", score);
+        // println!("");
+
+        counter += 1;
+        if counter > 10 {
+            break;
+        }
+        // roc_auc.update(&score, &label, Some(1.));
+    }
+
+    let elapsed_time = now.elapsed();
+    println!("Took {}ms", elapsed_time.as_millis());
+    // println!("ROCAUC: {:.2}%", roc_auc.get() * (100.0 as f32));
+}

src/classification/mod.rs

@@ -0,0 +1 @@
+pub mod mondrian_tree;

src/classification/mondrian_tree.rs

@@ -0,0 +1,186 @@
+use num::pow::Pow;
+use rand::prelude::*;
+
+use num::{Float, FromPrimitive};
+use std::cell::RefCell;
+use std::collections::HashMap;
+use std::convert::TryFrom;
+use std::env::consts;
+use std::iter::FlatMap;
+use std::mem;
+use std::ops::{AddAssign, DivAssign, MulAssign, SubAssign};
+use std::rc::Rc;
+
+use crate::common::{ClassifierOutput, ClassifierTarget, Observation};
+
+trait FType:
+    Float + FromPrimitive + AddAssign + SubAssign + MulAssign + DivAssign + std::fmt::Debug
+{
+}
+impl<T> FType for T where
+    T: Float + FromPrimitive + AddAssign + SubAssign + MulAssign + DivAssign + std::fmt::Debug
+{
+}
+
+/// Stats assocociated to one node
+/// Vecotor are the labels
+struct Stats {
+    sum: Vec<f64>,
+    sq_sum: Vec<f64>,
+    count: Vec<i32>,
+}
+impl Stats {
+    fn create_result() {
+        unimplemented!()
+    }
+    fn add() {
+        unimplemented!()
+    }
+    fn merge() {
+        unimplemented!()
+    }
+    fn predict_proba() {
+        unimplemented!()
+    }
+}
+#[derive(Debug, Copy, Clone)]
+struct Node<F> {
+    parent: Option<usize>,
+    tau: F, // Time parameter (?)
+    is_leaf: bool,
+    min_list: [F; 2], // Lists representing the minimum and maximum values of the data points contained in the current node
+    max_list: [F; 2],
+    delta: F, // Dimension in which a split occurs (?)
+    xi: F,    // Split point along the dimension specified by delta
+    left: Option<usize>,
+    right: Option<usize>,
+    // stats: Stats, // Ignoring stats for now since it should be a fixed-size array, vector should not work since we are using fixed-size arrays in Trees, but try it out and see what comes out
+}
+impl<F: FType> Node<F> {
+    // pub fn update_leaf(&mut self, x: F, label: F) {
+    pub fn update_leaf(&mut self) {
+        unimplemented!()
+    }
+    pub fn update_internal(&mut self) {
+        unimplemented!()
+    }
+    pub fn get_parent_tau(&self) -> f64 {
+        unimplemented!()
+        // match self.parent {
+        //     Some(ref parent) => parent.borrow().tau,
+        //     None => 0.0,
+        // }
+    }
+}
+
+struct Trees<F: FType> {
+    nodes: Vec<Node<F>>,
+}
+impl<F: FType> Trees<F> {
+    fn new(
+        n_trees: usize,
+        height: usize,
+        features: &Vec<String>,
+        rng: &mut ThreadRng,
+        n_nodes: usize,
+    ) -> Self {
+        if n_trees != 1 {
+            unimplemented!();
+        }
+
+        let node_default = Node::<F> {
+            parent: None,
+            tau: F::from_f64(0.33).unwrap(),
+            is_leaf: false,
+            min_list: [F::from_f64(0.1).unwrap(), F::from_f64(0.2).unwrap()],
+            max_list: [F::from_f64(0.3).unwrap(), F::from_f64(0.4).unwrap()],
+            delta: F::from_f64(0.123).unwrap(),
+            xi: F::from_f64(0.456).unwrap(),
+            left: None,
+            right: None,
+            // stats: Stats::new,
+        };
+        let mut nodes = vec![node_default; n_nodes];
+
+        for i in 0..n_nodes {
+            let left_idx = 2 * i + 1;
+            let right_idx = 2 * i + 2;
+
+            if (left_idx < n_nodes) && (right_idx < n_nodes) {
+                nodes[i].left = Some(left_idx);
+                nodes[i].right = Some(right_idx);
+                nodes[left_idx].parent = Some(i);
+                nodes[right_idx].parent = Some(i);
+            } else {
+                nodes[i].is_leaf = true;
+            }
+        }
+
+        Trees { nodes }
+    }
+}
+
+pub struct MondrianTree<F: FType> {
+    window_size: usize,
+    n_trees: usize,
+    height: usize,
+    features: Vec<String>,
+    rng: ThreadRng,
+    n_nodes: usize,
+    trees: Trees<F>,
+    first_learn: bool,
+    pos_val: ClassifierTarget,
+}
+impl<F: FType> MondrianTree<F> {
+    pub fn new(
+        window_size: usize,
+        n_trees: usize,
+        height: usize,
+        features: Vec<String>,
+        pos_val: ClassifierTarget,
+    ) -> Self {
+        let features_clone = features.clone();
+        let mut rng = rand::thread_rng();
+        // #nodes = 2 ^ height - 1
+        let n_nodes = usize::pow(2, height.try_into().unwrap()) - 1;
+        let mut trees = Trees::new(n_trees, height, &features, &mut rng, n_nodes);
+        MondrianTree::<F> {
+            window_size,
+            n_trees,
+            height,
+            features: features_clone,
+            rng,
+            n_nodes,
+            trees,
+            first_learn: false,
+            pos_val,
+        }
+    }
+
+    pub fn update(
+        &mut self,
+        observation: &Observation<F>,
+        do_score: bool,
+        do_update: bool,
+    ) -> Option<ClassifierOutput<F>> {
+        if do_score {
+            let score: F = F::from(1234.0).unwrap();
+            return Some(ClassifierOutput::Probabilities(HashMap::from([(
+                ClassifierTarget::from(self.pos_val.clone()),
+                score,
+            )])));
+        }
+        return None;
+    }
+    pub fn learn_one(&mut self, observation: &Observation<F>) {
+        self.update(observation, false, true);
+    }
+    pub fn score_one(&mut self, observation: &Observation<F>) -> Option<ClassifierOutput<F>> {
+        self.update(observation, true, false)
+    }
+    fn max_score(&self) -> F {
+        F::from(self.n_trees).unwrap()
+            * F::from(self.window_size).unwrap()
+            * (F::from(2.).unwrap().powi(self.height as i32 + 1) - F::one())
+    }
+}

src/lib.rs

@@ -1,4 +1,5 @@
 pub mod anomaly;
+pub mod classification;
 pub mod common;
 pub mod datasets;
 pub mod metrics;

src/stream/data_stream.rs

@@ -80,6 +80,7 @@ impl<F: Float + std::fmt::Display + std::str::FromStr> Data<F> {
     }
 }
 
+#[derive(Debug)]
 pub enum DataStream<F: Float + std::str::FromStr> {
     X(HashMap<String, Data<F>>),
     XY(HashMap<String, Data<F>>, HashMap<String, Data<F>>),