Struct RandomForestClassifier 

pub struct RandomForestClassifier<XT: Number, YT: WholeNumber> { /* private fields */ }

Implementations

impl<XT: Number, YT: WholeNumber> RandomForestClassifier<XT, YT>

This module contains the implementation of the RandomForestClassifier struct.

The RandomForestClassifier is a machine learning algorithm that combines multiple decision trees to make predictions. It is used for classification tasks where the input features are of type XT and the target labels are of type YT.

Example

use rusty_ai::forests::classifier::RandomForestClassifier;
use rusty_ai::data::dataset::Dataset;
use nalgebra::{DMatrix, DVector};

// Create a mock dataset
let x = DMatrix::from_row_slice(
    6,
    2,
    &[1.0, 2.0, 1.1, 2.1, 1.2, 2.2, 3.0, 4.0, 3.1, 4.1, 3.2, 4.2],
);
let y = DVector::from_vec(vec![0, 0, 0, 1, 1, 1]);
let dataset = Dataset::new(x, y);

// Create a random forest classifier with default parameters
let mut forest = RandomForestClassifier::<f64, u8>::default();

// Fit the classifier to the dataset
forest.fit(&dataset, Some(42)).unwrap();

// Make predictions on new features
let features = DMatrix::from_row_slice(
    2,
    2,
    &[
        1.0, 2.0, // Should be classified as class 0
        3.0, 4.0, // Should be classified as class 1
    ],
);
let predictions = forest.predict(&features).unwrap();
println!("Predictions: {:?}", predictions);

pub fn new() -> Self

Creates a new instance of the Random Forest Classifier.

This function initializes the classifier with empty frequency maps and an empty vector to store the count of unique feature values.

Returns

A new instance of the Random Forest Classifier.

pub fn with_params( num_trees: Option<usize>, min_samples_split: Option<u16>, max_depth: Option<u16>, criterion: Option<String>, sample_size: Option<usize>, ) -> Result<Self, Box<dyn Error>>

Creates a new instance of the Random Forest Classifier with specified parameters.

Arguments

• num_trees - The number of trees in the forest. If not specified, defaults to 3.
• min_samples_split - The minimum number of samples required to split an internal node. If not specified, defaults to 2.
• max_depth - The maximum depth of the decision trees. If not specified, defaults to None.
• criterion - The function to measure the quality of a split. If not specified, defaults to “gini”.
• sample_size - The size of the random subsets of the dataset to train each tree. If not specified, defaults to None.

Returns

A Result containing the Random Forest Classifier instance or an error.

pub fn set_trees(&mut self, trees: Vec<DecisionTreeClassifier<XT, YT>>)

Sets the decision trees of the random forest.

Arguments

• trees - A vector of DecisionTreeClassifier instances.

pub fn set_num_trees(&mut self, num_trees: usize) -> Result<(), Box<dyn Error>>

Sets the number of trees in the random forest.

Arguments

• num_trees - The number of trees.

Returns

A Result indicating success or an error.

pub fn set_sample_size( &mut self, sample_size: Option<usize>, ) -> Result<(), Box<dyn Error>>

Sets the sample size for each tree in the random forest.

Arguments

• sample_size - The sample size.

Returns

A Result indicating success or an error.

pub fn set_min_samples_split( &mut self, min_samples_split: u16, ) -> Result<(), Box<dyn Error>>

Sets the minimum number of samples required to split an internal node in each decision tree.

Arguments

• min_samples_split - The minimum number of samples.

Returns

A Result indicating success or an error.

pub fn set_max_depth( &mut self, max_depth: Option<u16>, ) -> Result<(), Box<dyn Error>>

Sets the maximum depth of each decision tree in the random forest.

Arguments

• max_depth - The maximum depth.

Returns

A Result indicating success or an error.

pub fn set_criterion(&mut self, criterion: String) -> Result<(), Box<dyn Error>>

Sets the criterion function to measure the quality of a split in each decision tree.

Arguments

• criterion - The criterion function.

Returns

A Result indicating success or an error.

pub fn trees(&self) -> &Vec<DecisionTreeClassifier<XT, YT>>

Returns a reference to the decision trees in the random forest.

pub fn num_trees(&self) -> usize

Returns the number of trees in the random forest.

pub fn sample_size(&self) -> Option<usize>

Returns the sample size for each tree in the random forest.

pub fn min_samples_split(&self) -> u16

Returns the minimum number of samples required to split an internal node in each decision tree.

pub fn max_depth(&self) -> Option<u16>

Returns the maximum depth of each decision tree in the random forest.

pub fn criterion(&self) -> &String

Returns a reference to the criterion function used to measure the quality of a split in each decision tree.

pub fn fit( &mut self, dataset: &Dataset<XT, YT>, seed: Option<u64>, ) -> Result<String, Box<dyn Error>>

Fits the random forest to the given dataset.

Arguments

• dataset - The dataset to fit the random forest to.
• seed - The seed for the random number generator used to generate random subsets of the dataset. If not specified, a random seed will be used.

Returns

A Result indicating whether the fitting process was successful or an error occurred.

pub fn predict( &self, features: &DMatrix<XT>, ) -> Result<DVector<YT>, Box<dyn Error>>

Predicts the class labels for the given features using the random forest.

Arguments

• features - The features to predict the class labels for.

Returns

A Result containing a vector of predicted class labels or an error if the prediction process fails.

Trait Implementations

impl<XT: Number, YT: WholeNumber> ClassificationMetrics<YT> for RandomForestClassifier<XT, YT>

fn confusion_matrix( &self, y_true: &DVector<T>, y_pred: &DVector<T>, ) -> Result<DMatrix<usize>, Box<dyn Error>>

Computes the confusion matrix based on the true labels and predicted labels.

fn accuracy( &self, y_true: &DVector<T>, y_pred: &DVector<T>, ) -> Result<f64, Box<dyn Error>>

Computes the accuracy based on the true labels and predicted labels.

fn precision( &self, y_true: &DVector<T>, y_pred: &DVector<T>, ) -> Result<f64, Box<dyn Error>>

Computes the precision based on the true labels and predicted labels.

fn recall( &self, y_true: &DVector<T>, y_pred: &DVector<T>, ) -> Result<f64, Box<dyn Error>>

Computes the recall based on the true labels and predicted labels.

fn f1_score( &self, y_true: &DVector<T>, y_pred: &DVector<T>, ) -> Result<f64, Box<dyn Error>>

Computes the F1 score based on the true labels and predicted labels.

impl<XT: Clone + Number, YT: Clone + WholeNumber> Clone for RandomForestClassifier<XT, YT>

fn clone(&self) -> RandomForestClassifier<XT, YT>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<XT: Debug + Number, YT: Debug + WholeNumber> Debug for RandomForestClassifier<XT, YT>

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

Formats the value using the given formatter.

impl<XT: Number, YT: WholeNumber> Default for RandomForestClassifier<XT, YT>

fn default() -> Self

Returns the “default value” for a type.