Ridge / Classifier Layer

Ridge Classifier - A linear classifier using Ridge regression with regularization. This classifier first converts the target values into {-1, 1} and then treats the problem as a regression task (multi-output regression in the multiclass case).

Mathematical form: $w min ∣∣ Xw - y ∣ ∣_{2}^{2} + α ∣∣ w ∣ ∣_{2}^{2}$ where:

$X$ is the feature matrix
$y$ is the target vector (converted to {-1, 1})
$α$ is the regularization strength
$w$ is the coefficient vector

Key characteristics:

L2 regularization
Linear decision boundaries
Efficient computation
Multiple solver options
Handles multiclass problems

Common applications:

Text classification
Bioinformatics
Image classification
Feature selection
High-dimensional data

Outputs:

Predicted Table: Input data with predictions
Validation Results: Cross-validation metrics
Test Metric: Test set performance
ROC Curve Data: ROC analysis information
Confusion Matrix: Classification breakdown
Feature Importances: Feature coefficients

Note: Particularly effective when features are correlated.

Table

Predicted Table

Validation Results

Test Metric

ROC Curve Data

Confusion Matrix

Feature Importances

SelectFeatures

[column, ...]

Feature columns for Ridge classification:

Requirements:

Numerical features required
No missing values
Non-constant columns
Finite values only

Preprocessing guidelines:

Scaling:
- Standardize features ( $μ = 0$ , $σ = 1$ )
- Critical for Ridge performance
- Ensures fair regularization
Feature engineering:
- Handle categorical variables
- Create interaction terms
- Remove redundant features
- Consider dimensionality reduction
Data quality:
- Handle missing values
- Remove outliers
- Check for collinearity
- Ensure feature consistency

If empty, uses all numeric columns except target.

SelectTarget

column

Target column for classification:

Requirements:

Categorical labels
No missing values
At least two classes
Properly encoded

Internal encoding:

Binary: {-1, 1}
Multiclass: One-vs-Rest

Class characteristics:

Check class balance
Monitor rare classes
Consider merging rare classes
Document class meanings

Quality checks:

Validate label accuracy
Check for label noise
Ensure consistent encoding
Verify class definitions

Params

oneof

DefaultParams

Standard configuration optimized for Ridge Classification tasks:

Mathematical objective: $w min \frac{1}{2 n _{s am pl es}} ∣∣ Xw - y ∣ ∣_{2}^{2} + \frac{α}{2} ∣∣ w ∣ ∣_{2}^{2}$

Default configuration:

Regularization:
- $α = 1.0$ (balanced regularization)
- Prevents overfitting while maintaining flexibility
- L2 penalty for stable solutions
Solver settings:
- Auto solver selection
- Tolerance = 0.0001
- Max iterations = 1000
Model structure:
- Fit intercept enabled
- Uniform class weights
- Standard scaling assumed

Performance characteristics:

Time complexity: $O (n_{s am pl es} \cdot n_{f e a t u res}^{2})$
Space complexity: $O (n_{f e a t u res}^{2})$
Convergence typically in < 1000 iterations
Numerically stable solutions

Best suited for:

Medium-sized datasets ( $1 0^{3} < n_{s am pl es} < 1 0^{5}$ )
Moderate feature counts ( $1 0^{2} < n_{f e a t u res} < 1 0^{4}$ )
Standardized features
Initial model exploration

Expected behavior:

Stable convergence
Balanced bias-variance trade-off
Good generalization
Reasonable training speed

Preprocessing requirements:

Feature standardization
Handling missing values
Encoding categorical variables
Removing constant features

Warning: May need tuning for:

Highly imbalanced classes
Very large datasets
Highly correlated features
Sparse feature matrices

CustomParams

Fine-grained control over Ridge Classifier parameters:

Mathematical framework: $w min \frac{1}{2 n _{s am pl es}} ∣∣ Xw - y ∣ ∣_{2}^{2} + \frac{α}{2} ∣∣ w ∣ ∣_{2}^{2}$ Subject to constraints and modifications based on parameters.

Parameter categories:

Regularization control
Optimization settings
Model structure
Computational options

Tuning guidelines provided for each parameter below.

Alpha

f64

Regularization strength parameter $α > 0$ :

Controls L2 penalty: $\frac{α}{2} ∣∣ w ∣ ∣_{2}^{2}$

Effect on model:

Larger $α$ : Stronger regularization, simpler model
Smaller $α$ : Weaker regularization, more complex model

Typical ranges:

Strong: [10.0, 100.0]
Standard: [0.1, 1.0]
Weak: [0.001, 0.1]

Selection guide:

High noise: Increase α
Large features: Increase α
Small dataset: Increase α
Clean data: Decrease α

Solver

enum

Auto

Optimization algorithm for solving the Ridge classification problem:

Objective function: $w min \frac{1}{2 n _{s am pl es}} ∣∣ Xw - y ∣ ∣_{2}^{2} + \frac{α}{2} ∣∣ w ∣ ∣_{2}^{2}$

Selection criteria:

Dataset size:

Small: Cholesky, SVD
Medium: Auto, LSQR
Large: SAG, SAGA, SparseCG

Memory constraints:

Low: LSQR, SparseCG
Medium: Auto, SAG
High: Cholesky, SVD

Matrix properties:

Singular: SVD
Sparse: SparseCG, LSQR
Well-conditioned: Cholesky

Auto ~

Automatically selects optimal solver based on data characteristics:

Selection criteria:

If $n_{s am pl es} > n_{f e a t u res}$ : Chooses SAG/SAGA
If sparsity > 0.5: Selects SparseCG/LSQR
If condition number $κ (X) > 1 0^{3}$ : Uses SVD
Otherwise: Uses Cholesky

Best for:

Initial modeling
Unknown data properties
General purpose use
Production systems

Svd ~

Singular Value Decomposition solver using matrix factorization:

Algorithm: $X = U Σ V^{T}$ Solution: $w = V Σ^{+} U^{T} y$ where: $Σ^{+} = diag (\frac{σ _{i}}{σ _{i}^{2} + α})$

Characteristics:

Highest numerical stability
Handles singular matrices
Computationally intensive
Dense matrix operations

Best for:

Ill-conditioned problems
Small to medium datasets
When accuracy critical
Multicollinear features

Cholesky ~

Cholesky decomposition solver using matrix factorization:

Algorithm: $X^{T} X + α I = L L^{T}$ Solution: $w = L^{- T} L^{- 1} X^{T} y$

Characteristics:

Fast for small problems
Direct solution method
Requires positive definite matrix
Dense matrix operations

Best for:

Small datasets
Well-conditioned problems
When speed important
Dense feature matrices

SparseCg ~

Conjugate Gradient solver for sparse matrices:

Iterative update: $w_{k + 1} = w_{k} + α_{k} p_{k}$ where: $p_{k} = r_{k} + β_{k} p_{k - 1}$ $r_{k} = X^{T} y - (X^{T} X + α I) w_{k}$

Characteristics:

Iterative method
Memory efficient
Handles large sparse data
No matrix factorization

Best for:

Large sparse datasets
Limited memory scenarios
High-dimensional data
Text classification

Lsqr ~

Least Squares QR solver using iterative procedure:

Minimizes: $w min [X α I] w - [y 0]_{2}$

Characteristics:

Fast convergence
Memory efficient
Good numerical properties
Handles rectangular systems

Best for:

Large sparse problems
Streaming data
Limited memory
Quick solutions needed

Sag ~

Stochastic Average Gradient descent:

Update rule: $w_{t + 1} = w_{t} - η_{t} \frac{1}{n} i = 1 \sum n d_{i}$ where $d_{i}$ is the stored gradient for sample i

Characteristics:

Linear convergence rate
Constant memory usage
Efficient for large samples
Handles L2 regularization

Best for:

Large datasets
Online learning
Smooth optimization
When memory limited

Saga ~

SAGA (Improved Stochastic Average Gradient):

Update rule: $w_{t + 1} = w_{t} - η_{t} (\nabla f_{i} (w_{t}) - \nabla f_{i} (w_{t - 1}) + \overset{ˉ}{\nabla})$ where $\overset{ˉ}{\nabla}$ is the average of stored gradients

Characteristics:

Unbiased gradient estimates
Supports all penalties
Fast convergence
Memory efficient

Best for:

Large datasets
Non-smooth penalties
Online learning
Complex regularization

Lbfgs ~

Limited-memory BFGS with positive constraint:

Approximates Hessian update: $H_{k + 1} = H_{k} + \frac{y _{k} y _{k}^{T}}{y _{k}^{T} s _{k}} - \frac{H _{k} s _{k} s _{k}^{T} H _{k}}{s _{k}^{T} H _{k} s _{k}}$ Subject to: $w_{i} \geq 0$ for all i

Characteristics:

Quasi-Newton method
Forces positive coefficients
Memory efficient
Good convergence

Best for:

Positive coefficient requirements
Medium-scale problems
When interpretability needed
Limited memory scenarios

Note: Only used with positive=True

Tol

f64

0.0001

Convergence tolerance $ϵ > 0$ :

Stopping criterion: $∣∣ w^{(t)} - w^{(t - 1)} ∣ ∣_{2} < ϵ$

Typical values:

Strict: 1e-6 to 1e-5
Standard: 1e-4 (default)
Relaxed: 1e-3 to 1e-2

Trade-offs:

Smaller: More precise, slower
Larger: Less precise, faster

ClassWeight

enum

Balanced

Class weight adjustment strategy for handling imbalanced datasets:

Mathematical formulation: Modified objective: $w min i = 1 \sum n_{s am pl es} w_{c_{i}} L (y_{i}, f (x_{i})) + α ∣∣ w ∣ ∣_{2}^{2}$ where:

$w_{c_{i}}$ is the weight for class of sample i
$L$ is the loss function
$f (x_{i})$ is the model prediction
$α$ is the regularization term

Impact on model:

Modifies effective sample importance
Adjusts decision boundary location
Influences classification thresholds
Affects gradient magnitudes

Selection criteria:

Class distribution imbalance
Misclassification costs
Business/domain requirements
Performance metric priorities

Uniform ~

Equal weights for all classes:

Weight formula: $w_{i} = 1 \forall i \in classes$

Characteristics:

Natural class proportions preserved
No adjustment for frequencies
Faster training process
Original distribution maintained

Best for:

Balanced datasets ( $n_{c l a s s_{1}} \approx n_{c l a s s_{2}}$ )
When natural proportions matter
Representative sampling
Equal misclassification costs

Warning: May underperform on imbalanced data

Balanced ~

Weights inversely proportional to class frequencies:

Weight formula: $w_{j} = \frac{n _{s am pl es}}{n _{c l a sses} \times n _{j}}$ where:

$n_{s am pl es}$ is total samples
$n_{c l a sses}$ is number of classes
$n_{j}$ is samples in class j

Example: For binary case with 100 samples (90/10 split):

Majority class weight: $w_{1} = \frac{100}{2 \times 90} \approx 0.56$
Minority class weight: $w_{2} = \frac{100}{2 \times 10} = 5$

Characteristics:

Automatically adjusts for imbalance
Higher weights for minority classes
Equalizes class importance
Helps rare class detection

Best for:

Imbalanced datasets
Rare event detection
Fraud detection
Medical diagnosis
Anomaly detection

Note: May increase prediction variance

FitIntercept

bool

true

Whether to calculate the intercept term $b$ :

Model form: $f (x) = w^{T} x + b$

Set false only when:

Data is already centered
$\sum_{i = 1}^{n} x_{i} = 0$
Zero-intercept desired
Testing theoretical properties

MaxIter

u64

1000

Maximum number of iterations for optimization:

Iteration bounds: $t_{ma x}$ in gradient descent: $w^{(t + 1)} = w^{(t)} - η \nabla L (w^{(t)})$

Guidelines:

Basic: 1000 (default)
Complex: 2000-5000
Large-scale: 5000+

Increase if:

Non-convergence warnings
Complex decision boundary
Large dataset

RandomState

u64

Random number generator seed:

Controls randomization in:

SAG/SAGA solvers
Data shuffling
Initialization

Fixed value ensures:

Reproducible results
Consistent behavior
Comparable experiments

GridSearch

Exhaustive hyperparameter optimization for Ridge Classifier:

Search strategy:

Tests all parameter combinations
Uses cross-validation for evaluation
Optimizes specified scoring metric
Returns best performing configuration

Computational complexity:

Time: $O (n_{co mbina t i o n s} \cdot n_{s pl i t s} \cdot n_{s am pl es})$
Memory: $O (n_{co mbina t i o n s} + n_{f e a t u res}^{2})$

Best practices:

Start with coarse grid
Focus on impactful parameters
Consider parameter interactions
Monitor resource usage

Alpha

[f64, ...]

Regularization strength values to evaluate:

Search spaces:

Linear: [0.1, 1.0, 10.0]
Logarithmic: [1e-3, 1e-2, 1e-1, 1e0, 1e1]
Fine-grained: [0.5, 1.0, 2.0, 5.0]

Strategy: Start wide, then refine around best values

Solver

[enum, ...]

Auto

Optimization algorithm for solving the Ridge classification problem:

Objective function: $w min \frac{1}{2 n _{s am pl es}} ∣∣ Xw - y ∣ ∣_{2}^{2} + \frac{α}{2} ∣∣ w ∣ ∣_{2}^{2}$

Selection criteria:

Dataset size:

Small: Cholesky, SVD
Medium: Auto, LSQR
Large: SAG, SAGA, SparseCG

Memory constraints:

Low: LSQR, SparseCG
Medium: Auto, SAG
High: Cholesky, SVD

Matrix properties:

Singular: SVD
Sparse: SparseCG, LSQR
Well-conditioned: Cholesky

Auto ~

Automatically selects optimal solver based on data characteristics:

Selection criteria:

If $n_{s am pl es} > n_{f e a t u res}$ : Chooses SAG/SAGA
If sparsity > 0.5: Selects SparseCG/LSQR
If condition number $κ (X) > 1 0^{3}$ : Uses SVD
Otherwise: Uses Cholesky

Best for:

Initial modeling
Unknown data properties
General purpose use
Production systems

Svd ~

Singular Value Decomposition solver using matrix factorization:

Algorithm: $X = U Σ V^{T}$ Solution: $w = V Σ^{+} U^{T} y$ where: $Σ^{+} = diag (\frac{σ _{i}}{σ _{i}^{2} + α})$

Characteristics:

Highest numerical stability
Handles singular matrices
Computationally intensive
Dense matrix operations

Best for:

Ill-conditioned problems
Small to medium datasets
When accuracy critical
Multicollinear features

Cholesky ~

Cholesky decomposition solver using matrix factorization:

Algorithm: $X^{T} X + α I = L L^{T}$ Solution: $w = L^{- T} L^{- 1} X^{T} y$

Characteristics:

Fast for small problems
Direct solution method
Requires positive definite matrix
Dense matrix operations

Best for:

Small datasets
Well-conditioned problems
When speed important
Dense feature matrices

SparseCg ~

Conjugate Gradient solver for sparse matrices:

Iterative update: $w_{k + 1} = w_{k} + α_{k} p_{k}$ where: $p_{k} = r_{k} + β_{k} p_{k - 1}$ $r_{k} = X^{T} y - (X^{T} X + α I) w_{k}$

Characteristics:

Iterative method
Memory efficient
Handles large sparse data
No matrix factorization

Best for:

Large sparse datasets
Limited memory scenarios
High-dimensional data
Text classification

Lsqr ~

Least Squares QR solver using iterative procedure:

Minimizes: $w min [X α I] w - [y 0]_{2}$

Characteristics:

Fast convergence
Memory efficient
Good numerical properties
Handles rectangular systems

Best for:

Large sparse problems
Streaming data
Limited memory
Quick solutions needed

Sag ~

Stochastic Average Gradient descent:

Update rule: $w_{t + 1} = w_{t} - η_{t} \frac{1}{n} i = 1 \sum n d_{i}$ where $d_{i}$ is the stored gradient for sample i

Characteristics:

Linear convergence rate
Constant memory usage
Efficient for large samples
Handles L2 regularization

Best for:

Large datasets
Online learning
Smooth optimization
When memory limited

Saga ~

SAGA (Improved Stochastic Average Gradient):

Update rule: $w_{t + 1} = w_{t} - η_{t} (\nabla f_{i} (w_{t}) - \nabla f_{i} (w_{t - 1}) + \overset{ˉ}{\nabla})$ where $\overset{ˉ}{\nabla}$ is the average of stored gradients

Characteristics:

Unbiased gradient estimates
Supports all penalties
Fast convergence
Memory efficient

Best for:

Large datasets
Non-smooth penalties
Online learning
Complex regularization

Lbfgs ~

Limited-memory BFGS with positive constraint:

Approximates Hessian update: $H_{k + 1} = H_{k} + \frac{y _{k} y _{k}^{T}}{y _{k}^{T} s _{k}} - \frac{H _{k} s _{k} s _{k}^{T} H _{k}}{s _{k}^{T} H _{k} s _{k}}$ Subject to: $w_{i} \geq 0$ for all i

Characteristics:

Quasi-Newton method
Forces positive coefficients
Memory efficient
Good convergence

Best for:

Positive coefficient requirements
Medium-scale problems
When interpretability needed
Limited memory scenarios

Note: Only used with positive=True

Tol

[f64, ...]

0.0001

Convergence tolerance values to test:

Typical grids:

Coarse: [1e-2, 1e-3, 1e-4]
Fine: [5e-5, 1e-4, 5e-4]
Extended: [1e-5, 1e-4, 1e-3, 1e-2]

Balance precision vs computation time

ClassWeight

[enum, ...]

Balanced

Class weight adjustment strategy for handling imbalanced datasets:

Mathematical formulation: Modified objective: $w min i = 1 \sum n_{s am pl es} w_{c_{i}} L (y_{i}, f (x_{i})) + α ∣∣ w ∣ ∣_{2}^{2}$ where:

$w_{c_{i}}$ is the weight for class of sample i
$L$ is the loss function
$f (x_{i})$ is the model prediction
$α$ is the regularization term

Impact on model:

Modifies effective sample importance
Adjusts decision boundary location
Influences classification thresholds
Affects gradient magnitudes

Selection criteria:

Class distribution imbalance
Misclassification costs
Business/domain requirements
Performance metric priorities

Uniform ~

Equal weights for all classes:

Weight formula: $w_{i} = 1 \forall i \in classes$

Characteristics:

Natural class proportions preserved
No adjustment for frequencies
Faster training process
Original distribution maintained

Best for:

Balanced datasets ( $n_{c l a s s_{1}} \approx n_{c l a s s_{2}}$ )
When natural proportions matter
Representative sampling
Equal misclassification costs

Warning: May underperform on imbalanced data

Balanced ~

Weights inversely proportional to class frequencies:

Weight formula: $w_{j} = \frac{n _{s am pl es}}{n _{c l a sses} \times n _{j}}$ where:

$n_{s am pl es}$ is total samples
$n_{c l a sses}$ is number of classes
$n_{j}$ is samples in class j

Example: For binary case with 100 samples (90/10 split):

Majority class weight: $w_{1} = \frac{100}{2 \times 90} \approx 0.56$
Minority class weight: $w_{2} = \frac{100}{2 \times 10} = 5$

Characteristics:

Automatically adjusts for imbalance
Higher weights for minority classes
Equalizes class importance
Helps rare class detection

Best for:

Imbalanced datasets
Rare event detection
Fraud detection
Medical diagnosis
Anomaly detection

Note: May increase prediction variance

FitIntercept

[bool, ...]

true

Whether to fit intercept:

Options:

[true]: Standard modeling
[true, false]: Compare both

Usually keep [true] unless data centered

MaxIter

[u64, ...]

1000

Maximum iterations to test:

Common ranges:

Basic: [500, 1000, 2000]
Extended: [1000, 2000, 5000]
Comprehensive: [500, 1000, 2000, 5000]

Include larger values if convergence issues

RandomState

u64

Random seed for reproducibility:

Controls:

Cross-validation splits
SAG/SAGA initialization
Data shuffling

Fixed value ensures reproducible search

RefitScore

enum

Accuracy

Metric for evaluating model performance during training and validation:

Purpose:

Model selection criteria
Performance evaluation
Cross-validation scoring
Hyperparameter optimization

Selection impact:

Guides model selection
Affects parameter tuning
Influences early stopping
Determines best model choice

Note: Choice should align with problem objectives and data characteristics

Default ~

Uses estimator's built-in scoring method:

For Ridge Classifier: $score = \frac{1}{n _{s am pl es}} i = 1 \sum n_{s am pl es} 1_{y_{i} = \overset{y}{^}_{i}}$

Characteristics:

Standard accuracy metric
Equal weight to all samples
Simple interpretation
Fast computation

Best for:

Balanced datasets
Quick evaluations
When unsure about metric
General performance assessment

Accuracy ~

Standard classification accuracy score:

Formula: $Accuracy = \frac{TP + TN}{TP + TN + FP + FN} = \frac{Correct Predictions}{Total Samples}$

Properties:

Range: [0, 1]
Perfect score: 1.0
Baseline: max(class proportions)

Advantages:

Intuitive interpretation
Fast computation
Direct meaning
Widely used

Best for:

Balanced classes
Equal error costs
Overall performance
Simple problems

Warning: Misleading for imbalanced data

BalancedAccuracy ~

Class-weighted accuracy score:

Formula: $Balanced Accuracy = \frac{1}{n _{c l a sses}} i = 1 \sum n_{c l a sses} \frac{T P _{i}}{T P _{i} + F N _{i}} = \frac{1}{n _{c l a sses}} i = 1 \sum n_{c l a sses} Recall_{i}$

For binary classification: $Balanced Accuracy = \frac{1}{2} (\frac{TP}{TP + FN} + \frac{TN}{TN + FP})$

Properties:

Range: [0, 1]
Perfect score: 1.0
Random baseline: 0.5
Accounts for class imbalance

Advantages:

Handles imbalanced data
Equal class importance
Better than raw accuracy
Robust to class skew

Best for:

Imbalanced datasets
When minority class important
Multi-class problems
Healthcare applications
Anomaly detection

Note: May differ significantly from raw accuracy

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