Struct linfa_trees::DecisionTreeParams

pub struct DecisionTreeParams<F, L> {
    pub split_quality: SplitQuality,
    pub max_depth: Option<usize>,
    pub min_weight_split: f32,
    pub min_weight_leaf: f32,
    pub min_impurity_decrease: F,
    pub phantom: PhantomData<L>,
}

The set of hyperparameters that can be specified for fitting a decision tree.

Example

use linfa_trees::{DecisionTree, SplitQuality};
use linfa_datasets::iris;
use linfa::prelude::*;

// Initialize the default set of parameters
let params = DecisionTree::params();
// Set the parameters to the desired values
let params = params.split_quality(SplitQuality::Entropy).max_depth(Some(5)).min_weight_leaf(2.);

// Load the data
let (train, val) = linfa_datasets::iris().split_with_ratio(0.9);
// Fit the decision tree on the training data
let tree = params.fit(&train).unwrap();
// Predict on validation and check accuracy
let val_accuracy = tree.predict(&val).confusion_matrix(&val).unwrap().accuracy();
assert!(val_accuracy > 0.99);

Fields

split_quality: SplitQuality

max_depth: Option<usize>

min_weight_split: f32

min_weight_leaf: f32

min_impurity_decrease: F

phantom: PhantomData<L>

Implementations

impl<F: Float, L: Label> DecisionTreeParams<F, L>

pub fn split_quality(self, split_quality: SplitQuality) -> Self

Sets the metric used to decide the feature on which to split a node

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

Sets the optional limit to the depth of the decision tree

pub fn min_weight_split(self, min_weight_split: f32) -> Self

Sets the minimum weight of samples required to split a node.

If the observations do not have associated weights, this value represents the minimum number of samples required to split a node.

pub fn min_weight_leaf(self, min_weight_leaf: f32) -> Self

Sets the minimum weight of samples that a split has to place in each leaf

If the observations do not have associated weights, this value represents the minimum number of samples that a split has to place in each leaf.

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

Sets the minimum decrease in impurity that a split needs to bring in order for it to be applied

pub fn validate(&self) -> Result<()>

Checks the correctness of the hyperparameters

Panics

If the minimum impurity increase is not greater than zero

Trait Implementations

impl<F: Clone, L: Clone> Clone for DecisionTreeParams<F, L>

fn clone(&self) -> DecisionTreeParams<F, L>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<F: Copy, L: Copy> Copy for DecisionTreeParams<F, L>

impl<F: Debug, L: Debug> Debug for DecisionTreeParams<F, L>

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

Formats the value using the given formatter.

impl<'a, F: Float, L: Label + 'a + Debug, D, T> Fit<'a, ArrayBase<D, Dim<[usize; 2]>>, T> for DecisionTreeParams<F, L> where
    D: Data<Elem = F>,
    T: AsTargets<Elem = L> + Labels<Elem = L>, 

type Object = Result<DecisionTree<F, L>>

fn fit(&self, dataset: &DatasetBase<ArrayBase<D, Ix2>, T>) -> Self::Object

Fit a decision tree using hyperparamters on the dataset consisting of a matrix of features x and an array of labels y.