Struct EnsembleLearner 

pub struct EnsembleLearner<M> {
    pub models: Vec<M>,
    pub model_features: Vec<Vec<usize>>,
}

A fitted ensemble of learners for classification.

Structure

An Ensemble Learner is composed of a collection of fitted models of type M.

Fitting Algorithm

Given a DatasetBase denoted as D,

1. Create as many distinct bootstrapped subset of the original dataset D as number of distinct model to fit.
2. Fit each distinct model on a distinct bootstrapped subset of D.

Note that the subset size, as well as the subset of feature to use in each training subset can be specified in the parameters.

Prediction Algorithm

The prediction result is the result of majority voting across the fitted learners.

Example

This example shows how to train a bagging model using 100 decision trees, each trained on 70% of the training data (bootstrap sampling).

use linfa::prelude::{Fit, Predict};
use linfa_ensemble::EnsembleLearnerParams;
use linfa_trees::DecisionTree;
use ndarray_rand::rand::SeedableRng;
use rand::rngs::SmallRng;

// Load Iris dataset
let mut rng = SmallRng::seed_from_u64(42);
let (train, test) = linfa_datasets::iris()
    .shuffle(&mut rng)
    .split_with_ratio(0.8);

// Train the model on the iris dataset
let bagging_model = EnsembleLearnerParams::new(DecisionTree::params())
    .ensemble_size(100)        // Number of Decision Tree to fit
    .bootstrap_proportion(0.7) // Select only 70% of the data via bootstrap
    .fit(&train)
    .unwrap();

// Make predictions on the test set
let predictions = bagging_model.predict(&test);

References

• Scikit-Learn User Guide
• An Introduction to Statistical Learning

Fields

models: Vec<M>

model_features: Vec<Vec<usize>>

Implementations

impl<M> EnsembleLearner<M>

pub fn generate_predictions<'b, R: Records, T>( &'b self, x: &'b [R], ) -> impl Iterator<Item = T> + 'b

where M: Predict<&'b R, T>,

Trait Implementations

impl<F: Clone, T, M> PredictInplace<ArrayBase<OwnedRepr<F>, Dim<[usize; 2]>>, T> for EnsembleLearner<M>

where M: PredictInplace<Array2<F>, T>, <T as AsTargets>::Elem: Copy + Eq + Hash + Debug, T: AsTargets + AsTargetsMut<Elem = <T as AsTargets>::Elem>,

fn predict_inplace(&self, x: &Array2<F>, y: &mut T)

Predict something in place

fn default_target(&self, x: &Array2<F>) -> T

Create targets that predict_inplace works with.