Struct RandomForestClassifier 

pub struct RandomForestClassifier { /* private fields */ }

Random Forest classifier - an ensemble of decision trees.

Combines multiple decision trees trained on bootstrap samples with random feature selection to reduce overfitting and improve accuracy.

Implementations

impl RandomForestClassifier

pub fn new(n_estimators: usize) -> Self

Creates a new Random Forest classifier.

Arguments

• n_estimators - Number of trees in the forest

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

Sets the maximum depth for each tree.

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

Sets the random state for reproducibility.

pub fn fit(&mut self, x: &Matrix<f32>, y: &[usize]) -> Result<()>

Fits the random forest to training data.

Errors

Returns an error if fitting fails.

pub fn predict(&self, x: &Matrix<f32>) -> Vec<usize>

Makes predictions for input data.

pub fn score(&self, x: &Matrix<f32>, y: &[usize]) -> f32

Calculates accuracy score on test data.

pub fn predict_proba(&self, x: &Matrix<f32>) -> Matrix<f32>

Predict class probabilities for input features.

Returns probability distribution over classes based on vote proportions across trees in the forest.

Returns

Matrix<f32> with shape (n_samples, n_classes) where each row sums to 1.0.

pub fn oob_prediction(&self) -> Option<Vec<usize>>

Returns Out-of-Bag (OOB) predictions for training samples.

For each training sample, predictions are made using only the trees where that sample was NOT in the bootstrap sample (out-of-bag).

Returns

Some(Vec<usize>) if the model has been fitted, None otherwise. The vector has the same length as the training data.

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

Returns Out-of-Bag (OOB) accuracy score.

Computes accuracy using OOB predictions. This provides an unbiased estimate of the model’s performance without needing a validation set.

Returns

Some(f32) with accuracy in [0, 1] if model has been fitted, None otherwise.

pub fn feature_importances(&self) -> Option<Vec<f32>>

Returns feature importances based on mean decrease in impurity.

Feature importance is calculated as the total decrease in node impurity (weighted by the number of samples) averaged over all trees in the forest.

Returns

Some(Vec<f32>) with importance for each feature (normalized to sum to 1.0) if model has been fitted, None otherwise.

Example

let mut rf = RandomForestClassifier::new(50);
rf.fit(&x_train, &y_train).expect("fit should succeed");

if let Some(importances) = rf.feature_importances() {
    for (i, &importance) in importances.iter().enumerate() {
        println!("Feature {}: {:.4}", i, importance);
    }
}

pub fn save_safetensors<P: AsRef<Path>>(&self, path: P) -> Result<(), String>

Saves the Random Forest model to a SafeTensors file.

Arguments

• path - Path where the SafeTensors file will be saved

Errors

Returns an error if the model is unfitted or if saving fails.

pub fn load_safetensors<P: AsRef<Path>>(path: P) -> Result<Self, String>

Loads a Random Forest model from a SafeTensors file.

Arguments

• path - Path to the SafeTensors file

Errors

Returns an error if loading fails or if the file format is invalid.

Trait Implementations

impl Clone for RandomForestClassifier

fn clone(&self) -> RandomForestClassifier

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RandomForestClassifier

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RandomForestClassifier

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for RandomForestClassifier

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.