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

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

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

Add target names to the dataset

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

Add feature names to the dataset

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

Add feature descriptions to the dataset

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

Add a description to the dataset

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

Add metadata to the dataset

pub fn n_samples(&self) -> usize

Get the number of samples 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/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 dataset.train_test_split(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 25)

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) = classification_data.train_test_split(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(())
}

pub fn n_features(&self) -> usize

Get the number of features 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/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) = classification_data.train_test_split(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(())
}

pub fn train_test_split( &self, test_size: f64, random_seed: Option<u64>, ) -> Result<(Dataset, Dataset)>

Split the dataset into training and test sets

Examples found in repository

examples/dataset_loaders.rs (line 31)

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 dataset.train_test_split(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),
    }
}

examples/data_generators.rs (line 22)

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) = classification_data.train_test_split(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(())
}

Trait Implementations

impl Clone for Dataset

fn clone(&self) -> Dataset

Returns a copy of the value.

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.