Struct ConfusionMatrix 

pub struct ConfusionMatrix<F: Float + Debug + Display> {
    pub matrix: Array2<F>,
    pub labels: Option<Vec<String>>,
    pub num_classes: usize,
}

Confusion matrix for classification problems

Fields

matrix: Array2<F>

The raw confusion matrix data

labels: Option<Vec<String>>

Class labels (optional)

num_classes: usize

Number of classes

Implementations

impl<F: Float + Debug + Display> ConfusionMatrix<F>

pub fn new( y_true: &ArrayView1<'_, usize>, y_pred: &ArrayView1<'_, usize>, num_classes: Option<usize>, labels: Option<Vec<String>>, ) -> Result<Self>

Create a new confusion matrix from predictions and true labels

Arguments

• y_true - True class labels as integers
• y_pred - Predicted class labels as integers
• num_classes - Number of classes (if None, determined from data)
• labels - Optional class labels as strings

Returns

• Result<ConfusionMatrix<F>> - The confusion matrix

Example

use scirs2_neural::utils::evaluation::ConfusionMatrix;
use scirs2_core::ndarray::Array1;
let y_true = Array1::from_vec(vec![0, 1, 2, 0, 1, 2, 0]);
let y_pred = Array1::from_vec(vec![0, 1, 1, 0, 1, 2, 0]);
let cm = ConfusionMatrix::<f32>::new(&y_true.view(), &y_pred.view(), None, None).unwrap();

Examples found in repository

examples/confusion_matrix_heatmap.rs (lines 52-57)

fn main() {
    // Create a reproducible random number generator
    let mut rng = SmallRng::from_seed([42; 32]);
    // Generate synthetic multiclass classification data
    let num_classes = 5;
    let n_samples = 500;
    // Generate true labels (0 to num_classes-1)
    let mut y_true = Vec::with_capacity(n_samples);
    for _ in 0..n_samples {
        y_true.push(rng.random_range(0..num_classes));
    }
    // Generate predicted labels with controlled accuracy
    let mut y_pred = Vec::with_capacity(n_samples);
    for &true_label in &y_true {
        // 80% chance to predict correctly..20% chance of error
        if rng.random::<f64>() < 0.8 {
            y_pred.push(true_label);
        } else {
            // When wrong, tend to predict adjacent classes more often
            let mut pred = true_label;
            while pred == true_label {
                // Generate error that's more likely to be close to true label
                let error_margin = (rng.random::<f64>() * 2.0).round() as usize; // 0, 1, or 2
                if rng.random::<bool>() {
                    pred = (true_label + error_margin) % num_classes;
                } else {
                    pred = (true_label + num_classes - error_margin) % num_classes;
                }
            }
            y_pred.push(pred);
        }
    }
    // Convert to ndarray arrays
    let y_true_array = Array1::from(y_true);
    let y_pred_array = Array1::from(y_pred);
    // Create class labels
    let class_labels = vec![
        "Cat".to_string(),
        "Dog".to_string(),
        "Bird".to_string(),
        "Fish".to_string(),
        "Rabbit".to_string(),
    ];
    // Create confusion matrix
    let cm = ConfusionMatrix::<f64>::new(
        &y_true_array.view(),
        &y_pred_array.view(),
        Some(num_classes),
        Some(class_labels),
    )
    .unwrap();
    // Example 1: Standard confusion matrix
    println!("Example 1: Standard Confusion Matrix\n");
    let regular_output = cm.to_ascii(Some("Animal Classification Results"), false);
    println!("{regular_output}");
    // Example 2: Confusion matrix with color
    println!("\n\nExample 2: Colored Confusion Matrix\n");
    let color_options = ColorOptions {
        enabled: true,
        use_bright: true,
        use_background: false,
    };
    let colored_output = cm.to_ascii_with_options(
        Some("Animal Classification Results (with color)"),
        false,
        &color_options,
    );
    println!("{colored_output}");
    // Example 3: Normalized confusion matrix heatmap
    println!("\n\nExample 3: Normalized Confusion Matrix Heatmap\n");
    let heatmap_output = cm.to_heatmap_with_options(
        Some("Animal Classification Heatmap (normalized)"),
        true, // normalized
        &color_options,
    );
    println!("{heatmap_output}");

    // Example 4: Raw counts heatmap
    println!("\n\nExample 4: Raw Counts Confusion Matrix Heatmap\n");
    let raw_heatmap = cm.to_heatmap_with_options(
        Some("Animal Classification Heatmap (raw counts)"),
        false, // not normalized
        &color_options,
    );
    println!("{raw_heatmap}");
}

examples/colored_eval_visualization.rs (lines 64-69)

fn main() -> Result<()> {
    println!(
        "{}",
        stylize("Neural Network Model Evaluation with Color", Style::Bold)
    );
    println!("{}", "-".repeat(50));
    // Set up color options
    let color_options = ColorOptions {
        enabled: true,
        use_background: false,
        use_bright: true,
    };
    // Generate some example data
    let n_samples = 500;
    let n_features = 10;
    let n_classes = 4;
    println!(
        "\n{} {} {} {} {} {}",
        colorize("Generating", Color::BrightGreen),
        colorize(n_samples.to_string(), Color::BrightYellow),
        colorize("samples with", Color::BrightGreen),
        colorize(n_features.to_string(), Color::BrightYellow),
        colorize("features for", Color::BrightGreen),
        colorize(n_classes.to_string(), Color::BrightYellow),
    );

    // Create a deterministic RNG for reproducibility
    let mut rng = SmallRng::from_seed([42; 32]);

    // 1. Confusion Matrix Example
    println!(
        "\n{}",
        stylize("1. CONFUSION MATRIX VISUALIZATION", Style::Bold)
    );
    // Generate random predictions and true labels
    let y_true = Array::from_shape_fn(n_samples, |_| rng.random_range(0..n_classes));
    // Create slightly correlated predictions (not completely random)
    let y_pred = Array::from_shape_fn(n_samples, |i| {
        if rng.random::<f32>() < 0.7 {
            // 70% chance of correct prediction
            y_true[i]
        } else {
            // 30% chance of random class
            rng.random_range(0..n_classes)
        }
    });
    // Create confusion matrix
    let class_labels = vec![
        "Class A".to_string(),
        "Class B".to_string(),
        "Class C".to_string(),
        "Class D".to_string(),
    ];
    let cm = ConfusionMatrix::<f32>::new(
        &y_true.view(),
        &y_pred.view(),
        Some(n_classes),
        Some(class_labels),
    )?;
    // Print raw and normalized confusion matrices with color
    println!("\n{}", colorize("Raw Confusion Matrix:", Color::BrightCyan));
    println!(
        "{}",
        cm.to_ascii_with_options(Some("Confusion Matrix"), false, &color_options)
    );
    println!(
        "\n{}",
        colorize("Normalized Confusion Matrix:", Color::BrightCyan)
    );
    println!(
        "{}",
        cm.to_ascii_with_options(Some("Normalized Confusion Matrix"), true, &color_options)
    );
    // Print metrics
    println!(
        "\n{} {:.3}",
        colorize("Overall Accuracy:", Color::BrightMagenta),
        cm.accuracy()
    );
    let precision = cm.precision();
    let recall = cm.recall();
    let f1 = cm.f1_score();
    println!("{}", colorize("Per-class metrics:", Color::BrightMagenta));
    for i in 0..n_classes {
        println!(
            "  {}: {}={:.3}, {}={:.3}, {}={:.3}",
            colorize(format!("Class {i}"), Color::BrightYellow),
            colorize("Precision", Color::BrightCyan),
            precision[i],
            colorize("Recall", Color::BrightGreen),
            recall[i],
            colorize("F1", Color::BrightBlue),
            f1[i]
        );
    }
    println!(
        "{} {:.3}",
        colorize("Macro F1 Score:", Color::BrightMagenta),
        cm.macro_f1()
    );
    // 2. Feature Importance Visualization
    println!(
        "{}",
        stylize("2. FEATURE IMPORTANCE VISUALIZATION", Style::Bold)
    );
    // Generate random feature importance scores
    let feature_names = (0..n_features)
        .map(|i| format!("Feature_{i}"))
        .collect::<Vec<String>>();
    let importance = Array1::from_shape_fn(n_features, |i| {
        // Make some features more important than others
        let base = (n_features - i) as f32 / n_features as f32;
        base + 0.2 * rng.random::<f32>()
    });

    let fi = FeatureImportance::new(feature_names, importance)?;

    // Print full feature importance with color
    println!(
        "{}",
        fi.to_ascii_with_options(Some("Feature Importance"), 60, None, &color_options)
    );

    // Print top-5 features with color
    println!(
        "{}",
        colorize("Top 5 Most Important Features:", Color::BrightCyan)
    );
    println!(
        "{}",
        fi.to_ascii_with_options(Some("Top 5 Features"), 60, Some(5), &color_options)
    );
    // 3. ROC Curve for Binary Classification
    println!("\n{}", stylize("3. ROC CURVE VISUALIZATION", Style::Bold));
    // Generate binary classification data
    let n_binary = 200;
    let y_true_binary = Array::from_shape_fn(n_binary, |_| rng.random_range(0..2));
    // Generate scores with some predictive power
    let y_scores = Array1::from_shape_fn(n_binary, |i| {
        if y_true_binary[i] == 1 {
            // Higher scores for positive class
            0.6 + 0.4 * rng.random::<f32>()
        } else {
            // Lower scores for negative class
            0.4 * rng.random::<f32>()
        }
    });

    let roc = ROCCurve::new(&y_true_binary.view(), &y_scores.view())?;
    println!(
        "{}: {:.3}",
        colorize("ROC AUC:", Color::BrightMagenta),
        roc.auc
    );
    println!("\n{}", roc.to_ascii(None, 50, 20));

    // 4. Learning Curve Visualization
    println!(
        "\n{}",
        stylize("4. LEARNING CURVE VISUALIZATION", Style::Bold)
    );
    // Generate learning curve data
    let n_points = 10;
    let n_cv = 5;
    let train_sizes = Array1::from_shape_fn(n_points, |i| 50 + i * 50);
    // Generate training scores (decreasing with size due to overfitting)
    let train_scores = Array2::from_shape_fn((n_points, n_cv), |(i, _)| {
        0.95 - 0.05 * (i as f32 / n_points as f32) + 0.03 * rng.random::<f32>()
    });

    // Generate validation scores (increasing with size)
    let val_scores = Array2::from_shape_fn((n_points, n_cv), |(i, _)| {
        0.7 + 0.2 * (i as f32 / n_points as f32) + 0.05 * rng.random::<f32>()
    });

    let lc = LearningCurve::new(train_sizes, train_scores, val_scores)?;
    println!("{}", lc.to_ascii(None, 60, 20, "Accuracy"));

    // Print final message with color
    println!(
        "{}",
        colorize(
            "Model evaluation visualizations completed successfully!",
            Color::BrightGreen
        )
    );
    Ok(())
}

pub fn from_matrix( matrix: Array2<F>, labels: Option<Vec<String>>, ) -> Result<Self>

Create a confusion matrix from raw matrix data

Arguments

• matrix - Raw confusion matrix data
• labels - Optional class labels

Examples found in repository

examples/error_pattern_heatmap.rs (line 53)

fn main() {
    // Create a reproducible random number generator
    let mut rng = SmallRng::from_seed([42; 32]);
    // Generate synthetic multiclass classification data with specific error patterns
    let num_classes = 5;
    // Create confusion matrix with controlled error patterns
    let mut matrix = vec![vec![0; num_classes]; num_classes];
    // Set diagonal elements (correct classifications) with high values
    #[allow(clippy::needless_range_loop)]
    for i in 0..num_classes {
        matrix[i][i] = 70 + rng.random_range(0..15); // 70-85 correct per class
    }
    // Create specific error patterns:
    // - Classes 0 and 1 often confused
    matrix[0][1] = 25;
    matrix[1][0] = 15;
    // - Class 2 sometimes confused with Class 3
    matrix[2][3] = 18;
    // - Class 4 has some misclassifications to all other classes
    matrix[4][0] = 8;
    matrix[4][1] = 5;
    matrix[4][2] = 10;
    matrix[4][3] = 12;
    // - Some minor errors scattered about
    #[allow(clippy::needless_range_loop)]
    for i in 0..num_classes {
        for j in 0..num_classes {
            if i != j && matrix[i][j] == 0 {
                matrix[i][j] = rng.random_range(0..5);
            }
        }
    }
    // Convert to ndarray
    let flat_matrix: Vec<f64> = matrix.iter().flatten().map(|&x| x as f64).collect();
    let ndarray_matrix =
        scirs2_core::ndarray::Array::from_shape_vec((num_classes, num_classes), flat_matrix)
            .unwrap();
    // Create class labels
    let class_labels = vec![
        "Class A".to_string(),
        "Class B".to_string(),
        "Class C".to_string(),
        "Class D".to_string(),
        "Class E".to_string(),
    ];
    // Create confusion matrix
    let cm = ConfusionMatrix::from_matrix(ndarray_matrix, Some(class_labels)).unwrap();
    // Example 1: Standard confusion matrix
    println!("Example 1: Standard Confusion Matrix\n");
    let regular_output = cm.to_ascii(Some("Classification Results"), false);
    println!("{regular_output}");
    // Example 2: Normal heatmap
    println!("\n\nExample 2: Standard Heatmap Visualization\n");
    let color_options = ColorOptions {
        enabled: true,
        use_bright: true,
        use_background: false,
    };
    let heatmap_output = cm.to_heatmap_with_options(
        Some("Classification Heatmap"),
        true, // normalized
        &color_options,
    );
    println!("{heatmap_output}");
    // Example 3: Error pattern heatmap
    println!("\n\nExample 3: Error Pattern Heatmap (highlighting misclassifications)\n");
    let error_heatmap = cm.error_heatmap(Some("Misclassification Analysis"));
    println!("{error_heatmap}");
}

pub fn normalized(&self) -> Array2<F>

Get the normalized confusion matrix (rows sum to 1)

pub fn accuracy(&self) -> F

Calculate accuracy from the confusion matrix

Examples found in repository

examples/colored_eval_visualization.rs (line 88)

fn main() -> Result<()> {
    println!(
        "{}",
        stylize("Neural Network Model Evaluation with Color", Style::Bold)
    );
    println!("{}", "-".repeat(50));
    // Set up color options
    let color_options = ColorOptions {
        enabled: true,
        use_background: false,
        use_bright: true,
    };
    // Generate some example data
    let n_samples = 500;
    let n_features = 10;
    let n_classes = 4;
    println!(
        "\n{} {} {} {} {} {}",
        colorize("Generating", Color::BrightGreen),
        colorize(n_samples.to_string(), Color::BrightYellow),
        colorize("samples with", Color::BrightGreen),
        colorize(n_features.to_string(), Color::BrightYellow),
        colorize("features for", Color::BrightGreen),
        colorize(n_classes.to_string(), Color::BrightYellow),
    );

    // Create a deterministic RNG for reproducibility
    let mut rng = SmallRng::from_seed([42; 32]);

    // 1. Confusion Matrix Example
    println!(
        "\n{}",
        stylize("1. CONFUSION MATRIX VISUALIZATION", Style::Bold)
    );
    // Generate random predictions and true labels
    let y_true = Array::from_shape_fn(n_samples, |_| rng.random_range(0..n_classes));
    // Create slightly correlated predictions (not completely random)
    let y_pred = Array::from_shape_fn(n_samples, |i| {
        if rng.random::<f32>() < 0.7 {
            // 70% chance of correct prediction
            y_true[i]
        } else {
            // 30% chance of random class
            rng.random_range(0..n_classes)
        }
    });
    // Create confusion matrix
    let class_labels = vec![
        "Class A".to_string(),
        "Class B".to_string(),
        "Class C".to_string(),
        "Class D".to_string(),
    ];
    let cm = ConfusionMatrix::<f32>::new(
        &y_true.view(),
        &y_pred.view(),
        Some(n_classes),
        Some(class_labels),
    )?;
    // Print raw and normalized confusion matrices with color
    println!("\n{}", colorize("Raw Confusion Matrix:", Color::BrightCyan));
    println!(
        "{}",
        cm.to_ascii_with_options(Some("Confusion Matrix"), false, &color_options)
    );
    println!(
        "\n{}",
        colorize("Normalized Confusion Matrix:", Color::BrightCyan)
    );
    println!(
        "{}",
        cm.to_ascii_with_options(Some("Normalized Confusion Matrix"), true, &color_options)
    );
    // Print metrics
    println!(
        "\n{} {:.3}",
        colorize("Overall Accuracy:", Color::BrightMagenta),
        cm.accuracy()
    );
    let precision = cm.precision();
    let recall = cm.recall();
    let f1 = cm.f1_score();
    println!("{}", colorize("Per-class metrics:", Color::BrightMagenta));
    for i in 0..n_classes {
        println!(
            "  {}: {}={:.3}, {}={:.3}, {}={:.3}",
            colorize(format!("Class {i}"), Color::BrightYellow),
            colorize("Precision", Color::BrightCyan),
            precision[i],
            colorize("Recall", Color::BrightGreen),
            recall[i],
            colorize("F1", Color::BrightBlue),
            f1[i]
        );
    }
    println!(
        "{} {:.3}",
        colorize("Macro F1 Score:", Color::BrightMagenta),
        cm.macro_f1()
    );
    // 2. Feature Importance Visualization
    println!(
        "{}",
        stylize("2. FEATURE IMPORTANCE VISUALIZATION", Style::Bold)
    );
    // Generate random feature importance scores
    let feature_names = (0..n_features)
        .map(|i| format!("Feature_{i}"))
        .collect::<Vec<String>>();
    let importance = Array1::from_shape_fn(n_features, |i| {
        // Make some features more important than others
        let base = (n_features - i) as f32 / n_features as f32;
        base + 0.2 * rng.random::<f32>()
    });

    let fi = FeatureImportance::new(feature_names, importance)?;

    // Print full feature importance with color
    println!(
        "{}",
        fi.to_ascii_with_options(Some("Feature Importance"), 60, None, &color_options)
    );

    // Print top-5 features with color
    println!(
        "{}",
        colorize("Top 5 Most Important Features:", Color::BrightCyan)
    );
    println!(
        "{}",
        fi.to_ascii_with_options(Some("Top 5 Features"), 60, Some(5), &color_options)
    );
    // 3. ROC Curve for Binary Classification
    println!("\n{}", stylize("3. ROC CURVE VISUALIZATION", Style::Bold));
    // Generate binary classification data
    let n_binary = 200;
    let y_true_binary = Array::from_shape_fn(n_binary, |_| rng.random_range(0..2));
    // Generate scores with some predictive power
    let y_scores = Array1::from_shape_fn(n_binary, |i| {
        if y_true_binary[i] == 1 {
            // Higher scores for positive class
            0.6 + 0.4 * rng.random::<f32>()
        } else {
            // Lower scores for negative class
            0.4 * rng.random::<f32>()
        }
    });

    let roc = ROCCurve::new(&y_true_binary.view(), &y_scores.view())?;
    println!(
        "{}: {:.3}",
        colorize("ROC AUC:", Color::BrightMagenta),
        roc.auc
    );
    println!("\n{}", roc.to_ascii(None, 50, 20));

    // 4. Learning Curve Visualization
    println!(
        "\n{}",
        stylize("4. LEARNING CURVE VISUALIZATION", Style::Bold)
    );
    // Generate learning curve data
    let n_points = 10;
    let n_cv = 5;
    let train_sizes = Array1::from_shape_fn(n_points, |i| 50 + i * 50);
    // Generate training scores (decreasing with size due to overfitting)
    let train_scores = Array2::from_shape_fn((n_points, n_cv), |(i, _)| {
        0.95 - 0.05 * (i as f32 / n_points as f32) + 0.03 * rng.random::<f32>()
    });

    // Generate validation scores (increasing with size)
    let val_scores = Array2::from_shape_fn((n_points, n_cv), |(i, _)| {
        0.7 + 0.2 * (i as f32 / n_points as f32) + 0.05 * rng.random::<f32>()
    });

    let lc = LearningCurve::new(train_sizes, train_scores, val_scores)?;
    println!("{}", lc.to_ascii(None, 60, 20, "Accuracy"));

    // Print final message with color
    println!(
        "{}",
        colorize(
            "Model evaluation visualizations completed successfully!",
            Color::BrightGreen
        )
    );
    Ok(())
}

pub fn precision(&self) -> Array1<F>

Calculate precision for each class

Examples found in repository

examples/colored_eval_visualization.rs (line 90)

fn main() -> Result<()> {
    println!(
        "{}",
        stylize("Neural Network Model Evaluation with Color", Style::Bold)
    );
    println!("{}", "-".repeat(50));
    // Set up color options
    let color_options = ColorOptions {
        enabled: true,
        use_background: false,
        use_bright: true,
    };
    // Generate some example data
    let n_samples = 500;
    let n_features = 10;
    let n_classes = 4;
    println!(
        "\n{} {} {} {} {} {}",
        colorize("Generating", Color::BrightGreen),
        colorize(n_samples.to_string(), Color::BrightYellow),
        colorize("samples with", Color::BrightGreen),
        colorize(n_features.to_string(), Color::BrightYellow),
        colorize("features for", Color::BrightGreen),
        colorize(n_classes.to_string(), Color::BrightYellow),
    );

    // Create a deterministic RNG for reproducibility
    let mut rng = SmallRng::from_seed([42; 32]);

    // 1. Confusion Matrix Example
    println!(
        "\n{}",
        stylize("1. CONFUSION MATRIX VISUALIZATION", Style::Bold)
    );
    // Generate random predictions and true labels
    let y_true = Array::from_shape_fn(n_samples, |_| rng.random_range(0..n_classes));
    // Create slightly correlated predictions (not completely random)
    let y_pred = Array::from_shape_fn(n_samples, |i| {
        if rng.random::<f32>() < 0.7 {
            // 70% chance of correct prediction
            y_true[i]
        } else {
            // 30% chance of random class
            rng.random_range(0..n_classes)
        }
    });
    // Create confusion matrix
    let class_labels = vec![
        "Class A".to_string(),
        "Class B".to_string(),
        "Class C".to_string(),
        "Class D".to_string(),
    ];
    let cm = ConfusionMatrix::<f32>::new(
        &y_true.view(),
        &y_pred.view(),
        Some(n_classes),
        Some(class_labels),
    )?;
    // Print raw and normalized confusion matrices with color
    println!("\n{}", colorize("Raw Confusion Matrix:", Color::BrightCyan));
    println!(
        "{}",
        cm.to_ascii_with_options(Some("Confusion Matrix"), false, &color_options)
    );
    println!(
        "\n{}",
        colorize("Normalized Confusion Matrix:", Color::BrightCyan)
    );
    println!(
        "{}",
        cm.to_ascii_with_options(Some("Normalized Confusion Matrix"), true, &color_options)
    );
    // Print metrics
    println!(
        "\n{} {:.3}",
        colorize("Overall Accuracy:", Color::BrightMagenta),
        cm.accuracy()
    );
    let precision = cm.precision();
    let recall = cm.recall();
    let f1 = cm.f1_score();
    println!("{}", colorize("Per-class metrics:", Color::BrightMagenta));
    for i in 0..n_classes {
        println!(
            "  {}: {}={:.3}, {}={:.3}, {}={:.3}",
            colorize(format!("Class {i}"), Color::BrightYellow),
            colorize("Precision", Color::BrightCyan),
            precision[i],
            colorize("Recall", Color::BrightGreen),
            recall[i],
            colorize("F1", Color::BrightBlue),
            f1[i]
        );
    }
    println!(
        "{} {:.3}",
        colorize("Macro F1 Score:", Color::BrightMagenta),
        cm.macro_f1()
    );
    // 2. Feature Importance Visualization
    println!(
        "{}",
        stylize("2. FEATURE IMPORTANCE VISUALIZATION", Style::Bold)
    );
    // Generate random feature importance scores
    let feature_names = (0..n_features)
        .map(|i| format!("Feature_{i}"))
        .collect::<Vec<String>>();
    let importance = Array1::from_shape_fn(n_features, |i| {
        // Make some features more important than others
        let base = (n_features - i) as f32 / n_features as f32;
        base + 0.2 * rng.random::<f32>()
    });

    let fi = FeatureImportance::new(feature_names, importance)?;

    // Print full feature importance with color
    println!(
        "{}",
        fi.to_ascii_with_options(Some("Feature Importance"), 60, None, &color_options)
    );

    // Print top-5 features with color
    println!(
        "{}",
        colorize("Top 5 Most Important Features:", Color::BrightCyan)
    );
    println!(
        "{}",
        fi.to_ascii_with_options(Some("Top 5 Features"), 60, Some(5), &color_options)
    );
    // 3. ROC Curve for Binary Classification
    println!("\n{}", stylize("3. ROC CURVE VISUALIZATION", Style::Bold));
    // Generate binary classification data
    let n_binary = 200;
    let y_true_binary = Array::from_shape_fn(n_binary, |_| rng.random_range(0..2));
    // Generate scores with some predictive power
    let y_scores = Array1::from_shape_fn(n_binary, |i| {
        if y_true_binary[i] == 1 {
            // Higher scores for positive class
            0.6 + 0.4 * rng.random::<f32>()
        } else {
            // Lower scores for negative class
            0.4 * rng.random::<f32>()
        }
    });

    let roc = ROCCurve::new(&y_true_binary.view(), &y_scores.view())?;
    println!(
        "{}: {:.3}",
        colorize("ROC AUC:", Color::BrightMagenta),
        roc.auc
    );
    println!("\n{}", roc.to_ascii(None, 50, 20));

    // 4. Learning Curve Visualization
    println!(
        "\n{}",
        stylize("4. LEARNING CURVE VISUALIZATION", Style::Bold)
    );
    // Generate learning curve data
    let n_points = 10;
    let n_cv = 5;
    let train_sizes = Array1::from_shape_fn(n_points, |i| 50 + i * 50);
    // Generate training scores (decreasing with size due to overfitting)
    let train_scores = Array2::from_shape_fn((n_points, n_cv), |(i, _)| {
        0.95 - 0.05 * (i as f32 / n_points as f32) + 0.03 * rng.random::<f32>()
    });

    // Generate validation scores (increasing with size)
    let val_scores = Array2::from_shape_fn((n_points, n_cv), |(i, _)| {
        0.7 + 0.2 * (i as f32 / n_points as f32) + 0.05 * rng.random::<f32>()
    });

    let lc = LearningCurve::new(train_sizes, train_scores, val_scores)?;
    println!("{}", lc.to_ascii(None, 60, 20, "Accuracy"));

    // Print final message with color
    println!(
        "{}",
        colorize(
            "Model evaluation visualizations completed successfully!",
            Color::BrightGreen
        )
    );
    Ok(())
}

pub fn recall(&self) -> Array1<F>

Calculate recall for each class

Examples found in repository

examples/colored_eval_visualization.rs (line 91)

fn main() -> Result<()> {
    println!(
        "{}",
        stylize("Neural Network Model Evaluation with Color", Style::Bold)
    );
    println!("{}", "-".repeat(50));
    // Set up color options
    let color_options = ColorOptions {
        enabled: true,
        use_background: false,
        use_bright: true,
    };
    // Generate some example data
    let n_samples = 500;
    let n_features = 10;
    let n_classes = 4;
    println!(
        "\n{} {} {} {} {} {}",
        colorize("Generating", Color::BrightGreen),
        colorize(n_samples.to_string(), Color::BrightYellow),
        colorize("samples with", Color::BrightGreen),
        colorize(n_features.to_string(), Color::BrightYellow),
        colorize("features for", Color::BrightGreen),
        colorize(n_classes.to_string(), Color::BrightYellow),
    );

    // Create a deterministic RNG for reproducibility
    let mut rng = SmallRng::from_seed([42; 32]);

    // 1. Confusion Matrix Example
    println!(
        "\n{}",
        stylize("1. CONFUSION MATRIX VISUALIZATION", Style::Bold)
    );
    // Generate random predictions and true labels
    let y_true = Array::from_shape_fn(n_samples, |_| rng.random_range(0..n_classes));
    // Create slightly correlated predictions (not completely random)
    let y_pred = Array::from_shape_fn(n_samples, |i| {
        if rng.random::<f32>() < 0.7 {
            // 70% chance of correct prediction
            y_true[i]
        } else {
            // 30% chance of random class
            rng.random_range(0..n_classes)
        }
    });
    // Create confusion matrix
    let class_labels = vec![
        "Class A".to_string(),
        "Class B".to_string(),
        "Class C".to_string(),
        "Class D".to_string(),
    ];
    let cm = ConfusionMatrix::<f32>::new(
        &y_true.view(),
        &y_pred.view(),
        Some(n_classes),
        Some(class_labels),
    )?;
    // Print raw and normalized confusion matrices with color
    println!("\n{}", colorize("Raw Confusion Matrix:", Color::BrightCyan));
    println!(
        "{}",
        cm.to_ascii_with_options(Some("Confusion Matrix"), false, &color_options)
    );
    println!(
        "\n{}",
        colorize("Normalized Confusion Matrix:", Color::BrightCyan)
    );
    println!(
        "{}",
        cm.to_ascii_with_options(Some("Normalized Confusion Matrix"), true, &color_options)
    );
    // Print metrics
    println!(
        "\n{} {:.3}",
        colorize("Overall Accuracy:", Color::BrightMagenta),
        cm.accuracy()
    );
    let precision = cm.precision();
    let recall = cm.recall();
    let f1 = cm.f1_score();
    println!("{}", colorize("Per-class metrics:", Color::BrightMagenta));
    for i in 0..n_classes {
        println!(
            "  {}: {}={:.3}, {}={:.3}, {}={:.3}",
            colorize(format!("Class {i}"), Color::BrightYellow),
            colorize("Precision", Color::BrightCyan),
            precision[i],
            colorize("Recall", Color::BrightGreen),
            recall[i],
            colorize("F1", Color::BrightBlue),
            f1[i]
        );
    }
    println!(
        "{} {:.3}",
        colorize("Macro F1 Score:", Color::BrightMagenta),
        cm.macro_f1()
    );
    // 2. Feature Importance Visualization
    println!(
        "{}",
        stylize("2. FEATURE IMPORTANCE VISUALIZATION", Style::Bold)
    );
    // Generate random feature importance scores
    let feature_names = (0..n_features)
        .map(|i| format!("Feature_{i}"))
        .collect::<Vec<String>>();
    let importance = Array1::from_shape_fn(n_features, |i| {
        // Make some features more important than others
        let base = (n_features - i) as f32 / n_features as f32;
        base + 0.2 * rng.random::<f32>()
    });

    let fi = FeatureImportance::new(feature_names, importance)?;

    // Print full feature importance with color
    println!(
        "{}",
        fi.to_ascii_with_options(Some("Feature Importance"), 60, None, &color_options)
    );

    // Print top-5 features with color
    println!(
        "{}",
        colorize("Top 5 Most Important Features:", Color::BrightCyan)
    );
    println!(
        "{}",
        fi.to_ascii_with_options(Some("Top 5 Features"), 60, Some(5), &color_options)
    );
    // 3. ROC Curve for Binary Classification
    println!("\n{}", stylize("3. ROC CURVE VISUALIZATION", Style::Bold));
    // Generate binary classification data
    let n_binary = 200;
    let y_true_binary = Array::from_shape_fn(n_binary, |_| rng.random_range(0..2));
    // Generate scores with some predictive power
    let y_scores = Array1::from_shape_fn(n_binary, |i| {
        if y_true_binary[i] == 1 {
            // Higher scores for positive class
            0.6 + 0.4 * rng.random::<f32>()
        } else {
            // Lower scores for negative class
            0.4 * rng.random::<f32>()
        }
    });

    let roc = ROCCurve::new(&y_true_binary.view(), &y_scores.view())?;
    println!(
        "{}: {:.3}",
        colorize("ROC AUC:", Color::BrightMagenta),
        roc.auc
    );
    println!("\n{}", roc.to_ascii(None, 50, 20));

    // 4. Learning Curve Visualization
    println!(
        "\n{}",
        stylize("4. LEARNING CURVE VISUALIZATION", Style::Bold)
    );
    // Generate learning curve data
    let n_points = 10;
    let n_cv = 5;
    let train_sizes = Array1::from_shape_fn(n_points, |i| 50 + i * 50);
    // Generate training scores (decreasing with size due to overfitting)
    let train_scores = Array2::from_shape_fn((n_points, n_cv), |(i, _)| {
        0.95 - 0.05 * (i as f32 / n_points as f32) + 0.03 * rng.random::<f32>()
    });

    // Generate validation scores (increasing with size)
    let val_scores = Array2::from_shape_fn((n_points, n_cv), |(i, _)| {
        0.7 + 0.2 * (i as f32 / n_points as f32) + 0.05 * rng.random::<f32>()
    });

    let lc = LearningCurve::new(train_sizes, train_scores, val_scores)?;
    println!("{}", lc.to_ascii(None, 60, 20, "Accuracy"));

    // Print final message with color
    println!(
        "{}",
        colorize(
            "Model evaluation visualizations completed successfully!",
            Color::BrightGreen
        )
    );
    Ok(())
}

pub fn f1_score(&self) -> Array1<F>

Calculate F1 score for each class

Examples found in repository

examples/colored_eval_visualization.rs (line 92)

fn main() -> Result<()> {
    println!(
        "{}",
        stylize("Neural Network Model Evaluation with Color", Style::Bold)
    );
    println!("{}", "-".repeat(50));
    // Set up color options
    let color_options = ColorOptions {
        enabled: true,
        use_background: false,
        use_bright: true,
    };
    // Generate some example data
    let n_samples = 500;
    let n_features = 10;
    let n_classes = 4;
    println!(
        "\n{} {} {} {} {} {}",
        colorize("Generating", Color::BrightGreen),
        colorize(n_samples.to_string(), Color::BrightYellow),
        colorize("samples with", Color::BrightGreen),
        colorize(n_features.to_string(), Color::BrightYellow),
        colorize("features for", Color::BrightGreen),
        colorize(n_classes.to_string(), Color::BrightYellow),
    );

    // Create a deterministic RNG for reproducibility
    let mut rng = SmallRng::from_seed([42; 32]);

    // 1. Confusion Matrix Example
    println!(
        "\n{}",
        stylize("1. CONFUSION MATRIX VISUALIZATION", Style::Bold)
    );
    // Generate random predictions and true labels
    let y_true = Array::from_shape_fn(n_samples, |_| rng.random_range(0..n_classes));
    // Create slightly correlated predictions (not completely random)
    let y_pred = Array::from_shape_fn(n_samples, |i| {
        if rng.random::<f32>() < 0.7 {
            // 70% chance of correct prediction
            y_true[i]
        } else {
            // 30% chance of random class
            rng.random_range(0..n_classes)
        }
    });
    // Create confusion matrix
    let class_labels = vec![
        "Class A".to_string(),
        "Class B".to_string(),
        "Class C".to_string(),
        "Class D".to_string(),
    ];
    let cm = ConfusionMatrix::<f32>::new(
        &y_true.view(),
        &y_pred.view(),
        Some(n_classes),
        Some(class_labels),
    )?;
    // Print raw and normalized confusion matrices with color
    println!("\n{}", colorize("Raw Confusion Matrix:", Color::BrightCyan));
    println!(
        "{}",
        cm.to_ascii_with_options(Some("Confusion Matrix"), false, &color_options)
    );
    println!(
        "\n{}",
        colorize("Normalized Confusion Matrix:", Color::BrightCyan)
    );
    println!(
        "{}",
        cm.to_ascii_with_options(Some("Normalized Confusion Matrix"), true, &color_options)
    );
    // Print metrics
    println!(
        "\n{} {:.3}",
        colorize("Overall Accuracy:", Color::BrightMagenta),
        cm.accuracy()
    );
    let precision = cm.precision();
    let recall = cm.recall();
    let f1 = cm.f1_score();
    println!("{}", colorize("Per-class metrics:", Color::BrightMagenta));
    for i in 0..n_classes {
        println!(
            "  {}: {}={:.3}, {}={:.3}, {}={:.3}",
            colorize(format!("Class {i}"), Color::BrightYellow),
            colorize("Precision", Color::BrightCyan),
            precision[i],
            colorize("Recall", Color::BrightGreen),
            recall[i],
            colorize("F1", Color::BrightBlue),
            f1[i]
        );
    }
    println!(
        "{} {:.3}",
        colorize("Macro F1 Score:", Color::BrightMagenta),
        cm.macro_f1()
    );
    // 2. Feature Importance Visualization
    println!(
        "{}",
        stylize("2. FEATURE IMPORTANCE VISUALIZATION", Style::Bold)
    );
    // Generate random feature importance scores
    let feature_names = (0..n_features)
        .map(|i| format!("Feature_{i}"))
        .collect::<Vec<String>>();
    let importance = Array1::from_shape_fn(n_features, |i| {
        // Make some features more important than others
        let base = (n_features - i) as f32 / n_features as f32;
        base + 0.2 * rng.random::<f32>()
    });

    let fi = FeatureImportance::new(feature_names, importance)?;

    // Print full feature importance with color
    println!(
        "{}",
        fi.to_ascii_with_options(Some("Feature Importance"), 60, None, &color_options)
    );

    // Print top-5 features with color
    println!(
        "{}",
        colorize("Top 5 Most Important Features:", Color::BrightCyan)
    );
    println!(
        "{}",
        fi.to_ascii_with_options(Some("Top 5 Features"), 60, Some(5), &color_options)
    );
    // 3. ROC Curve for Binary Classification
    println!("\n{}", stylize("3. ROC CURVE VISUALIZATION", Style::Bold));
    // Generate binary classification data
    let n_binary = 200;
    let y_true_binary = Array::from_shape_fn(n_binary, |_| rng.random_range(0..2));
    // Generate scores with some predictive power
    let y_scores = Array1::from_shape_fn(n_binary, |i| {
        if y_true_binary[i] == 1 {
            // Higher scores for positive class
            0.6 + 0.4 * rng.random::<f32>()
        } else {
            // Lower scores for negative class
            0.4 * rng.random::<f32>()
        }
    });

    let roc = ROCCurve::new(&y_true_binary.view(), &y_scores.view())?;
    println!(
        "{}: {:.3}",
        colorize("ROC AUC:", Color::BrightMagenta),
        roc.auc
    );
    println!("\n{}", roc.to_ascii(None, 50, 20));

    // 4. Learning Curve Visualization
    println!(
        "\n{}",
        stylize("4. LEARNING CURVE VISUALIZATION", Style::Bold)
    );
    // Generate learning curve data
    let n_points = 10;
    let n_cv = 5;
    let train_sizes = Array1::from_shape_fn(n_points, |i| 50 + i * 50);
    // Generate training scores (decreasing with size due to overfitting)
    let train_scores = Array2::from_shape_fn((n_points, n_cv), |(i, _)| {
        0.95 - 0.05 * (i as f32 / n_points as f32) + 0.03 * rng.random::<f32>()
    });

    // Generate validation scores (increasing with size)
    let val_scores = Array2::from_shape_fn((n_points, n_cv), |(i, _)| {
        0.7 + 0.2 * (i as f32 / n_points as f32) + 0.05 * rng.random::<f32>()
    });

    let lc = LearningCurve::new(train_sizes, train_scores, val_scores)?;
    println!("{}", lc.to_ascii(None, 60, 20, "Accuracy"));

    // Print final message with color
    println!(
        "{}",
        colorize(
            "Model evaluation visualizations completed successfully!",
            Color::BrightGreen
        )
    );
    Ok(())
}

pub fn macro_f1(&self) -> F

Calculate macro-averaged F1 score

Examples found in repository

examples/colored_eval_visualization.rs (line 109)

fn main() -> Result<()> {
    println!(
        "{}",
        stylize("Neural Network Model Evaluation with Color", Style::Bold)
    );
    println!("{}", "-".repeat(50));
    // Set up color options
    let color_options = ColorOptions {
        enabled: true,
        use_background: false,
        use_bright: true,
    };
    // Generate some example data
    let n_samples = 500;
    let n_features = 10;
    let n_classes = 4;
    println!(
        "\n{} {} {} {} {} {}",
        colorize("Generating", Color::BrightGreen),
        colorize(n_samples.to_string(), Color::BrightYellow),
        colorize("samples with", Color::BrightGreen),
        colorize(n_features.to_string(), Color::BrightYellow),
        colorize("features for", Color::BrightGreen),
        colorize(n_classes.to_string(), Color::BrightYellow),
    );

    // Create a deterministic RNG for reproducibility
    let mut rng = SmallRng::from_seed([42; 32]);

    // 1. Confusion Matrix Example
    println!(
        "\n{}",
        stylize("1. CONFUSION MATRIX VISUALIZATION", Style::Bold)
    );
    // Generate random predictions and true labels
    let y_true = Array::from_shape_fn(n_samples, |_| rng.random_range(0..n_classes));
    // Create slightly correlated predictions (not completely random)
    let y_pred = Array::from_shape_fn(n_samples, |i| {
        if rng.random::<f32>() < 0.7 {
            // 70% chance of correct prediction
            y_true[i]
        } else {
            // 30% chance of random class
            rng.random_range(0..n_classes)
        }
    });
    // Create confusion matrix
    let class_labels = vec![
        "Class A".to_string(),
        "Class B".to_string(),
        "Class C".to_string(),
        "Class D".to_string(),
    ];
    let cm = ConfusionMatrix::<f32>::new(
        &y_true.view(),
        &y_pred.view(),
        Some(n_classes),
        Some(class_labels),
    )?;
    // Print raw and normalized confusion matrices with color
    println!("\n{}", colorize("Raw Confusion Matrix:", Color::BrightCyan));
    println!(
        "{}",
        cm.to_ascii_with_options(Some("Confusion Matrix"), false, &color_options)
    );
    println!(
        "\n{}",
        colorize("Normalized Confusion Matrix:", Color::BrightCyan)
    );
    println!(
        "{}",
        cm.to_ascii_with_options(Some("Normalized Confusion Matrix"), true, &color_options)
    );
    // Print metrics
    println!(
        "\n{} {:.3}",
        colorize("Overall Accuracy:", Color::BrightMagenta),
        cm.accuracy()
    );
    let precision = cm.precision();
    let recall = cm.recall();
    let f1 = cm.f1_score();
    println!("{}", colorize("Per-class metrics:", Color::BrightMagenta));
    for i in 0..n_classes {
        println!(
            "  {}: {}={:.3}, {}={:.3}, {}={:.3}",
            colorize(format!("Class {i}"), Color::BrightYellow),
            colorize("Precision", Color::BrightCyan),
            precision[i],
            colorize("Recall", Color::BrightGreen),
            recall[i],
            colorize("F1", Color::BrightBlue),
            f1[i]
        );
    }
    println!(
        "{} {:.3}",
        colorize("Macro F1 Score:", Color::BrightMagenta),
        cm.macro_f1()
    );
    // 2. Feature Importance Visualization
    println!(
        "{}",
        stylize("2. FEATURE IMPORTANCE VISUALIZATION", Style::Bold)
    );
    // Generate random feature importance scores
    let feature_names = (0..n_features)
        .map(|i| format!("Feature_{i}"))
        .collect::<Vec<String>>();
    let importance = Array1::from_shape_fn(n_features, |i| {
        // Make some features more important than others
        let base = (n_features - i) as f32 / n_features as f32;
        base + 0.2 * rng.random::<f32>()
    });

    let fi = FeatureImportance::new(feature_names, importance)?;

    // Print full feature importance with color
    println!(
        "{}",
        fi.to_ascii_with_options(Some("Feature Importance"), 60, None, &color_options)
    );

    // Print top-5 features with color
    println!(
        "{}",
        colorize("Top 5 Most Important Features:", Color::BrightCyan)
    );
    println!(
        "{}",
        fi.to_ascii_with_options(Some("Top 5 Features"), 60, Some(5), &color_options)
    );
    // 3. ROC Curve for Binary Classification
    println!("\n{}", stylize("3. ROC CURVE VISUALIZATION", Style::Bold));
    // Generate binary classification data
    let n_binary = 200;
    let y_true_binary = Array::from_shape_fn(n_binary, |_| rng.random_range(0..2));
    // Generate scores with some predictive power
    let y_scores = Array1::from_shape_fn(n_binary, |i| {
        if y_true_binary[i] == 1 {
            // Higher scores for positive class
            0.6 + 0.4 * rng.random::<f32>()
        } else {
            // Lower scores for negative class
            0.4 * rng.random::<f32>()
        }
    });

    let roc = ROCCurve::new(&y_true_binary.view(), &y_scores.view())?;
    println!(
        "{}: {:.3}",
        colorize("ROC AUC:", Color::BrightMagenta),
        roc.auc
    );
    println!("\n{}", roc.to_ascii(None, 50, 20));

    // 4. Learning Curve Visualization
    println!(
        "\n{}",
        stylize("4. LEARNING CURVE VISUALIZATION", Style::Bold)
    );
    // Generate learning curve data
    let n_points = 10;
    let n_cv = 5;
    let train_sizes = Array1::from_shape_fn(n_points, |i| 50 + i * 50);
    // Generate training scores (decreasing with size due to overfitting)
    let train_scores = Array2::from_shape_fn((n_points, n_cv), |(i, _)| {
        0.95 - 0.05 * (i as f32 / n_points as f32) + 0.03 * rng.random::<f32>()
    });

    // Generate validation scores (increasing with size)
    let val_scores = Array2::from_shape_fn((n_points, n_cv), |(i, _)| {
        0.7 + 0.2 * (i as f32 / n_points as f32) + 0.05 * rng.random::<f32>()
    });

    let lc = LearningCurve::new(train_sizes, train_scores, val_scores)?;
    println!("{}", lc.to_ascii(None, 60, 20, "Accuracy"));

    // Print final message with color
    println!(
        "{}",
        colorize(
            "Model evaluation visualizations completed successfully!",
            Color::BrightGreen
        )
    );
    Ok(())
}

pub fn class_metrics(&self) -> HashMap<String, Vec<F>>

Get class-wise metrics as a HashMap

pub fn to_ascii(&self, title: Option<&str>, normalized: bool) -> String

Convert the confusion matrix to an ASCII representation

Examples found in repository

examples/error_pattern_heatmap.rs (line 56)

fn main() {
    // Create a reproducible random number generator
    let mut rng = SmallRng::from_seed([42; 32]);
    // Generate synthetic multiclass classification data with specific error patterns
    let num_classes = 5;
    // Create confusion matrix with controlled error patterns
    let mut matrix = vec![vec![0; num_classes]; num_classes];
    // Set diagonal elements (correct classifications) with high values
    #[allow(clippy::needless_range_loop)]
    for i in 0..num_classes {
        matrix[i][i] = 70 + rng.random_range(0..15); // 70-85 correct per class
    }
    // Create specific error patterns:
    // - Classes 0 and 1 often confused
    matrix[0][1] = 25;
    matrix[1][0] = 15;
    // - Class 2 sometimes confused with Class 3
    matrix[2][3] = 18;
    // - Class 4 has some misclassifications to all other classes
    matrix[4][0] = 8;
    matrix[4][1] = 5;
    matrix[4][2] = 10;
    matrix[4][3] = 12;
    // - Some minor errors scattered about
    #[allow(clippy::needless_range_loop)]
    for i in 0..num_classes {
        for j in 0..num_classes {
            if i != j && matrix[i][j] == 0 {
                matrix[i][j] = rng.random_range(0..5);
            }
        }
    }
    // Convert to ndarray
    let flat_matrix: Vec<f64> = matrix.iter().flatten().map(|&x| x as f64).collect();
    let ndarray_matrix =
        scirs2_core::ndarray::Array::from_shape_vec((num_classes, num_classes), flat_matrix)
            .unwrap();
    // Create class labels
    let class_labels = vec![
        "Class A".to_string(),
        "Class B".to_string(),
        "Class C".to_string(),
        "Class D".to_string(),
        "Class E".to_string(),
    ];
    // Create confusion matrix
    let cm = ConfusionMatrix::from_matrix(ndarray_matrix, Some(class_labels)).unwrap();
    // Example 1: Standard confusion matrix
    println!("Example 1: Standard Confusion Matrix\n");
    let regular_output = cm.to_ascii(Some("Classification Results"), false);
    println!("{regular_output}");
    // Example 2: Normal heatmap
    println!("\n\nExample 2: Standard Heatmap Visualization\n");
    let color_options = ColorOptions {
        enabled: true,
        use_bright: true,
        use_background: false,
    };
    let heatmap_output = cm.to_heatmap_with_options(
        Some("Classification Heatmap"),
        true, // normalized
        &color_options,
    );
    println!("{heatmap_output}");
    // Example 3: Error pattern heatmap
    println!("\n\nExample 3: Error Pattern Heatmap (highlighting misclassifications)\n");
    let error_heatmap = cm.error_heatmap(Some("Misclassification Analysis"));
    println!("{error_heatmap}");
}

examples/confusion_matrix_heatmap.rs (line 61)

fn main() {
    // Create a reproducible random number generator
    let mut rng = SmallRng::from_seed([42; 32]);
    // Generate synthetic multiclass classification data
    let num_classes = 5;
    let n_samples = 500;
    // Generate true labels (0 to num_classes-1)
    let mut y_true = Vec::with_capacity(n_samples);
    for _ in 0..n_samples {
        y_true.push(rng.random_range(0..num_classes));
    }
    // Generate predicted labels with controlled accuracy
    let mut y_pred = Vec::with_capacity(n_samples);
    for &true_label in &y_true {
        // 80% chance to predict correctly..20% chance of error
        if rng.random::<f64>() < 0.8 {
            y_pred.push(true_label);
        } else {
            // When wrong, tend to predict adjacent classes more often
            let mut pred = true_label;
            while pred == true_label {
                // Generate error that's more likely to be close to true label
                let error_margin = (rng.random::<f64>() * 2.0).round() as usize; // 0, 1, or 2
                if rng.random::<bool>() {
                    pred = (true_label + error_margin) % num_classes;
                } else {
                    pred = (true_label + num_classes - error_margin) % num_classes;
                }
            }
            y_pred.push(pred);
        }
    }
    // Convert to ndarray arrays
    let y_true_array = Array1::from(y_true);
    let y_pred_array = Array1::from(y_pred);
    // Create class labels
    let class_labels = vec![
        "Cat".to_string(),
        "Dog".to_string(),
        "Bird".to_string(),
        "Fish".to_string(),
        "Rabbit".to_string(),
    ];
    // Create confusion matrix
    let cm = ConfusionMatrix::<f64>::new(
        &y_true_array.view(),
        &y_pred_array.view(),
        Some(num_classes),
        Some(class_labels),
    )
    .unwrap();
    // Example 1: Standard confusion matrix
    println!("Example 1: Standard Confusion Matrix\n");
    let regular_output = cm.to_ascii(Some("Animal Classification Results"), false);
    println!("{regular_output}");
    // Example 2: Confusion matrix with color
    println!("\n\nExample 2: Colored Confusion Matrix\n");
    let color_options = ColorOptions {
        enabled: true,
        use_bright: true,
        use_background: false,
    };
    let colored_output = cm.to_ascii_with_options(
        Some("Animal Classification Results (with color)"),
        false,
        &color_options,
    );
    println!("{colored_output}");
    // Example 3: Normalized confusion matrix heatmap
    println!("\n\nExample 3: Normalized Confusion Matrix Heatmap\n");
    let heatmap_output = cm.to_heatmap_with_options(
        Some("Animal Classification Heatmap (normalized)"),
        true, // normalized
        &color_options,
    );
    println!("{heatmap_output}");

    // Example 4: Raw counts heatmap
    println!("\n\nExample 4: Raw Counts Confusion Matrix Heatmap\n");
    let raw_heatmap = cm.to_heatmap_with_options(
        Some("Animal Classification Heatmap (raw counts)"),
        false, // not normalized
        &color_options,
    );
    println!("{raw_heatmap}");
}

pub fn to_ascii_with_options( &self, title: Option<&str>, normalized: bool, color_options: &ColorOptions, ) -> String

Convert the confusion matrix to an ASCII representation with color options

Examples found in repository

examples/confusion_matrix_heatmap.rs (lines 70-74)

fn main() {
    // Create a reproducible random number generator
    let mut rng = SmallRng::from_seed([42; 32]);
    // Generate synthetic multiclass classification data
    let num_classes = 5;
    let n_samples = 500;
    // Generate true labels (0 to num_classes-1)
    let mut y_true = Vec::with_capacity(n_samples);
    for _ in 0..n_samples {
        y_true.push(rng.random_range(0..num_classes));
    }
    // Generate predicted labels with controlled accuracy
    let mut y_pred = Vec::with_capacity(n_samples);
    for &true_label in &y_true {
        // 80% chance to predict correctly..20% chance of error
        if rng.random::<f64>() < 0.8 {
            y_pred.push(true_label);
        } else {
            // When wrong, tend to predict adjacent classes more often
            let mut pred = true_label;
            while pred == true_label {
                // Generate error that's more likely to be close to true label
                let error_margin = (rng.random::<f64>() * 2.0).round() as usize; // 0, 1, or 2
                if rng.random::<bool>() {
                    pred = (true_label + error_margin) % num_classes;
                } else {
                    pred = (true_label + num_classes - error_margin) % num_classes;
                }
            }
            y_pred.push(pred);
        }
    }
    // Convert to ndarray arrays
    let y_true_array = Array1::from(y_true);
    let y_pred_array = Array1::from(y_pred);
    // Create class labels
    let class_labels = vec![
        "Cat".to_string(),
        "Dog".to_string(),
        "Bird".to_string(),
        "Fish".to_string(),
        "Rabbit".to_string(),
    ];
    // Create confusion matrix
    let cm = ConfusionMatrix::<f64>::new(
        &y_true_array.view(),
        &y_pred_array.view(),
        Some(num_classes),
        Some(class_labels),
    )
    .unwrap();
    // Example 1: Standard confusion matrix
    println!("Example 1: Standard Confusion Matrix\n");
    let regular_output = cm.to_ascii(Some("Animal Classification Results"), false);
    println!("{regular_output}");
    // Example 2: Confusion matrix with color
    println!("\n\nExample 2: Colored Confusion Matrix\n");
    let color_options = ColorOptions {
        enabled: true,
        use_bright: true,
        use_background: false,
    };
    let colored_output = cm.to_ascii_with_options(
        Some("Animal Classification Results (with color)"),
        false,
        &color_options,
    );
    println!("{colored_output}");
    // Example 3: Normalized confusion matrix heatmap
    println!("\n\nExample 3: Normalized Confusion Matrix Heatmap\n");
    let heatmap_output = cm.to_heatmap_with_options(
        Some("Animal Classification Heatmap (normalized)"),
        true, // normalized
        &color_options,
    );
    println!("{heatmap_output}");

    // Example 4: Raw counts heatmap
    println!("\n\nExample 4: Raw Counts Confusion Matrix Heatmap\n");
    let raw_heatmap = cm.to_heatmap_with_options(
        Some("Animal Classification Heatmap (raw counts)"),
        false, // not normalized
        &color_options,
    );
    println!("{raw_heatmap}");
}

examples/colored_eval_visualization.rs (line 74)

fn main() -> Result<()> {
    println!(
        "{}",
        stylize("Neural Network Model Evaluation with Color", Style::Bold)
    );
    println!("{}", "-".repeat(50));
    // Set up color options
    let color_options = ColorOptions {
        enabled: true,
        use_background: false,
        use_bright: true,
    };
    // Generate some example data
    let n_samples = 500;
    let n_features = 10;
    let n_classes = 4;
    println!(
        "\n{} {} {} {} {} {}",
        colorize("Generating", Color::BrightGreen),
        colorize(n_samples.to_string(), Color::BrightYellow),
        colorize("samples with", Color::BrightGreen),
        colorize(n_features.to_string(), Color::BrightYellow),
        colorize("features for", Color::BrightGreen),
        colorize(n_classes.to_string(), Color::BrightYellow),
    );

    // Create a deterministic RNG for reproducibility
    let mut rng = SmallRng::from_seed([42; 32]);

    // 1. Confusion Matrix Example
    println!(
        "\n{}",
        stylize("1. CONFUSION MATRIX VISUALIZATION", Style::Bold)
    );
    // Generate random predictions and true labels
    let y_true = Array::from_shape_fn(n_samples, |_| rng.random_range(0..n_classes));
    // Create slightly correlated predictions (not completely random)
    let y_pred = Array::from_shape_fn(n_samples, |i| {
        if rng.random::<f32>() < 0.7 {
            // 70% chance of correct prediction
            y_true[i]
        } else {
            // 30% chance of random class
            rng.random_range(0..n_classes)
        }
    });
    // Create confusion matrix
    let class_labels = vec![
        "Class A".to_string(),
        "Class B".to_string(),
        "Class C".to_string(),
        "Class D".to_string(),
    ];
    let cm = ConfusionMatrix::<f32>::new(
        &y_true.view(),
        &y_pred.view(),
        Some(n_classes),
        Some(class_labels),
    )?;
    // Print raw and normalized confusion matrices with color
    println!("\n{}", colorize("Raw Confusion Matrix:", Color::BrightCyan));
    println!(
        "{}",
        cm.to_ascii_with_options(Some("Confusion Matrix"), false, &color_options)
    );
    println!(
        "\n{}",
        colorize("Normalized Confusion Matrix:", Color::BrightCyan)
    );
    println!(
        "{}",
        cm.to_ascii_with_options(Some("Normalized Confusion Matrix"), true, &color_options)
    );
    // Print metrics
    println!(
        "\n{} {:.3}",
        colorize("Overall Accuracy:", Color::BrightMagenta),
        cm.accuracy()
    );
    let precision = cm.precision();
    let recall = cm.recall();
    let f1 = cm.f1_score();
    println!("{}", colorize("Per-class metrics:", Color::BrightMagenta));
    for i in 0..n_classes {
        println!(
            "  {}: {}={:.3}, {}={:.3}, {}={:.3}",
            colorize(format!("Class {i}"), Color::BrightYellow),
            colorize("Precision", Color::BrightCyan),
            precision[i],
            colorize("Recall", Color::BrightGreen),
            recall[i],
            colorize("F1", Color::BrightBlue),
            f1[i]
        );
    }
    println!(
        "{} {:.3}",
        colorize("Macro F1 Score:", Color::BrightMagenta),
        cm.macro_f1()
    );
    // 2. Feature Importance Visualization
    println!(
        "{}",
        stylize("2. FEATURE IMPORTANCE VISUALIZATION", Style::Bold)
    );
    // Generate random feature importance scores
    let feature_names = (0..n_features)
        .map(|i| format!("Feature_{i}"))
        .collect::<Vec<String>>();
    let importance = Array1::from_shape_fn(n_features, |i| {
        // Make some features more important than others
        let base = (n_features - i) as f32 / n_features as f32;
        base + 0.2 * rng.random::<f32>()
    });

    let fi = FeatureImportance::new(feature_names, importance)?;

    // Print full feature importance with color
    println!(
        "{}",
        fi.to_ascii_with_options(Some("Feature Importance"), 60, None, &color_options)
    );

    // Print top-5 features with color
    println!(
        "{}",
        colorize("Top 5 Most Important Features:", Color::BrightCyan)
    );
    println!(
        "{}",
        fi.to_ascii_with_options(Some("Top 5 Features"), 60, Some(5), &color_options)
    );
    // 3. ROC Curve for Binary Classification
    println!("\n{}", stylize("3. ROC CURVE VISUALIZATION", Style::Bold));
    // Generate binary classification data
    let n_binary = 200;
    let y_true_binary = Array::from_shape_fn(n_binary, |_| rng.random_range(0..2));
    // Generate scores with some predictive power
    let y_scores = Array1::from_shape_fn(n_binary, |i| {
        if y_true_binary[i] == 1 {
            // Higher scores for positive class
            0.6 + 0.4 * rng.random::<f32>()
        } else {
            // Lower scores for negative class
            0.4 * rng.random::<f32>()
        }
    });

    let roc = ROCCurve::new(&y_true_binary.view(), &y_scores.view())?;
    println!(
        "{}: {:.3}",
        colorize("ROC AUC:", Color::BrightMagenta),
        roc.auc
    );
    println!("\n{}", roc.to_ascii(None, 50, 20));

    // 4. Learning Curve Visualization
    println!(
        "\n{}",
        stylize("4. LEARNING CURVE VISUALIZATION", Style::Bold)
    );
    // Generate learning curve data
    let n_points = 10;
    let n_cv = 5;
    let train_sizes = Array1::from_shape_fn(n_points, |i| 50 + i * 50);
    // Generate training scores (decreasing with size due to overfitting)
    let train_scores = Array2::from_shape_fn((n_points, n_cv), |(i, _)| {
        0.95 - 0.05 * (i as f32 / n_points as f32) + 0.03 * rng.random::<f32>()
    });

    // Generate validation scores (increasing with size)
    let val_scores = Array2::from_shape_fn((n_points, n_cv), |(i, _)| {
        0.7 + 0.2 * (i as f32 / n_points as f32) + 0.05 * rng.random::<f32>()
    });

    let lc = LearningCurve::new(train_sizes, train_scores, val_scores)?;
    println!("{}", lc.to_ascii(None, 60, 20, "Accuracy"));

    // Print final message with color
    println!(
        "{}",
        colorize(
            "Model evaluation visualizations completed successfully!",
            Color::BrightGreen
        )
    );
    Ok(())
}

pub fn to_heatmap(&self, title: Option<&str>, normalized: bool) -> String

Convert the confusion matrix to a heatmap visualization This creates a colorful heatmap visualization of the confusion matrix where cell colors represent the intensity of values using a detailed color gradient.

Arguments

• title - Optional title for the heatmap
• normalized - Whether to normalize the matrix (row values sum to 1)

Returns

• String - ASCII heatmap representation

pub fn error_heatmap(&self, title: Option<&str>) -> String

Create a confusion matrix heatmap that focuses on misclassification patterns This visualization is specialized to highlight where the model makes mistakes, with emphasis on the off-diagonal elements to help identify error patterns.

The key features of this visualization are:

• Diagonal elements (correct classifications) are de-emphasized with dim styling
• Off-diagonal elements (errors) are highlighted with a color gradient
• Colors are normalized relative to the maximum off-diagonal value
• A specialized legend explains error intensity levels

Arguments

• title - Optional title for the error heatmap

Returns

• String - ASCII error pattern heatmap

Example

use scirs2_core::ndarray::Array1;
use scirs2_neural::utils::ConfusionMatrix;
// Create some example data
let y_true = Array1::from_vec(vec![0, 1, 2, 0, 1, 2, 0, 1, 2, 0]);
let y_pred = Array1::from_vec(vec![0, 1, 1, 0, 1, 2, 1, 1, 0, 0]);
let class_labels = vec!["Class A".to_string(), "Class B".to_string(), "Class C".to_string()];
let cm = ConfusionMatrix::<f32>::new(&y_true.view(), &y_pred.view(), None, Some(class_labels)).unwrap();
// Generate the error pattern heatmap
let error_viz = cm.error_heatmap(Some("Misclassification Analysis"));
println!("{}", error_viz);

Examples found in repository

examples/error_pattern_heatmap.rs (line 73)

fn main() {
    // Create a reproducible random number generator
    let mut rng = SmallRng::from_seed([42; 32]);
    // Generate synthetic multiclass classification data with specific error patterns
    let num_classes = 5;
    // Create confusion matrix with controlled error patterns
    let mut matrix = vec![vec![0; num_classes]; num_classes];
    // Set diagonal elements (correct classifications) with high values
    #[allow(clippy::needless_range_loop)]
    for i in 0..num_classes {
        matrix[i][i] = 70 + rng.random_range(0..15); // 70-85 correct per class
    }
    // Create specific error patterns:
    // - Classes 0 and 1 often confused
    matrix[0][1] = 25;
    matrix[1][0] = 15;
    // - Class 2 sometimes confused with Class 3
    matrix[2][3] = 18;
    // - Class 4 has some misclassifications to all other classes
    matrix[4][0] = 8;
    matrix[4][1] = 5;
    matrix[4][2] = 10;
    matrix[4][3] = 12;
    // - Some minor errors scattered about
    #[allow(clippy::needless_range_loop)]
    for i in 0..num_classes {
        for j in 0..num_classes {
            if i != j && matrix[i][j] == 0 {
                matrix[i][j] = rng.random_range(0..5);
            }
        }
    }
    // Convert to ndarray
    let flat_matrix: Vec<f64> = matrix.iter().flatten().map(|&x| x as f64).collect();
    let ndarray_matrix =
        scirs2_core::ndarray::Array::from_shape_vec((num_classes, num_classes), flat_matrix)
            .unwrap();
    // Create class labels
    let class_labels = vec![
        "Class A".to_string(),
        "Class B".to_string(),
        "Class C".to_string(),
        "Class D".to_string(),
        "Class E".to_string(),
    ];
    // Create confusion matrix
    let cm = ConfusionMatrix::from_matrix(ndarray_matrix, Some(class_labels)).unwrap();
    // Example 1: Standard confusion matrix
    println!("Example 1: Standard Confusion Matrix\n");
    let regular_output = cm.to_ascii(Some("Classification Results"), false);
    println!("{regular_output}");
    // Example 2: Normal heatmap
    println!("\n\nExample 2: Standard Heatmap Visualization\n");
    let color_options = ColorOptions {
        enabled: true,
        use_bright: true,
        use_background: false,
    };
    let heatmap_output = cm.to_heatmap_with_options(
        Some("Classification Heatmap"),
        true, // normalized
        &color_options,
    );
    println!("{heatmap_output}");
    // Example 3: Error pattern heatmap
    println!("\n\nExample 3: Error Pattern Heatmap (highlighting misclassifications)\n");
    let error_heatmap = cm.error_heatmap(Some("Misclassification Analysis"));
    println!("{error_heatmap}");
}

pub fn to_heatmap_with_options( &self, title: Option<&str>, normalized: bool, color_options: &ColorOptions, ) -> String

Convert the confusion matrix to a heatmap visualization with customizable options

Arguments

• title - Optional title for the heatmap
• normalized - Whether to normalize the matrix
• color_options - Color options for visualization

Returns

• String - ASCII heatmap representation with colors

Examples found in repository

examples/error_pattern_heatmap.rs (lines 65-69)

fn main() {
    // Create a reproducible random number generator
    let mut rng = SmallRng::from_seed([42; 32]);
    // Generate synthetic multiclass classification data with specific error patterns
    let num_classes = 5;
    // Create confusion matrix with controlled error patterns
    let mut matrix = vec![vec![0; num_classes]; num_classes];
    // Set diagonal elements (correct classifications) with high values
    #[allow(clippy::needless_range_loop)]
    for i in 0..num_classes {
        matrix[i][i] = 70 + rng.random_range(0..15); // 70-85 correct per class
    }
    // Create specific error patterns:
    // - Classes 0 and 1 often confused
    matrix[0][1] = 25;
    matrix[1][0] = 15;
    // - Class 2 sometimes confused with Class 3
    matrix[2][3] = 18;
    // - Class 4 has some misclassifications to all other classes
    matrix[4][0] = 8;
    matrix[4][1] = 5;
    matrix[4][2] = 10;
    matrix[4][3] = 12;
    // - Some minor errors scattered about
    #[allow(clippy::needless_range_loop)]
    for i in 0..num_classes {
        for j in 0..num_classes {
            if i != j && matrix[i][j] == 0 {
                matrix[i][j] = rng.random_range(0..5);
            }
        }
    }
    // Convert to ndarray
    let flat_matrix: Vec<f64> = matrix.iter().flatten().map(|&x| x as f64).collect();
    let ndarray_matrix =
        scirs2_core::ndarray::Array::from_shape_vec((num_classes, num_classes), flat_matrix)
            .unwrap();
    // Create class labels
    let class_labels = vec![
        "Class A".to_string(),
        "Class B".to_string(),
        "Class C".to_string(),
        "Class D".to_string(),
        "Class E".to_string(),
    ];
    // Create confusion matrix
    let cm = ConfusionMatrix::from_matrix(ndarray_matrix, Some(class_labels)).unwrap();
    // Example 1: Standard confusion matrix
    println!("Example 1: Standard Confusion Matrix\n");
    let regular_output = cm.to_ascii(Some("Classification Results"), false);
    println!("{regular_output}");
    // Example 2: Normal heatmap
    println!("\n\nExample 2: Standard Heatmap Visualization\n");
    let color_options = ColorOptions {
        enabled: true,
        use_bright: true,
        use_background: false,
    };
    let heatmap_output = cm.to_heatmap_with_options(
        Some("Classification Heatmap"),
        true, // normalized
        &color_options,
    );
    println!("{heatmap_output}");
    // Example 3: Error pattern heatmap
    println!("\n\nExample 3: Error Pattern Heatmap (highlighting misclassifications)\n");
    let error_heatmap = cm.error_heatmap(Some("Misclassification Analysis"));
    println!("{error_heatmap}");
}

examples/confusion_matrix_heatmap.rs (lines 78-82)

fn main() {
    // Create a reproducible random number generator
    let mut rng = SmallRng::from_seed([42; 32]);
    // Generate synthetic multiclass classification data
    let num_classes = 5;
    let n_samples = 500;
    // Generate true labels (0 to num_classes-1)
    let mut y_true = Vec::with_capacity(n_samples);
    for _ in 0..n_samples {
        y_true.push(rng.random_range(0..num_classes));
    }
    // Generate predicted labels with controlled accuracy
    let mut y_pred = Vec::with_capacity(n_samples);
    for &true_label in &y_true {
        // 80% chance to predict correctly..20% chance of error
        if rng.random::<f64>() < 0.8 {
            y_pred.push(true_label);
        } else {
            // When wrong, tend to predict adjacent classes more often
            let mut pred = true_label;
            while pred == true_label {
                // Generate error that's more likely to be close to true label
                let error_margin = (rng.random::<f64>() * 2.0).round() as usize; // 0, 1, or 2
                if rng.random::<bool>() {
                    pred = (true_label + error_margin) % num_classes;
                } else {
                    pred = (true_label + num_classes - error_margin) % num_classes;
                }
            }
            y_pred.push(pred);
        }
    }
    // Convert to ndarray arrays
    let y_true_array = Array1::from(y_true);
    let y_pred_array = Array1::from(y_pred);
    // Create class labels
    let class_labels = vec![
        "Cat".to_string(),
        "Dog".to_string(),
        "Bird".to_string(),
        "Fish".to_string(),
        "Rabbit".to_string(),
    ];
    // Create confusion matrix
    let cm = ConfusionMatrix::<f64>::new(
        &y_true_array.view(),
        &y_pred_array.view(),
        Some(num_classes),
        Some(class_labels),
    )
    .unwrap();
    // Example 1: Standard confusion matrix
    println!("Example 1: Standard Confusion Matrix\n");
    let regular_output = cm.to_ascii(Some("Animal Classification Results"), false);
    println!("{regular_output}");
    // Example 2: Confusion matrix with color
    println!("\n\nExample 2: Colored Confusion Matrix\n");
    let color_options = ColorOptions {
        enabled: true,
        use_bright: true,
        use_background: false,
    };
    let colored_output = cm.to_ascii_with_options(
        Some("Animal Classification Results (with color)"),
        false,
        &color_options,
    );
    println!("{colored_output}");
    // Example 3: Normalized confusion matrix heatmap
    println!("\n\nExample 3: Normalized Confusion Matrix Heatmap\n");
    let heatmap_output = cm.to_heatmap_with_options(
        Some("Animal Classification Heatmap (normalized)"),
        true, // normalized
        &color_options,
    );
    println!("{heatmap_output}");

    // Example 4: Raw counts heatmap
    println!("\n\nExample 4: Raw Counts Confusion Matrix Heatmap\n");
    let raw_heatmap = cm.to_heatmap_with_options(
        Some("Animal Classification Heatmap (raw counts)"),
        false, // not normalized
        &color_options,
    );
    println!("{raw_heatmap}");
}

Trait Implementations

impl<F: Clone + Float + Debug + Display> Clone for ConfusionMatrix<F>

fn clone(&self) -> ConfusionMatrix<F>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F: Debug + Float + Debug + Display> Debug for ConfusionMatrix<F>

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

Formats the value using the given formatter.