Struct Dataset

pub struct Dataset {
    pub data: Array2<f64>,
    pub target: Option<Array1<f64>>,
    pub target_names: Option<Vec<String>>,
    pub feature_names: Option<Vec<String>>,
    pub feature_descriptions: Option<Vec<String>>,
    pub description: Option<String>,
    pub metadata: HashMap<String, String>,
}

Represents a dataset with features, optional targets, and metadata

The Dataset struct is the core data structure for managing machine learning datasets. It stores the feature matrix, optional target values, and rich metadata including feature names, descriptions, and arbitrary key-value pairs.

Examples

use ndarray::Array2;
use scirs2_datasets::utils::Dataset;

let data = Array2::from_shape_vec((3, 2), vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0]).unwrap();
let dataset = Dataset::new(data, None)
    .with_feature_names(vec!["feature1".to_string(), "feature2".to_string()])
    .with_description("Sample dataset".to_string());

assert_eq!(dataset.n_samples(), 3);
assert_eq!(dataset.n_features(), 2);

Fields

data: Array2<f64>

Features/data matrix (n_samples, n_features)

target: Option<Array1<f64>>

Optional target values

target_names: Option<Vec<String>>

Optional target names for classification problems

feature_names: Option<Vec<String>>

Optional feature names

feature_descriptions: Option<Vec<String>>

Optional descriptions for each feature

description: Option<String>

Optional dataset description

metadata: HashMap<String, String>

Optional dataset metadata

Implementations

impl Dataset

pub fn new(data: Array2<f64>, target: Option<Array1<f64>>) -> Self

Create a new dataset with the given data and target

Arguments

• data - The feature matrix (n_samples, n_features)
• target - Optional target values (n_samples,)

Returns

A new Dataset instance with empty metadata

Examples

use ndarray::{Array1, Array2};
use scirs2_datasets::utils::Dataset;

let data = Array2::zeros((100, 5));
let target = Some(Array1::zeros(100));
let dataset = Dataset::new(data, target);

Examples found in repository

examples/cross_validation_demo.rs (line 20)

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 ===");
}

examples/sampling_demo.rs (line 45)

fn main() {
    println!("=== Sampling and Bootstrapping Demonstration ===\n");

    // Load the Iris dataset for demonstration
    let iris = load_iris().unwrap();
    let n_samples = iris.n_samples();

    println!("Original Iris dataset:");
    println!("- Samples: {}", n_samples);
    println!("- Features: {}", iris.n_features());

    if let Some(target) = &iris.target {
        let class_counts = count_classes(target);
        println!("- Class distribution: {:?}\n", class_counts);
    }

    // Demonstrate random sampling without replacement
    println!("=== Random Sampling (without replacement) ===");
    let sample_size = 30;
    let random_indices = random_sample(n_samples, sample_size, false, Some(42)).unwrap();

    println!(
        "Sampled {} indices from {} total samples",
        sample_size, n_samples
    );
    println!(
        "Sample indices: {:?}",
        &random_indices[..10.min(random_indices.len())]
    );

    // Create a subset dataset
    let sample_data = iris.data.select(ndarray::Axis(0), &random_indices);
    let sample_target = iris
        .target
        .as_ref()
        .map(|t| t.select(ndarray::Axis(0), &random_indices));
    let sample_dataset = Dataset::new(sample_data, sample_target)
        .with_description("Random sample from Iris dataset".to_string());

    println!(
        "Random sample dataset: {} samples, {} features",
        sample_dataset.n_samples(),
        sample_dataset.n_features()
    );

    if let Some(target) = &sample_dataset.target {
        let sample_class_counts = count_classes(target);
        println!("Sample class distribution: {:?}\n", sample_class_counts);
    }

    // Demonstrate bootstrap sampling (with replacement)
    println!("=== Bootstrap Sampling (with replacement) ===");
    let bootstrap_size = 200; // More than original dataset size
    let bootstrap_indices = random_sample(n_samples, bootstrap_size, true, Some(42)).unwrap();

    println!(
        "Bootstrap sampled {} indices from {} total samples",
        bootstrap_size, n_samples
    );
    println!(
        "Bootstrap may have duplicates - first 10 indices: {:?}",
        &bootstrap_indices[..10]
    );

    // Count frequency of each index in bootstrap sample
    let mut index_counts = vec![0; n_samples];
    for &idx in &bootstrap_indices {
        index_counts[idx] += 1;
    }
    let max_count = *index_counts.iter().max().unwrap();
    let zero_count = index_counts.iter().filter(|&&count| count == 0).count();

    println!("Bootstrap statistics:");
    println!("- Maximum frequency of any sample: {}", max_count);
    println!(
        "- Number of original samples not selected: {}\n",
        zero_count
    );

    // Demonstrate stratified sampling
    println!("=== Stratified Sampling ===");
    if let Some(target) = &iris.target {
        let stratified_size = 30;
        let stratified_indices = stratified_sample(target, stratified_size, Some(42)).unwrap();

        println!(
            "Stratified sampled {} indices maintaining class proportions",
            stratified_size
        );

        // Create stratified subset
        let stratified_data = iris.data.select(ndarray::Axis(0), &stratified_indices);
        let stratified_target = target.select(ndarray::Axis(0), &stratified_indices);
        let stratified_dataset = Dataset::new(stratified_data, Some(stratified_target))
            .with_description("Stratified sample from Iris dataset".to_string());

        println!(
            "Stratified sample dataset: {} samples, {} features",
            stratified_dataset.n_samples(),
            stratified_dataset.n_features()
        );

        let stratified_class_counts = count_classes(&stratified_dataset.target.unwrap());
        println!(
            "Stratified sample class distribution: {:?}",
            stratified_class_counts
        );

        // Verify proportions are maintained
        let original_proportions = calculate_proportions(&count_classes(target));
        let stratified_proportions = calculate_proportions(&stratified_class_counts);

        println!("Class proportion comparison:");
        for (&class, &original_prop) in &original_proportions {
            let stratified_prop = stratified_proportions.get(&class).unwrap_or(&0.0);
            println!(
                "  Class {}: Original {:.2}%, Stratified {:.2}%",
                class,
                original_prop * 100.0,
                stratified_prop * 100.0
            );
        }
    }

    // Demonstrate practical use case: creating training/validation splits
    println!("\n=== Practical Example: Multiple Train/Validation Splits ===");
    for i in 1..=3 {
        let split_indices = random_sample(n_samples, 100, false, Some(42 + i)).unwrap();
        let (train_indices, val_indices) = split_indices.split_at(80);

        println!(
            "Split {}: {} training samples, {} validation samples",
            i,
            train_indices.len(),
            val_indices.len()
        );
    }

    println!("\n=== Sampling Demo Complete ===");
}

pub fn with_target_names(self, target_names: Vec<String>) -> Self

Add target names to the dataset (builder pattern)

Arguments

• target_names - Vector of target class names

Returns

Self for method chaining

pub fn with_feature_names(self, feature_names: Vec<String>) -> Self

Add feature names to the dataset (builder pattern)

Arguments

• feature_names - Vector of feature names

Returns

Self for method chaining

pub fn with_feature_descriptions( self, feature_descriptions: Vec<String>, ) -> Self

Add feature descriptions to the dataset (builder pattern)

Arguments

• feature_descriptions - Vector of feature descriptions

Returns

Self for method chaining

pub fn with_description(self, description: String) -> Self

Add a description to the dataset (builder pattern)

Arguments

• description - Dataset description

Returns

Self for method chaining

Examples found in repository

examples/cross_validation_demo.rs (line 21)

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 ===");
}

examples/sampling_demo.rs (line 46)

fn main() {
    println!("=== Sampling and Bootstrapping Demonstration ===\n");

    // Load the Iris dataset for demonstration
    let iris = load_iris().unwrap();
    let n_samples = iris.n_samples();

    println!("Original Iris dataset:");
    println!("- Samples: {}", n_samples);
    println!("- Features: {}", iris.n_features());

    if let Some(target) = &iris.target {
        let class_counts = count_classes(target);
        println!("- Class distribution: {:?}\n", class_counts);
    }

    // Demonstrate random sampling without replacement
    println!("=== Random Sampling (without replacement) ===");
    let sample_size = 30;
    let random_indices = random_sample(n_samples, sample_size, false, Some(42)).unwrap();

    println!(
        "Sampled {} indices from {} total samples",
        sample_size, n_samples
    );
    println!(
        "Sample indices: {:?}",
        &random_indices[..10.min(random_indices.len())]
    );

    // Create a subset dataset
    let sample_data = iris.data.select(ndarray::Axis(0), &random_indices);
    let sample_target = iris
        .target
        .as_ref()
        .map(|t| t.select(ndarray::Axis(0), &random_indices));
    let sample_dataset = Dataset::new(sample_data, sample_target)
        .with_description("Random sample from Iris dataset".to_string());

    println!(
        "Random sample dataset: {} samples, {} features",
        sample_dataset.n_samples(),
        sample_dataset.n_features()
    );

    if let Some(target) = &sample_dataset.target {
        let sample_class_counts = count_classes(target);
        println!("Sample class distribution: {:?}\n", sample_class_counts);
    }

    // Demonstrate bootstrap sampling (with replacement)
    println!("=== Bootstrap Sampling (with replacement) ===");
    let bootstrap_size = 200; // More than original dataset size
    let bootstrap_indices = random_sample(n_samples, bootstrap_size, true, Some(42)).unwrap();

    println!(
        "Bootstrap sampled {} indices from {} total samples",
        bootstrap_size, n_samples
    );
    println!(
        "Bootstrap may have duplicates - first 10 indices: {:?}",
        &bootstrap_indices[..10]
    );

    // Count frequency of each index in bootstrap sample
    let mut index_counts = vec![0; n_samples];
    for &idx in &bootstrap_indices {
        index_counts[idx] += 1;
    }
    let max_count = *index_counts.iter().max().unwrap();
    let zero_count = index_counts.iter().filter(|&&count| count == 0).count();

    println!("Bootstrap statistics:");
    println!("- Maximum frequency of any sample: {}", max_count);
    println!(
        "- Number of original samples not selected: {}\n",
        zero_count
    );

    // Demonstrate stratified sampling
    println!("=== Stratified Sampling ===");
    if let Some(target) = &iris.target {
        let stratified_size = 30;
        let stratified_indices = stratified_sample(target, stratified_size, Some(42)).unwrap();

        println!(
            "Stratified sampled {} indices maintaining class proportions",
            stratified_size
        );

        // Create stratified subset
        let stratified_data = iris.data.select(ndarray::Axis(0), &stratified_indices);
        let stratified_target = target.select(ndarray::Axis(0), &stratified_indices);
        let stratified_dataset = Dataset::new(stratified_data, Some(stratified_target))
            .with_description("Stratified sample from Iris dataset".to_string());

        println!(
            "Stratified sample dataset: {} samples, {} features",
            stratified_dataset.n_samples(),
            stratified_dataset.n_features()
        );

        let stratified_class_counts = count_classes(&stratified_dataset.target.unwrap());
        println!(
            "Stratified sample class distribution: {:?}",
            stratified_class_counts
        );

        // Verify proportions are maintained
        let original_proportions = calculate_proportions(&count_classes(target));
        let stratified_proportions = calculate_proportions(&stratified_class_counts);

        println!("Class proportion comparison:");
        for (&class, &original_prop) in &original_proportions {
            let stratified_prop = stratified_proportions.get(&class).unwrap_or(&0.0);
            println!(
                "  Class {}: Original {:.2}%, Stratified {:.2}%",
                class,
                original_prop * 100.0,
                stratified_prop * 100.0
            );
        }
    }

    // Demonstrate practical use case: creating training/validation splits
    println!("\n=== Practical Example: Multiple Train/Validation Splits ===");
    for i in 1..=3 {
        let split_indices = random_sample(n_samples, 100, false, Some(42 + i)).unwrap();
        let (train_indices, val_indices) = split_indices.split_at(80);

        println!(
            "Split {}: {} training samples, {} validation samples",
            i,
            train_indices.len(),
            val_indices.len()
        );
    }

    println!("\n=== Sampling Demo Complete ===");
}

pub fn with_metadata(self, key: &str, value: &str) -> Self

Add metadata to the dataset (builder pattern)

Arguments

• key - Metadata key
• value - Metadata value

Returns

Self for method chaining

pub fn n_samples(&self) -> usize

Get the number of samples in the dataset

Returns

Number of samples (rows) in the dataset

Examples found in repository

examples/toy_datasets.rs (line 6)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let iris = load_iris()?;
    println!("Iris dataset loaded:");
    println!("  Samples: {}", iris.n_samples());
    println!("  Features: {}", iris.n_features());
    println!(
        "  Target classes: {}",
        iris.target_names.as_ref().map_or(0, |v| v.len())
    );

    let boston = load_boston()?;
    println!("\nBoston Housing dataset loaded:");
    println!("  Samples: {}", boston.n_samples());
    println!("  Features: {}", boston.n_features());

    Ok(())
}

examples/csv_loading.rs (line 12)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Load a CSV file with headers and target column
    let dataset = load_csv(
        "scirs2-datasets/data/example.csv",
        true,    // has header
        Some(3), // target column index (0-based)
    )?;

    println!("CSV dataset loaded successfully:");
    println!("  Samples: {}", dataset.n_samples());
    println!("  Features: {}", dataset.n_features());
    println!("  Feature names: {:?}", dataset.feature_names);

    // Access data and target
    println!("\nFirst 3 samples:");
    for i in 0..3 {
        let features = dataset.data.row(i);
        let target = dataset.target.as_ref().map(|t| t[i]);
        println!(
            "  Sample {}: Features = {:?}, Target = {:?}",
            i, features, target
        );
    }

    Ok(())
}

examples/noise_models_demo.rs (line 198)

fn demonstrate_comprehensive_corruption() {
    println!("Testing comprehensive dataset corruption:");

    // Load a real dataset
    let iris = load_iris().unwrap();
    println!(
        "Original Iris dataset: {} samples, {} features",
        iris.n_samples(),
        iris.n_features()
    );

    let original_stats = calculate_basic_stats(&iris.data);
    println!(
        "Original stats - Mean: {:.3}, Std: {:.3}",
        original_stats.0, original_stats.1
    );

    // Create different levels of corruption
    let corruption_levels = [
        (0.05, 0.02, "Light corruption"),
        (0.1, 0.05, "Moderate corruption"),
        (0.2, 0.1, "Heavy corruption"),
        (0.3, 0.15, "Severe corruption"),
    ];

    for (missing_rate, outlier_rate, description) in corruption_levels {
        let corrupted = make_corrupted_dataset(
            &iris,
            missing_rate,
            MissingPattern::MAR, // More realistic than MCAR
            outlier_rate,
            OutlierType::Point,
            2.5,
            Some(42),
        )
        .unwrap();

        // Calculate how much data is usable
        let total_elements = corrupted.data.len();
        let missing_elements = corrupted.data.iter().filter(|&&x| x.is_nan()).count();
        let usable_percentage =
            ((total_elements - missing_elements) as f64 / total_elements as f64) * 100.0;

        println!("{}:", description);
        println!("  Missing data: {:.1}%", missing_rate * 100.0);
        println!("  Outliers: {:.1}%", outlier_rate * 100.0);
        println!("  Usable data: {:.1}%", usable_percentage);

        // Show metadata
        if let Some(missing_count) = corrupted.metadata.get("missing_count") {
            println!("  Actual missing: {} elements", missing_count);
        }
        if let Some(outlier_count) = corrupted.metadata.get("outlier_count") {
            println!("  Actual outliers: {} samples", outlier_count);
        }
    }
}

examples/time_series_datasets.rs (line 11)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("Loading time series datasets...\n");

    // Load the electrocardiogram dataset
    let ecg = electrocardiogram()?;

    println!("Electrocardiogram dataset:");
    println!("  Time steps: {}", ecg.n_samples());
    println!("  Features: {}", ecg.n_features());
    println!(
        "  Sampling rate: {} Hz",
        ecg.metadata
            .get("sampling_rate")
            .unwrap_or(&"unknown".to_string())
    );
    println!(
        "  Duration: {}",
        ecg.metadata
            .get("duration")
            .unwrap_or(&"unknown".to_string())
    );

    // Get a slice of the data and display basic statistics
    let ecg_slice = ecg.data.slice(s![0..10, 0]);
    println!("  First 10 data points: {:?}", ecg_slice);

    // Calculate some basic statistics
    let ecg_data = ecg.data.column(0);
    let min = ecg_data.fold(f64::INFINITY, |a, &b| a.min(b));
    let max = ecg_data.fold(f64::NEG_INFINITY, |a, &b| a.max(b));
    let mean = ecg_data.sum() / ecg_data.len() as f64;

    println!("  Min: {:.3} mV", min);
    println!("  Max: {:.3} mV", max);
    println!("  Mean: {:.3} mV", mean);

    // Note: Stock market and weather datasets are commented out because their source data
    // is not yet available.

    /*
    // Load the stock market dataset
    println!("\nStock market dataset:");

    // Get price changes (returns)
    let stock_returns = stock_market(true)?;
    println!("  Time steps: {}", stock_returns.n_samples());
    println!("  Companies: {}", stock_returns.n_features());

    // Print companies
    if let Some(feature_names) = &stock_returns.feature_names {
        println!("  Companies: {}", feature_names.join(", "));
    }

    // Load the weather dataset
    println!("\nWeather dataset:");
    let temp_data = weather(Some("temperature"))?;

    println!("  Time steps: {}", temp_data.n_samples());
    println!("  Locations: {}", temp_data.n_features());
    */

    println!("\nTime series dataset loaded successfully!");

    Ok(())
}

examples/dataset_loaders.rs (line 33)

fn main() {
    // Check if a CSV file is provided as a command-line argument
    let args: Vec<String> = env::args().collect();
    if args.len() < 2 {
        println!("Usage: {} <path_to_csv_file>", args[0]);
        println!("Example: {} examples/sample_data.csv", args[0]);
        return;
    }

    let file_path = &args[1];

    // Verify the file exists
    if !Path::new(file_path).exists() {
        println!("Error: File '{}' does not exist", file_path);
        return;
    }

    // Load CSV file
    println!("Loading CSV file: {}", file_path);
    match loaders::load_csv(file_path, true, None) {
        Ok(dataset) => {
            print_dataset_info(&dataset, "Loaded CSV");

            // Split the dataset for demonstration
            println!("\nDemonstrating train-test split...");
            match train_test_split(&dataset, 0.2, Some(42)) {
                Ok((train, test)) => {
                    println!("Training set: {} samples", train.n_samples());
                    println!("Test set: {} samples", test.n_samples());

                    // Save as JSON for demonstration
                    let json_path = format!("{}.json", file_path);
                    println!("\nSaving training dataset to JSON: {}", json_path);
                    if let Err(e) = loaders::save_json(&train, &json_path) {
                        println!("Error saving JSON: {}", e);
                    } else {
                        println!("Successfully saved JSON file");

                        // Load back the JSON file
                        println!("\nLoading back from JSON file...");
                        match loaders::load_json(&json_path) {
                            Ok(loaded) => {
                                print_dataset_info(&loaded, "Loaded JSON");
                            }
                            Err(e) => println!("Error loading JSON: {}", e),
                        }
                    }
                }
                Err(e) => println!("Error splitting dataset: {}", e),
            }
        }
        Err(e) => println!("Error loading CSV: {}", e),
    }
}

fn print_dataset_info(dataset: &Dataset, name: &str) {
    println!("=== {} Dataset ===", name);
    println!("Number of samples: {}", dataset.n_samples());
    println!("Number of features: {}", dataset.n_features());

    if let Some(feature_names) = &dataset.feature_names {
        println!(
            "Features: {:?}",
            &feature_names[0..std::cmp::min(5, feature_names.len())]
        );
        if feature_names.len() > 5 {
            println!("... and {} more", feature_names.len() - 5);
        }
    }

    if let Some(target) = &dataset.target {
        println!("Target shape: {}", target.len());

        if let Some(target_names) = &dataset.target_names {
            println!("Target classes: {:?}", target_names);
        }
    }

    for (key, value) in &dataset.metadata {
        println!("Metadata - {}: {}", key, value);
    }
}

examples/data_generators.rs (line 26)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("Creating synthetic datasets...\n");

    // Generate classification dataset
    let n_samples = 100;
    let n_features = 5;

    let classification_data = make_classification(
        n_samples,
        n_features,
        3,        // 3 classes
        2,        // 2 clusters per class
        3,        // 3 informative features
        Some(42), // random seed
    )?;

    // Train-test split
    let (train, test) = train_test_split(&classification_data, 0.2, Some(42))?;

    println!("Classification dataset:");
    println!("  Total samples: {}", classification_data.n_samples());
    println!("  Features: {}", classification_data.n_features());
    println!("  Training samples: {}", train.n_samples());
    println!("  Test samples: {}", test.n_samples());

    // Generate regression dataset
    let regression_data = make_regression(
        n_samples,
        n_features,
        3,   // 3 informative features
        0.5, // noise level
        Some(42),
    )?;

    println!("\nRegression dataset:");
    println!("  Samples: {}", regression_data.n_samples());
    println!("  Features: {}", regression_data.n_features());

    // Normalize the data (in-place)
    let mut data_copy = regression_data.data.clone();
    normalize(&mut data_copy);
    println!("  Data normalized successfully");

    // Generate clustering data (blobs)
    let clustering_data = make_blobs(
        n_samples,
        2,   // 2 features for easy visualization
        4,   // 4 clusters
        0.8, // cluster standard deviation
        Some(42),
    )?;

    println!("\nClustering dataset (blobs):");
    println!("  Samples: {}", clustering_data.n_samples());
    println!("  Features: {}", clustering_data.n_features());

    // Find the number of clusters by finding the max value of target
    let num_clusters = clustering_data.target.as_ref().map_or(0, |t| {
        let mut max_val = -1.0;
        for &val in t.iter() {
            if val > max_val {
                max_val = val;
            }
        }
        (max_val as usize) + 1
    });

    println!("  Clusters: {}", num_clusters);

    // Generate time series data
    let time_series = make_time_series(
        100,  // 100 time steps
        3,    // 3 features/variables
        true, // with trend
        true, // with seasonality
        0.2,  // noise level
        Some(42),
    )?;

    println!("\nTime series dataset:");
    println!("  Time steps: {}", time_series.n_samples());
    println!("  Features: {}", time_series.n_features());

    Ok(())
}

Additional examples can be found in:

• examples/cross_validation_demo.rs
• examples/sampling_demo.rs
• examples/feature_extraction_demo.rs
• examples/complex_patterns_demo.rs

pub fn n_features(&self) -> usize

Get the number of features in the dataset

Returns

Number of features (columns) in the dataset

Examples found in repository

examples/toy_datasets.rs (line 7)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let iris = load_iris()?;
    println!("Iris dataset loaded:");
    println!("  Samples: {}", iris.n_samples());
    println!("  Features: {}", iris.n_features());
    println!(
        "  Target classes: {}",
        iris.target_names.as_ref().map_or(0, |v| v.len())
    );

    let boston = load_boston()?;
    println!("\nBoston Housing dataset loaded:");
    println!("  Samples: {}", boston.n_samples());
    println!("  Features: {}", boston.n_features());

    Ok(())
}

examples/csv_loading.rs (line 13)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Load a CSV file with headers and target column
    let dataset = load_csv(
        "scirs2-datasets/data/example.csv",
        true,    // has header
        Some(3), // target column index (0-based)
    )?;

    println!("CSV dataset loaded successfully:");
    println!("  Samples: {}", dataset.n_samples());
    println!("  Features: {}", dataset.n_features());
    println!("  Feature names: {:?}", dataset.feature_names);

    // Access data and target
    println!("\nFirst 3 samples:");
    for i in 0..3 {
        let features = dataset.data.row(i);
        let target = dataset.target.as_ref().map(|t| t[i]);
        println!(
            "  Sample {}: Features = {:?}, Target = {:?}",
            i, features, target
        );
    }

    Ok(())
}

examples/dataset_loaders.rs (line 64)

fn print_dataset_info(dataset: &Dataset, name: &str) {
    println!("=== {} Dataset ===", name);
    println!("Number of samples: {}", dataset.n_samples());
    println!("Number of features: {}", dataset.n_features());

    if let Some(feature_names) = &dataset.feature_names {
        println!(
            "Features: {:?}",
            &feature_names[0..std::cmp::min(5, feature_names.len())]
        );
        if feature_names.len() > 5 {
            println!("... and {} more", feature_names.len() - 5);
        }
    }

    if let Some(target) = &dataset.target {
        println!("Target shape: {}", target.len());

        if let Some(target_names) = &dataset.target_names {
            println!("Target classes: {:?}", target_names);
        }
    }

    for (key, value) in &dataset.metadata {
        println!("Metadata - {}: {}", key, value);
    }
}

examples/complex_patterns_demo.rs (line 201)

fn print_dataset_summary(dataset: &scirs2_datasets::Dataset, name: &str) {
    let n_classes = if let Some(target) = &dataset.target {
        let unique_labels: std::collections::HashSet<_> =
            target.iter().map(|&x| x as i32).collect();
        unique_labels.len()
    } else {
        0
    };

    let class_info = if n_classes > 0 {
        format!(", {} classes", n_classes)
    } else {
        " (unsupervised)".to_string()
    };

    println!(
        "   {}: {} samples, {} features{}",
        name,
        dataset.n_samples(),
        dataset.n_features(),
        class_info
    );

    // Print first few data points for small datasets
    if dataset.n_samples() <= 10 && dataset.n_features() <= 3 {
        println!("   Sample points:");
        for i in 0..dataset.n_samples().min(3) {
            let point: Vec<f64> = (0..dataset.n_features())
                .map(|j| dataset.data[[i, j]])
                .collect();
            println!(
                "     [{:.3}, {:.3}{}]",
                point[0],
                point[1],
                if point.len() > 2 {
                    format!(", {:.3}", point[2])
                } else {
                    "".to_string()
                }
            );
        }
    }
}

examples/noise_models_demo.rs (line 199)

fn demonstrate_comprehensive_corruption() {
    println!("Testing comprehensive dataset corruption:");

    // Load a real dataset
    let iris = load_iris().unwrap();
    println!(
        "Original Iris dataset: {} samples, {} features",
        iris.n_samples(),
        iris.n_features()
    );

    let original_stats = calculate_basic_stats(&iris.data);
    println!(
        "Original stats - Mean: {:.3}, Std: {:.3}",
        original_stats.0, original_stats.1
    );

    // Create different levels of corruption
    let corruption_levels = [
        (0.05, 0.02, "Light corruption"),
        (0.1, 0.05, "Moderate corruption"),
        (0.2, 0.1, "Heavy corruption"),
        (0.3, 0.15, "Severe corruption"),
    ];

    for (missing_rate, outlier_rate, description) in corruption_levels {
        let corrupted = make_corrupted_dataset(
            &iris,
            missing_rate,
            MissingPattern::MAR, // More realistic than MCAR
            outlier_rate,
            OutlierType::Point,
            2.5,
            Some(42),
        )
        .unwrap();

        // Calculate how much data is usable
        let total_elements = corrupted.data.len();
        let missing_elements = corrupted.data.iter().filter(|&&x| x.is_nan()).count();
        let usable_percentage =
            ((total_elements - missing_elements) as f64 / total_elements as f64) * 100.0;

        println!("{}:", description);
        println!("  Missing data: {:.1}%", missing_rate * 100.0);
        println!("  Outliers: {:.1}%", outlier_rate * 100.0);
        println!("  Usable data: {:.1}%", usable_percentage);

        // Show metadata
        if let Some(missing_count) = corrupted.metadata.get("missing_count") {
            println!("  Actual missing: {} elements", missing_count);
        }
        if let Some(outlier_count) = corrupted.metadata.get("outlier_count") {
            println!("  Actual outliers: {} samples", outlier_count);
        }
    }
}

examples/time_series_datasets.rs (line 12)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("Loading time series datasets...\n");

    // Load the electrocardiogram dataset
    let ecg = electrocardiogram()?;

    println!("Electrocardiogram dataset:");
    println!("  Time steps: {}", ecg.n_samples());
    println!("  Features: {}", ecg.n_features());
    println!(
        "  Sampling rate: {} Hz",
        ecg.metadata
            .get("sampling_rate")
            .unwrap_or(&"unknown".to_string())
    );
    println!(
        "  Duration: {}",
        ecg.metadata
            .get("duration")
            .unwrap_or(&"unknown".to_string())
    );

    // Get a slice of the data and display basic statistics
    let ecg_slice = ecg.data.slice(s![0..10, 0]);
    println!("  First 10 data points: {:?}", ecg_slice);

    // Calculate some basic statistics
    let ecg_data = ecg.data.column(0);
    let min = ecg_data.fold(f64::INFINITY, |a, &b| a.min(b));
    let max = ecg_data.fold(f64::NEG_INFINITY, |a, &b| a.max(b));
    let mean = ecg_data.sum() / ecg_data.len() as f64;

    println!("  Min: {:.3} mV", min);
    println!("  Max: {:.3} mV", max);
    println!("  Mean: {:.3} mV", mean);

    // Note: Stock market and weather datasets are commented out because their source data
    // is not yet available.

    /*
    // Load the stock market dataset
    println!("\nStock market dataset:");

    // Get price changes (returns)
    let stock_returns = stock_market(true)?;
    println!("  Time steps: {}", stock_returns.n_samples());
    println!("  Companies: {}", stock_returns.n_features());

    // Print companies
    if let Some(feature_names) = &stock_returns.feature_names {
        println!("  Companies: {}", feature_names.join(", "));
    }

    // Load the weather dataset
    println!("\nWeather dataset:");
    let temp_data = weather(Some("temperature"))?;

    println!("  Time steps: {}", temp_data.n_samples());
    println!("  Locations: {}", temp_data.n_features());
    */

    println!("\nTime series dataset loaded successfully!");

    Ok(())
}

Additional examples can be found in:

• examples/data_generators.rs
• examples/cross_validation_demo.rs
• examples/sampling_demo.rs
• examples/feature_extraction_demo.rs

pub fn shape(&self) -> (usize, usize)

Get dataset shape as (n_samples, n_features)

Returns

Tuple of (n_samples, n_features)

pub fn has_target(&self) -> bool

Check if the dataset has target values

Returns

True if target values are present, false otherwise

pub fn feature_names(&self) -> Option<&Vec<String>>

Get a reference to the feature names if available

Returns

Optional reference to feature names vector

pub fn target_names(&self) -> Option<&Vec<String>>

Get a reference to the target names if available

Returns

Optional reference to target names vector

pub fn description(&self) -> Option<&String>

Get a reference to the dataset description if available

Returns

Optional reference to dataset description

pub fn metadata(&self) -> &HashMap<String, String>

Get a reference to the metadata

Returns

Reference to metadata HashMap

pub fn set_metadata(&mut self, key: &str, value: &str)

Add or update a metadata entry

Arguments

• key - Metadata key
• value - Metadata value

pub fn get_metadata(&self, key: &str) -> Option<&String>

Get a metadata value by key

Arguments

• key - Metadata key to lookup

Returns

Optional reference to the metadata value

Trait Implementations

impl Clone for Dataset

fn clone(&self) -> Dataset

Returns a duplicate of the value.

const fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Dataset

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Dataset

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Dataset

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.