Add type alias for Random Forest as an EnsembleLearner with model type DecisionTree.

Author: ladezai

algorithms/linfa-ensemble/examples/ensemble_iris.rs

@@ -1,14 +1,10 @@
 use linfa::prelude::{Fit, Predict, ToConfusionMatrix};
-use linfa_ensemble::EnsembleLearnerParams;
+use linfa_ensemble::{EnsembleLearnerParams, RandomForestParams};
 use linfa_trees::DecisionTree;
 use ndarray_rand::rand::SeedableRng;
 use rand::rngs::SmallRng;
 
-fn ensemble_learner(
-    ensemble_size: usize,
-    bootstrap_proportion: f64,
-    feature_proportion: f64,
-) -> () {
+fn ensemble_learner(ensemble_size: usize, bootstrap_proportion: f64) -> () {
     // Load dataset
     let mut rng = SmallRng::seed_from_u64(42);
     let (train, test) = linfa_datasets::iris()
@@ -17,6 +13,30 @@ fn ensemble_learner(
 
     // Train ensemble learner model
     let model = EnsembleLearnerParams::new_fixed_rng(DecisionTree::params(), rng)
+        .ensemble_size(ensemble_size)
+        .bootstrap_proportion(bootstrap_proportion)
+        .fit(&train)
+        .unwrap();
+
+    // Return highest ranking predictions
+    let final_predictions_ensemble = model.predict(&test);
+    println!("Final Predictions: \n{final_predictions_ensemble:?}");
+
+    let cm = final_predictions_ensemble.confusion_matrix(&test).unwrap();
+
+    println!("{cm:?}");
+    println!("Test accuracy: {} \n with default Decision Tree params, \n Ensemble Size: {ensemble_size},\n Bootstrap Proportion: {bootstrap_proportion}",
+    100.0 * cm.accuracy());
+}
+
+fn random_forest(ensemble_size: usize, bootstrap_proportion: f64, feature_proportion: f64) {
+    let mut rng = SmallRng::seed_from_u64(42);
+    let (train, test) = linfa_datasets::iris()
+        .shuffle(&mut rng)
+        .split_with_ratio(0.8);
+
+    // Train ensemble learner model
+    let model = RandomForestParams::new_fixed_rng(DecisionTree::params(), rng)
         .ensemble_size(ensemble_size)
         .bootstrap_proportion(bootstrap_proportion)
         .feature_proportion(feature_proportion)
@@ -37,9 +57,9 @@ fn ensemble_learner(
 fn main() {
     // This is an example bagging with decision tree
     println!("An example using Bagging with Decision Tree on Iris Dataset");
-    ensemble_learner(100, 0.7, 1.0);
+    ensemble_learner(100, 0.7);
     println!("");
     // This is basically a Random Forest ensemble
     println!("An example using a Random Forest on Iris Dataset");
-    ensemble_learner(100, 0.7, 0.2);
+    random_forest(100, 0.7, 0.2);
 }

algorithms/linfa-ensemble/src/algorithm.rs

@@ -5,10 +5,13 @@ use linfa::{
     traits::*,
     DatasetBase,
 };
+use linfa_trees::DecisionTree;
 use ndarray::{Array2, Axis, Zip};
 use rand::Rng;
 use std::{cmp::Eq, collections::HashMap, hash::Hash};
 
+pub type RandomForest<F, L> = EnsembleLearner<DecisionTree<F, L>>;
+
 pub struct EnsembleLearner<M> {
     pub models: Vec<M>,
     pub model_features: Vec<Vec<usize>>,
@@ -18,14 +21,14 @@ impl<M> EnsembleLearner<M> {
     // Generates prediction iterator returning predictions from each model
     pub fn generate_predictions<'b, R: Records, T>(
         &'b self,
-        x: &'b Vec<R>,
+        x: &'b [R],
     ) -> impl Iterator<Item = T> + 'b
     where
         M: Predict<&'b R, T>,
     {
         self.models
             .iter()
-            .zip(x.into_iter())
+            .zip(x.iter())
             .map(move |(m, sub_data)| m.predict(sub_data))
     }
 }
@@ -112,8 +115,8 @@ where
         }
 
         Ok(EnsembleLearner {
-            models: models,
-            model_features: model_features,
+            models,
+            model_features,
         })
     }
 }

algorithms/linfa-ensemble/src/hyperparams.rs

@@ -2,6 +2,7 @@ use linfa::{
     error::{Error, Result},
     ParamGuard,
 };
+use linfa_trees::DecisionTreeParams;
 use rand::rngs::ThreadRng;
 use rand::Rng;
 
@@ -21,6 +22,8 @@ pub struct EnsembleLearnerValidParams<P, R> {
 #[derive(Clone, Copy, Debug, PartialEq)]
 pub struct EnsembleLearnerParams<P, R>(EnsembleLearnerValidParams<P, R>);
 
+pub type RandomForestParams<F, L, R> = EnsembleLearnerParams<DecisionTreeParams<F, L>, R>;
+
 impl<P> EnsembleLearnerParams<P, ThreadRng> {
     pub fn new(model_params: P) -> EnsembleLearnerParams<P, ThreadRng> {
         Self::new_fixed_rng(model_params, rand::thread_rng())