Add synthetic dataset and tree integrity tests

Author: MarcoDiFrancesco

Cargo.toml

@@ -35,6 +35,10 @@ path = "examples/anomaly_detection/credit_card.rs"
 name = "keystroke"
 path = "examples/classification/keystroke.rs"
 
+[[example]]
+name = "synthetic"
+path = "examples/classification/synthetic.rs"
+
 [[bench]]
 name = "hst"
 harness = false

examples/classification/keystroke.rs

@@ -44,13 +44,14 @@ fn main() {
     let n_trees: usize = 1;
 
     let transactions_f = Keystroke::load_data().unwrap();
-    let mut features = get_features(transactions_f);
+    let features = get_features(transactions_f);
     // DEBUG: remove it
-    features = features[0..2].to_vec();
+    // let features = features[0..2].to_vec();
 
     let transactions_c = Keystroke::load_data().unwrap();
-    let mut labels = get_labels(transactions_c);
-    labels = labels[0..3].to_vec();
+    let labels = get_labels(transactions_c);
+    // DEBUG: remove it
+    // let labels = labels[0..3].to_vec();
     println!("labels: {labels:?}");
     let mut mf: MondrianForest<f32> = MondrianForest::new(window_size, n_trees, &features, &labels);
 
@@ -66,9 +67,9 @@ fn main() {
             ClassifierTarget::String(y) => y,
             _ => unimplemented!(),
         };
-        let mut x_ord = Array1::<f32>::from_vec(features.iter().map(|k| x[k]).collect());
+        let x_ord = Array1::<f32>::from_vec(features.iter().map(|k| x[k]).collect());
         // DEBUG: remove it
-        x_ord = x_ord.slice(s![0..2]).to_owned();
+        // let x_ord = x_ord.slice(s![0..2]).to_owned();
 
         println!("=M=1 partial_fit");
         mf.partial_fit(&x_ord, &y);

examples/classification/synthetic.rs

@@ -0,0 +1,84 @@
+use light_river::classification::alias::FType;
+use light_river::classification::mondrian_forest::MondrianForest;
+use light_river::classification::mondrian_tree::MondrianTree;
+use light_river::common::ClassifierOutput;
+use light_river::common::ClassifierTarget;
+use light_river::datasets::synthetic::Synthetic;
+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 ndarray::{s, Array1};
+use std::borrow::Borrow;
+use std::fs::File;
+use std::time::Instant;
+
+/// Get list of features of the dataset.
+///
+/// e.g. features: ["H.e", "UD.t.i", "H.i", ...]
+fn get_features(transactions: IterCsv<f32, File>) -> Vec<String> {
+    let sample = transactions.into_iter().next();
+    let observation = sample.unwrap().unwrap().get_observation();
+    observation.iter().map(|(k, _)| k.clone()).collect()
+}
+
+fn get_labels(transactions: IterCsv<f32, File>) -> Vec<String> {
+    let mut labels = vec![];
+    for t in transactions {
+        let data = t.unwrap();
+        // TODO: use instead 'to_classifier_target' and a vector of 'ClassifierTarget'
+        let target = data.get_y().unwrap()["label"].to_string();
+        if !labels.contains(&target) {
+            labels.push(target);
+        }
+    }
+    labels
+}
+
+fn main() {
+    let now = Instant::now();
+    let window_size: usize = 1000;
+    let n_trees: usize = 1;
+
+    let transactions_f = Synthetic::load_data().unwrap();
+    let features = get_features(transactions_f);
+    // DEBUG: remove it
+    // let features = features[0..2].to_vec();
+
+    let transactions_c = Synthetic::load_data().unwrap();
+    let labels = get_labels(transactions_c);
+    // DEBUG: remove it
+    // let labels = labels[0..3].to_vec();
+    println!("labels: {labels:?}");
+    let mut mf: MondrianForest<f32> = MondrianForest::new(window_size, n_trees, &features, &labels);
+
+    let transactions = Synthetic::load_data().unwrap();
+    for transaction in transactions {
+        let data = transaction.unwrap();
+
+        let x = data.get_observation();
+        let y = data.to_classifier_target("label").unwrap();
+        // TODO: generalize to non-classification only by implementing 'ClassifierTarget'
+        // instead of taking directly the string.
+        let y = match y {
+            ClassifierTarget::String(y) => y,
+            _ => unimplemented!(),
+        };
+        let x_ord = Array1::<f32>::from_vec(features.iter().map(|k| x[k]).collect());
+        // DEBUG: remove it
+        // let x_ord = x_ord.slice(s![0..2]).to_owned();
+
+        println!("=M=1 partial_fit {x_ord}");
+        mf.partial_fit(&x_ord, &y);
+
+        println!("=M=2 predict_proba");
+        let score = mf.predict_proba(&x_ord);
+
+        println!("=M=3 score: {:?}", score);
+        println!("");
+    }
+
+    let elapsed_time = now.elapsed();
+    println!("Took {}ms", elapsed_time.as_millis());
+    // println!("ROCAUC: {:.2}%", roc_auc.get() * (100.0 as f32));
+}

src/classification/mondrian_forest.rs

@@ -43,9 +43,9 @@ impl<F: FType> MondrianForest<F> {
     ///
     /// Function in River/LightRiver: "learn_one()"
     pub fn partial_fit(&mut self, x: &Array1<F>, y: &String) {
-        println!("partial_fit() - x: {:?}, y: {y:?}", x.to_vec());
         for tree in &mut self.trees {
             tree.partial_fit(x, y);
+            println!("treeee {}", tree);
         }
     }
 

src/classification/mondrian_tree.rs

@@ -13,6 +13,7 @@ use rand::prelude::*;
 use rand_distr::{Distribution, Exp};
 use std::cell::RefCell;
 use std::collections::HashMap;
+use std::collections::HashSet;
 use std::convert::TryFrom;
 use std::env::consts;
 use std::fmt;
@@ -31,6 +32,7 @@ pub struct MondrianTree<F: FType> {
     rng: ThreadRng,
     first_learn: bool,
     nodes: Vec<Node<F>>,
+    root: Option<usize>,
 }
 impl<F: FType + fmt::Display> fmt::Display for MondrianTree<F> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -39,22 +41,23 @@ impl<F: FType + fmt::Display> fmt::Display for MondrianTree<F> {
         write!(f, "│ window_size: {}", self.window_size)?;
         for (i, node) in self.nodes.iter().enumerate() {
             writeln!(f)?;
-            write!(f, "│ │ Node {}: left = {:?}, right = {:?}, parent = {:?}, tau = {}, is_leaf = {}, min = {:?}, max = {:?}", i, node.left, node.right, node.parent, node.tau,  node.is_leaf, node.min_list.to_vec(), node.max_list.to_vec())?;
+            // write!(f, "│ │ Node {}: left = {:?}, right = {:?}, parent = {:?}, tau = {}, min = {:?}, max = {:?}", i, node.left, node.right, node.parent, node.tau,  node.min_list.to_vec(), node.max_list.to_vec())?;
+            write!(f, "│ │ Node {}: left={:?}, right={:?}, parent={:?}, tau={}, is_leaf={}, min={:?}, max={:?}", i, node.left, node.right, node.parent, node.tau,  node.is_leaf, node.min_list.to_vec(), node.max_list.to_vec())?;
+            // write!(f, "│ │ Node {}: left={:?}, right={:?}, parent={:?}, tau={}, min={:?}, max={:?}", i, node.left, node.right, node.parent, node.tau, node.min_list.to_vec(), node.max_list.to_vec())?;
         }
         Ok(())
     }
 }
 impl<F: FType> MondrianTree<F> {
     pub fn new(window_size: usize, features: &Vec<String>, labels: &Vec<String>) -> Self {
-        let mut rng = rand::thread_rng();
-        let nodes = vec![];
         MondrianTree::<F> {
             window_size,
             features: features.clone(),
             labels: labels.clone(),
-            rng,
+            rng: rand::thread_rng(),
             first_learn: false,
-            nodes,
+            nodes: vec![],
+            root: None,
         }
     }
 
@@ -79,6 +82,7 @@ impl<F: FType> MondrianTree<F> {
             right: None,
             stats: Stats::new(num_labels, feature_dim),
         };
+
         // TODO: check if this works:
         // labels: ["s002", "s003", "s004"]
         let label_idx = labels.iter().position(|l| l == label).unwrap();
@@ -92,10 +96,43 @@ impl<F: FType> MondrianTree<F> {
     /// working only on one, so it's the same as "predict()".
     pub fn predict_proba(&self, x: &Array1<F>) -> Array1<F> {
         let root = 0;
+        self.test_tree();
         self.predict(x, root, F::one())
     }
 
-    fn extend_mondrian_block(&mut self, node_idx: usize, x: &Array1<F>, label: &String) {
+    fn test_tree(&self) {
+        for node_idx in 0..self.nodes.len() {
+            // TODO: check if self.root is None, if so tree should be empty
+            if node_idx == self.root.unwrap() {
+                // Root node
+                assert!(self.nodes[node_idx].parent.is_none(), "Root has a parent.");
+            } else {
+                // Non-root node
+                assert!(
+                    !self.nodes[node_idx].parent.is_none(),
+                    "Non-root node has no parent"
+                )
+            }
+        }
+
+        let children_l: Vec<usize> = self.nodes.iter().filter_map(|node| node.left).collect();
+        let children_r: Vec<usize> = self.nodes.iter().filter_map(|node| node.right).collect();
+        let children = [children_l.clone(), children_r.clone()].concat();
+        let mut seen = HashSet::new();
+        let has_duplicates = children.iter().any(|item| !seen.insert(item));
+        assert!(
+            !has_duplicates,
+            "Multiple nodes share 1 child. Children left: {:?}, Children right: {:?}",
+            children_l, children_r
+        );
+
+        // TODO: replace this test with a "Tree integrity" by starting from the root node, recursively
+        //       go to the child, check if the parent is correct.
+    }
+
+    fn extend_mondrian_block(&mut self, node_idx: usize, x: &Array1<F>, label: &String) -> usize {
+        println!("PRE_MONDRIAN");
+
         // Collect necessary values for computations
         let parent_tau = self.get_parent_tau(node_idx);
         let tau = self.nodes[node_idx].tau;
@@ -168,6 +205,8 @@ impl<F: FType> MondrianTree<F> {
             self.nodes[node_idx].parent = Some(parent_idx);
 
             self.update_internal(parent_idx); // Moved the update logic to a new method
+
+            return parent_idx;
         } else {
             let node = &mut self.nodes[node_idx];
             node.min_list.zip_mut_with(x, |a, b| *a = F::min(*a, *b));
@@ -184,6 +223,7 @@ impl<F: FType> MondrianTree<F> {
             } else {
                 node.update_leaf(x, self.labels.iter().position(|l| l == label).unwrap());
             }
+            return node_idx;
         }
     }
 
@@ -200,11 +240,12 @@ impl<F: FType> MondrianTree<F> {
     ///
     /// Function in River/LightRiver: "learn_one()"
     pub fn partial_fit(&mut self, x: &Array1<F>, y: &String) {
-        if self.nodes.len() == 0 {
-            self.create_leaf(x, y, None);
-        } else {
-            self.extend_mondrian_block(0, x, y);
-        }
+        println!("partial_fit() - post root: {:?}", self.root);
+        self.root = match self.root {
+            None => Some(self.create_leaf(x, y, None)),
+            Some(root_idx) => Some(self.extend_mondrian_block(root_idx, x, y)),
+        };
+        println!("partial_fit() - post root: {:?}", self.root);
     }
 
     fn fit(&self) {

src/datasets/mod.rs

@@ -1,3 +1,4 @@
 pub mod credit_card;
 pub mod keystroke;
+pub mod synthetic;
 pub mod utils;

src/datasets/synthetic.rs

@@ -0,0 +1,20 @@
+use crate::datasets::utils;
+use crate::stream::data_stream::Target;
+use crate::stream::iter_csv::IterCsv;
+use std::{fs::File, path::Path};
+
+/// ChatGPT Generated synthetic dataset.
+///
+/// Add 'synthetic.csv' to project root directory.
+pub struct Synthetic;
+impl Synthetic {
+    pub fn load_data() -> Result<IterCsv<f32, File>, Box<dyn std::error::Error>> {
+        let file_name = "syntetic_dataset_int.csv";
+        let file = File::open(file_name)?;
+        let y_cols = Some(Target::Name("label".to_string()));
+        match IterCsv::<f32, File>::new(file, y_cols) {
+            Ok(x) => Ok(x),
+            Err(e) => Err(Box::new(e)),
+        }
+    }
+}