Struct BaggingClassifier 

pub struct BaggingClassifier<State = Untrained> { /* private fields */ }

Enhanced Bagging classifier with OOB estimation and feature bagging

Implementations

impl BaggingClassifier<Untrained>

pub fn new() -> Self

Create a new bagging classifier

pub fn n_estimators(self, n_estimators: usize) -> Self

Set the number of estimators

pub fn max_samples(self, max_samples: Option<usize>) -> Self

Set the maximum number of samples per estimator

pub fn max_features(self, max_features: Option<usize>) -> Self

Set the maximum number of features per estimator

pub fn bootstrap(self, bootstrap: bool) -> Self

Set whether to use bootstrap sampling

pub fn bootstrap_features(self, bootstrap_features: bool) -> Self

Set whether to use bootstrap feature sampling

pub fn random_state(self, random_state: u64) -> Self

Set the random state

pub fn oob_score(self, oob_score: bool) -> Self

Set whether to calculate out-of-bag score

pub fn max_depth(self, max_depth: Option<usize>) -> Self

Set maximum depth for base estimators

pub fn min_samples_split(self, min_samples_split: usize) -> Self

Set minimum samples to split

pub fn min_samples_leaf(self, min_samples_leaf: usize) -> Self

Set minimum samples at leaf

pub fn confidence_level(self, confidence_level: Float) -> Self

Set confidence level for bootstrap intervals

pub fn n_jobs(self, n_jobs: Option<i32>) -> Self

Set number of parallel jobs for training (None for automatic detection)

pub fn parallel(self) -> Self

Enable parallel training with automatic job detection

pub fn extra_randomized(self, extra_randomized: bool) -> Self

Enable extra randomization (Extremely Randomized Trees)

pub fn extremely_randomized(self) -> Self

Enable extra randomization (convenient shorthand)

impl BaggingClassifier<Trained>

pub fn estimators(&self) -> &[DecisionTreeClassifier<Trained>]

Get the fitted base estimators

pub fn estimators_features(&self) -> &[Vec<usize>]

Get the feature indices used by each estimator

pub fn estimators_samples(&self) -> &[Vec<usize>]

Get the sample indices used by each estimator

pub fn oob_score(&self) -> Option<Float>

Get the out-of-bag score if calculated

pub fn classes(&self) -> &Array1<Int>

Get the classes

pub fn n_classes(&self) -> usize

Get the number of classes

pub fn n_features_in(&self) -> usize

Get the number of input features

pub fn feature_importances(&self) -> &Array1<Float>

Get feature importances

pub fn predict_with_confidence( &self, x: &Array2<Float>, ) -> Result<(Array1<Int>, Array2<Float>)>

Calculate bootstrap confidence intervals for predictions

Trait Implementations

impl Default for BaggingClassifier<Untrained>

fn default() -> Self

Returns the “default value” for a type.

impl<State> Estimator<State> for BaggingClassifier<State>

type Config = BaggingConfig

Configuration type for the estimator

type Error = SklearsError

Error type for the estimator

type Float = f64

The numeric type used by this estimator

fn config(&self) -> &Self::Config

Get estimator configuration

fn validate_config(&self) -> Result<()>

Validate estimator configuration with detailed error context

fn metadata(&self) -> EstimatorMetadata

Get estimator metadata

fn check_compatibility( &self, n_samples: usize, n_features: usize, ) -> Result<(), SklearsError>

Check if estimator is compatible with given data dimensions

impl Fit<ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>, ArrayBase<OwnedRepr<i32>, Dim<[usize; 1]>>> for BaggingClassifier<Untrained>

type Fitted = BaggingClassifier<Trained>

The fitted model type

fn fit(self, x: &Array2<Float>, y: &Array1<Int>) -> Result<Self::Fitted>

Fit the model to the provided data with validation

fn fit_with_validation( self, x: &X, y: &Y, _x_val: Option<&X>, _y_val: Option<&Y>, ) -> Result<(Self::Fitted, FitMetrics), SklearsError>

where Self: Sized,

Fit with custom validation and early stopping

impl Predict<ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>, ArrayBase<OwnedRepr<i32>, Dim<[usize; 1]>>> for BaggingClassifier<Trained>

fn predict(&self, x: &Array2<Float>) -> Result<Array1<Int>>

Make predictions on the provided data

fn predict_with_uncertainty( &self, x: &X, ) -> Result<(Output, UncertaintyMeasure), SklearsError>

Make predictions with confidence intervals