Struct RandomForestClassifier 

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

Random Forest Classifier

Implementations

impl RandomForestClassifier<Untrained>

pub fn new() -> Self

Create a new Random Forest Classifier

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

Set the number of trees in the forest

pub fn criterion(self, criterion: SplitCriterion) -> Self

Set the split criterion

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

Set the maximum depth of trees

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

Set the minimum samples required to split

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

Set the minimum samples required at a leaf

pub fn max_features(self, max_features: MaxFeatures) -> Self

Set the maximum features strategy

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

Set whether to bootstrap samples

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

Set whether to compute out-of-bag score

pub fn class_weight(self, class_weight: ClassWeight) -> Self

Set class weighting strategy for imbalanced datasets

pub fn sampling_strategy(self, sampling_strategy: SamplingStrategy) -> Self

Set sampling strategy for building trees

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

Set the random state

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

Set the number of parallel jobs

pub fn min_impurity_decrease(self, min_impurity_decrease: f64) -> Self

Set the minimum impurity decrease

impl RandomForestClassifier<Trained>

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

Get the classes

pub fn n_classes(&self) -> usize

Get the number of classes

pub fn n_features(&self) -> usize

Get the number of features

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

Get the out-of-bag score if computed

pub fn oob_decision_function(&self) -> Option<&Array2<f64>>

Get the out-of-bag decision function if computed

pub fn compute_proximity_matrix(&self, x: &Array2<Float>) -> Result<Array2<f64>>

Compute the proximity matrix between samples

The proximity matrix measures how often pairs of samples end up in the same leaf nodes across all trees in the forest. Values range from 0 to 1, where 1 indicates samples always end up in the same leaves.

pub fn proximity_matrix(&self) -> Option<&Array2<f64>>

Get the computed proximity matrix

Returns None if the proximity matrix hasn’t been computed yet. Call compute_proximity_matrix() first to calculate it.

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

Predict class labels using parallel processing

This method performs prediction in parallel, which can significantly speed up predictions on large datasets when the parallel feature is enabled.

pub fn predict_proba_parallel(&self, x: &Array2<Float>) -> Result<Array2<f64>>

Predict class probabilities using parallel processing

This method performs probability prediction in parallel, which can significantly speed up predictions on large datasets when the parallel feature is enabled.

Note: Since SmartCore’s RandomForestClassifier doesn’t provide predict_proba, this implementation creates probability estimates by running multiple predictions and averaging the results across different bootstrap samples of the trees.

pub fn feature_importances(&self) -> Result<Array1<f64>>

Get feature importances

Returns the feature importances (the higher, the more important the feature).

Since SmartCore doesn’t expose detailed tree structure, this implementation uses permutation-based feature importance as an approximation.

pub fn permutation_feature_importance( &self, x: &Array2<Float>, y: &Array1<i32>, n_repeats: usize, ) -> Result<Array1<f64>>

Compute permutation-based feature importance

This method computes feature importance by measuring the decrease in model performance when feature values are randomly permuted.

pub fn predict_proba(&self, _x: &Array2<Float>) -> Result<Array2<f64>>

Predict class probabilities

Trait Implementations

impl Default for RandomForestClassifier<Untrained>

fn default() -> Self

Returns the “default value” for a type.

impl Estimator for RandomForestClassifier<Untrained>

type Config = RandomForestConfig

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<(), SklearsError>

Validate estimator configuration with detailed error context

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

Check if estimator is compatible with given data dimensions

fn metadata(&self) -> EstimatorMetadata

Get estimator metadata

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

type Fitted = RandomForestClassifier<Trained>

The fitted model type

fn fit(self, x: &Array2<Float>, y: &Array1<i32>) -> 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 RandomForestClassifier<Trained>

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

Make predictions on the provided data

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

Make predictions with confidence intervals