Function time_series_split 

pub fn time_series_split(
    n_samples: usize,
    n_splits: usize,
    n_test_samples: usize,
    gap: usize,
) -> Result<CrossValidationFolds>

Performs time series cross-validation splitting

Creates splits suitable for time series data where future observations should not be used to predict past observations. Each training set contains all observations up to a certain point, and the validation set contains the next n_test_samples observations.

Arguments

• n_samples - Number of samples in the dataset
• n_splits - Number of splits to create
• n_test_samples - Number of samples in each test set
• gap - Number of samples to skip between train and test sets (default: 0)

Returns

A vector of (train_indices, validation_indices) tuples for each split

Examples

use scirs2__datasets::utils::time_series_split;

let folds = time_series_split(100, 5, 10, 0).unwrap();
assert_eq!(folds.len(), 5);

// Training sets should be increasing in size
for i in 1..folds.len() {
    assert!(folds[i].0.len() > folds[i-1].0.len());
}

Examples found in repository

examples/datasets_cross_validation_demo.rs (line 72)

fn main() {
    println!("=== Cross-Validation Demonstration ===\n");

    // Create sample dataset
    let data = Array2::from_shape_vec((20, 3), (0..60).map(|x| x as f64 / 10.0).collect()).unwrap();
    let target = Array1::from(
        (0..20)
            .map(|i| if i % 2 == 0 { 0.0 } else { 1.0 })
            .collect::<Vec<_>>(),
    );

    let dataset = Dataset::new(data.clone(), Some(target.clone()))
        .with_description("Sample dataset for cross-validation demo".to_string());

    println!("Dataset info:");
    println!("- Samples: {}", dataset.n_samples());
    println!("- Features: {}", dataset.n_features());
    println!("- Description: {}\n", dataset.description.as_ref().unwrap());

    // Demonstrate K-fold cross-validation
    println!("=== K-Fold Cross-Validation (k=5) ===");
    let k_folds = k_fold_split(dataset.n_samples(), 5, true, Some(42)).unwrap();

    for (i, (train_indices, val_indices)) in k_folds.iter().enumerate() {
        println!(
            "Fold {}: Train, size: {}, Validation size: {}",
            i + 1,
            train_indices.len(),
            val_indices.len()
        );
        println!(
            "  Train indices: {:?}",
            &train_indices[..5.min(train_indices.len())]
        );
        println!("  Val indices: {val_indices:?}");
    }
    println!();

    // Demonstrate Stratified K-fold cross-validation
    println!("=== Stratified K-Fold Cross-Validation (k=4) ===");
    let stratified_folds = stratified_k_fold_split(&target, 4, true, Some(42)).unwrap();

    for (i, (train_indices, val_indices)) in stratified_folds.iter().enumerate() {
        // Calculate class distribution in validation set
        let val_targets: Vec<f64> = val_indices.iter().map(|&idx| target[idx]).collect();
        let class_0_count = val_targets.iter().filter(|&&x| x == 0.0).count();
        let class_1_count = val_targets.iter().filter(|&&x| x == 1.0).count();

        println!(
            "Fold {}: Train, size: {}, Validation size: {}",
            i + 1,
            train_indices.len(),
            val_indices.len()
        );
        println!(
            "  Class distribution in validation: Class 0: {class_0_count}, Class 1: {class_1_count}"
        );
    }
    println!();

    // Demonstrate Time Series cross-validation
    println!("=== Time Series Cross-Validation ===");
    let ts_folds = time_series_split(dataset.n_samples(), 3, 3, 1).unwrap();

    for (i, (train_indices, val_indices)) in ts_folds.iter().enumerate() {
        println!(
            "Split {}: Train, size: {}, Test size: {}",
            i + 1,
            train_indices.len(),
            val_indices.len()
        );
        println!(
            "  Train range: {} to {}",
            train_indices.first().unwrap_or(&0),
            train_indices.last().unwrap_or(&0)
        );
        println!(
            "  Test range: {} to {}",
            val_indices.first().unwrap_or(&0),
            val_indices.last().unwrap_or(&0)
        );
    }
    println!();

    // Demonstrate usage with Dataset methods
    println!("=== Using Cross-Validation with Dataset ===");
    let first_fold = &k_folds[0];
    let (train_indices, val_indices) = first_fold;

    // Create training subset
    let traindata = data.select(ndarray::Axis(0), train_indices);
    let train_target = target.select(ndarray::Axis(0), train_indices);
    let traindataset = Dataset::new(traindata, Some(train_target))
        .with_description("Training fold from K-fold CV".to_string());

    // Create validation subset
    let valdata = data.select(ndarray::Axis(0), val_indices);
    let val_target = target.select(ndarray::Axis(0), val_indices);
    let valdataset = Dataset::new(valdata, Some(val_target))
        .with_description("Validation fold from K-fold CV".to_string());

    println!(
        "Training dataset: {} samples, {} features",
        traindataset.n_samples(),
        traindataset.n_features()
    );
    println!(
        "Validation dataset: {} samples, {} features",
        valdataset.n_samples(),
        valdataset.n_features()
    );

    println!("\n=== Cross-Validation Demo Complete ===");
}