refactored decision tree into reusable components

[DanielLacina]

No description provided.

[Mec-iS]

this should problably be Node<TX>, why it should be limited to f64? in general everytime you write a fixed numerical type you should ask yourself if it is generalisable.

[DanielLacina]

All this code is copied and pasted from the DecisionTree file with the difference being that I use the name BaseTree instead of DecisionTree. This implementation is already in your codebase: https://github.com/smartcorelib/smartcore/blob/development/src/tree/decision_tree_regressor.rs#L129.

[DanielLacina]

Plus Node is an implementation detail (no pub keyword) so it doesn't matter what numeric type it contains.

[Mec-iS]

again, this will work only for f64?

[DanielLacina]

Node is an implementation detail

[Mec-iS]

missing docstring

[Mec-iS]

this should explain a little more like:

/// Parameters for configuring the behavior of a decision tree regressor.
/// 
/// This struct controls various aspects of tree construction including
/// depth limits, sample requirements, and splitting strategies.

[Mec-iS]

this one could be just maybe?

let mut col_view: Vec<f64> = x.get_col(i).iterator(0).copied().collect();
let indices = col_view.argsort_mut();

[DanielLacina]

I copied and pasted this code from the decision tree file. That would probably be more readable. Ima be honest, it was pretty hard reading the code of the decision tree implementation, but it is indeed optimal.

[Mec-iS]

I don't think this comment is correct, please double-check

[DanielLacina]

That's already written in the codebase.

[DanielLacina]

https://github.com/smartcorelib/smartcore/blob/development/src/tree/decision_tree_regressor.rs#L121

[Mec-iS]

Thank you!

This is a nice starting point so to make possible to implement:

• Classification Trees
• Ensemble Methods: random forests
• Feature Selection: mtry can be used for feature sampling

[Mec-iS]

This opens up to implementations like:

trait TreeRegressor<TX, TY, X, Y> {
    fn fit_tree(&self, x: &X, y: &Y, samples: Vec<usize>) -> Result<Self, Failed>;
    fn predict_tree(&self, x: &X) -> Result<Y, Failed>;
}

trait EnsembleRegressor<TX, TY, X, Y> {
    fn fit_ensemble(&self, x: &X, y: &Y, n_estimators: usize) -> Result<Self, Failed>;
    fn predict_ensemble(&self, x: &X) -> Result<Y, Failed>;
}

is that correct?

Recommended Implementation Priority

• Random Forest Regressor: Highest priority due to existing foundation
• Gradient Boosting Regressor: High impact for predictive performance
• Extra Trees Regressor: Low implementation cost with good diversity benefits
• Quantile Regression Trees: Valuable for uncertainty quantification
• Pruned Regression Trees: Important for model interpretability

[DanielLacina]

I think we should build Base models that other more complex models can build on top of.

[DanielLacina]

Idk if traits are necessary. I think all we need is for example a complex model that stores the base model as an attribute. And then we can add extra logic on top of the base model.