NuSvc / Classifier Layer

Nu-Support Vector Classification - Alternative SVM formulation. Similar to SVC but uses a parameter to control the number of support vectors.

Mathematical form: $w, b, ρ, ξ min \frac{1}{2} ∣∣ w ∣ ∣^{2} - ν ρ + \frac{1}{n} i = 1 \sum n ξ_{i}$ subject to: $y_{i} (w^{T} ϕ (x_{i}) + b) \geq ρ - ξ_{i}, ξ_{i} \geq 0, ρ \geq 0$

where:

$ν$ controls support vector fraction
$ρ$ is the margin parameter
$ξ_{i}$ are slack variables
$ϕ$ is the kernel mapping

Key characteristics:

Direct control over support vectors
Bounded parameter range [0,1]
Automatic margin optimization
Similar to standard SVC

Common applications:

Outlier detection
Support vector control
Margin optimization
Novel class detection

Limitations:

Feasibility constraints
Parameter sensitivity
Complex optimization
Training instability

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: Requires careful nu parameter selection to avoid infeasibility

Table

Predicted Table

Validation Results

Test Metric

ROC Curve Data

Confusion Matrix

Feature Importances

SelectFeatures

[column, ...]

Feature columns for Nu-SVC classification:

Data requirements:

Format specifications:
- Numerical features only
- No missing values allowed
- Finite numbers required
- Dense or sparse format
Preprocessing essentials:
- Standardization (recommended):
  - StandardScaler: Mean=0, Var=1
  - Critical for kernel methods
  - Affects gamma scaling
- Normalization (alternative):
  - MinMaxScaler: Fixed range
  - Useful for bounded kernels
Feature engineering:
- Kernel-appropriate transforms
- Polynomial features for linear kernel
- Domain-specific mappings
- Dimensionality considerations
Quality checks:
- Feature relevance
- Scale compatibility
- Outlier detection
- Correlation analysis

Selection behavior:

Empty: Uses all numeric columns except target
Specified: Only listed columns used
Order: Maintains specified sequence

SelectTarget

column

Target column for Nu-SVC classification:

Data requirements:

Label specifications:
- Categorical values
- No missing values
- At least two classes
- Integer encoding preferred
Class characteristics:
- Support for multi-class
- Binary special case
- Class label encoding:
  - Integers from 0 to n_classes-1
  - Consistent encoding scheme
Distribution considerations:
- Affects nu parameter feasibility
- Influences class weights
- Impacts model performance
- Consider class balance
Implementation notes:
- First column in multi-label case
- Automatic label encoding
- Supports label transformation
- Maintains label ordering

Validation requirements:

Consistent encoding across splits
Stratification recommended
Class presence in all folds
Representative sampling

Params

oneof

DefaultParams

Optimized default configuration for Nu-SVC:

Default settings:

Core parameters:
- nu = 0.5 (support vector ratio)
- 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:

Initial exploration
Medium-sized datasets
Unknown distributions
Standard problems

Note: May require nu adjustment for feasibility

CustomParams

Fine-tuned configuration for Nu-SVC:

Parameter categories:

Model control:
- Nu parameter
- Kernel selection
- Feature mapping
Optimization:
- Convergence criteria
- Training limits
- Memory usage
Output control:
- Decision function
- Probability estimation
- Class weighting

Note: Parameter feasibility crucial for Nu-SVC

Nu

f64

0.5

An upper bound on the fraction of margin errors and a lower bound of the fraction of support vectors.

Properties:

Controls support vector fraction
Bounds training errors
Range: (0, 1]

Interpretation:

Upper bound on training errors
Lower bound on support vectors
Automatic margin control

Selection guide:

Small (0.1-0.3): Fewer SVs, strict
Medium (0.3-0.7): Balanced
Large (0.7-1.0): More SVs, flexible

Note: Must satisfy feasibility conditions

Kernel

enum

Rbf

Kernel functions for feature space mapping:

Purpose:

Non-linear transformation
Implicit feature mapping
Similarity computation
Pattern recognition

Selection impact:

Model complexity
Training speed
Memory usage
Prediction accuracy

Linear ~

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

Properties:

Simplest kernel
No hyperparameters
Fast computation
Linear boundaries

Best for:

High-dimensional data
Large datasets
Linear problems
Text classification

Poly ~

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

Properties:

Feature interactions
Degree control
Bounded values
Variable complexity

Parameters:

degree (d)
gamma (γ)
coef0 (r)

Best for:

Structured data
Image processing
Feature combinations

Rbf ~

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

Properties:

Universal approximator
Infinite dimensions
Local influence
Smooth boundaries

Parameter:

gamma (γ): Influence radius

Best for:

General purpose
Unknown relationships
Non-linear patterns
Default choice

Sigmoid ~

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

Properties:

Neural network relation
Bounded output
Non-positive definite
S-shaped function

Parameters:

gamma (γ)
coef0 (r)

Best for:

Neural network alternative
Specific applications
Historical comparison

Degree

u32

Polynomial kernel degree:

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

Common values:

2: Quadratic patterns
3: Default complexity
4+: Higher-order patterns

Impact:

Feature space dimension
Model complexity
Training time
Memory usage

Note: Only for polynomial kernel

Gamma

enum

Scale

Kernel coefficient computation strategies:

Role:

Controls kernel shape
Defines feature similarity
Affects model complexity
Influences decision boundaries

Impact:

Large γ: More complex boundaries
Small γ: Smoother boundaries
Critical for RBF, Poly, Sigmoid
Key hyperparameter

Scale ~

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

Properties:

Data-dependent scaling
Variance-aware
Automatic adaptation
Robust behavior

Advantages:

Scale invariant
Default choice
Robust performance
Modern approach

Best for:

General usage
Unknown scales
Varied features

Auto ~

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

Properties:

Dimension-based
Simple scaling
Legacy approach
Scale sensitive

Advantages:

Simple computation
Predictable behavior
Historical compatibility

Best for:

Normalized features
Legacy code
Simple problems

Custom ~

Manual gamma specification:

Usage:

Expert-defined value
Fine-tuning control
Optimization target
Research purposes

Advantages:

Full control
Precise tuning
Experimental freedom

Best for:

Grid search
Expert users
Research needs

GammaF

f64

Custom gamma value:

Usage:

RBF: Influence radius
Polynomial: Scale factor
Sigmoid: Scale parameter

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 kernel term:

Usage 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, 1.0]
Extended: [-5.0, 5.0]

Impact:

Kernel output shift
Decision boundary shape
Model flexibility

Note: Only affects polynomial and sigmoid kernels

Shrinking

bool

true

Whether to use the shrinking heuristic.

Purpose:

Speeds up training
Reduces memory usage
Removes bounded variables
Optimizes solution search

Benefits:

Faster convergence
Memory efficiency
Reduced complexity

Trade-offs:

Speed vs precision
Memory vs accuracy

Probability

bool

false

Whether to enable probability estimates.

Implementation:

Uses Platt scaling
Internal cross-validation
Fits sigmoid to scores

Impact:

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

Use when:

Confidence needed
Risk assessment
Decision thresholds
Probability requirements

Tol

f64

0.001

Optimization tolerance threshold:

Purpose:

Controls convergence
Affects solution precision
Balances computation

Typical values:

Strict: 1e-4 to 1e-3
Standard: 1e-3
Relaxed: 1e-3 to 1e-2

Trade-off:

Precision vs speed
Accuracy vs time

CacheSize

u64

200

Kernel cache memory (MB):

Purpose:

Stores kernel evaluations
Speeds up training
Reduces computations

Sizing guide:

Small: 50-100MB
Medium: 200-500MB
Large: 1000MB+

Consider:

Available RAM
Dataset size
Training speed needs

ClassWeight

enum

None

Class importance weighting schemes:

Purpose:

Handles imbalanced data
Adjusts class influence
Controls error costs
Modifies optimization

Effect:

Changes margin importance
Adjusts support vectors
Influences boundaries
Modifies ν interpretation

None ~

Uniform class weighting:

Properties:

Equal class importance
Natural distribution
Unmodified optimization
Standard behavior

Best for:

Balanced datasets
Equal error costs
Default choice
Simple problems

Balanced ~

Inverse frequency weighting:

Formula: $w_{i} = \frac{n}{n _{c l a sses} * n _{i}}$

Properties:

Automatic adjustment
Class-size compensation
Balanced errors
Fair classification

Best for:

Imbalanced data
Minority class focus
Uneven distributions
Fair evaluation

MaxIter

i64

-1

Maximum iteration limit:

Values:

-1: No limit
>0: Maximum iterations

Guidelines:

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

Purpose:

Prevents infinite loops
Resource control
Time management

DecisionFunctionShape

enum

Ovr

Multi-class decision function configuration:

Purpose:

Multi-class handling
Decision boundary type
Prediction structure
Output format

Impact:

Memory usage
Computation speed
Model interpretability
Prediction format

Ovr ~

One-vs-Rest strategy:

Properties:

n_classes binary classifiers
Standard output format
Memory efficient
Common interface

Advantages:

Simple interpretation
Fast predictions
Memory efficient
Compatible output

Best for:

Large-scale problems
Many classes
Production systems

Ovo ~

One-vs-One strategy:

Properties:

n_classes*(n_classes-1)/2 classifiers
Pairwise comparisons
Original LIBSVM format
Detailed boundaries

Advantages:

Better separation
More precise
Traditional approach
Balanced decisions

Best for:

Few classes
Complex boundaries
Detailed analysis

RandomState

u64

Controls the pseudo random number generation for shuffling the data for probability estimates. Ignored when 'probability' is False.

Controls:

Data shuffling
Probability estimation
Cross-validation splits

Importance:

Reproducibility
Debugging
Result validation
Consistent behavior

GridSearch

Hyperparameter optimization for Nu-SVC:

Search process:

Core parameters:
- Nu values
- Kernel selection
- Kernel parameters
Training control:
- Optimization settings
- Convergence criteria
- Resource limits
Model features:
- Class weights
- Decision functions
- Output options

Computational impact:

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

Nu

[f64, ...]

0.5

Nu parameter search space:

Search strategies:

Conservative range:
- [0.1, 0.3, 0.5]
- [0.2, 0.4, 0.6]
Wide range:
- [0.1, 0.3, 0.5, 0.7, 0.9]
- [0.05, 0.1, 0.25, 0.5]

Considerations:

Class distribution
Feasibility constraints
Support vector goals
Error tolerance

Note: Values must satisfy feasibility conditions

Kernel

[enum, ...]

Rbf

Kernel functions for feature space mapping:

Purpose:

Non-linear transformation
Implicit feature mapping
Similarity computation
Pattern recognition

Selection impact:

Model complexity
Training speed
Memory usage
Prediction accuracy

Linear ~

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

Properties:

Simplest kernel
No hyperparameters
Fast computation
Linear boundaries

Best for:

High-dimensional data
Large datasets
Linear problems
Text classification

Poly ~

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

Properties:

Feature interactions
Degree control
Bounded values
Variable complexity

Parameters:

degree (d)
gamma (γ)
coef0 (r)

Best for:

Structured data
Image processing
Feature combinations

Rbf ~

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

Properties:

Universal approximator
Infinite dimensions
Local influence
Smooth boundaries

Parameter:

gamma (γ): Influence radius

Best for:

General purpose
Unknown relationships
Non-linear patterns
Default choice

Sigmoid ~

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

Properties:

Neural network relation
Bounded output
Non-positive definite
S-shaped function

Parameters:

gamma (γ)
coef0 (r)

Best for:

Neural network alternative
Specific applications
Historical comparison

Degree

[u32, ...]

Polynomial degrees to evaluate:

Common ranges:

Standard search:
- [2, 3, 4]: Basic polynomials
- [2, 3, 4, 5]: Extended range
Specific needs:
- [1, 2]: Linear to quadratic
- [2, 3, 4, 5, 6]: Complex patterns

Consider:

Computational cost
Memory requirements
Overfitting risk

Gamma

[enum, ...]

Scale

Kernel coefficient computation strategies:

Role:

Controls kernel shape
Defines feature similarity
Affects model complexity
Influences decision boundaries

Impact:

Large γ: More complex boundaries
Small γ: Smoother boundaries
Critical for RBF, Poly, Sigmoid
Key hyperparameter

Scale ~

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

Properties:

Data-dependent scaling
Variance-aware
Automatic adaptation
Robust behavior

Advantages:

Scale invariant
Default choice
Robust performance
Modern approach

Best for:

General usage
Unknown scales
Varied features

Auto ~

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

Properties:

Dimension-based
Simple scaling
Legacy approach
Scale sensitive

Advantages:

Simple computation
Predictable behavior
Historical compatibility

Best for:

Normalized features
Legacy code
Simple problems

Custom ~

Manual gamma specification:

Usage:

Expert-defined value
Fine-tuning control
Optimization target
Research purposes

Advantages:

Full control
Precise tuning
Experimental freedom

Best for:

Grid search
Expert users
Research needs

GammaF

[f64, ...]

Custom gamma values to evaluate:

Search spaces:

Log scale (recommended):
- [0.0001, 0.001, 0.01, 0.1, 1.0]
- [0.001, 0.003, 0.01, 0.03, 0.1]
Problem-specific:
- [0.001, 0.01]: Smoother boundaries
- [0.1, 1.0, 10.0]: Complex boundaries

Note: Only used with gamma='custom'

Coef0

[f64, ...]

Independent term in kernel functions:

Search ranges for poly/sigmoid kernels:

Conservative:
- [-1.0, 0.0, 1.0]: Standard range
Exploratory:
- [-5.0, -1.0, 0.0, 1.0, 5.0]: Wide search
- [-2.0, -1.0, 0.0, 1.0, 2.0]: Medium range

Kernel-specific effects:

Polynomial: Controls homogeneity
Sigmoid: Shifts decision boundary
Other kernels: No effect

Selection strategy:

Start with 0.0 for baseline
Adjust based on kernel type
Consider data scale

Shrinking

[bool, ...]

true

Shrinking heuristic optimization:

Search combinations:

Single option evaluation:
- [true]: Enable shrinking heuristic
- [false]: Disable optimization
Comparative analysis:
- [true, false]: Full comparison

Performance impact:

Reduces active set size
Accelerates convergence
Optimizes memory usage
May affect final precision

Usage considerations:

Enable for large datasets
Disable for maximum precision
Test both for optimal balance

Probability

bool

false

Probability estimation configuration:

Implementation details:

Uses internal cross-validation
Must be enabled before fitting
Significantly impacts training time
Adds memory overhead

Performance implications:

Training: 5-10x slower
Memory: Additional storage for probabilities
Computation: Extra cross-validation step

Use cases:

Confidence scoring needs
Risk assessment requirements
Threshold optimization
Probability calibration

Tol

[f64, ...]

0.001

Optimization stopping tolerance:

Search spaces:

Precision-focused:
- [1e-5, 1e-4]: High precision needs
- [1e-4, 5e-4]: Strict convergence
Speed-focused:
- [1e-3, 1e-2]: Faster convergence
- [5e-3, 1e-2]: Quick approximation

Convergence criteria:

Monitors dual gap
Affects iteration count
Controls solution precision
Balances time vs accuracy

Selection strategy:

Smaller: Better precision, slower
Larger: Faster, approximate
Default (1e-3): Good balance

CacheSize

f64

200

Kernel cache memory allocation (MB):

Guidelines:

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

Impact:

Training speed
Memory usage
Resource utilization

ClassWeight

[enum, ...]

None

Class importance weighting schemes:

Purpose:

Handles imbalanced data
Adjusts class influence
Controls error costs
Modifies optimization

Effect:

Changes margin importance
Adjusts support vectors
Influences boundaries
Modifies ν interpretation

None ~

Uniform class weighting:

Properties:

Equal class importance
Natural distribution
Unmodified optimization
Standard behavior

Best for:

Balanced datasets
Equal error costs
Default choice
Simple problems

Balanced ~

Inverse frequency weighting:

Formula: $w_{i} = \frac{n}{n _{c l a sses} * n _{i}}$

Properties:

Automatic adjustment
Class-size compensation
Balanced errors
Fair classification

Best for:

Imbalanced data
Minority class focus
Uneven distributions
Fair evaluation

MaxIter

[i64, ...]

-1

Maximum solver iterations:

Value interpretation:

-1: No iteration limit
>0: Hard iteration ceiling

Search ranges:

Standard problems:
- [1000, 2000, 5000]: Basic range
- [-1, 1000, 5000]: Include unlimited
Complex problems:
- [5000, 10000, 50000]: Extended range
- [10000, 50000, -1]: High iterations

Selection factors:

Dataset complexity
Convergence patterns
Time constraints
Solution quality needs

DecisionFunctionShape

enum

Ovr

Multi-class decision function configuration:

Purpose:

Multi-class handling
Decision boundary type
Prediction structure
Output format

Impact:

Memory usage
Computation speed
Model interpretability
Prediction format

Ovr ~

One-vs-Rest strategy:

Properties:

n_classes binary classifiers
Standard output format
Memory efficient
Common interface

Advantages:

Simple interpretation
Fast predictions
Memory efficient
Compatible output

Best for:

Large-scale problems
Many classes
Production systems

Ovo ~

One-vs-One strategy:

Properties:

n_classes*(n_classes-1)/2 classifiers
Pairwise comparisons
Original LIBSVM format
Detailed boundaries

Advantages:

Better separation
More precise
Traditional approach
Balanced decisions

Best for:

Few classes
Complex boundaries
Detailed analysis

RandomState

u64

Random number generator control:

Affects randomization in:

Training process:
- Data shuffling sequences
- Probability estimation
- Cross-validation splits
Implementation details:
- Active when probability=True
- Ignored when probability=False
- Controls internal CV

Usage importance:

Reproducible results
Consistent validation
Debugging support
Performance comparison

RefitScore

enum

Accuracy

Performance evaluation metrics:

Purpose:

Model selection
Performance evaluation
Cross-validation scoring
Parameter optimization

Selection criteria:

Problem objectives
Class distribution
Error sensitivity
Application needs

Default ~

Built-in accuracy scoring:

Properties:

Standard accuracy metric
Equal error weighting
Fast computation
Model's native score

Best for:

Initial evaluation
Balanced datasets
Quick assessment
Standard problems

Accuracy ~

Standard classification accuracy:

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

Properties:

Range: [0, 1]
Intuitive metric
Standard benchmark
Equal weighting

Best for:

Balanced classes
Equal error costs
General evaluation

BalancedAccuracy ~

Class-normalized accuracy:

Formula: $\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-independent
Balanced evaluation
Fair metric

Best for:

Imbalanced datasets
Varying class sizes
Fair comparison

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.

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