Struct LearningCurve

pub struct LearningCurve<F: Float + Debug + Display> {
    pub train_sizes: Array1<usize>,
    pub train_scores: Array2<F>,
    pub val_scores: Array2<F>,
    pub train_mean: Array1<F>,
    pub train_std: Array1<F>,
    pub val_mean: Array1<F>,
    pub val_std: Array1<F>,
}

Learning curve data structure for visualizing model performance

This structure represents learning curves that show how model performance changes as the training set size increases, comparing training and validation metrics to help diagnose overfitting, underfitting, and other training issues.

Fields

train_sizes: Array1<usize>

Training set sizes used for evaluation

train_scores: Array2<F>

Training scores for each size and fold (rows=sizes, cols=folds)

val_scores: Array2<F>

Validation scores for each size and fold (rows=sizes, cols=folds)

train_mean: Array1<F>

Mean training scores across folds

train_std: Array1<F>

Standard deviation of training scores

val_mean: Array1<F>

Mean validation scores across folds

val_std: Array1<F>

Standard deviation of validation scores

Implementations

impl<F: Float + Debug + Display + FromPrimitive> LearningCurve<F>

pub fn new( train_sizes: Array1<usize>, train_scores: Array2<F>, val_scores: Array2<F>, ) -> Result<Self>

Create a new learning curve from training and validation scores

Arguments

• train_sizes - Array of training set sizes
• train_scores - 2D array of training scores (rows=sizes, cols=cv folds)
• val_scores - 2D array of validation scores (rows=sizes, cols=cv folds)

Returns

• Result<LearningCurve<F>> - Learning curve data

Example

use ndarray::{Array1, Array2};
use scirs2_neural::utils::evaluation::LearningCurve;

// Create sample data
let train_sizes = Array1::from_vec(vec![100, 200, 300, 400, 500]);
let train_scores = Array2::from_shape_vec((5, 3), vec![
    0.6, 0.62, 0.58,    // 100 samples, 3 folds
    0.7, 0.72, 0.68,    // 200 samples, 3 folds
    0.8, 0.78, 0.79,    // 300 samples, 3 folds
    0.85, 0.83, 0.84,   // 400 samples, 3 folds
    0.87, 0.88, 0.86,   // 500 samples, 3 folds
]).unwrap();
let val_scores = Array2::from_shape_vec((5, 3), vec![
    0.55, 0.53, 0.54,   // 100 samples, 3 folds
    0.65, 0.63, 0.64,   // 200 samples, 3 folds
    0.75, 0.73, 0.74,   // 300 samples, 3 folds
    0.76, 0.74, 0.75,   // 400 samples, 3 folds
    0.77, 0.76, 0.76,   // 500 samples, 3 folds
]).unwrap();

// Create learning curve
let curve = LearningCurve::<f64>::new(train_sizes, train_scores, val_scores).unwrap();

Examples found in repository

examples/colored_curve_visualization.rs (line 79)

fn main() {
    // Create a reproducible random number generator
    let mut rng = SmallRng::seed_from_u64(42);

    // Example 1: ROC Curve with color
    println!("Example 1: ROC Curve Visualization (with color)\n");

    // Generate synthetic binary classification data
    let n_samples = 200;

    // Generate true labels: 0 or 1
    let y_true: Vec<usize> = (0..n_samples)
        .map(|_| if rng.random::<f64>() > 0.5 { 1 } else { 0 })
        .collect();

    // Generate scores with some separability
    let y_score: Vec<f64> = y_true
        .iter()
        .map(|&label| {
            if label == 1 {
                0.7 + 0.3 * rng.sample::<f64, _>(StandardNormal)
            } else {
                0.3 + 0.3 * rng.sample::<f64, _>(StandardNormal)
            }
        })
        .collect();

    // Convert to ndarray views
    let y_true_array = Array1::from(y_true.clone());
    let y_score_array = Array1::from(y_score.clone());

    // Create ROC curve
    let roc = ROCCurve::new(&y_true_array.view(), &y_score_array.view()).unwrap();

    // Enable color options
    let color_options = ColorOptions {
        enabled: true,
        use_bright: true,
        use_background: false,
    };

    // Plot ROC curve with color
    let roc_plot = roc.to_ascii_with_options(
        Some("Binary Classification ROC Curve"),
        60,
        20,
        &color_options,
    );
    println!("{}", roc_plot);

    // Example 2: Learning Curve with color
    println!("\nExample 2: Learning Curve Visualization (with color)\n");

    // Simulate learning curves for different training set sizes
    let train_sizes = Array1::from(vec![100, 200, 300, 400, 500]);

    // Simulated training scores for each size (5 sizes, 3 CV folds)
    let train_scores = Array2::from_shape_fn((5, 3), |(i, _j)| {
        let base = 0.5 + 0.4 * (i as f64 / 4.0);
        let noise = 0.05 * rng.sample::<f64, _>(StandardNormal);
        base + noise
    });

    // Simulated validation scores (typically lower than training)
    let val_scores = Array2::from_shape_fn((5, 3), |(i, _j)| {
        let base = 0.4 + 0.3 * (i as f64 / 4.0);
        let noise = 0.07 * rng.sample::<f64, _>(StandardNormal);
        base + noise
    });

    // Create learning curve
    let learning_curve = LearningCurve::new(train_sizes, train_scores, val_scores).unwrap();

    // Plot learning curve with color
    let learning_plot = learning_curve.to_ascii_with_options(
        Some("Neural Network Training"),
        70,
        20,
        "Accuracy",
        &color_options,
    );
    println!("{}", learning_plot);
}

examples/model_visualization_example.rs (line 144)

fn main() -> Result<()> {
    println!("Neural Network Model Evaluation Visualization Example\n");

    // Generate some example data
    let n_samples = 500;
    let n_features = 10;
    let n_classes = 4;

    println!(
        "Generating {} samples with {} features for {} classes",
        n_samples, n_features, n_classes
    );

    // 1. Confusion Matrix Example
    println!("\n--- Confusion Matrix Visualization ---\n");

    // Create a deterministic RNG for reproducibility
    let mut rng = SmallRng::seed_from_u64(42);

    // 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
    println!("Raw Confusion Matrix:\n");
    println!("{}", cm.to_ascii(Some("Confusion Matrix"), false));

    println!("\nNormalized Confusion Matrix:\n");
    println!("{}", cm.to_ascii(Some("Normalized Confusion Matrix"), true));

    // Print metrics
    println!("\nAccuracy: {:.3}", cm.accuracy());

    let precision = cm.precision();
    let recall = cm.recall();
    let f1 = cm.f1_score();

    println!("Per-class metrics:");
    for i in 0..n_classes {
        println!(
            "  Class {}: Precision={:.3}, Recall={:.3}, F1={:.3}",
            i, precision[i], recall[i], f1[i]
        );
    }

    println!("Macro F1 Score: {:.3}", cm.macro_f1());

    // 2. Feature Importance Visualization
    println!("\n--- Feature Importance Visualization ---\n");

    // 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
    println!("{}", fi.to_ascii(Some("Feature Importance"), 60, None));

    // Print top-5 features
    println!("\nTop 5 Most Important Features:\n");
    println!("{}", fi.to_ascii(Some("Top 5 Features"), 60, Some(5)));

    // 3. ROC Curve for Binary Classification
    println!("\n--- ROC Curve Visualization ---\n");

    // 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!("ROC AUC: {:.3}", roc.auc);
    println!("\n{}", roc.to_ascii(None, 50, 20));

    // 4. Learning Curve Visualization
    println!("\n--- Learning Curve Visualization ---\n");

    // 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
    println!("\nModel evaluation visualizations completed successfully!");

    Ok(())
}

examples/colored_eval_visualization.rs (line 209)

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::seed_from_u64(42);

    // 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!(
        "\n{}",
        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!(
        "\n{}",
        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!(
        "\n{}",
        colorize(
            "Model evaluation visualizations completed successfully!",
            Color::BrightGreen
        )
    );

    Ok(())
}

pub fn to_ascii( &self, title: Option<&str>, width: usize, height: usize, metric_name: &str, ) -> String

Create an ASCII line plot of the learning curve

Arguments

• title - Optional title for the plot
• width - Width of the plot
• height - Height of the plot
• metric_name - Name of the metric (e.g., “Accuracy”)

Returns

• String - ASCII line plot

Examples found in repository

examples/model_visualization_example.rs (line 146)

fn main() -> Result<()> {
    println!("Neural Network Model Evaluation Visualization Example\n");

    // Generate some example data
    let n_samples = 500;
    let n_features = 10;
    let n_classes = 4;

    println!(
        "Generating {} samples with {} features for {} classes",
        n_samples, n_features, n_classes
    );

    // 1. Confusion Matrix Example
    println!("\n--- Confusion Matrix Visualization ---\n");

    // Create a deterministic RNG for reproducibility
    let mut rng = SmallRng::seed_from_u64(42);

    // 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
    println!("Raw Confusion Matrix:\n");
    println!("{}", cm.to_ascii(Some("Confusion Matrix"), false));

    println!("\nNormalized Confusion Matrix:\n");
    println!("{}", cm.to_ascii(Some("Normalized Confusion Matrix"), true));

    // Print metrics
    println!("\nAccuracy: {:.3}", cm.accuracy());

    let precision = cm.precision();
    let recall = cm.recall();
    let f1 = cm.f1_score();

    println!("Per-class metrics:");
    for i in 0..n_classes {
        println!(
            "  Class {}: Precision={:.3}, Recall={:.3}, F1={:.3}",
            i, precision[i], recall[i], f1[i]
        );
    }

    println!("Macro F1 Score: {:.3}", cm.macro_f1());

    // 2. Feature Importance Visualization
    println!("\n--- Feature Importance Visualization ---\n");

    // 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
    println!("{}", fi.to_ascii(Some("Feature Importance"), 60, None));

    // Print top-5 features
    println!("\nTop 5 Most Important Features:\n");
    println!("{}", fi.to_ascii(Some("Top 5 Features"), 60, Some(5)));

    // 3. ROC Curve for Binary Classification
    println!("\n--- ROC Curve Visualization ---\n");

    // 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!("ROC AUC: {:.3}", roc.auc);
    println!("\n{}", roc.to_ascii(None, 50, 20));

    // 4. Learning Curve Visualization
    println!("\n--- Learning Curve Visualization ---\n");

    // 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
    println!("\nModel evaluation visualizations completed successfully!");

    Ok(())
}

examples/colored_eval_visualization.rs (line 211)

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::seed_from_u64(42);

    // 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!(
        "\n{}",
        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!(
        "\n{}",
        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!(
        "\n{}",
        colorize(
            "Model evaluation visualizations completed successfully!",
            Color::BrightGreen
        )
    );

    Ok(())
}

pub fn to_ascii_with_options( &self, title: Option<&str>, width: usize, height: usize, metric_name: &str, color_options: &ColorOptions, ) -> String

Create an ASCII line plot of the learning curve with customizable colors

This method allows fine-grained control over the color scheme using the provided ColorOptions parameter.

Arguments

• title - Optional title for the plot
• width - Width of the plot
• height - Height of the plot
• metric_name - Name of the metric (e.g., “Accuracy”)
• color_options - Color options for visualization

Returns

• String - ASCII line plot with colors

Examples found in repository

examples/colored_curve_visualization.rs (lines 82-88)

fn main() {
    // Create a reproducible random number generator
    let mut rng = SmallRng::seed_from_u64(42);

    // Example 1: ROC Curve with color
    println!("Example 1: ROC Curve Visualization (with color)\n");

    // Generate synthetic binary classification data
    let n_samples = 200;

    // Generate true labels: 0 or 1
    let y_true: Vec<usize> = (0..n_samples)
        .map(|_| if rng.random::<f64>() > 0.5 { 1 } else { 0 })
        .collect();

    // Generate scores with some separability
    let y_score: Vec<f64> = y_true
        .iter()
        .map(|&label| {
            if label == 1 {
                0.7 + 0.3 * rng.sample::<f64, _>(StandardNormal)
            } else {
                0.3 + 0.3 * rng.sample::<f64, _>(StandardNormal)
            }
        })
        .collect();

    // Convert to ndarray views
    let y_true_array = Array1::from(y_true.clone());
    let y_score_array = Array1::from(y_score.clone());

    // Create ROC curve
    let roc = ROCCurve::new(&y_true_array.view(), &y_score_array.view()).unwrap();

    // Enable color options
    let color_options = ColorOptions {
        enabled: true,
        use_bright: true,
        use_background: false,
    };

    // Plot ROC curve with color
    let roc_plot = roc.to_ascii_with_options(
        Some("Binary Classification ROC Curve"),
        60,
        20,
        &color_options,
    );
    println!("{}", roc_plot);

    // Example 2: Learning Curve with color
    println!("\nExample 2: Learning Curve Visualization (with color)\n");

    // Simulate learning curves for different training set sizes
    let train_sizes = Array1::from(vec![100, 200, 300, 400, 500]);

    // Simulated training scores for each size (5 sizes, 3 CV folds)
    let train_scores = Array2::from_shape_fn((5, 3), |(i, _j)| {
        let base = 0.5 + 0.4 * (i as f64 / 4.0);
        let noise = 0.05 * rng.sample::<f64, _>(StandardNormal);
        base + noise
    });

    // Simulated validation scores (typically lower than training)
    let val_scores = Array2::from_shape_fn((5, 3), |(i, _j)| {
        let base = 0.4 + 0.3 * (i as f64 / 4.0);
        let noise = 0.07 * rng.sample::<f64, _>(StandardNormal);
        base + noise
    });

    // Create learning curve
    let learning_curve = LearningCurve::new(train_sizes, train_scores, val_scores).unwrap();

    // Plot learning curve with color
    let learning_plot = learning_curve.to_ascii_with_options(
        Some("Neural Network Training"),
        70,
        20,
        "Accuracy",
        &color_options,
    );
    println!("{}", learning_plot);
}