Struct FeatureImportance

pub struct FeatureImportance<F: Float + Debug + Display> {
    pub feature_names: Vec<String>,
    pub importance: Array1<F>,
}

Feature importance visualization for machine learning models

This struct facilitates the visualization and analysis of feature importance scores from machine learning models, helping to identify which features contribute most to predictions.

Fields

feature_names: Vec<String>

Names of the features

importance: Array1<F>

Importance scores for each feature

Implementations

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

pub fn new(feature_names: Vec<String>, importance: Array1<F>) -> Result<Self>

Create a new feature importance visualization

Arguments

• feature_names - Names of features
• importance - Importance scores

Returns

• Result<FeatureImportance<F>> - The feature importance visualization

Example

use ndarray::Array1;
use scirs2_neural::utils::evaluation::FeatureImportance;

// Create feature names and importance scores
let feature_names = vec![
    "Age".to_string(),
    "Income".to_string(),
    "Education".to_string(),
    "Location".to_string()
];
let importance = Array1::from_vec(vec![0.35, 0.25, 0.20, 0.10]);

// Create feature importance visualization
let feature_importance = FeatureImportance::<f64>::new(feature_names, importance).unwrap();

Examples found in repository

examples/model_visualization_example.rs (line 93)

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 141)

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 top_k(&self, k: usize) -> (Vec<String>, Array1<F>)

Get the top-k most important features

Arguments

• k - Number of top features to return

Returns

• (Vec<String>, Array1<F>) - Feature names and importance scores

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

Create an ASCII bar chart of feature importance

Arguments

• title - Optional title for the chart
• width - Width of the bar chart
• k - Number of top features to include (None for all)

Returns

• String - ASCII bar chart

Examples found in repository

examples/model_visualization_example.rs (line 96)

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(())
}

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

Create an ASCII bar chart of feature importance with color options

This method creates a bar chart visualization with customizable colors, showing feature importance scores in descending order.

Arguments

• title - Optional title for the chart
• width - Width of the bar chart
• k - Number of top features to include (None for all)
• color_options - Color options for visualization

Returns

• String - ASCII bar chart with colors

Examples found in repository

examples/colored_eval_visualization.rs (line 146)

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(())
}