Struct TextDataset 

pub struct TextDataset {
    pub texts: Vec<String>,
    pub labels: Vec<String>,
    /* private fields */
}

Text classification dataset

Fields

texts: Vec<String>

The text samples

labels: Vec<String>

The labels for each text

Implementations

impl TextDataset

pub fn new(texts: Vec<String>, labels: Vec<String>) -> Result<Self>

Create a new text dataset

Examples found in repository

examples/ml_sentiment_demo.rs (line 230)

fn create_sentiment_dataset() -> Result<(TextDataset, TextDataset), Box<dyn std::error::Error>> {
    // Training data
    let traintexts = vec![
        "I absolutely loved this movie! The acting was superb.",
        "Terrible experience, would not recommend to anyone.",
        "The product was okay, nothing special but it works.",
        "Great customer service and fast delivery.",
        "Disappointing quality for the price paid.",
        "This is the best purchase I've made all year!",
        "Waste of money, doesn't work as advertised.",
        "Mixed feelings about this. Some parts good, others bad.",
        "Pleasantly surprised by how well this performs.",
        "Not worth the price. Broke after two weeks.",
        "Amazing value for the price. Highly recommended!",
        "Mediocre at best. Wouldn't buy again.",
        "Fantastic product that exceeds expectations.",
        "Poor construction quality, arrived damaged.",
        "It's decent but there are better options available.",
        "This changed my life! Can't imagine living without it.",
        "Regret buying this. Customer service was unhelpful.",
        "Satisfied with my purchase, does what it claims.",
        "Best in its class. Outstanding performance.",
        "Very disappointed, doesn't match the description.",
        "Just average, nothing to write home about.",
        "Exceeded my expectations in every way.",
        "One of the worst products I've ever bought.",
        "Good enough for the price, but has limitations.",
        "Incredible value! Works perfectly for my needs.",
        "Would not purchase again. Many flaws.",
        "Does the job fine, but nothing spectacular.",
        "Absolutely worthless. Don't waste your money.",
        "A solid choice. Reliable and well-designed.",
        "Not impressed at all. Many issues from day one.",
    ];

    let train_labels = vec![
        "positive", "negative", "neutral", "positive", "negative", "positive", "negative",
        "neutral", "positive", "negative", "positive", "negative", "positive", "negative",
        "neutral", "positive", "negative", "neutral", "positive", "negative", "neutral",
        "positive", "negative", "neutral", "positive", "negative", "neutral", "negative",
        "positive", "negative",
    ];

    // Test data (different examples)
    let testtexts = [
        "Loved every minute of it. Highly recommended!",
        "Terrible product. Complete waste of money.",
        "It's okay, nothing special but gets the job done.",
        "Outstanding quality and service. Will buy again!",
        "Very poor experience. Many issues encountered.",
        "Adequate for basic needs, but lacks advanced features.",
        "Couldn't be happier with this purchase.",
        "Avoid at all costs. Terrible quality.",
        "Average performance. Neither good nor bad.",
        "Top-notch quality and design. Very impressed!",
    ];

    let test_labels = [
        "positive", "negative", "neutral", "positive", "negative", "neutral", "positive",
        "negative", "neutral", "positive",
    ];

    // Convert to strings
    let traintexts = traintexts.iter().map(|t| t.to_string()).collect();
    let train_labels = train_labels.iter().map(|l| l.to_string()).collect();
    let testtexts = testtexts.iter().map(|t| t.to_string()).collect();
    let test_labels = test_labels.iter().map(|l| l.to_string()).collect();

    // Create datasets
    let train_dataset = TextDataset::new(traintexts, train_labels)?;
    let test_dataset = TextDataset::new(testtexts, test_labels)?;

    Ok((train_dataset, test_dataset))
}

examples/text_classification_demo.rs (line 32)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("Text Classification Demo");
    println!("=======================\n");

    // Create sample dataset
    let texts = vec![
        "This movie is absolutely fantastic and amazing!".to_string(),
        "I really hated this film, it was terrible.".to_string(),
        "The acting was superb and the plot was engaging.".to_string(),
        "Worst movie I've ever seen, complete waste of time.".to_string(),
        "A masterpiece of cinema, truly exceptional work.".to_string(),
        "Boring, predictable, and poorly executed.".to_string(),
    ];

    let labels = vec![
        "positive".to_string(),
        "negative".to_string(),
        "positive".to_string(),
        "negative".to_string(),
        "positive".to_string(),
        "negative".to_string(),
    ];

    // Create dataset
    let dataset = TextDataset::new(texts, labels)?;
    println!("Dataset Statistics:");
    println!("  Total samples: {}", dataset.len());
    println!("  Number of classes: {}", dataset.unique_labels().len());
    println!();

    // Split into train and test
    let (train_dataset, test_dataset) = dataset.train_test_split(0.33, Some(42))?;
    println!("Train/Test Split:");
    println!("  Training samples: {}", train_dataset.len());
    println!("  Test samples: {}", test_dataset.len());
    println!();

    // Create text processing pipeline
    let mut pipeline = TextClassificationPipeline::with_tfidf();

    // Fit the pipeline
    pipeline.fit(&train_dataset)?;

    // Transform to features
    let train_features = pipeline.transform(&train_dataset)?;
    let test_features = pipeline.transform(&test_dataset)?;

    println!("Feature Extraction:");
    println!(
        "  Train feature shape: ({}, {})",
        train_features.nrows(),
        train_features.ncols()
    );
    println!(
        "  Test feature shape: ({}, {})",
        test_features.nrows(),
        test_features.ncols()
    );
    println!();

    // Demonstrate feature selection
    let mut feature_selector = TextFeatureSelector::new()
        .set_max_features(10.0)?
        .set_min_df(0.1)?
        .set_max_df(0.9)?;

    let selected_train_features = feature_selector.fit_transform(&train_features)?;
    println!("Feature Selection:");
    println!("  Selected features: {}", selected_train_features.ncols());
    println!();

    // Simulate classification results (in a real scenario, you'd use a classifier)
    // For demo purposes, we'll create mock predictions based on simple heuristics
    let _unique_labels = train_dataset.unique_labels();

    // Create binary labels (0 for negative, 1 for positive) for this demo
    let mut train_labels = Vec::new();
    let mut test_labels = Vec::new();

    for label in &train_dataset.labels {
        train_labels.push(if label == "positive" { 1 } else { 0 });
    }

    for label in &test_dataset.labels {
        test_labels.push(if label == "positive" { 1 } else { 0 });
    }

    // Mock predictions (in practice, use a real classifier)
    let predictions = test_labels.clone(); // Perfect predictions for demo

    // Calculate metrics
    let metrics = TextClassificationMetrics::new();
    let accuracy = metrics.accuracy(&predictions, &test_labels)?;
    let (precision, recall, f1) = metrics.binary_metrics(&predictions, &test_labels)?;

    println!("Classification Metrics:");
    println!("  Accuracy: {:.2}%", accuracy * 100.0);
    println!("  Precision: {:.2}%", precision * 100.0);
    println!("  Recall: {:.2}%", recall * 100.0);
    println!("  F1 Score: {:.2}%", f1 * 100.0);
    println!();

    // Create a simple confusion matrix manually since the method isn't available
    let mut true_positive = 0;
    let mut true_negative = 0;
    let mut false_positive = 0;
    let mut false_negative = 0;

    for (pred, actual) in predictions.iter().zip(test_labels.iter()) {
        match (pred, actual) {
            (1, 1) => true_positive += 1,
            (0, 0) => true_negative += 1,
            (1, 0) => false_positive += 1,
            (0, 1) => false_negative += 1,
            _ => {}
        }
    }

    println!("Confusion Matrix:");
    println!("[ {true_negative} {false_positive} ]");
    println!("[ {false_negative} {true_positive} ]");

    Ok(())
}

examples/ml_integration_demo.rs (lines 30-33)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("Machine Learning Integration Demo");
    println!("================================\n");

    // Sample dataset for demonstration
    let texts = [
        "This product is absolutely amazing! I love it.",
        "Terrible experience, would not recommend.",
        "It's okay, nothing special but works fine.",
        "Excellent quality and fast shipping.",
        "Complete waste of money, very disappointed.",
        "Good value for the price, satisfied with purchase.",
        "Outstanding service and great product!",
        "Not worth it, many issues with this item.",
    ];

    let labels = [
        "positive", "negative", "neutral", "positive", "negative", "positive", "positive",
        "negative",
    ];

    // Create dataset
    let dataset = TextDataset::new(
        texts.iter().map(|s| s.to_string()).collect(),
        labels.iter().map(|s| s.to_string()).collect(),
    )?;

    // Demonstrate different feature extraction modes
    println!("1. TF-IDF Feature Extraction");
    println!("---------------------------");

    let mut tfidf_processor = MLTextPreprocessor::new(FeatureExtractionMode::TfIdf)
        .with_tfidf_params(0.1, 0.9, Some(100));

    let text_refs = texts.to_vec();
    let tfidf_features = tfidf_processor.fit_transform(&text_refs)?;

    println!(
        "TF-IDF Features shape: {:?}",
        tfidf_features.features.shape()
    );
    println!(
        "First document features (first 5 values): {:?}\n",
        &tfidf_features
            .features
            .row(0)
            .iter()
            .take(5)
            .collect::<Vec<_>>()
    );

    // Topic modeling features
    println!("2. Topic Modeling Features");
    println!("-------------------------");

    let mut topic_processor =
        MLTextPreprocessor::new(FeatureExtractionMode::TopicModeling).with_topic_modeling(3);

    let topic_features = topic_processor.fit_transform(&text_refs)?;

    println!(
        "Topic Features shape: {:?}",
        topic_features.features.shape()
    );
    println!(
        "Topic distribution for first document: {:?}\n",
        topic_features.features.row(0)
    );

    // Combined features
    println!("3. Combined Features");
    println!("-------------------");

    let mut combined_processor = MLTextPreprocessor::new(FeatureExtractionMode::Combined);
    let combined_features = combined_processor.fit_transform(&text_refs)?;

    println!(
        "Combined Features shape: {:?}",
        combined_features.features.shape()
    );
    println!("Metadata: {:?}\n", combined_features.metadata);

    // ML Pipeline
    println!("4. ML Pipeline with Classification");
    println!("---------------------------------");

    let mut pipeline = TextMLPipeline::with_mode(FeatureExtractionMode::TfIdf)
        .configure_preprocessor(|p| {
            p.with_tfidf_params(0.0, 1.0, Some(50))
                .with_feature_selection(20)
        });

    let features = pipeline.process(&text_refs)?;
    println!("Pipeline features shape: {:?}", features.features.shape());

    // Batch processing for large datasets
    println!("\n5. Batch Processing");
    println!("-------------------");

    let mut batch_processor = BatchTextProcessor::new(3);
    let batches = batch_processor.process_batches(&text_refs)?;

    println!("Number of batches: {}", batches.len());
    for (i, batch) in batches.iter().enumerate() {
        println!("Batch {} shape: {:?}", i + 1, batch.features.shape());
    }

    // Feature extraction for classification
    println!("\n6. Classification with ML Features");
    println!("----------------------------------");

    // Split data
    let (train_dataset, test_dataset) = dataset.train_test_split(0.25, Some(42))?;

    // Extract features
    let traintexts: Vec<&str> = train_dataset.texts.iter().map(|s| s.as_ref()).collect();
    let testtexts: Vec<&str> = test_dataset.texts.iter().map(|s| s.as_ref()).collect();

    let mut feature_extractor = MLTextPreprocessor::new(FeatureExtractionMode::TfIdf);
    feature_extractor.fit(&traintexts)?;

    let train_features = feature_extractor.transform(&traintexts)?;
    let test_features = feature_extractor.transform(&testtexts)?;

    println!("Training features: {:?}", train_features.features.shape());
    println!("Test features: {:?}", test_features.features.shape());

    // In a real scenario, you would now use these features with a classifier
    println!("\nFeatures are ready for machine learning models!");

    // Demonstrate feature statistics
    println!("\n7. Feature Statistics");
    println!("--------------------");

    let feature_means = train_features
        .features
        .mean_axis(scirs2_core::ndarray::Axis(0))
        .unwrap();
    let feature_stds = train_features
        .features
        .std_axis(scirs2_core::ndarray::Axis(0), 0.0);

    println!(
        "Mean of first 5 features: {:?}",
        &feature_means.iter().take(5).collect::<Vec<_>>()
    );
    println!(
        "Std of first 5 features: {:?}",
        &feature_stds.iter().take(5).collect::<Vec<_>>()
    );

    Ok(())
}

pub fn len(&self) -> usize

Get the number of samples

Examples found in repository

examples/text_classification_demo.rs (line 34)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("Text Classification Demo");
    println!("=======================\n");

    // Create sample dataset
    let texts = vec![
        "This movie is absolutely fantastic and amazing!".to_string(),
        "I really hated this film, it was terrible.".to_string(),
        "The acting was superb and the plot was engaging.".to_string(),
        "Worst movie I've ever seen, complete waste of time.".to_string(),
        "A masterpiece of cinema, truly exceptional work.".to_string(),
        "Boring, predictable, and poorly executed.".to_string(),
    ];

    let labels = vec![
        "positive".to_string(),
        "negative".to_string(),
        "positive".to_string(),
        "negative".to_string(),
        "positive".to_string(),
        "negative".to_string(),
    ];

    // Create dataset
    let dataset = TextDataset::new(texts, labels)?;
    println!("Dataset Statistics:");
    println!("  Total samples: {}", dataset.len());
    println!("  Number of classes: {}", dataset.unique_labels().len());
    println!();

    // Split into train and test
    let (train_dataset, test_dataset) = dataset.train_test_split(0.33, Some(42))?;
    println!("Train/Test Split:");
    println!("  Training samples: {}", train_dataset.len());
    println!("  Test samples: {}", test_dataset.len());
    println!();

    // Create text processing pipeline
    let mut pipeline = TextClassificationPipeline::with_tfidf();

    // Fit the pipeline
    pipeline.fit(&train_dataset)?;

    // Transform to features
    let train_features = pipeline.transform(&train_dataset)?;
    let test_features = pipeline.transform(&test_dataset)?;

    println!("Feature Extraction:");
    println!(
        "  Train feature shape: ({}, {})",
        train_features.nrows(),
        train_features.ncols()
    );
    println!(
        "  Test feature shape: ({}, {})",
        test_features.nrows(),
        test_features.ncols()
    );
    println!();

    // Demonstrate feature selection
    let mut feature_selector = TextFeatureSelector::new()
        .set_max_features(10.0)?
        .set_min_df(0.1)?
        .set_max_df(0.9)?;

    let selected_train_features = feature_selector.fit_transform(&train_features)?;
    println!("Feature Selection:");
    println!("  Selected features: {}", selected_train_features.ncols());
    println!();

    // Simulate classification results (in a real scenario, you'd use a classifier)
    // For demo purposes, we'll create mock predictions based on simple heuristics
    let _unique_labels = train_dataset.unique_labels();

    // Create binary labels (0 for negative, 1 for positive) for this demo
    let mut train_labels = Vec::new();
    let mut test_labels = Vec::new();

    for label in &train_dataset.labels {
        train_labels.push(if label == "positive" { 1 } else { 0 });
    }

    for label in &test_dataset.labels {
        test_labels.push(if label == "positive" { 1 } else { 0 });
    }

    // Mock predictions (in practice, use a real classifier)
    let predictions = test_labels.clone(); // Perfect predictions for demo

    // Calculate metrics
    let metrics = TextClassificationMetrics::new();
    let accuracy = metrics.accuracy(&predictions, &test_labels)?;
    let (precision, recall, f1) = metrics.binary_metrics(&predictions, &test_labels)?;

    println!("Classification Metrics:");
    println!("  Accuracy: {:.2}%", accuracy * 100.0);
    println!("  Precision: {:.2}%", precision * 100.0);
    println!("  Recall: {:.2}%", recall * 100.0);
    println!("  F1 Score: {:.2}%", f1 * 100.0);
    println!();

    // Create a simple confusion matrix manually since the method isn't available
    let mut true_positive = 0;
    let mut true_negative = 0;
    let mut false_positive = 0;
    let mut false_negative = 0;

    for (pred, actual) in predictions.iter().zip(test_labels.iter()) {
        match (pred, actual) {
            (1, 1) => true_positive += 1,
            (0, 0) => true_negative += 1,
            (1, 0) => false_positive += 1,
            (0, 1) => false_negative += 1,
            _ => {}
        }
    }

    println!("Confusion Matrix:");
    println!("[ {true_negative} {false_positive} ]");
    println!("[ {false_negative} {true_positive} ]");

    Ok(())
}

pub fn is_empty(&self) -> bool

Check if the dataset is empty

pub fn unique_labels(&self) -> Vec<String>

Get the unique labels in the dataset

Examples found in repository

examples/text_classification_demo.rs (line 35)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("Text Classification Demo");
    println!("=======================\n");

    // Create sample dataset
    let texts = vec![
        "This movie is absolutely fantastic and amazing!".to_string(),
        "I really hated this film, it was terrible.".to_string(),
        "The acting was superb and the plot was engaging.".to_string(),
        "Worst movie I've ever seen, complete waste of time.".to_string(),
        "A masterpiece of cinema, truly exceptional work.".to_string(),
        "Boring, predictable, and poorly executed.".to_string(),
    ];

    let labels = vec![
        "positive".to_string(),
        "negative".to_string(),
        "positive".to_string(),
        "negative".to_string(),
        "positive".to_string(),
        "negative".to_string(),
    ];

    // Create dataset
    let dataset = TextDataset::new(texts, labels)?;
    println!("Dataset Statistics:");
    println!("  Total samples: {}", dataset.len());
    println!("  Number of classes: {}", dataset.unique_labels().len());
    println!();

    // Split into train and test
    let (train_dataset, test_dataset) = dataset.train_test_split(0.33, Some(42))?;
    println!("Train/Test Split:");
    println!("  Training samples: {}", train_dataset.len());
    println!("  Test samples: {}", test_dataset.len());
    println!();

    // Create text processing pipeline
    let mut pipeline = TextClassificationPipeline::with_tfidf();

    // Fit the pipeline
    pipeline.fit(&train_dataset)?;

    // Transform to features
    let train_features = pipeline.transform(&train_dataset)?;
    let test_features = pipeline.transform(&test_dataset)?;

    println!("Feature Extraction:");
    println!(
        "  Train feature shape: ({}, {})",
        train_features.nrows(),
        train_features.ncols()
    );
    println!(
        "  Test feature shape: ({}, {})",
        test_features.nrows(),
        test_features.ncols()
    );
    println!();

    // Demonstrate feature selection
    let mut feature_selector = TextFeatureSelector::new()
        .set_max_features(10.0)?
        .set_min_df(0.1)?
        .set_max_df(0.9)?;

    let selected_train_features = feature_selector.fit_transform(&train_features)?;
    println!("Feature Selection:");
    println!("  Selected features: {}", selected_train_features.ncols());
    println!();

    // Simulate classification results (in a real scenario, you'd use a classifier)
    // For demo purposes, we'll create mock predictions based on simple heuristics
    let _unique_labels = train_dataset.unique_labels();

    // Create binary labels (0 for negative, 1 for positive) for this demo
    let mut train_labels = Vec::new();
    let mut test_labels = Vec::new();

    for label in &train_dataset.labels {
        train_labels.push(if label == "positive" { 1 } else { 0 });
    }

    for label in &test_dataset.labels {
        test_labels.push(if label == "positive" { 1 } else { 0 });
    }

    // Mock predictions (in practice, use a real classifier)
    let predictions = test_labels.clone(); // Perfect predictions for demo

    // Calculate metrics
    let metrics = TextClassificationMetrics::new();
    let accuracy = metrics.accuracy(&predictions, &test_labels)?;
    let (precision, recall, f1) = metrics.binary_metrics(&predictions, &test_labels)?;

    println!("Classification Metrics:");
    println!("  Accuracy: {:.2}%", accuracy * 100.0);
    println!("  Precision: {:.2}%", precision * 100.0);
    println!("  Recall: {:.2}%", recall * 100.0);
    println!("  F1 Score: {:.2}%", f1 * 100.0);
    println!();

    // Create a simple confusion matrix manually since the method isn't available
    let mut true_positive = 0;
    let mut true_negative = 0;
    let mut false_positive = 0;
    let mut false_negative = 0;

    for (pred, actual) in predictions.iter().zip(test_labels.iter()) {
        match (pred, actual) {
            (1, 1) => true_positive += 1,
            (0, 0) => true_negative += 1,
            (1, 0) => false_positive += 1,
            (0, 1) => false_negative += 1,
            _ => {}
        }
    }

    println!("Confusion Matrix:");
    println!("[ {true_negative} {false_positive} ]");
    println!("[ {false_negative} {true_positive} ]");

    Ok(())
}

pub fn build_label_index(&mut self) -> Result<&mut Self>

Build a label index mapping

pub fn get_label_indices(&self) -> Result<Vec<usize>>

Get label indices

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

Split the dataset into train and test sets

Examples found in repository

examples/text_classification_demo.rs (line 39)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("Text Classification Demo");
    println!("=======================\n");

    // Create sample dataset
    let texts = vec![
        "This movie is absolutely fantastic and amazing!".to_string(),
        "I really hated this film, it was terrible.".to_string(),
        "The acting was superb and the plot was engaging.".to_string(),
        "Worst movie I've ever seen, complete waste of time.".to_string(),
        "A masterpiece of cinema, truly exceptional work.".to_string(),
        "Boring, predictable, and poorly executed.".to_string(),
    ];

    let labels = vec![
        "positive".to_string(),
        "negative".to_string(),
        "positive".to_string(),
        "negative".to_string(),
        "positive".to_string(),
        "negative".to_string(),
    ];

    // Create dataset
    let dataset = TextDataset::new(texts, labels)?;
    println!("Dataset Statistics:");
    println!("  Total samples: {}", dataset.len());
    println!("  Number of classes: {}", dataset.unique_labels().len());
    println!();

    // Split into train and test
    let (train_dataset, test_dataset) = dataset.train_test_split(0.33, Some(42))?;
    println!("Train/Test Split:");
    println!("  Training samples: {}", train_dataset.len());
    println!("  Test samples: {}", test_dataset.len());
    println!();

    // Create text processing pipeline
    let mut pipeline = TextClassificationPipeline::with_tfidf();

    // Fit the pipeline
    pipeline.fit(&train_dataset)?;

    // Transform to features
    let train_features = pipeline.transform(&train_dataset)?;
    let test_features = pipeline.transform(&test_dataset)?;

    println!("Feature Extraction:");
    println!(
        "  Train feature shape: ({}, {})",
        train_features.nrows(),
        train_features.ncols()
    );
    println!(
        "  Test feature shape: ({}, {})",
        test_features.nrows(),
        test_features.ncols()
    );
    println!();

    // Demonstrate feature selection
    let mut feature_selector = TextFeatureSelector::new()
        .set_max_features(10.0)?
        .set_min_df(0.1)?
        .set_max_df(0.9)?;

    let selected_train_features = feature_selector.fit_transform(&train_features)?;
    println!("Feature Selection:");
    println!("  Selected features: {}", selected_train_features.ncols());
    println!();

    // Simulate classification results (in a real scenario, you'd use a classifier)
    // For demo purposes, we'll create mock predictions based on simple heuristics
    let _unique_labels = train_dataset.unique_labels();

    // Create binary labels (0 for negative, 1 for positive) for this demo
    let mut train_labels = Vec::new();
    let mut test_labels = Vec::new();

    for label in &train_dataset.labels {
        train_labels.push(if label == "positive" { 1 } else { 0 });
    }

    for label in &test_dataset.labels {
        test_labels.push(if label == "positive" { 1 } else { 0 });
    }

    // Mock predictions (in practice, use a real classifier)
    let predictions = test_labels.clone(); // Perfect predictions for demo

    // Calculate metrics
    let metrics = TextClassificationMetrics::new();
    let accuracy = metrics.accuracy(&predictions, &test_labels)?;
    let (precision, recall, f1) = metrics.binary_metrics(&predictions, &test_labels)?;

    println!("Classification Metrics:");
    println!("  Accuracy: {:.2}%", accuracy * 100.0);
    println!("  Precision: {:.2}%", precision * 100.0);
    println!("  Recall: {:.2}%", recall * 100.0);
    println!("  F1 Score: {:.2}%", f1 * 100.0);
    println!();

    // Create a simple confusion matrix manually since the method isn't available
    let mut true_positive = 0;
    let mut true_negative = 0;
    let mut false_positive = 0;
    let mut false_negative = 0;

    for (pred, actual) in predictions.iter().zip(test_labels.iter()) {
        match (pred, actual) {
            (1, 1) => true_positive += 1,
            (0, 0) => true_negative += 1,
            (1, 0) => false_positive += 1,
            (0, 1) => false_negative += 1,
            _ => {}
        }
    }

    println!("Confusion Matrix:");
    println!("[ {true_negative} {false_positive} ]");
    println!("[ {false_negative} {true_positive} ]");

    Ok(())
}

examples/ml_integration_demo.rs (line 120)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("Machine Learning Integration Demo");
    println!("================================\n");

    // Sample dataset for demonstration
    let texts = [
        "This product is absolutely amazing! I love it.",
        "Terrible experience, would not recommend.",
        "It's okay, nothing special but works fine.",
        "Excellent quality and fast shipping.",
        "Complete waste of money, very disappointed.",
        "Good value for the price, satisfied with purchase.",
        "Outstanding service and great product!",
        "Not worth it, many issues with this item.",
    ];

    let labels = [
        "positive", "negative", "neutral", "positive", "negative", "positive", "positive",
        "negative",
    ];

    // Create dataset
    let dataset = TextDataset::new(
        texts.iter().map(|s| s.to_string()).collect(),
        labels.iter().map(|s| s.to_string()).collect(),
    )?;

    // Demonstrate different feature extraction modes
    println!("1. TF-IDF Feature Extraction");
    println!("---------------------------");

    let mut tfidf_processor = MLTextPreprocessor::new(FeatureExtractionMode::TfIdf)
        .with_tfidf_params(0.1, 0.9, Some(100));

    let text_refs = texts.to_vec();
    let tfidf_features = tfidf_processor.fit_transform(&text_refs)?;

    println!(
        "TF-IDF Features shape: {:?}",
        tfidf_features.features.shape()
    );
    println!(
        "First document features (first 5 values): {:?}\n",
        &tfidf_features
            .features
            .row(0)
            .iter()
            .take(5)
            .collect::<Vec<_>>()
    );

    // Topic modeling features
    println!("2. Topic Modeling Features");
    println!("-------------------------");

    let mut topic_processor =
        MLTextPreprocessor::new(FeatureExtractionMode::TopicModeling).with_topic_modeling(3);

    let topic_features = topic_processor.fit_transform(&text_refs)?;

    println!(
        "Topic Features shape: {:?}",
        topic_features.features.shape()
    );
    println!(
        "Topic distribution for first document: {:?}\n",
        topic_features.features.row(0)
    );

    // Combined features
    println!("3. Combined Features");
    println!("-------------------");

    let mut combined_processor = MLTextPreprocessor::new(FeatureExtractionMode::Combined);
    let combined_features = combined_processor.fit_transform(&text_refs)?;

    println!(
        "Combined Features shape: {:?}",
        combined_features.features.shape()
    );
    println!("Metadata: {:?}\n", combined_features.metadata);

    // ML Pipeline
    println!("4. ML Pipeline with Classification");
    println!("---------------------------------");

    let mut pipeline = TextMLPipeline::with_mode(FeatureExtractionMode::TfIdf)
        .configure_preprocessor(|p| {
            p.with_tfidf_params(0.0, 1.0, Some(50))
                .with_feature_selection(20)
        });

    let features = pipeline.process(&text_refs)?;
    println!("Pipeline features shape: {:?}", features.features.shape());

    // Batch processing for large datasets
    println!("\n5. Batch Processing");
    println!("-------------------");

    let mut batch_processor = BatchTextProcessor::new(3);
    let batches = batch_processor.process_batches(&text_refs)?;

    println!("Number of batches: {}", batches.len());
    for (i, batch) in batches.iter().enumerate() {
        println!("Batch {} shape: {:?}", i + 1, batch.features.shape());
    }

    // Feature extraction for classification
    println!("\n6. Classification with ML Features");
    println!("----------------------------------");

    // Split data
    let (train_dataset, test_dataset) = dataset.train_test_split(0.25, Some(42))?;

    // Extract features
    let traintexts: Vec<&str> = train_dataset.texts.iter().map(|s| s.as_ref()).collect();
    let testtexts: Vec<&str> = test_dataset.texts.iter().map(|s| s.as_ref()).collect();

    let mut feature_extractor = MLTextPreprocessor::new(FeatureExtractionMode::TfIdf);
    feature_extractor.fit(&traintexts)?;

    let train_features = feature_extractor.transform(&traintexts)?;
    let test_features = feature_extractor.transform(&testtexts)?;

    println!("Training features: {:?}", train_features.features.shape());
    println!("Test features: {:?}", test_features.features.shape());

    // In a real scenario, you would now use these features with a classifier
    println!("\nFeatures are ready for machine learning models!");

    // Demonstrate feature statistics
    println!("\n7. Feature Statistics");
    println!("--------------------");

    let feature_means = train_features
        .features
        .mean_axis(scirs2_core::ndarray::Axis(0))
        .unwrap();
    let feature_stds = train_features
        .features
        .std_axis(scirs2_core::ndarray::Axis(0), 0.0);

    println!(
        "Mean of first 5 features: {:?}",
        &feature_means.iter().take(5).collect::<Vec<_>>()
    );
    println!(
        "Std of first 5 features: {:?}",
        &feature_stds.iter().take(5).collect::<Vec<_>>()
    );

    Ok(())
}

Trait Implementations

impl Clone for TextDataset

fn clone(&self) -> TextDataset

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TextDataset

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

Formats the value using the given formatter.