Struct ModelInterpreter

pub struct ModelInterpreter<F: Float + Debug + 'static + ScalarOperand + FromPrimitive + Sum + Clone + Copy> { /* private fields */ }

Model interpreter for analyzing neural network decisions

This is the main orchestrator for all interpretation methods. It manages:

• Attribution method registration and dispatch
• Layer activation and gradient caching
• Integration between different interpretation techniques
• Unified interface for model analysis

Implementations

impl<F: Float + Debug + 'static + ScalarOperand + FromPrimitive + Sum + Clone + Copy> ModelInterpreter<F>

pub fn new() -> Self

Create a new model interpreter

Examples found in repository

examples/neural_advanced_features.rs (line 360)

fn demonstrate_model_interpretation() -> Result<()> {
    println!("🔍 Model Interpretation Demonstration");
    println!("====================================\n");

    // Create model interpreter
    let mut interpreter = ModelInterpreter::<f64>::new();

    // Add attribution methods
    interpreter.add_attribution_method(AttributionMethod::Saliency);
    interpreter.add_attribution_method(AttributionMethod::IntegratedGradients {
        baseline: BaselineMethod::Zero,
        num_steps: 50,
    });

    // Simulate input data and gradients
    let input = Array2::from_shape_fn((2, 10), |(i, j)| (i as f64 + j as f64) / 10.0).into_dyn();

    let gradients =
        Array2::from_shape_fn((2, 10), |(i, j)| ((i + j) as f64 / 20.0).sin()).into_dyn();

    // Cache gradients for attribution computation
    interpreter.cache_gradients("input_gradient".to_string(), gradients.clone());

    println!("1. Computing feature attributions...");
    println!("   Input shape: {:?}", input.shape());

    // Compute saliency attribution
    let saliency =
        interpreter.compute_attribution(&AttributionMethod::Saliency, &input, Some(1))?;
    println!("   Saliency attribution shape: {:?}", saliency.shape());

    // Compute integrated gradients
    let integrated_grad = interpreter.compute_attribution(
        &AttributionMethod::IntegratedGradients {
            baseline: BaselineMethod::Zero,
            num_steps: 50,
        },
        &input,
        Some(1),
    )?;
    println!(
        "   Integrated gradients shape: {:?}",
        integrated_grad.shape()
    );

    // Analyze layer activations
    println!("\n2. Analyzing layer activations...");
    let _layer_activations = Array2::from_shape_fn((20, 64), |(i, j)| {
        if (i + j) % 7 == 0 {
            0.0
        } else {
            ((i * j) as f64 / 100.0).tanh()
        }
    })
    .into_dyn();

    interpreter.analyze_layer_activations("conv_layer")?;

    if let Some(stats) = interpreter.layer_statistics().get("conv_layer") {
        println!("   Layer statistics:");
        println!("     Mean activation: {:.4}", stats.mean_activation);
        println!("     Std activation: {:.4}", stats.std_activation);
        println!("     Sparsity: {:.1}%", stats.sparsity);
        println!("     Dead neurons: {:.1}%", stats.dead_neuron_percentage);
    }

    // Generate comprehensive interpretation report
    println!("\n3. Generating interpretation report...");
    let report = interpreter.generate_report(&input)?;
    println!("{}", report);

    println!("✅ Model interpretation demonstration completed!\n");
    Ok(())
}

pub fn add_attribution_method(&mut self, method: AttributionMethod)

Add an attribution method to the interpreter

Examples found in repository

examples/neural_advanced_features.rs (line 363)

fn demonstrate_model_interpretation() -> Result<()> {
    println!("🔍 Model Interpretation Demonstration");
    println!("====================================\n");

    // Create model interpreter
    let mut interpreter = ModelInterpreter::<f64>::new();

    // Add attribution methods
    interpreter.add_attribution_method(AttributionMethod::Saliency);
    interpreter.add_attribution_method(AttributionMethod::IntegratedGradients {
        baseline: BaselineMethod::Zero,
        num_steps: 50,
    });

    // Simulate input data and gradients
    let input = Array2::from_shape_fn((2, 10), |(i, j)| (i as f64 + j as f64) / 10.0).into_dyn();

    let gradients =
        Array2::from_shape_fn((2, 10), |(i, j)| ((i + j) as f64 / 20.0).sin()).into_dyn();

    // Cache gradients for attribution computation
    interpreter.cache_gradients("input_gradient".to_string(), gradients.clone());

    println!("1. Computing feature attributions...");
    println!("   Input shape: {:?}", input.shape());

    // Compute saliency attribution
    let saliency =
        interpreter.compute_attribution(&AttributionMethod::Saliency, &input, Some(1))?;
    println!("   Saliency attribution shape: {:?}", saliency.shape());

    // Compute integrated gradients
    let integrated_grad = interpreter.compute_attribution(
        &AttributionMethod::IntegratedGradients {
            baseline: BaselineMethod::Zero,
            num_steps: 50,
        },
        &input,
        Some(1),
    )?;
    println!(
        "   Integrated gradients shape: {:?}",
        integrated_grad.shape()
    );

    // Analyze layer activations
    println!("\n2. Analyzing layer activations...");
    let _layer_activations = Array2::from_shape_fn((20, 64), |(i, j)| {
        if (i + j) % 7 == 0 {
            0.0
        } else {
            ((i * j) as f64 / 100.0).tanh()
        }
    })
    .into_dyn();

    interpreter.analyze_layer_activations("conv_layer")?;

    if let Some(stats) = interpreter.layer_statistics().get("conv_layer") {
        println!("   Layer statistics:");
        println!("     Mean activation: {:.4}", stats.mean_activation);
        println!("     Std activation: {:.4}", stats.std_activation);
        println!("     Sparsity: {:.1}%", stats.sparsity);
        println!("     Dead neurons: {:.1}%", stats.dead_neuron_percentage);
    }

    // Generate comprehensive interpretation report
    println!("\n3. Generating interpretation report...");
    let report = interpreter.generate_report(&input)?;
    println!("{}", report);

    println!("✅ Model interpretation demonstration completed!\n");
    Ok(())
}

pub fn cache_activations(&mut self, layer_name: String, activations: ArrayD<F>)

Cache layer activations for later analysis

pub fn cache_gradients(&mut self, layer_name: String, gradients: ArrayD<F>)

Cache layer gradients for attribution computation

Examples found in repository

examples/neural_advanced_features.rs (line 376)

fn demonstrate_model_interpretation() -> Result<()> {
    println!("🔍 Model Interpretation Demonstration");
    println!("====================================\n");

    // Create model interpreter
    let mut interpreter = ModelInterpreter::<f64>::new();

    // Add attribution methods
    interpreter.add_attribution_method(AttributionMethod::Saliency);
    interpreter.add_attribution_method(AttributionMethod::IntegratedGradients {
        baseline: BaselineMethod::Zero,
        num_steps: 50,
    });

    // Simulate input data and gradients
    let input = Array2::from_shape_fn((2, 10), |(i, j)| (i as f64 + j as f64) / 10.0).into_dyn();

    let gradients =
        Array2::from_shape_fn((2, 10), |(i, j)| ((i + j) as f64 / 20.0).sin()).into_dyn();

    // Cache gradients for attribution computation
    interpreter.cache_gradients("input_gradient".to_string(), gradients.clone());

    println!("1. Computing feature attributions...");
    println!("   Input shape: {:?}", input.shape());

    // Compute saliency attribution
    let saliency =
        interpreter.compute_attribution(&AttributionMethod::Saliency, &input, Some(1))?;
    println!("   Saliency attribution shape: {:?}", saliency.shape());

    // Compute integrated gradients
    let integrated_grad = interpreter.compute_attribution(
        &AttributionMethod::IntegratedGradients {
            baseline: BaselineMethod::Zero,
            num_steps: 50,
        },
        &input,
        Some(1),
    )?;
    println!(
        "   Integrated gradients shape: {:?}",
        integrated_grad.shape()
    );

    // Analyze layer activations
    println!("\n2. Analyzing layer activations...");
    let _layer_activations = Array2::from_shape_fn((20, 64), |(i, j)| {
        if (i + j) % 7 == 0 {
            0.0
        } else {
            ((i * j) as f64 / 100.0).tanh()
        }
    })
    .into_dyn();

    interpreter.analyze_layer_activations("conv_layer")?;

    if let Some(stats) = interpreter.layer_statistics().get("conv_layer") {
        println!("   Layer statistics:");
        println!("     Mean activation: {:.4}", stats.mean_activation);
        println!("     Std activation: {:.4}", stats.std_activation);
        println!("     Sparsity: {:.1}%", stats.sparsity);
        println!("     Dead neurons: {:.1}%", stats.dead_neuron_percentage);
    }

    // Generate comprehensive interpretation report
    println!("\n3. Generating interpretation report...");
    let report = interpreter.generate_report(&input)?;
    println!("{}", report);

    println!("✅ Model interpretation demonstration completed!\n");
    Ok(())
}

pub fn get_cached_activations(&self, layer_name: &str) -> Option<&ArrayD<F>>

Get cached activations for a layer

pub fn get_cached_gradients(&self, layer_name: &str) -> Option<&ArrayD<F>>

Get cached gradients for a layer

pub fn clear_caches(&mut self)

Clear all caches

pub fn attribution_methods(&self) -> &[AttributionMethod]

Get available attribution methods

pub fn has_layer_data(&self, layer_name: &str) -> bool

Check if a specific layer has cached data

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

Get all cached layer names

pub fn set_counterfactual_generator( &mut self, generator: CounterfactualGenerator<F>, )

Set the counterfactual generator

pub fn counterfactual_generator(&self) -> Option<&CounterfactualGenerator<F>>

Get the counterfactual generator

pub fn set_lime_explainer(&mut self, explainer: LIMEExplainer<F>)

Set the LIME explainer

pub fn lime_explainer(&self) -> Option<&LIMEExplainer<F>>

Get the LIME explainer

pub fn set_attention_visualizer(&mut self, visualizer: AttentionVisualizer<F>)

Set the attention visualizer

pub fn attention_visualizer(&self) -> Option<&AttentionVisualizer<F>>

Get the attention visualizer

pub fn add_concept_vector( &mut self, name: String, vector: ConceptActivationVector<F>, )

Add concept activation vector

pub fn get_concept_vector( &self, name: &str, ) -> Option<&ConceptActivationVector<F>>

Get concept activation vector

pub fn layer_statistics(&self) -> &HashMap<String, LayerAnalysisStats<F>>

Get layer statistics

Examples found in repository

examples/neural_advanced_features.rs (line 413)

fn demonstrate_model_interpretation() -> Result<()> {
    println!("🔍 Model Interpretation Demonstration");
    println!("====================================\n");

    // Create model interpreter
    let mut interpreter = ModelInterpreter::<f64>::new();

    // Add attribution methods
    interpreter.add_attribution_method(AttributionMethod::Saliency);
    interpreter.add_attribution_method(AttributionMethod::IntegratedGradients {
        baseline: BaselineMethod::Zero,
        num_steps: 50,
    });

    // Simulate input data and gradients
    let input = Array2::from_shape_fn((2, 10), |(i, j)| (i as f64 + j as f64) / 10.0).into_dyn();

    let gradients =
        Array2::from_shape_fn((2, 10), |(i, j)| ((i + j) as f64 / 20.0).sin()).into_dyn();

    // Cache gradients for attribution computation
    interpreter.cache_gradients("input_gradient".to_string(), gradients.clone());

    println!("1. Computing feature attributions...");
    println!("   Input shape: {:?}", input.shape());

    // Compute saliency attribution
    let saliency =
        interpreter.compute_attribution(&AttributionMethod::Saliency, &input, Some(1))?;
    println!("   Saliency attribution shape: {:?}", saliency.shape());

    // Compute integrated gradients
    let integrated_grad = interpreter.compute_attribution(
        &AttributionMethod::IntegratedGradients {
            baseline: BaselineMethod::Zero,
            num_steps: 50,
        },
        &input,
        Some(1),
    )?;
    println!(
        "   Integrated gradients shape: {:?}",
        integrated_grad.shape()
    );

    // Analyze layer activations
    println!("\n2. Analyzing layer activations...");
    let _layer_activations = Array2::from_shape_fn((20, 64), |(i, j)| {
        if (i + j) % 7 == 0 {
            0.0
        } else {
            ((i * j) as f64 / 100.0).tanh()
        }
    })
    .into_dyn();

    interpreter.analyze_layer_activations("conv_layer")?;

    if let Some(stats) = interpreter.layer_statistics().get("conv_layer") {
        println!("   Layer statistics:");
        println!("     Mean activation: {:.4}", stats.mean_activation);
        println!("     Std activation: {:.4}", stats.std_activation);
        println!("     Sparsity: {:.1}%", stats.sparsity);
        println!("     Dead neurons: {:.1}%", stats.dead_neuron_percentage);
    }

    // Generate comprehensive interpretation report
    println!("\n3. Generating interpretation report...");
    let report = interpreter.generate_report(&input)?;
    println!("{}", report);

    println!("✅ Model interpretation demonstration completed!\n");
    Ok(())
}

pub fn cache_layer_statistics( &mut self, layer_name: String, stats: LayerAnalysisStats<F>, )

Cache layer statistics

pub fn compute_attribution( &self, method: &AttributionMethod, input: &ArrayD<F>, target_class: Option<usize>, ) -> Result<ArrayD<F>>

Compute attribution using specified method

This is the main dispatch method that delegates to specific attribution implementations in the attribution module.

Examples found in repository

examples/neural_advanced_features.rs (line 383)

fn demonstrate_model_interpretation() -> Result<()> {
    println!("🔍 Model Interpretation Demonstration");
    println!("====================================\n");

    // Create model interpreter
    let mut interpreter = ModelInterpreter::<f64>::new();

    // Add attribution methods
    interpreter.add_attribution_method(AttributionMethod::Saliency);
    interpreter.add_attribution_method(AttributionMethod::IntegratedGradients {
        baseline: BaselineMethod::Zero,
        num_steps: 50,
    });

    // Simulate input data and gradients
    let input = Array2::from_shape_fn((2, 10), |(i, j)| (i as f64 + j as f64) / 10.0).into_dyn();

    let gradients =
        Array2::from_shape_fn((2, 10), |(i, j)| ((i + j) as f64 / 20.0).sin()).into_dyn();

    // Cache gradients for attribution computation
    interpreter.cache_gradients("input_gradient".to_string(), gradients.clone());

    println!("1. Computing feature attributions...");
    println!("   Input shape: {:?}", input.shape());

    // Compute saliency attribution
    let saliency =
        interpreter.compute_attribution(&AttributionMethod::Saliency, &input, Some(1))?;
    println!("   Saliency attribution shape: {:?}", saliency.shape());

    // Compute integrated gradients
    let integrated_grad = interpreter.compute_attribution(
        &AttributionMethod::IntegratedGradients {
            baseline: BaselineMethod::Zero,
            num_steps: 50,
        },
        &input,
        Some(1),
    )?;
    println!(
        "   Integrated gradients shape: {:?}",
        integrated_grad.shape()
    );

    // Analyze layer activations
    println!("\n2. Analyzing layer activations...");
    let _layer_activations = Array2::from_shape_fn((20, 64), |(i, j)| {
        if (i + j) % 7 == 0 {
            0.0
        } else {
            ((i * j) as f64 / 100.0).tanh()
        }
    })
    .into_dyn();

    interpreter.analyze_layer_activations("conv_layer")?;

    if let Some(stats) = interpreter.layer_statistics().get("conv_layer") {
        println!("   Layer statistics:");
        println!("     Mean activation: {:.4}", stats.mean_activation);
        println!("     Std activation: {:.4}", stats.std_activation);
        println!("     Sparsity: {:.1}%", stats.sparsity);
        println!("     Dead neurons: {:.1}%", stats.dead_neuron_percentage);
    }

    // Generate comprehensive interpretation report
    println!("\n3. Generating interpretation report...");
    let report = interpreter.generate_report(&input)?;
    println!("{}", report);

    println!("✅ Model interpretation demonstration completed!\n");
    Ok(())
}

pub fn analyze_layer_activations( &mut self, layer_name: &str, ) -> Result<LayerAnalysisStats<F>>

Analyze layer activations

Delegates to the analysis module for detailed layer analysis.

Examples found in repository

examples/neural_advanced_features.rs (line 411)

fn demonstrate_model_interpretation() -> Result<()> {
    println!("🔍 Model Interpretation Demonstration");
    println!("====================================\n");

    // Create model interpreter
    let mut interpreter = ModelInterpreter::<f64>::new();

    // Add attribution methods
    interpreter.add_attribution_method(AttributionMethod::Saliency);
    interpreter.add_attribution_method(AttributionMethod::IntegratedGradients {
        baseline: BaselineMethod::Zero,
        num_steps: 50,
    });

    // Simulate input data and gradients
    let input = Array2::from_shape_fn((2, 10), |(i, j)| (i as f64 + j as f64) / 10.0).into_dyn();

    let gradients =
        Array2::from_shape_fn((2, 10), |(i, j)| ((i + j) as f64 / 20.0).sin()).into_dyn();

    // Cache gradients for attribution computation
    interpreter.cache_gradients("input_gradient".to_string(), gradients.clone());

    println!("1. Computing feature attributions...");
    println!("   Input shape: {:?}", input.shape());

    // Compute saliency attribution
    let saliency =
        interpreter.compute_attribution(&AttributionMethod::Saliency, &input, Some(1))?;
    println!("   Saliency attribution shape: {:?}", saliency.shape());

    // Compute integrated gradients
    let integrated_grad = interpreter.compute_attribution(
        &AttributionMethod::IntegratedGradients {
            baseline: BaselineMethod::Zero,
            num_steps: 50,
        },
        &input,
        Some(1),
    )?;
    println!(
        "   Integrated gradients shape: {:?}",
        integrated_grad.shape()
    );

    // Analyze layer activations
    println!("\n2. Analyzing layer activations...");
    let _layer_activations = Array2::from_shape_fn((20, 64), |(i, j)| {
        if (i + j) % 7 == 0 {
            0.0
        } else {
            ((i * j) as f64 / 100.0).tanh()
        }
    })
    .into_dyn();

    interpreter.analyze_layer_activations("conv_layer")?;

    if let Some(stats) = interpreter.layer_statistics().get("conv_layer") {
        println!("   Layer statistics:");
        println!("     Mean activation: {:.4}", stats.mean_activation);
        println!("     Std activation: {:.4}", stats.std_activation);
        println!("     Sparsity: {:.1}%", stats.sparsity);
        println!("     Dead neurons: {:.1}%", stats.dead_neuron_percentage);
    }

    // Generate comprehensive interpretation report
    println!("\n3. Generating interpretation report...");
    let report = interpreter.generate_report(&input)?;
    println!("{}", report);

    println!("✅ Model interpretation demonstration completed!\n");
    Ok(())
}

pub fn generate_report( &self, input: &ArrayD<F>, ) -> Result<ComprehensiveInterpretationReport<F>>

Generate comprehensive interpretation report

Delegates to the reporting module for unified reporting.

Examples found in repository

examples/neural_advanced_features.rs (line 423)

fn demonstrate_model_interpretation() -> Result<()> {
    println!("🔍 Model Interpretation Demonstration");
    println!("====================================\n");

    // Create model interpreter
    let mut interpreter = ModelInterpreter::<f64>::new();

    // Add attribution methods
    interpreter.add_attribution_method(AttributionMethod::Saliency);
    interpreter.add_attribution_method(AttributionMethod::IntegratedGradients {
        baseline: BaselineMethod::Zero,
        num_steps: 50,
    });

    // Simulate input data and gradients
    let input = Array2::from_shape_fn((2, 10), |(i, j)| (i as f64 + j as f64) / 10.0).into_dyn();

    let gradients =
        Array2::from_shape_fn((2, 10), |(i, j)| ((i + j) as f64 / 20.0).sin()).into_dyn();

    // Cache gradients for attribution computation
    interpreter.cache_gradients("input_gradient".to_string(), gradients.clone());

    println!("1. Computing feature attributions...");
    println!("   Input shape: {:?}", input.shape());

    // Compute saliency attribution
    let saliency =
        interpreter.compute_attribution(&AttributionMethod::Saliency, &input, Some(1))?;
    println!("   Saliency attribution shape: {:?}", saliency.shape());

    // Compute integrated gradients
    let integrated_grad = interpreter.compute_attribution(
        &AttributionMethod::IntegratedGradients {
            baseline: BaselineMethod::Zero,
            num_steps: 50,
        },
        &input,
        Some(1),
    )?;
    println!(
        "   Integrated gradients shape: {:?}",
        integrated_grad.shape()
    );

    // Analyze layer activations
    println!("\n2. Analyzing layer activations...");
    let _layer_activations = Array2::from_shape_fn((20, 64), |(i, j)| {
        if (i + j) % 7 == 0 {
            0.0
        } else {
            ((i * j) as f64 / 100.0).tanh()
        }
    })
    .into_dyn();

    interpreter.analyze_layer_activations("conv_layer")?;

    if let Some(stats) = interpreter.layer_statistics().get("conv_layer") {
        println!("   Layer statistics:");
        println!("     Mean activation: {:.4}", stats.mean_activation);
        println!("     Std activation: {:.4}", stats.std_activation);
        println!("     Sparsity: {:.1}%", stats.sparsity);
        println!("     Dead neurons: {:.1}%", stats.dead_neuron_percentage);
    }

    // Generate comprehensive interpretation report
    println!("\n3. Generating interpretation report...");
    let report = interpreter.generate_report(&input)?;
    println!("{}", report);

    println!("✅ Model interpretation demonstration completed!\n");
    Ok(())
}

Trait Implementations

impl<F: Float + Debug + 'static + ScalarOperand + FromPrimitive + Sum + Clone + Copy> Default for ModelInterpreter<F>

fn default() -> Self

Returns the “default value” for a type.