trustformers-debug 0.1.1

//! # Interpretability Tools
//!
//! Comprehensive model interpretability toolkit including SHAP integration, LIME support,
//! attention analysis, feature attribution, and counterfactual generation for TrustformeRS models.
//!
//! ## Refactoring Summary
//!
//! Previously this was a single 2,803-line file containing all interpretability functionality.
//! It has been split into focused modules:
//!
//! - `interpretability/config.rs` - Configuration structures and enums (77 lines)
//! - `interpretability/shap.rs` - SHAP analysis types and functionality (66 lines)
//! - `interpretability/lime.rs` - LIME analysis types and functionality (78 lines)
//! - `interpretability/attention.rs` - Attention analysis for transformers (426 lines)
//! - `interpretability/attribution.rs` - Feature attribution methods (103 lines)
//! - `interpretability/counterfactual.rs` - Counterfactual generation (191 lines)
//! - `interpretability/analyzer.rs` - Main analyzer implementation (318 lines)
//! - `interpretability/report.rs` - Reporting functionality (23 lines)
//!
//! This refactoring improves:
//! - Code maintainability and readability
//! - Module compilation times
//! - Test isolation
//! - Code reuse through focused modules
//! - Developer experience when working on specific interpretability methods

// TODO: Re-enable when interpretability module is implemented
// Re-export the entire interpretability module
// pub use self::interpretability::*;

// Import the interpretability module
// mod interpretability;

// TODO: Re-enable when interpretability module is implemented
// Convenience exports for backwards compatibility
/*
pub use interpretability::{
    // Configuration
    InterpretabilityConfig,
    AttributionMethod,

    // SHAP analysis
    ShapAnalysisResult,
    FeatureContribution,
    ShapSummary,

    // LIME analysis
    LimeAnalysisResult,
    FeatureImportance,
    PerturbationAnalysis,
    PerturbationResult,
    NeighborhoodStats,

    // Attention analysis
    AttentionAnalysisResult,
    AttentionLayerResult,
    AttentionHeadResult,
    TokenAttentionScore,
    HeadSpecializationType,
    AttentionPatterns,
    DiagonalPattern,
    VerticalPattern,
    BlockPattern,
    RepetitivePattern,
    LayerAttentionPatterns,
    LayerAttentionStats,
    HeadSpecializationAnalysis,
    HeadCluster,
    SpecializationEvolution,
    SpecializationTransition,
    SpecializationTrend,
    HeadRedundancyAnalysis,
    RedundantHeadPair,
    RedundancyType,
    PruningRecommendation,
    PruningImpact,
    RiskLevel,
    AttentionFlowAnalysis,
    AttentionFlowPath,
    LayerFlowStep,
    FlowTransformation,
    AttentionBottleneck,
    BottleneckType,
    FlowEfficiencyMetrics,
    LayerFlowStats,
    AttentionStatistics,
    SparsityDistribution,
    AttentionInsight,
    InsightType,

    // Feature attribution
    FeatureAttributionResult,
    AttributionMethodResult,
    FeatureAttribution,
    MethodAgreementAnalysis,
    TopFeature,
    AttributionVisualizationData,
    TimelinePoint,
    FeatureInteraction,
    InteractionType,

    // Counterfactual generation
    CounterfactualResult,
    Counterfactual,
    FeatureChange,
    ChangeDirection,
    CounterfactualQualityMetrics,
    FeatureSensitivityAnalysis,
    InteractionEffect,
    InteractionEffectType,
    ThresholdAnalysis,
    DecisionBoundaryAnalysis,
    BoundaryCrossingPoint,
    ActionableInsight,
    ImplementationDifficulty,
    TimeHorizon,

    // Main analyzer
    InterpretabilityAnalyzer,

    // Reporting
    InterpretabilityReport,
};
*/

// Re-export tests for compatibility
#[cfg(test)]
mod tests {

    use crate::{InterpretabilityAnalyzer, InterpretabilityConfig};
    use std::collections::HashMap;

    #[tokio::test]
    async fn test_interpretability_analyzer_creation() {
        let config = InterpretabilityConfig;
        let _analyzer = InterpretabilityAnalyzer::new(config);
        // Basic test to ensure analyzer can be created
    }

    #[tokio::test]
    async fn test_shap_analysis() {
        let config = InterpretabilityConfig;
        let analyzer = InterpretabilityAnalyzer::new(config);

        let mut instance = HashMap::new();
        instance.insert("feature1".to_string(), 1.0);
        instance.insert("feature2".to_string(), 2.0);

        let model_predictions = vec![0.8, 0.7, 0.9];
        let background_data = vec![{
            let mut bg = HashMap::new();
            bg.insert("feature1".to_string(), 0.5);
            bg.insert("feature2".to_string(), 1.0);
            bg
        }];

        let result = analyzer.analyze_shap(&instance, &model_predictions, &background_data).await;
        assert!(result.is_ok());
    }

    #[tokio::test]
    async fn test_lime_analysis() {
        let config = InterpretabilityConfig;
        let analyzer = InterpretabilityAnalyzer::new(config);

        let mut instance = HashMap::new();
        instance.insert("feature1".to_string(), 1.0);
        instance.insert("feature2".to_string(), 2.0);

        let model_fn =
            Box::new(|input: &HashMap<String, f64>| -> f64 { input.values().sum::<f64>() * 0.1 });

        let result = analyzer.analyze_lime(&instance, model_fn).await;
        assert!(result.is_ok());
    }
}