explainiverse 0.8.5__py3-none-any.whl → 0.8.6__py3-none-any.whl

explainiverse/__init__.py

@@ -34,7 +34,7 @@ from explainiverse.adapters.sklearn_adapter import SklearnAdapter
 from explainiverse.adapters import TORCH_AVAILABLE
 from explainiverse.engine.suite import ExplanationSuite
 
-__version__ = "0.8.5"
+__version__ = "0.8.6"
 
 __all__ = [
     # Core

explainiverse/evaluation/__init__.py

@@ -47,6 +47,8 @@ from explainiverse.evaluation.faithfulness_extended import (
     compute_batch_pixel_flipping,
     compute_region_perturbation,
     compute_batch_region_perturbation,
+    compute_selectivity,
+    compute_batch_selectivity,
 )
 
 __all__ = [
@@ -82,4 +84,6 @@ __all__ = [
     "compute_batch_pixel_flipping",
     "compute_region_perturbation",
     "compute_batch_region_perturbation",
+    "compute_selectivity",
+    "compute_batch_selectivity",
 ]

explainiverse/evaluation/faithfulness_extended.py

@@ -256,6 +256,204 @@ def compute_batch_faithfulness_estimate(
     }
 
 
+# =============================================================================
+# Metric 6: Selectivity (Montavon et al., 2018)
+# =============================================================================
+
+def compute_selectivity(
+    model,
+    instance: np.ndarray,
+    explanation: Explanation,
+    baseline: Union[str, float, np.ndarray, Callable] = "mean",
+    background_data: np.ndarray = None,
+    target_class: int = None,
+    n_steps: int = None,
+    use_absolute: bool = True,
+    return_details: bool = False,
+) -> Union[float, Dict[str, Union[float, np.ndarray]]]:
+    """
+    Compute Selectivity score using AOPC (Montavon et al., 2018).
+    
+    Measures how quickly the prediction function drops when removing features
+    with the highest attributed values. Computed as the Area Over the
+    Perturbation Curve (AOPC), which is the average prediction drop across
+    all perturbation steps.
+    
+    AOPC = (1/(K+1)) * Σₖ₌₀ᴷ [f(x) - f(x_{1..k})]
+    
+    where:
+    - f(x) is the original prediction for the target class
+    - f(x_{1..k}) is the prediction after removing the top-k most important features
+    - K is the total number of perturbation steps (default: n_features)
+    
+    Higher AOPC indicates better selectivity - the explanation correctly
+    identifies features whose removal causes the largest prediction drop.
+    
+    Args:
+        model: Model adapter with predict/predict_proba method
+        instance: Input instance (1D array)
+        explanation: Explanation object with feature_attributions
+        baseline: Baseline for feature removal ("mean", "median", scalar, array, callable)
+        background_data: Reference data for computing baseline (required for "mean"/"median")
+        target_class: Target class index for probability (default: predicted class)
+        n_steps: Number of perturbation steps (default: n_features, max features to remove)
+        use_absolute: If True, sort features by absolute attribution value (default: True)
+        return_details: If True, return detailed results including prediction drops per step
+        
+    Returns:
+        If return_details=False: AOPC score (float, higher is better)
+        If return_details=True: Dictionary with:
+            - 'aopc': float - Area Over the Perturbation Curve (average drop)
+            - 'prediction_drops': np.ndarray - Drop at each step [f(x) - f(x_{1..k})]
+            - 'predictions': np.ndarray - Predictions at each step
+            - 'feature_order': np.ndarray - Order in which features were removed
+            - 'n_steps': int - Number of perturbation steps
+        
+    References:
+        Montavon, G., Samek, W., & Müller, K. R. (2018). Methods for Interpreting
+        and Understanding Deep Neural Networks. Digital Signal Processing, 73, 1-15.
+        
+        Samek, W., Binder, A., Montavon, G., Lapuschkin, S., & Müller, K. R. (2016).
+        Evaluating the Visualization of What a Deep Neural Network has Learned.
+        IEEE Transactions on Neural Networks and Learning Systems, 28(11), 2660-2673.
+    """
+    instance = np.asarray(instance).flatten()
+    n_features = len(instance)
+    
+    # Get baseline values
+    baseline_values = compute_baseline_values(
+        baseline, background_data, n_features
+    )
+    
+    # Extract attributions as array
+    attr_array = _extract_attribution_array(explanation, n_features)
+    
+    # Determine number of steps (default: all features)
+    if n_steps is None:
+        n_steps = n_features
+    n_steps = min(n_steps, n_features)
+    
+    # Sort features by attribution (descending - most important first)
+    if use_absolute:
+        sorted_indices = np.argsort(-np.abs(attr_array))
+    else:
+        sorted_indices = np.argsort(-attr_array)
+    
+    # Determine target class
+    if target_class is None:
+        pred = get_prediction_value(model, instance.reshape(1, -1))
+        if isinstance(pred, np.ndarray) and pred.ndim > 0:
+            target_class = int(np.argmax(pred))
+        else:
+            target_class = 0
+    
+    # Get original prediction for the target class
+    original_pred = get_prediction_value(model, instance.reshape(1, -1))
+    if isinstance(original_pred, np.ndarray) and original_pred.ndim > 0 and len(original_pred) > target_class:
+        original_value = original_pred[target_class]
+    else:
+        original_value = float(original_pred)
+    
+    # Start with original instance
+    current = instance.copy()
+    
+    # Track predictions and drops at each step
+    # Step 0: no features removed (drop = 0)
+    predictions = [original_value]
+    prediction_drops = [0.0]  # f(x) - f(x) = 0
+    
+    # Remove features one by one (most important first)
+    for k in range(n_steps):
+        idx = sorted_indices[k]
+        # Remove this feature (replace with baseline)
+        current[idx] = baseline_values[idx]
+        
+        # Get prediction
+        pred = get_prediction_value(model, current.reshape(1, -1))
+        if isinstance(pred, np.ndarray) and pred.ndim > 0 and len(pred) > target_class:
+            current_pred = pred[target_class]
+        else:
+            current_pred = float(pred)
+        
+        predictions.append(current_pred)
+        # Prediction drop: f(x) - f(x_{1..k})
+        prediction_drops.append(original_value - current_pred)
+    
+    predictions = np.array(predictions)
+    prediction_drops = np.array(prediction_drops)
+    
+    # Compute AOPC: average of prediction drops across all steps
+    # AOPC = (1/(K+1)) * Σₖ₌₀ᴷ [f(x) - f(x_{1..k})]
+    aopc = np.mean(prediction_drops)
+    
+    if return_details:
+        return {
+            "aopc": float(aopc),
+            "prediction_drops": prediction_drops,
+            "predictions": predictions,
+            "feature_order": sorted_indices[:n_steps],
+            "n_steps": n_steps,
+            "original_prediction": original_value,
+        }
+    
+    return float(aopc)
+
+
+def compute_batch_selectivity(
+    model,
+    X: np.ndarray,
+    explanations: List[Explanation],
+    baseline: Union[str, float, np.ndarray, Callable] = "mean",
+    max_samples: int = None,
+    n_steps: int = None,
+    use_absolute: bool = True,
+) -> Dict[str, float]:
+    """
+    Compute average Selectivity (AOPC) over a batch of instances.
+    
+    Args:
+        model: Model adapter
+        X: Input data (2D array)
+        explanations: List of Explanation objects (one per instance)
+        baseline: Baseline for feature removal
+        max_samples: Maximum number of samples to evaluate
+        n_steps: Number of perturbation steps per instance
+        use_absolute: If True, sort features by absolute attribution value
+        
+    Returns:
+        Dictionary with mean, std, min, max, and count of valid scores
+    """
+    n_samples = len(explanations)
+    if max_samples:
+        n_samples = min(n_samples, max_samples)
+    
+    scores = []
+    
+    for i in range(n_samples):
+        try:
+            score = compute_selectivity(
+                model, X[i], explanations[i],
+                baseline=baseline, background_data=X,
+                n_steps=n_steps,
+                use_absolute=use_absolute
+            )
+            if not np.isnan(score):
+                scores.append(score)
+        except Exception:
+            continue
+    
+    if not scores:
+        return {"mean": 0.0, "std": 0.0, "min": 0.0, "max": 0.0, "n_samples": 0}
+    
+    return {
+        "mean": float(np.mean(scores)),
+        "std": float(np.std(scores)),
+        "min": float(np.min(scores)),
+        "max": float(np.max(scores)),
+        "n_samples": len(scores),
+    }
+
+
 # =============================================================================
 # Metric 5: Region Perturbation (Samek et al., 2015)
 # =============================================================================

{explainiverse-0.8.5.dist-info → explainiverse-0.8.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: explainiverse
-Version: 0.8.5
+Version: 0.8.6
 Summary: Unified, extensible explainability framework supporting 18 XAI methods including LIME, SHAP, LRP, TCAV, GradCAM, and more
 Home-page: https://github.com/jemsbhai/explainiverse
 License: MIT
@@ -44,7 +44,7 @@ Description-Content-Type: text/markdown
 | Feature | Description |
 |---------|-------------|
 | **18 Explainers** | LIME, KernelSHAP, TreeSHAP, Integrated Gradients, DeepLIFT, DeepSHAP, SmoothGrad, Saliency Maps, GradCAM/GradCAM++, LRP, TCAV, Anchors, Counterfactual, Permutation Importance, PDP, ALE, SAGE, ProtoDash |
-| **14 Evaluation Metrics** | Faithfulness (PGI, PGU, Comprehensiveness, Sufficiency, Correlation, Faithfulness Estimate, Monotonicity, Monotonicity-Nguyen, Pixel Flipping, Region Perturbation) and Stability (RIS, ROS, Lipschitz) |
+| **15 Evaluation Metrics** | Faithfulness (PGI, PGU, Comprehensiveness, Sufficiency, Correlation, Faithfulness Estimate, Monotonicity, Monotonicity-Nguyen, Pixel Flipping, Region Perturbation, Selectivity) and Stability (RIS, ROS, Lipschitz) |
 | **Unified API** | Consistent `BaseExplainer` interface with standardized `Explanation` output |
 | **Plugin Registry** | Filter explainers by scope, model type, data type; automatic recommendations |
 | **Framework Support** | Adapters for scikit-learn and PyTorch (with gradient computation) |
@@ -101,6 +101,7 @@ Explainiverse includes a comprehensive suite of evaluation metrics based on the
 | **Monotonicity-Nguyen** | Spearman correlation between attributions and feature removal impact | [Nguyen & Martinez, 2020](https://arxiv.org/abs/2010.07455) |
 | **Pixel Flipping** | AUC of prediction degradation when removing features by importance | [Bach et al., 2015](https://doi.org/10.1371/journal.pone.0130140) |
 | **Region Perturbation** | AUC of prediction degradation when perturbing feature regions by importance | [Samek et al., 2015](https://arxiv.org/abs/1509.06321) |
+| **Selectivity (AOPC)** | Average prediction drop when sequentially removing features by importance | [Montavon et al., 2018](https://doi.org/10.1016/j.dsp.2017.10.011) |
 
 ### Stability Metrics
 

{explainiverse-0.8.5.dist-info → explainiverse-0.8.6.dist-info}/RECORD

@@ -1,4 +1,4 @@
-explainiverse/__init__.py,sha256=aI5BiLl4bBBvP5icTtOou1_gsdNE6gnl_yeJoGFldFo,1694
+explainiverse/__init__.py,sha256=KFPDVxlFzpILL_9pdWSDKFtrnVo086_K1KeYcJIT6cc,1694
 explainiverse/adapters/__init__.py,sha256=HcQGISyp-YQ4jEj2IYveX_c9X5otLcTNWRnVRRhzRik,781
 explainiverse/adapters/base_adapter.py,sha256=Nqt0GeDn_-PjTyJcZsE8dRTulavqFQsv8sMYWS_ps-M,603
 explainiverse/adapters/pytorch_adapter.py,sha256=DLQKJ7gB0foPwAmcrru7QdZnPRnhqDKpFCT-EaD3420,15612
@@ -9,10 +9,10 @@ explainiverse/core/explanation.py,sha256=498BbRYrNR-BOql78sENOsyWxgqLsBVZXn14lh-
 explainiverse/core/registry.py,sha256=6HttL27Ty4jYtugRf-EDIKPy80M8BfvUppAKwwGDyQ8,27207
 explainiverse/engine/__init__.py,sha256=1sZO8nH1mmwK2e-KUavBQm7zYDWUe27nyWoFy9tgsiA,197
 explainiverse/engine/suite.py,sha256=G-7OjESisSTaQ1FQrlPl4YydX13uz8Bb70hJZNlcl2M,8918
-explainiverse/evaluation/__init__.py,sha256=k45VxDn04v0Quy9WqmNuwFfLebMtFHUSgMAvAaiaMkQ,2381
+explainiverse/evaluation/__init__.py,sha256=bde3iDHvCKlYJ1TgJMhkY1ldCHBZ26eQxQX7u6iCDkY,2497
 explainiverse/evaluation/_utils.py,sha256=ej7YOPZ90gVHuuIMj45EXHq9Jx3QG7lhaj5sk26hRpg,10519
 explainiverse/evaluation/faithfulness.py,sha256=_40afOW6vJ3dQguHlJySlgWqiJF_xIvN-uVA3nPKRvI,14841
-explainiverse/evaluation/faithfulness_extended.py,sha256=OA6KjhT5fORuOjRFStIXVtWan_nxM4WUChEEKEjW44s,35523
+explainiverse/evaluation/faithfulness_extended.py,sha256=c1tQazZBR9sdH3Y431VCL00nE8w9p1vMOYsx2mOBzJg,43101
 explainiverse/evaluation/metrics.py,sha256=snNK9Ua1VzHDT6DlrhYL4m2MmRF3X15vuuVXiHbeicU,9944
 explainiverse/evaluation/stability.py,sha256=q2d3rpxpp0X1s6ADST1iZA4tzksLJpR0mYBnA_U5FIs,12090
 explainiverse/explainers/__init__.py,sha256=-ncRXbFKahH3bR0oXM2UQM4LtTdTlvdeprL6cHeqNBs,2549
@@ -39,7 +39,7 @@ explainiverse/explainers/gradient/smoothgrad.py,sha256=COIKZSFcApmMkA62M0AForHiY
 explainiverse/explainers/gradient/tcav.py,sha256=zc-8wMsc2ZOhUeSZNBJ6H6BPXlVMJ9DRcAMiL25wU9I,32242
 explainiverse/explainers/rule_based/__init__.py,sha256=gKzlFCAzwurAMLJcuYgal4XhDj1thteBGcaHWmN7iWk,243
 explainiverse/explainers/rule_based/anchors_wrapper.py,sha256=ML7W6aam-eMGZHy5ilol8qupZvNBJpYAFatEEPnuMyo,13254
-explainiverse-0.8.5.dist-info/LICENSE,sha256=28rbHe8rJgmUlRdxJACfq1Sj-MtCEhyHxkJedQd1ZYA,1070
-explainiverse-0.8.5.dist-info/METADATA,sha256=pPkloUD3bjPOpmbrCqJktcNRAmG9izq42ApYiopiA74,25078
-explainiverse-0.8.5.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-explainiverse-0.8.5.dist-info/RECORD,,
+explainiverse-0.8.6.dist-info/LICENSE,sha256=28rbHe8rJgmUlRdxJACfq1Sj-MtCEhyHxkJedQd1ZYA,1070
+explainiverse-0.8.6.dist-info/METADATA,sha256=7KtAAsGj0I3PpqYofYwk-OfSaCEs2HyQo9rW3YCxLks,25263
+explainiverse-0.8.6.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+explainiverse-0.8.6.dist-info/RECORD,,