Function k_fold_split

pub fn k_fold_split(
    n_samples: usize,
    n_folds: usize,
    shuffle: bool,
    random_seed: Option<u64>,
) -> Result<CrossValidationFolds>

Performs K-fold cross-validation splitting

Splits the dataset into k consecutive folds. Each fold is used once as a validation set while the remaining k-1 folds form the training set.

Arguments

• n_samples - Number of samples in the dataset
• n_folds - Number of folds (must be >= 2 and <= n_samples)
• shuffle - Whether to shuffle the data before splitting
• random_seed - Optional random seed for reproducible shuffling

Returns

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

Examples

use scirs2_datasets::utils::k_fold_split;

let folds = k_fold_split(10, 3, true, Some(42)).unwrap();
assert_eq!(folds.len(), 3);

// Each fold should have roughly equal size
for (train_idx, val_idx) in &folds {
    assert!(val_idx.len() >= 3 && val_idx.len() <= 4);
    assert_eq!(train_idx.len() + val_idx.len(), 10);
}

Examples found in repository

examples/cross_validation_demo.rs (line 30)

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 1: {}",
            class_0_count, 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 train_data = data.select(ndarray::Axis(0), train_indices);
    let train_target = target.select(ndarray::Axis(0), train_indices);
    let train_dataset = Dataset::new(train_data, Some(train_target))
        .with_description("Training fold from K-fold CV".to_string());

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

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

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