Svc / Classifier Layer

Support Vector Classification - A powerful non-linear classification algorithm. The fit time scales at least quadratically with the number of samples and may be impractical beyond tens of thousands of samples.

Mathematical form: $f (x) = sign (i = 1 \sum n α_{i} y_{i} K (x_{i}, x) + b)$ where:

$K (x_{i}, x)$ is the kernel function
$α_{i}$ are Lagrange multipliers
$y_{i}$ are class labels
$b$ is the bias term

Key characteristics:

Maximum margin classification
Kernel-based learning
Non-linear capability
Robust to high dimensions
Support vector sparsity

Common applications:

Text classification
Image recognition
Bioinformatics
Pattern recognition
Face detection

Computational notes:

Time complexity: O(n²) to O(n³)
Space complexity: O(n²)
Best for n < 10,000 samples
Kernel computations intensive

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 weights/coefficients

Note: For larger datasets, consider LinearSVC or SGDClassifier

Table

Predicted Table

Validation Results

Test Metric

ROC Curve Data

Confusion Matrix

Feature Importances

SelectFeatures

[column, ...]

Feature columns for SVM classification:

Data requirements:

Preprocessing:
- Numerical features
- Standardized/normalized
- No missing values
- Finite numbers only
Scaling recommendations:
- StandardScaler: Zero mean, unit variance
- MinMaxScaler: Bounded range
- RobustScaler: Outlier presence
Feature engineering:
- Kernel-appropriate transforms
- Meaningful interactions
- Domain-specific features
Quality checks:
- Feature relevance
- Correlation analysis
- Scale compatibility
- Outlier detection

Note: If empty, uses all numeric columns except target

SelectTarget

column

Target column for SVM classification:

Requirements:

Data format:
- Categorical labels
- No missing values
- Unique class labels
- Valid encodings
Class characteristics:
- At least two classes
- Balanced preferred
- Clear separation
- Meaningful categories
Quality considerations:
- Label consistency
- Class distributions
- Error costs
- Domain validity
Processing needs:
- Label encoding
- Class weighting
- Stratification
- Validation strategy

Params

oneof

DefaultParams

Optimized default configuration for Support Vector Classification:

Default settings:

Core parameters:
- C = 1.0 (regularization)
- RBF kernel (non-linear)
- gamma = 'scale' (auto-scaling)
Kernel settings:
- degree = 3 (polynomial)
- coef0 = 0.0 (kernel offset)
Training control:
- shrinking = true
- tolerance = 0.001
- cache_size = 200MB

Best suited for:

Medium-sized datasets
Unknown data distributions
General classification tasks
Initial modeling phase

Note: Provides good baseline performance for most problems

CustomParams

Fine-tuned configuration for Support Vector Classification:

Parameter categories:

Model complexity:
- Regularization strength
- Kernel selection
- Feature mapping
Kernel configuration:
- Kernel parameters
- Feature space control
- Similarity measures
Optimization settings:
- Numerical precision
- Memory usage
- Convergence control
Output control:
- Decision function
- Probability estimation
- Class weighting

Note: Parameter interactions significantly impact model performance

CFactor

f64

Regularization parameter (C):

Mathematical role: $w, b, ξ min \frac{1}{2} ∣∣ w ∣ ∣^{2} + C i = 1 \sum n ξ_{i}$

Impact:

Controls margin width
Balances error vs complexity
Affects overfitting

Typical ranges:

Weak: 0.1 - 1.0
Medium: 1.0 - 10.0
Strong: 10.0 - 100.0

Note: Lower C = more regularization

Kernel

enum

Rbf

Kernel functions for non-linear feature mapping:

Role in SVM:

Implicit feature space mapping
Non-linear pattern learning
Similarity measurement
Computational efficiency

Selection criteria:

Data distribution
Problem non-linearity
Computational resources
Domain knowledge

Linear ~

Linear kernel: $K (x, y) = x^{T} y$

Properties:

Fastest computation
No hyperparameters
Linear decision boundary
Memory efficient

Best for:

High-dimensional data
Text classification
Sparse datasets
Linear relationships

Note: Equivalent to LinearSVC with better small-dataset handling

Poly ~

Polynomial kernel: $K (x, y) = (γ x^{T} y + r)^{d}$

Properties:

Degree d controls flexibility
Models feature interactions
Homogeneous (r=0) or inhomogeneous (r≠0)
Computationally intensive

Best for:

Feature interaction modeling
Bounded non-linearity
Image processing
Structured data

Parameters: degree (d), gamma (γ), coef0 (r)

Rbf ~

Radial Basis Function: $K (x, y) = exp (- γ ∣∣ x - y ∣ ∣^{2})$

Properties:

Infinite-dimensional feature space
Universal approximator
Distance-based similarity
Most versatile kernel

Best for:

General-purpose use
Unknown non-linearity
Real-valued features
Default choice

Parameter: gamma (γ) controls influence radius

Sigmoid ~

Sigmoid kernel: $K (x, y) = tanh (γ x^{T} y + r)$

Properties:

Neural network connection
Non-positive definite
Bounded output [-1, 1]
Historical importance

Best for:

Neural network alternative
Binary classification
Specific applications

Parameters: gamma (γ), coef0 (r)

Degree

u32

Polynomial kernel degree:

Effect: $K (x, y) = (γ x^{T} y + r)^{d e g ree}$

Impact:

Feature space complexity
Model flexibility
Computational cost

Common values:

2: Quadratic relationships
3: Cubic (default)
4+: Higher-order patterns

Note: Only affects polynomial kernel

Gamma

enum

Scale

Kernel coefficient scaling strategies:

Mathematical role:

Controls kernel bandwidth
Influences decision boundary flexibility
Affects model complexity
Impacts feature space transformation

Selection impact:

Training-validation trade-off
Model generalization
Computational efficiency
Prediction stability

Scale ~

Scale-dependent gamma: $γ = \frac{1}{n _{f e a t u res} * X . v a r ( )}$

Properties:

Adapts to feature variance
Scale-invariant behavior
Data-driven selection
Default choice

Advantages:

Robust to feature scaling
Automatic adaptation
Good default performance
Handles varying scales

Best for:

General use cases
Unknown data scales
Automated pipelines

Auto ~

Dimension-based gamma: $γ = \frac{1}{n _{f e a t u res}}$

Properties:

Simple dimensionality scaling
Feature count adaptation
Scale-sensitive behavior
Legacy default

Advantages:

Simple computation
Dimensionality aware
Consistent behavior

Best for:

Normalized features
Legacy compatibility
Simple problems

Custom ~

User-specified gamma value:

Usage:

Manual gamma selection
Fine-tuned optimization
Expert configuration
Cross-validation tuning

Advantages:

Full control
Problem-specific tuning
Optimization potential
Research flexibility

Best for:

Expert users
Grid search
Specialized problems
Performance optimization

GammaF

f64

Custom gamma value:

Usage:

RBF: Inverse radius of influence
Polynomial: Scale of inner product
Sigmoid: Scale factor

Typical ranges:

Small: 0.001 - 0.01
Medium: 0.01 - 0.1
Large: 0.1 - 1.0

Note: Only used when gamma='custom'

Coef0

f64

Independent term in kernel function:

Impact in kernels: Polynomial: $K (x, y) = (γ x^{T} y + coe f 0)^{d}$ Sigmoid: $K (x, y) = tanh (γ x^{T} y + coe f 0)$

Typical ranges:

Conservative: -1.0 to 1.0
Extended: -5.0 to 5.0

Effect:

Controls decision boundary offset
Affects feature space mapping
Influences model flexibility

Note: Only significant for polynomial and sigmoid kernels

Shrinking

bool

true

Whether to use the shrinking heuristic.

Purpose:

Accelerates training
Reduces memory usage
Eliminates non-support vectors
Optimizes solution search

Advantages:

Faster convergence
Memory efficiency
Solution sparsity

Trade-offs:

Speed vs precision
Memory vs accuracy
Early elimination risk

Probability

bool

false

Enable probability estimates:

Method:

Uses Platt scaling
Requires additional cross-validation
Fits sigmoid to SVM scores

Impact:

Slower training (5-10x)
Additional memory usage
Probabilistic outputs
Calibrated predictions

Best for:

Uncertainty quantification
Risk assessment
Decision thresholding
Probability requirements

Tol

f64

0.001

Optimization convergence tolerance:

Controls:

Solution precision
Training termination
Optimization accuracy

Typical values:

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

Trade-offs:

Precision vs speed
Convergence time
Solution accuracy

CacheSize

u64

200

Kernel cache size in MB:

Purpose:

Speeds up training
Stores kernel evaluations
Reduces computations

Guidelines:

Small (100MB): Limited memory
Medium (200MB): Default
Large (1000MB+): Fast training

Considerations:

Available RAM
Dataset size
Training speed needs
System resources

ClassWeight

enum

None

Class importance weighting schemes:

Purpose:

Handles class imbalance
Adjusts error penalties
Controls class importance
Influences decision boundary

Impact:

Classification bias
Model sensitivity
Error distribution
Training dynamics

None ~

Uniform class weights: $w_{i} = 1$

Properties:

Equal class importance
No bias adjustment
Standard optimization
Raw data distribution

Best for:

Balanced datasets
Equal error costs
Standard problems
When class balance not critical

Balanced ~

Inverse frequency weighting:

Formula: $w_{i} = \frac{N}{K \times N _{i}}$

where:

$w_{i}$ is weight for class i
$N$ is total samples
$K$ is number of classes
$N_{i}$ is samples in class i

Properties:

Automatic weight adjustment
Compensates class imbalance
Balanced error contribution
Frequency-based weights

Best for:

Imbalanced datasets
Minority class importance
Skewed distributions
Fair classification needs

Note: May increase sensitivity to noise in rare classes

MaxIter

i64

-1

Maximum iterations limit:

Control:

Training duration
Optimization steps
Convergence limit

Values:

-1: No limit
>0: Maximum iterations

Guidelines:

Simple: 1000-10000
Complex: 10000-100000
Very complex: >100000

DecisionFunctionShape

enum

Ovr

Whether to return a one-vs-rest ('ovr') decision function of shape (n_samples, n_classes) as all other classifiers, or the original one-vs-one ('ovo') decision function of libsvm which has shape (n_samples, n_classes * (n_classes - 1) / 2). However, note that internally, one-vs-one ('ovo') is always used as a multi-class strategy to train models; an ovr matrix is only constructed from the ovo matrix. The parameter is ignored for binary classification.

Impact:

Decision boundary construction
Computational complexity
Memory requirements
Prediction interpretation

Trade-offs:

Speed vs accuracy
Memory vs precision
Simplicity vs detail
Training vs prediction time

Ovr ~

One-vs-Rest strategy:

Properties:

n_classes binary classifiers
Linear memory scaling
Simpler decision boundaries
Standard approach

Advantages:

Memory efficient
Faster prediction
Easier interpretation
Common interface

Best for:

Many classes
Limited memory
Standard applications

Ovo ~

One-vs-One strategy:

Properties:

n_classes * (n_classes-1)/2 classifiers
Quadratic memory scaling
Pairwise class separation
Original LIBSVM approach

Advantages:

Better class separation
Handles unbalanced classes
More detailed boundaries
Original implementation

Best for:

Few classes
Complex boundaries
Detailed analysis needs

RandomState

u64

Random number generator seed:

Controls:

Data shuffling
Probability estimation
Cross-validation splits

Important for:

Reproducibility
Debugging
Result comparison
Validation stability

GridSearch

Hyperparameter optimization for Support Vector Classification:

Search process:

Model complexity:
- Regularization (C)
- Kernel selection
- Kernel parameters
Feature mapping:
- Gamma values
- Polynomial degrees
- Kernel coefficients
Optimization:
- Numerical parameters
- Training control
- Convergence settings

Computational impact:

Time complexity: O(n_params * n_samples²)
Memory needs: O(n_params * cache_size)
Storage: O(n_params * n_support_vectors)

Best practices:

Start with coarse grid
Focus on key parameters
Monitor resource usage
Use domain knowledge

CFactor

[f64, ...]

Regularization parameter search space:

Common search patterns:

Logarithmic scale (recommended):
- Wide: [0.1, 1.0, 10.0, 100.0]
- Fine: [0.1, 0.3, 1.0, 3.0, 10.0]
Problem-specific:
- Noisy data: [0.1, 0.5, 1.0]
- Clean data: [1.0, 10.0, 100.0]

Selection strategy:

Start with log-spaced values
Refine around best performance
Consider noise levels
Monitor overfitting

Kernel

[enum, ...]

Rbf

Kernel functions for non-linear feature mapping:

Role in SVM:

Implicit feature space mapping
Non-linear pattern learning
Similarity measurement
Computational efficiency

Selection criteria:

Data distribution
Problem non-linearity
Computational resources
Domain knowledge

Linear ~

Linear kernel: $K (x, y) = x^{T} y$

Properties:

Fastest computation
No hyperparameters
Linear decision boundary
Memory efficient

Best for:

High-dimensional data
Text classification
Sparse datasets
Linear relationships

Note: Equivalent to LinearSVC with better small-dataset handling

Poly ~

Polynomial kernel: $K (x, y) = (γ x^{T} y + r)^{d}$

Properties:

Degree d controls flexibility
Models feature interactions
Homogeneous (r=0) or inhomogeneous (r≠0)
Computationally intensive

Best for:

Feature interaction modeling
Bounded non-linearity
Image processing
Structured data

Parameters: degree (d), gamma (γ), coef0 (r)

Rbf ~

Radial Basis Function: $K (x, y) = exp (- γ ∣∣ x - y ∣ ∣^{2})$

Properties:

Infinite-dimensional feature space
Universal approximator
Distance-based similarity
Most versatile kernel

Best for:

General-purpose use
Unknown non-linearity
Real-valued features
Default choice

Parameter: gamma (γ) controls influence radius

Sigmoid ~

Sigmoid kernel: $K (x, y) = tanh (γ x^{T} y + r)$

Properties:

Neural network connection
Non-positive definite
Bounded output [-1, 1]
Historical importance

Best for:

Neural network alternative
Binary classification
Specific applications

Parameters: gamma (γ), coef0 (r)

Degree

[u32, ...]

Polynomial degree values to evaluate:

Common ranges:

Standard search:
- [2, 3, 4]: Basic polynomial orders
- [2, 3, 4, 5]: Extended range
Specialized:
- [1, 2]: Linear to quadratic
- [2, 3, 4, 5, 6]: Complex patterns

Considerations:

Computational cost grows with degree
Risk of overfitting increases
Feature space dimensionality
Memory requirements

Gamma

[enum, ...]

Scale

Kernel coefficient scaling strategies:

Mathematical role:

Controls kernel bandwidth
Influences decision boundary flexibility
Affects model complexity
Impacts feature space transformation

Selection impact:

Training-validation trade-off
Model generalization
Computational efficiency
Prediction stability

Scale ~

Scale-dependent gamma: $γ = \frac{1}{n _{f e a t u res} * X . v a r ( )}$

Properties:

Adapts to feature variance
Scale-invariant behavior
Data-driven selection
Default choice

Advantages:

Robust to feature scaling
Automatic adaptation
Good default performance
Handles varying scales

Best for:

General use cases
Unknown data scales
Automated pipelines

Auto ~

Dimension-based gamma: $γ = \frac{1}{n _{f e a t u res}}$

Properties:

Simple dimensionality scaling
Feature count adaptation
Scale-sensitive behavior
Legacy default

Advantages:

Simple computation
Dimensionality aware
Consistent behavior

Best for:

Normalized features
Legacy compatibility
Simple problems

Custom ~

User-specified gamma value:

Usage:

Manual gamma selection
Fine-tuned optimization
Expert configuration
Cross-validation tuning

Advantages:

Full control
Problem-specific tuning
Optimization potential
Research flexibility

Best for:

Expert users
Grid search
Specialized problems
Performance optimization

GammaF

[f64, ...]

Custom gamma values to evaluate:

Search spaces:

Log scale (recommended):
- Wide: [0.0001, 0.001, 0.01, 0.1, 1.0]
- Fine: [0.001, 0.003, 0.01, 0.03, 0.1]
Problem-specific:
- Low complexity: [0.001, 0.01]
- High complexity: [0.1, 1.0, 10.0]

Note: Only used when gamma='custom'

Coef0

[f64, ...]

Independent term values to evaluate:

Search ranges:

Conservative:
- [-1.0, 0.0, 1.0]
- [-0.5, 0.0, 0.5]
Exploratory:
- [-5.0, -1.0, 0.0, 1.0, 5.0]
- [-2.0, -1.0, 0.0, 1.0, 2.0]

Impact:

Polynomial kernel homogeneity
Sigmoid kernel shift
Decision boundary shape

Shrinking

[bool, ...]

true

Shrinking heuristic options:

Evaluation strategies:

Single option:
- [true]: Use shrinking
- [false]: No shrinking
Compare both:
- [true, false]: Full evaluation

Trade-off analysis:

Training speed
Memory usage
Solution accuracy
Convergence behavior

Probability

bool

false

Probability estimation setting:

Configuration impact:

Training time (5-10x slower)
Memory requirements
Output capabilities
Cross-validation needs

Use cases:

Uncertainty estimation
Confidence scoring
Risk assessment
Calibrated predictions

Tol

[f64, ...]

0.001

Convergence tolerance values:

Search ranges:

Standard scale:
- [1e-4, 1e-3, 1e-2]
- [0.0001, 0.001, 0.01]
Fine-tuning:
- [0.0005, 0.001, 0.002]
- [0.0008, 0.001, 0.0012]

Trade-offs:

Solution precision
Training time
Convergence guarantee

CacheSize

f64

200

Kernel cache memory allocation (MB):

Common configurations:

System-based:
- Small: 100MB (limited memory)
- Medium: 200MB (default)
- Large: 1000MB+ (fast training)
Dataset-based:
- Small data: 100-200MB
- Medium data: 200-500MB
- Large data: 500MB+

Note: Fixed during grid search to manage resources

ClassWeight

[enum, ...]

None

Class importance weighting schemes:

Purpose:

Handles class imbalance
Adjusts error penalties
Controls class importance
Influences decision boundary

Impact:

Classification bias
Model sensitivity
Error distribution
Training dynamics

None ~

Uniform class weights: $w_{i} = 1$

Properties:

Equal class importance
No bias adjustment
Standard optimization
Raw data distribution

Best for:

Balanced datasets
Equal error costs
Standard problems
When class balance not critical

Balanced ~

Inverse frequency weighting:

Formula: $w_{i} = \frac{N}{K \times N _{i}}$

where:

$w_{i}$ is weight for class i
$N$ is total samples
$K$ is number of classes
$N_{i}$ is samples in class i

Properties:

Automatic weight adjustment
Compensates class imbalance
Balanced error contribution
Frequency-based weights

Best for:

Imbalanced datasets
Minority class importance
Skewed distributions
Fair classification needs

Note: May increase sensitivity to noise in rare classes

MaxIter

[i64, ...]

-1

Maximum iteration limits to evaluate:

Search ranges:

Conservative:
- [-1]: No limit
- [1000, 5000, 10000]
Extensive:
- [5000, 10000, 50000, 100000]
- [10000, 25000, 50000]

Considerations:

Problem complexity
Convergence patterns
Time constraints
Resource limitations

DecisionFunctionShape

enum

Ovr

Impact:

Decision boundary construction
Computational complexity
Memory requirements
Prediction interpretation

Trade-offs:

Speed vs accuracy
Memory vs precision
Simplicity vs detail
Training vs prediction time

Ovr ~

One-vs-Rest strategy:

Properties:

n_classes binary classifiers
Linear memory scaling
Simpler decision boundaries
Standard approach

Advantages:

Memory efficient
Faster prediction
Easier interpretation
Common interface

Best for:

Many classes
Limited memory
Standard applications

Ovo ~

One-vs-One strategy:

Properties:

n_classes * (n_classes-1)/2 classifiers
Quadratic memory scaling
Pairwise class separation
Original LIBSVM approach

Advantages:

Better class separation
Handles unbalanced classes
More detailed boundaries
Original implementation

Best for:

Few classes
Complex boundaries
Detailed analysis needs

RandomState

u64

Random number generation seed:

Controls randomization in:

Cross-validation splits
Data shuffling
Probability estimation

Importance:

Reproducible results
Consistent comparison
Debugging capability
Validation stability

RefitScore

enum

Accuracy

Performance evaluation metrics for SVM classification:

Purpose:

Model selection
Performance evaluation
Cross-validation scoring
Hyperparameter tuning

Selection criteria:

Problem objectives
Class distribution
Error costs
Application needs

Default ~

Uses model's built-in accuracy score:

Properties:

Standard accuracy metric
Equal error weighting
Fast computation
Simple interpretation

Best for:

Balanced datasets
Quick evaluation
Standard problems
Initial testing

Accuracy ~

Standard classification accuracy:

Formula: $Accuracy = \frac{Correct Predictions}{Total Predictions}$

Properties:

Range: [0, 1]
Intuitive metric
Equal error weights
Fast computation

Best for:

Balanced classes
Equal error costs
Simple evaluation

BalancedAccuracy ~

Class-weighted accuracy score:

Formula: $BalancedAccuracy = \frac{1}{n _{c l a sses}} \sum_{i = 1}^{n_{c l a sses}} \frac{T P _{i}}{T P _{i} + F N _{i}}$

Properties:

Range: [0, 1]
Class-normalized
Balanced evaluation
Robust to imbalance

Best for:

Imbalanced datasets
Varying class sizes
Fair evaluation needs

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