DecisionTree / Regressor Layer

Decision Tree Regression: Rule-based hierarchical modeling.

Mathematical formulation: $f (x) = m = 1 \sum M c_{m} I (x \in R_{m})$ where:

Rₘ are regions (leaf nodes)
cₘ are constant predictions
I() is indicator function

Key characteristics:

Model structure:
- Hierarchical decisions
- Binary splits
- Recursive partitioning
- Piecewise constant predictions
Learning process:
- Greedy split selection
- Top-down growth
- Impurity reduction
- Local optimization

Advantages:

Handles non-linear patterns
No feature scaling needed
Captures interactions
Highly interpretable

Common applications:

Structured regression
Feature importance
Rule extraction
Decision support

Outputs:

Predicted Table: Results with predictions
Validation Results: Cross-validation metrics
Test Metric: Hold-out performance
Feature Importances: Split importance scores

Table

Predicted Table

Validation Results

Test Metric

Feature Importances

SelectFeatures

[column, ...]

Feature selection for Decision Tree:

Requirements:

Data types:
- Numeric features preferred
- Categorical (encoded)
- No missing values
- Finite numbers
Tree considerations:
- No scaling needed
- Handles non-linear
- Captures interactions
- Feature redundancy ok
Best practices:
- Remove irrelevant features
- Handle missing data
- Encode categories
- Consider domain knowledge
Performance impact:
- Tree depth
- Split quality
- Memory usage
- Training speed

Note: If empty, uses all numeric columns except target

SelectTarget

column

Target variable for Decision Tree:

Requirements:

Data type:
- Numeric continuous
- No missing values
- Finite values
- Real-valued
Distribution properties:
- No scaling needed
- Any distribution ok
- Outliers handled
- Non-linear patterns ok
Model implications:
- Criterion choice
- Leaf size impact
- Prediction granularity
- Error distribution
Special cases:
- Count data: Use Poisson
- Heavy tails: Use MAE
- Clean data: Use MSE
- Outliers: Consider MAE

Note: Must be a single numeric column

Params

oneof

DefaultParams

Default Decision Tree configuration:

Tree structure:
- Unlimited depth
- MSE criterion
- Best splitter
- All features
Node constraints:
- Min samples split: 2
- Min samples leaf: 1
- No leaf fraction limit
Optimization:
- No pre-pruning
- No cost-complexity
- Pure leaf targeting

Best suited for:

Initial modeling
Small datasets
Exploratory analysis
Baseline performance

CustomParams

Customizable Decision Tree parameters:

Control aspects:

Split quality:
- Criterion choice
- Feature selection
- Split strategy
Tree growth:
- Depth control
- Node constraints
- Leaf requirements
Pruning options:
- Pre-pruning rules
- Cost-complexity
- Impurity thresholds

Optimization goals:

Model complexity
Prediction accuracy
Generalization power

Criterion

enum

Mse

Split quality measurement:

Available criteria:

Mean Squared Error:
- Variance reduction
- L2 loss minimization
- Standard choice
Friedman MSE:
- MSE with improvements
- Better split selection
- Potential gains
Absolute Error:
- L1 loss minimization
- Median-based splits
- Robust to outliers
Poisson:
- Deviance reduction
- Count data
- Non-negative targets

Mse ~

Mean squared error criterion:

Formula: $MSE = \frac{1}{N} i = 1 \sum N (y_{i} - \overset{y}{ˉ})^{2}$ Gain: $G ain = MS E_{p a re n t} - j \in {L, R} \sum \frac{N _{j}}{N} MS E_{j}$

Properties:

Minimizes variance
Sensitive to outliers
Mean-based splits

Best for:

Normal distributions
Continuous targets
General regression

FriedManMse ~

Friedman's MSE criterion:

Formula: $MS E_{F} = \frac{N _{L} N _{R}}{N ^{2}} (\overset{y}{ˉ}_{L} - \overset{y}{ˉ}_{R})^{2}$

Properties:

Enhanced MSE
Split potential
Local improvements
Better splits

Best for:

Complex patterns
Gradient boosting
Refined splitting

AbsoluteError ~

Mean absolute error criterion:

Formula: $M A E = \frac{1}{N} i = 1 \sum N ∣ y_{i} - m e d ian (y) ∣$ Gain: $G ain = M A E_{p a re n t} - j \in {L, R} \sum \frac{N _{j}}{N} M A E_{j}$

Properties:

Median-based splits
Outlier resistant
Robust predictions

Best for:

Skewed distributions
Outlier presence
Robust modeling

Poisson ~

Poisson deviance criterion:

Formula: $D = 2 i = 1 \sum N (y_{i} l o g (\frac{y _{i}}{y ˉ}) - (y_{i} - \overset{y}{ˉ}))$

Properties:

Count data modeling
Non-negative targets
Rate prediction

Best for:

Count outcomes
Event rates
Frequency data

Splitter

enum

Best

Split selection strategy:

Best splits:
- Exhaustive search
- Optimal local decisions
- Maximum gain selection
Random splits:
- Random feature subset
- Faster computation
- More diverse trees

Trade-offs:

Computation vs optimality
Deterministic vs random
Speed vs precision

Best ~

Best split selection:

Process:

Evaluates all possible splits
Chooses maximum gain
Deterministic choices

Best for:

Small to medium datasets
Optimal local decisions
Reproducible results

Random ~

Random split selection:

Process:

Random feature sampling
Best split within subset
Stochastic decisions

Best for:

Large datasets
Faster training
Ensemble methods

MaxDepth

u32

Maximum tree depth:

Control options:

0: Unlimited growth
>0: Fixed depth limit

Impact:

Model complexity
Training time
Memory usage

Guidelines:

Small: 3-5 (simple)
Medium: 5-10 (balanced)
Large: >10 (complex)

MinSamplesSplit

u32

Minimum samples for splitting:

Effects:

Prevents overfitting
Controls granularity
Ensures stability

Typical values:

2: Maximum splits
5-10: Balanced
>10: Conservative

MinSamplesLeaf

u32

Minimum samples in leaves:

Purpose:

Ensures prediction stability
Prevents single-point leaves
Controls overfitting

Common settings:

1: Maximum detail
5-10: Stable predictions
>10: Smooth regions

MinWeightFractionLeaf

f64

Minimum weighted leaf fraction:

Usage:

0.0: No constraint
>0.0: Forces larger leaves
Handles imbalanced data

Range: [0.0, 0.5]

MaxFeatures

enum

Auto

Feature subset size for splits:

Options:

All features: n_features
Square root: √n_features
Log base 2: log₂(n_features)
Custom count: user-defined

Impact:

Split quality
Training speed
Tree diversity
Memory usage

Auto ~

Use all features:

Properties:

Maximum information
Slower computation
Optimal splits

Best for:

Small feature sets
Important decisions
Single trees

Sqrt ~

Square root of features:

Formula: $n_{s u b se t} = n_{f e a t u res}$

Benefits:

Balanced selection
Reduced computation
Common default

Best for:

Random forests
General usage
Medium feature sets

Log2 ~

Log base 2 of features:

Formula: $n_{s u b se t} = l o g_{2} (n_{f e a t u res})$

Benefits:

Smaller subsets
Faster splitting
High dimensions

Best for:

Many features
Quick training
Feature sampling

Custom ~

User-defined feature count:

Properties:

Flexible control
Manual optimization
Problem-specific

Best for:

Expert tuning
Known requirements
Special cases

MaxFeaturesF

u32

Custom feature count:

Usage:

Active when max_features=Custom
Must be ≤ total features

Selection guide:

Small: More randomization
Large: Better splits
Trade-off: Speed vs quality

MaxLeafNodes

u32

Maximum leaf node count:

Growth control:

0: Unlimited leaves
>0: Best-first growth

Effects:

Tree size limitation
Memory control
Complexity bound

Alternative to max_depth

MinImpurityDecrease

f64

Minimum impurity decrease:

Purpose:

Prevents weak splits
Controls growth
Pre-pruning method

Controls the randomness of the estimator. The features are always randomly permuted at each split, even if splitter is set to 'best'. When max_features < n_features, the algorithm will select max_features at random at each split before finding the best split among them.

Controls:

Split selection
Feature sampling
Tree structure

Usage:

Fixed: Reproducible results
Different: Model variation
0: System random

CcpAlpha

f64

Cost-complexity pruning alpha:

Pruning criterion: $R_{α} (T) = R (T) + α ∣ T ∣$ where:

R(T): Tree error
|T|: Number of leaves
α: Complexity parameter

Effect:

Larger α: More pruning
Smaller α: Less pruning
0: No pruning

GridSearch

Decision Tree hyperparameter optimization:

Search dimensions:

Tree structure:
- Growth controls
- Node constraints
- Split criteria
Complexity control:
- Depth/leaves limits
- Sample thresholds
- Pruning parameters
Split quality:
- Feature selection
- Impurity measures
- Splitting strategy

Best practices:

Start coarse-grained
Focus on key parameters
Monitor complexity
Consider interactions

Criterion

[enum, ...]

Mse

Split quality measurement:

Available criteria:

Mean Squared Error:
- Variance reduction
- L2 loss minimization
- Standard choice
Friedman MSE:
- MSE with improvements
- Better split selection
- Potential gains
Absolute Error:
- L1 loss minimization
- Median-based splits
- Robust to outliers
Poisson:
- Deviance reduction
- Count data
- Non-negative targets

Mse ~

Mean squared error criterion:

Formula: $MSE = \frac{1}{N} i = 1 \sum N (y_{i} - \overset{y}{ˉ})^{2}$ Gain: $G ain = MS E_{p a re n t} - j \in {L, R} \sum \frac{N _{j}}{N} MS E_{j}$

Properties:

Minimizes variance
Sensitive to outliers
Mean-based splits

Best for:

Normal distributions
Continuous targets
General regression

FriedManMse ~

Friedman's MSE criterion:

Formula: $MS E_{F} = \frac{N _{L} N _{R}}{N ^{2}} (\overset{y}{ˉ}_{L} - \overset{y}{ˉ}_{R})^{2}$

Properties:

Enhanced MSE
Split potential
Local improvements
Better splits

Best for:

Complex patterns
Gradient boosting
Refined splitting

AbsoluteError ~

Mean absolute error criterion:

Formula: $M A E = \frac{1}{N} i = 1 \sum N ∣ y_{i} - m e d ian (y) ∣$ Gain: $G ain = M A E_{p a re n t} - j \in {L, R} \sum \frac{N _{j}}{N} M A E_{j}$

Properties:

Median-based splits
Outlier resistant
Robust predictions

Best for:

Skewed distributions
Outlier presence
Robust modeling

Poisson ~

Poisson deviance criterion:

Formula: $D = 2 i = 1 \sum N (y_{i} l o g (\frac{y _{i}}{y ˉ}) - (y_{i} - \overset{y}{ˉ}))$

Properties:

Count data modeling
Non-negative targets
Rate prediction

Best for:

Count outcomes
Event rates
Frequency data

Splitter

[enum, ...]

Best

Split selection strategy:

Best splits:
- Exhaustive search
- Optimal local decisions
- Maximum gain selection
Random splits:
- Random feature subset
- Faster computation
- More diverse trees

Trade-offs:

Computation vs optimality
Deterministic vs random
Speed vs precision

Best ~

Best split selection:

Process:

Evaluates all possible splits
Chooses maximum gain
Deterministic choices

Best for:

Small to medium datasets
Optimal local decisions
Reproducible results

Random ~

Random split selection:

Process:

Random feature sampling
Best split within subset
Stochastic decisions

Best for:

Large datasets
Faster training
Ensemble methods

MaxDepth

[u32, ...]

Tree depth search:

Search patterns:

Simple trees:
- [3, 5, 7]
- Fast training
- Good generalization
Complex trees:
- [10, 15, 20, None]
- Detailed patterns
- More capacity

MinSamplesSplit

[u32, ...]

Split threshold search:

Common ranges:

Fine-grained:
- [2, 5, 10]
- Detailed splits
Coarse-grained:
- [10, 20, 50]
- Stable splits
- Prevent overfitting

MinSamplesLeaf

[u32, ...]

Leaf size search:

Search spaces:

Detailed leaves:
- [1, 3, 5]
- Fine predictions
Stable leaves:
- [5, 10, 20]
- Robust predictions
- Smoother regions

MinWeightFractionLeaf

[f64, ...]

Leaf weight fraction search:

Ranges:

No constraint: [0.0]
Light constraint:
- [0.0, 0.1, 0.2]
- Balanced trees
Heavy constraint:
- [0.2, 0.3, 0.4]
- Force larger leaves

MaxFeatures

[enum, ...]

Sqrt

Feature subset size for splits:

Options:

All features: n_features
Square root: √n_features
Log base 2: log₂(n_features)
Custom count: user-defined

Impact:

Split quality
Training speed
Tree diversity
Memory usage

Auto ~

Use all features:

Properties:

Maximum information
Slower computation
Optimal splits

Best for:

Small feature sets
Important decisions
Single trees

Sqrt ~

Square root of features:

Formula: $n_{s u b se t} = n_{f e a t u res}$

Benefits:

Balanced selection
Reduced computation
Common default

Best for:

Random forests
General usage
Medium feature sets

Log2 ~

Log base 2 of features:

Formula: $n_{s u b se t} = l o g_{2} (n_{f e a t u res})$

Benefits:

Smaller subsets
Faster splitting
High dimensions

Best for:

Many features
Quick training
Feature sampling

Custom ~

User-defined feature count:

Properties:

Flexible control
Manual optimization
Problem-specific

Best for:

Expert tuning
Known requirements
Special cases

MaxFeaturesF

[u32, ...]

Custom feature count search:

Search patterns:

Small subsets:
- [2, 4, 6]
- Fast training
Large subsets:
- [0.3n, 0.5n, 0.7*n]
- Better splits

Note: Used with max_features=Custom

MaxLeafNodes

[u32, ...]

Leaf count search:

Search ranges:

Simple trees:
- [10, 20, 30]
- Basic patterns
Complex trees:
- [50, 100, None]
- Detailed patterns

Alternative to max_depth search

MinImpurityDecrease

[f64, ...]

Impurity threshold search:

Ranges:

Fine splits:
- [0.0, 1e-4, 1e-3]
- Detailed trees
Coarse splits:
- [1e-3, 1e-2, 1e-1]
- Pre-pruning effect
- Prevent weak splits

RandomState

u64

Random seed control:

Usage patterns:

Development:
- Fixed seed
- Reproducible results
Production:
- Multiple seeds
- Stability check

CcpAlpha

[f64, ...]

Cost-complexity search:

Search patterns:

No pruning: [0.0]
Light pruning:
- [0.001, 0.01, 0.1]
- Maintain complexity
Heavy pruning:
- [0.1, 0.2, 0.3]
- Simplify tree

RefitScore

enum

R2score

Regression model evaluation metrics:

Purpose:

Model performance evaluation
Error measurement
Quality assessment
Model comparison

Selection criteria:

Error distribution
Scale sensitivity
Domain requirements
Business objectives

Default ~

Model's native scoring method:

Typically R² score
Model-specific implementation
Standard evaluation
Quick assessment

R2score ~

Coefficient of determination (R²):

Formula: $R^{2} = 1 - \frac{\sum ( y _{i} - y ^ _{i} ) ^{2}}{\sum ( y _{i} - y ˉ ) ^{2}}$

Properties:

Range: (-∞, 1]
1: Perfect prediction
0: Constant model
Negative: Worse than mean

Best for:

General performance
Variance explanation
Model comparison
Standard reporting

ExplainedVariance ~

Explained variance score:

Formula: $1 - \frac{Va r ( y - y ^ )}{Va r ( y )}$

Properties:

Range: (-∞, 1]
Accounts for bias
Variance focus
Similar to R²

Best for:

Variance analysis
Bias assessment
Model stability

MaxError ~

Maximum absolute error:

Formula: $max (∣ y_{i} - \overset{y}{^}_{i} ∣)$

Properties:

Worst case error
Original scale
Sensitive to outliers
Upper error bound

Best for:

Critical applications
Error bounds
Safety margins
Risk assessment

NegMeanAbsoluteError ~

Negative mean absolute error:

Formula: $- \frac{1}{n} \sum ∣ y_{i} - \overset{y}{^}_{i} ∣$

Properties:

Linear error scale
Robust to outliers
Original units
Negated for optimization

Best for:

Robust evaluation
Interpretable errors
Outlier presence

NegMeanSquaredError ~

Negative mean squared error:

Formula: $- \frac{1}{n} \sum (y_{i} - \overset{y}{^}_{i})^{2}$

Properties:

Squared error scale
Outlier sensitive
Squared units
Negated for optimization

Best for:

Standard optimization
Large error penalty
Statistical analysis

NegRootMeanSquaredError ~

Negative root mean squared error:

Formula: $- \frac{1}{n} \sum (y_{i} - \overset{y}{^}_{i})^{2}$

Properties:

Original scale
Outlier sensitive
Interpretable units
Negated for optimization

Best for:

Standard reporting
Interpretable errors
Model comparison

NegMeanSquaredLogError ~

Negative mean squared logarithmic error:

Formula: $- \frac{1}{n} \sum (lo g (1 + y_{i}) - lo g (1 + \overset{y}{^}_{i}))^{2}$

Properties:

Relative error scale
For positive values
Sensitive to ratios
Negated for optimization

Best for:

Exponential growth
Relative differences
Positive predictions

NegMedianAbsoluteError ~

Negative median absolute error:

Formula: $- m e d ian (∣ y_{i} - \overset{y}{^}_{i} ∣)$

Properties:

Highly robust
Original scale
Outlier resistant
Negated for optimization

Best for:

Robust evaluation
Heavy-tailed errors
Outlier presence

NegMeanPoissonDeviance ~

Negative Poisson deviance:

Formula: $- 2 \sum (y_{i} lo g (\frac{y _{i}}{y ^ _{i}}) - (y_{i} - \overset{y}{^}_{i}))$

Properties:

For count data
Non-negative values
Poisson assumption
Negated for optimization

Best for:

Count prediction
Event frequency
Rate modeling

NegMeanGammaDeviance ~

Negative Gamma deviance:

Formula: $- 2 \sum (lo g (\frac{y _{i}}{y ^ _{i}}) + \frac{y _{i} - y ^ _{i}}{y ^ _{i}})$

Properties:

For positive continuous data
Constant CV assumption
Relative errors
Negated for optimization

Best for:

Positive continuous data
Multiplicative errors
Financial modeling

NegMeanAbsolutePercentageError ~

Negative mean absolute percentage error:

Formula: $- \frac{100}{n} \sum ∣ \frac{y _{i} - y ^ _{i}}{y _{i}} ∣$

Properties:

Percentage scale
Scale independent
For non-zero targets
Negated for optimization

Best for:

Relative performance
Scale-free comparison
Business metrics

D2AbsoluteErrorScore ~

D² score with absolute error:

Formula: $1 - \frac{\sum ∣ y _{i} - y ^ _{i} ∣}{\sum ∣ y _{i} - y ˉ ∣}$

Properties:

Range: (-∞, 1]
Robust version of R²
Linear error scale
Outlier resistant

Best for:

Robust evaluation
Non-normal errors
Alternative to R²

D2PinballScore ~

D² score with pinball loss:

Properties:

Quantile focus
Asymmetric errors
Risk assessment
Distribution modeling

Best for:

Quantile regression
Risk analysis
Asymmetric costs
Distribution tails

D2TweedieScore ~

D² score with Tweedie deviance:

Properties:

Compound Poisson-Gamma
Flexible dispersion
Mixed distributions
Insurance modeling

Best for:

Insurance claims
Mixed continuous-discrete
Compound distributions
Specialized modeling

Split

oneof

DefaultSplit

Standard train-test split configuration optimized for general classification tasks.

Configuration:

Test size: 20% (0.2)
Random seed: 98
Shuffling: Enabled
Stratification: Based on target distribution

Advantages:

Preserves class distribution
Provides reliable validation
Suitable for most datasets

Best for:

Medium to large datasets
Independent observations
Initial model evaluation

Splitting uses the ShuffleSplit strategy or StratifiedShuffleSplit strategy depending on the field stratified. Note: If shuffle is false then stratified must be false.

CustomSplit

Configurable train-test split parameters for specialized requirements. Allows fine-tuning of data division strategy for specific use cases or constraints.

Use cases:

Time series data
Grouped observations
Specific train/test ratios
Custom validation schemes

RandomState

u64

Random seed for reproducible splits. Ensures:

Consistent train/test sets
Reproducible experiments
Comparable model evaluations

Same seed guarantees identical splits across runs.

Shuffle

bool

true

Data shuffling before splitting. Effects:

true: Randomizes order, better for i.i.d. data
false: Maintains order, important for time series

When to disable:

Time dependent data
Sequential patterns
Grouped observations

TrainSize

f64

0.8

Proportion of data for training. Considerations:

Larger (e.g., 0.8-0.9): Better model learning
Smaller (e.g., 0.5-0.7): Better validation

Common splits:

0.8: Standard (80/20 split)
0.7: More validation emphasis
0.9: More training emphasis

Stratified

bool

false

Maintain class distribution in splits. Important when:

Classes are imbalanced
Small classes present
Representative splits needed

Requirements:

Classification tasks only
Cannot use with shuffle=false
Sufficient samples per class

Cv

oneof

DefaultCv

Standard cross-validation configuration using stratified 3-fold splitting.

Configuration:

Folds: 3
Method: StratifiedKFold
Stratification: Preserves class proportions

Advantages:

Balanced evaluation
Reasonable computation time
Good for medium-sized datasets

Limitations:

May be insufficient for small datasets
Higher variance than larger fold counts
May miss some data patterns

CustomCv

Configurable stratified k-fold cross-validation for specific validation requirements.

Features:

Adjustable fold count with NFolds determining the number of splits.
Stratified sampling
Preserved class distributions

Use cases:

Small datasets (more folds)
Large datasets (fewer folds)
Detailed model evaluation
Robust performance estimation

NFolds

u32

Number of cross-validation folds. Guidelines:

3-5: Large datasets, faster training
5-10: Standard choice, good balance
10+: Small datasets, thorough evaluation

Trade-offs:

More folds: Better evaluation, slower training
Fewer folds: Faster training, higher variance

Must be at least 2.

KfoldCv

K-fold cross-validation without stratification. Divides data into k consecutive folds for iterative validation.

Process:

Splits data into k equal parts
Each fold serves as validation once
Remaining k-1 folds form training set

Use cases:

Regression problems
Large, balanced datasets
When stratification unnecessary
Continuous target variables

Limitations:

May not preserve class distributions
Less suitable for imbalanced data
Can create biased splits with ordered data

NSplits

u32

Number of folds for cross-validation. Selection guide: Recommended values:

5: Standard choice (default)
3: Large datasets/quick evaluation
10: Thorough evaluation/smaller datasets

Trade-offs:

Higher values: More thorough, computationally expensive
Lower values: Faster, potentially higher variance

Must be at least 2 for valid cross-validation.

RandomState

u64

Random seed for fold generation when shuffling. Important for:

Reproducible results
Consistent fold assignments
Benchmark comparisons
Debugging and validation

Set specific value for reproducibility across runs.

Shuffle

bool

true

Whether to shuffle data before splitting into folds. Effects:

true: Randomized fold composition (recommended)
false: Sequential splitting

Enable when:

Data may have ordering
Better fold independence needed

Disable for:

Time series data
Ordered observations

StratifiedKfoldCv

Stratified K-fold cross-validation maintaining class proportions across folds.

Key features:

Preserves class distribution in each fold
Handles imbalanced datasets
Ensures representative splits

Best for:

Classification problems
Imbalanced class distributions
When class proportions matter

Requirements:

Classification tasks only
Sufficient samples per class
Categorical target variable

NSplits

u32

Number of stratified folds. Guidelines: Typical values:

5: Standard for most cases
3: Quick evaluation/large datasets
10: Detailed evaluation/smaller datasets

Considerations:

Must allow sufficient samples per class per fold
Balance between stability and computation time
Consider smallest class size when choosing

RandomState

u64

Seed for reproducible stratified splits. Ensures:

Consistent fold assignments
Reproducible results
Comparable experiments
Systematic validation

Fixed seed guarantees identical stratified splits.

Shuffle

bool

false

Data shuffling before stratified splitting. Impact:

true: Randomizes while maintaining stratification
false: Maintains data order within strata

Use cases:

true: Independent observations
false: Grouped or sequential data

Class proportions maintained regardless of setting.

ShuffleSplitCv

Random permutation cross-validator with independent sampling.

Characteristics:

Random sampling for each split
Independent train/test sets
More flexible than K-fold
Can have overlapping test sets

Advantages:

Control over test size
Fresh splits each iteration
Good for large datasets

Limitations:

Some samples might never be tested
Others might be tested multiple times
No guarantee of complete coverage

NSplits

u32

Number of random splits to perform. Consider: Common values:

5: Standard evaluation
10: More thorough assessment
3: Quick estimates

Trade-offs:

More splits: Better estimation, longer runtime
Fewer splits: Faster, less stable estimates

Balance between computation and stability.

RandomState

u64

Random seed for reproducible shuffling. Controls:

Split randomization
Sample selection
Result reproducibility

Important for:

Debugging
Comparative studies
Result verification

TestSize

f64

0.2

Proportion of samples for test set. Guidelines: Common ratios:

0.2: Standard (80/20 split)
0.25: More validation emphasis
0.1: More training data

Considerations:

Dataset size
Model complexity
Validation requirements

It must be between 0.0 and 1.0.

StratifiedShuffleSplitCv

Stratified random permutation cross-validator combining shuffle-split with stratification.

Features:

Maintains class proportions
Random sampling within strata
Independent splits
Flexible test size

Ideal for:

Imbalanced datasets
Large-scale problems
When class distributions matter
Flexible validation schemes

NSplits

u32

Number of stratified random splits. Guidelines: Recommended values:

5: Standard evaluation
10: Detailed analysis
3: Quick assessment

Consider:

Sample size per class
Computational resources
Stability requirements

RandomState

u64

Seed for reproducible stratified sampling. Ensures:

Consistent class proportions
Reproducible splits
Comparable experiments

Critical for:

Benchmarking
Research studies
Quality assurance

TestSize

f64

0.2

Fraction of samples for stratified test set. Best practices: Common splits:

0.2: Balanced evaluation
0.3: More thorough testing
0.15: Preserve training size

Consider:

Minority class size
Overall dataset size
Validation objectives

It must be between 0.0 and 1.0.

TimeSeriesSplitCv

Time Series cross-validator. Provides train/test indices to split time series data samples that are observed at fixed time intervals, in train/test sets. It is a variation of k-fold which returns first k folds as train set and the k + 1th fold as test set. Note that unlike standard cross-validation methods, successive training sets are supersets of those that come before them. Also, it adds all surplus data to the first training partition, which is always used to train the model. Key features:

Maintains temporal dependence
Expanding window approach
Forward-chaining splits
No future data leakage

Use cases:

Sequential data
Financial forecasting
Temporal predictions
Time-dependent patterns

Note: Training sets are supersets of previous iterations.

NSplits

u32

Number of temporal splits. Considerations: Typical values:

5: Standard forward chaining
3: Limited historical data
10: Long time series

Impact:

Affects training window growth
Determines validation points
Influences computational load

MaxTrainSize

u64

Maximum size of training set. Should be strictly less than the number of samples. Applications:

0: Use all available past data
>0: Rolling window of fixed size

Use cases:

Limit historical relevance
Control computational cost
Handle concept drift
Memory constraints

TestSize

u64

Number of samples in each test set. When 0:

Auto-calculated as n_samples/(n_splits+1)
Ensures equal-sized test sets

Considerations:

Forecast horizon
Validation requirements
Available future data

Gap

u64

Number of samples to exclude from the end of each train set before the test set.Gap between train and test sets. Uses:

Avoid data leakage
Model forecast lag
Buffer periods

Common scenarios:

0: Continuous prediction
>0: Forward gap for realistic evaluation
Match business forecasting needs