explainiverse 0.2.2__py3-none-any.whl → 0.2.3__py3-none-any.whl

explainiverse/__init__.py

@@ -33,7 +33,7 @@ from explainiverse.adapters.sklearn_adapter import SklearnAdapter
 from explainiverse.adapters import TORCH_AVAILABLE
 from explainiverse.engine.suite import ExplanationSuite
 
-__version__ = "0.2.2"
+__version__ = "0.2.3"
 
 __all__ = [
     # Core

explainiverse/core/registry.py

@@ -369,6 +369,7 @@ def _create_default_registry() -> ExplainerRegistry:
     from explainiverse.explainers.global_explainers.ale import ALEExplainer
     from explainiverse.explainers.global_explainers.sage import SAGEExplainer
     from explainiverse.explainers.counterfactual.dice_wrapper import CounterfactualExplainer
+    from explainiverse.explainers.gradient.integrated_gradients import IntegratedGradientsExplainer
     
     registry = ExplainerRegistry()
     
@@ -461,6 +462,23 @@ def _create_default_registry() -> ExplainerRegistry:
         )
     )
     
+    # Register Integrated Gradients (for neural networks)
+    registry.register(
+        name="integrated_gradients",
+        explainer_class=IntegratedGradientsExplainer,
+        meta=ExplainerMeta(
+            scope="local",
+            model_types=["neural"],
+            data_types=["tabular", "image"],
+            task_types=["classification", "regression"],
+            description="Integrated Gradients - axiomatic attributions for neural networks (requires PyTorch)",
+            paper_reference="Sundararajan et al., 2017 - 'Axiomatic Attribution for Deep Networks' (ICML)",
+            complexity="O(n_steps * forward_pass)",
+            requires_training_data=False,
+            supports_batching=True
+        )
+    )
+    
     # =========================================================================
     # Global Explainers (model-level)
     # =========================================================================

explainiverse/explainers/__init__.py

@@ -8,6 +8,7 @@ Local Explainers (instance-level):
 - TreeSHAP: Optimized exact SHAP for tree-based models
 - Anchors: High-precision rule-based explanations
 - Counterfactual: Diverse counterfactual explanations
+- Integrated Gradients: Gradient-based attributions for neural networks
 
 Global Explainers (model-level):
 - Permutation Importance: Feature importance via permutation
@@ -25,6 +26,7 @@ from explainiverse.explainers.global_explainers.permutation_importance import Pe
 from explainiverse.explainers.global_explainers.partial_dependence import PartialDependenceExplainer
 from explainiverse.explainers.global_explainers.ale import ALEExplainer
 from explainiverse.explainers.global_explainers.sage import SAGEExplainer
+from explainiverse.explainers.gradient.integrated_gradients import IntegratedGradientsExplainer
 
 __all__ = [
     # Local explainers
@@ -33,6 +35,7 @@ __all__ = [
     "TreeShapExplainer",
     "AnchorsExplainer",
     "CounterfactualExplainer",
+    "IntegratedGradientsExplainer",
     # Global explainers
     "PermutationImportanceExplainer",
     "PartialDependenceExplainer",

explainiverse/explainers/gradient/__init__.py

@@ -0,0 +1,11 @@
+# src/explainiverse/explainers/gradient/__init__.py
+"""
+Gradient-based explainers for neural networks.
+
+These explainers require models that support gradient computation,
+typically via the PyTorchAdapter.
+"""
+
+from explainiverse.explainers.gradient.integrated_gradients import IntegratedGradientsExplainer
+
+__all__ = ["IntegratedGradientsExplainer"]

explainiverse/explainers/gradient/integrated_gradients.py

@@ -0,0 +1,348 @@
+# src/explainiverse/explainers/gradient/integrated_gradients.py
+"""
+Integrated Gradients - Axiomatic Attribution for Deep Networks.
+
+Integrated Gradients computes feature attributions by accumulating gradients
+along a straight-line path from a baseline to the input. It satisfies two
+key axioms:
+- Sensitivity: If a feature differs between input and baseline and changes
+  the prediction, it receives non-zero attribution.
+- Implementation Invariance: Attributions are identical for functionally
+  equivalent networks.
+
+Reference:
+    Sundararajan, M., Taly, A., & Yan, Q. (2017). Axiomatic Attribution for
+    Deep Networks. ICML 2017. https://arxiv.org/abs/1703.01365
+
+Example:
+    from explainiverse.explainers.gradient import IntegratedGradientsExplainer
+    from explainiverse.adapters import PyTorchAdapter
+    
+    adapter = PyTorchAdapter(model, task="classification")
+    
+    explainer = IntegratedGradientsExplainer(
+        model=adapter,
+        feature_names=feature_names,
+        n_steps=50
+    )
+    
+    explanation = explainer.explain(instance)
+"""
+
+import numpy as np
+from typing import List, Optional, Union, Callable
+
+from explainiverse.core.explainer import BaseExplainer
+from explainiverse.core.explanation import Explanation
+
+
+class IntegratedGradientsExplainer(BaseExplainer):
+    """
+    Integrated Gradients explainer for neural networks.
+    
+    Computes attributions by integrating gradients along the path from
+    a baseline (default: zero vector) to the input. The integral is
+    approximated using the Riemann sum.
+    
+    Attributes:
+        model: Model adapter with predict_with_gradients() method
+        feature_names: List of feature names
+        class_names: List of class names (for classification)
+        n_steps: Number of steps for integral approximation
+        baseline: Baseline input (default: zeros)
+        method: Integration method ("riemann_middle", "riemann_left", "riemann_right", "riemann_trapezoid")
+    """
+    
+    def __init__(
+        self,
+        model,
+        feature_names: List[str],
+        class_names: Optional[List[str]] = None,
+        n_steps: int = 50,
+        baseline: Optional[np.ndarray] = None,
+        method: str = "riemann_middle"
+    ):
+        """
+        Initialize the Integrated Gradients explainer.
+        
+        Args:
+            model: A model adapter with predict_with_gradients() method.
+                   Use PyTorchAdapter for PyTorch models.
+            feature_names: List of input feature names.
+            class_names: List of class names (for classification tasks).
+            n_steps: Number of steps for approximating the integral.
+                    More steps = more accurate but slower. Default: 50.
+            baseline: Baseline input for comparison. If None, uses zeros.
+                     Can also be "random" for random baseline or a callable.
+            method: Integration method:
+                   - "riemann_middle": Middle Riemann sum (default, most accurate)
+                   - "riemann_left": Left Riemann sum
+                   - "riemann_right": Right Riemann sum
+                   - "riemann_trapezoid": Trapezoidal rule
+        """
+        super().__init__(model)
+        
+        # Validate model has gradient capability
+        if not hasattr(model, 'predict_with_gradients'):
+            raise TypeError(
+                "Model adapter must have predict_with_gradients() method. "
+                "Use PyTorchAdapter for PyTorch models."
+            )
+        
+        self.feature_names = list(feature_names)
+        self.class_names = list(class_names) if class_names else None
+        self.n_steps = n_steps
+        self.baseline = baseline
+        self.method = method
+    
+    def _get_baseline(self, instance: np.ndarray) -> np.ndarray:
+        """Get the baseline for a given input shape."""
+        if self.baseline is None:
+            # Default: zero baseline
+            return np.zeros_like(instance)
+        elif isinstance(self.baseline, str) and self.baseline == "random":
+            # Random baseline (useful for images)
+            return np.random.uniform(
+                low=instance.min(),
+                high=instance.max(),
+                size=instance.shape
+            ).astype(instance.dtype)
+        elif callable(self.baseline):
+            return self.baseline(instance)
+        else:
+            return np.array(self.baseline).reshape(instance.shape)
+    
+    def _get_interpolation_alphas(self) -> np.ndarray:
+        """Get interpolation points based on method."""
+        if self.method == "riemann_left":
+            return np.linspace(0, 1 - 1/self.n_steps, self.n_steps)
+        elif self.method == "riemann_right":
+            return np.linspace(1/self.n_steps, 1, self.n_steps)
+        elif self.method == "riemann_middle":
+            return np.linspace(0.5/self.n_steps, 1 - 0.5/self.n_steps, self.n_steps)
+        elif self.method == "riemann_trapezoid":
+            return np.linspace(0, 1, self.n_steps + 1)
+        else:
+            raise ValueError(f"Unknown method: {self.method}")
+    
+    def _compute_integrated_gradients(
+        self,
+        instance: np.ndarray,
+        baseline: np.ndarray,
+        target_class: Optional[int] = None
+    ) -> np.ndarray:
+        """
+        Compute integrated gradients for a single instance.
+        
+        The integral is approximated as:
+        IG_i = (x_i - x'_i) * sum_{k=1}^{m} grad_i(x' + k/m * (x - x')) / m
+        
+        where x is the input, x' is the baseline, and m is n_steps.
+        """
+        # Get interpolation points
+        alphas = self._get_interpolation_alphas()
+        
+        # Compute path from baseline to input
+        # Shape: (n_steps, n_features)
+        delta = instance - baseline
+        interpolated_inputs = baseline + alphas[:, np.newaxis] * delta
+        
+        # Compute gradients at each interpolation point
+        all_gradients = []
+        for interp_input in interpolated_inputs:
+            _, gradients = self.model.predict_with_gradients(
+                interp_input.reshape(1, -1),
+                target_class=target_class
+            )
+            all_gradients.append(gradients.flatten())
+        
+        all_gradients = np.array(all_gradients)  # Shape: (n_steps, n_features)
+        
+        # Approximate the integral
+        if self.method == "riemann_trapezoid":
+            # Trapezoidal rule: (f(0) + 2*f(1) + ... + 2*f(n-1) + f(n)) / (2n)
+            weights = np.ones(self.n_steps + 1)
+            weights[0] = 0.5
+            weights[-1] = 0.5
+            avg_gradients = np.average(all_gradients, axis=0, weights=weights)
+        else:
+            # Standard Riemann sum: average of gradients
+            avg_gradients = np.mean(all_gradients, axis=0)
+        
+        # Scale by input - baseline difference
+        integrated_gradients = delta * avg_gradients
+        
+        return integrated_gradients
+    
+    def explain(
+        self,
+        instance: np.ndarray,
+        target_class: Optional[int] = None,
+        baseline: Optional[np.ndarray] = None,
+        return_convergence_delta: bool = False
+    ) -> Explanation:
+        """
+        Generate Integrated Gradients explanation for an instance.
+        
+        Args:
+            instance: 1D numpy array of input features.
+            target_class: For classification, which class to explain.
+                         If None, uses the predicted class.
+            baseline: Override the default baseline for this explanation.
+            return_convergence_delta: If True, include the convergence delta
+                                     (difference between sum of attributions
+                                     and prediction difference).
+        
+        Returns:
+            Explanation object with feature attributions.
+        """
+        instance = np.array(instance).flatten().astype(np.float32)
+        
+        # Get baseline
+        if baseline is not None:
+            bl = np.array(baseline).flatten().astype(np.float32)
+        else:
+            bl = self._get_baseline(instance)
+        
+        # Determine target class if not specified
+        if target_class is None and self.class_names:
+            predictions = self.model.predict(instance.reshape(1, -1))
+            target_class = int(np.argmax(predictions))
+        
+        # Compute integrated gradients
+        ig_attributions = self._compute_integrated_gradients(
+            instance, bl, target_class
+        )
+        
+        # Build attributions dict
+        attributions = {
+            fname: float(ig_attributions[i])
+            for i, fname in enumerate(self.feature_names)
+        }
+        
+        # Determine class name
+        if self.class_names and target_class is not None:
+            label_name = self.class_names[target_class]
+        else:
+            label_name = f"class_{target_class}" if target_class is not None else "output"
+        
+        explanation_data = {
+            "feature_attributions": attributions,
+            "attributions_raw": ig_attributions.tolist(),
+            "baseline": bl.tolist(),
+            "n_steps": self.n_steps,
+            "method": self.method
+        }
+        
+        # Optionally compute convergence delta
+        if return_convergence_delta:
+            # The sum of attributions should equal F(x) - F(baseline)
+            pred_input = self.model.predict(instance.reshape(1, -1))
+            pred_baseline = self.model.predict(bl.reshape(1, -1))
+            
+            if target_class is not None:
+                pred_diff = pred_input[0, target_class] - pred_baseline[0, target_class]
+            else:
+                pred_diff = pred_input[0, 0] - pred_baseline[0, 0]
+            
+            attribution_sum = np.sum(ig_attributions)
+            convergence_delta = abs(pred_diff - attribution_sum)
+            
+            explanation_data["convergence_delta"] = float(convergence_delta)
+            explanation_data["prediction_difference"] = float(pred_diff)
+            explanation_data["attribution_sum"] = float(attribution_sum)
+        
+        return Explanation(
+            explainer_name="IntegratedGradients",
+            target_class=label_name,
+            explanation_data=explanation_data
+        )
+    
+    def explain_batch(
+        self,
+        X: np.ndarray,
+        target_class: Optional[int] = None
+    ) -> List[Explanation]:
+        """
+        Generate explanations for multiple instances.
+        
+        Note: This is not optimized for batching - it processes
+        instances sequentially. For large batches, consider using
+        the batched gradient computation in a custom implementation.
+        
+        Args:
+            X: 2D numpy array of instances (n_samples, n_features).
+            target_class: Target class for all instances.
+        
+        Returns:
+            List of Explanation objects.
+        """
+        X = np.array(X)
+        if X.ndim == 1:
+            X = X.reshape(1, -1)
+        
+        return [
+            self.explain(X[i], target_class=target_class)
+            for i in range(X.shape[0])
+        ]
+    
+    def compute_attributions_with_noise(
+        self,
+        instance: np.ndarray,
+        target_class: Optional[int] = None,
+        n_samples: int = 5,
+        noise_scale: float = 0.1
+    ) -> Explanation:
+        """
+        Compute attributions averaged over noisy baselines (SmoothGrad-style).
+        
+        This can help reduce noise in the attributions by averaging over
+        multiple baselines sampled around the zero baseline.
+        
+        Args:
+            instance: Input instance.
+            target_class: Target class for attribution.
+            n_samples: Number of noisy baselines to average.
+            noise_scale: Standard deviation of Gaussian noise.
+        
+        Returns:
+            Explanation with averaged attributions.
+        """
+        instance = np.array(instance).flatten().astype(np.float32)
+        
+        all_attributions = []
+        for _ in range(n_samples):
+            # Create noisy baseline
+            noise = np.random.normal(0, noise_scale, instance.shape).astype(np.float32)
+            noisy_baseline = noise  # Noise around zero
+            
+            ig = self._compute_integrated_gradients(
+                instance, noisy_baseline, target_class
+            )
+            all_attributions.append(ig)
+        
+        # Average attributions
+        avg_attributions = np.mean(all_attributions, axis=0)
+        std_attributions = np.std(all_attributions, axis=0)
+        
+        attributions = {
+            fname: float(avg_attributions[i])
+            for i, fname in enumerate(self.feature_names)
+        }
+        
+        if self.class_names and target_class is not None:
+            label_name = self.class_names[target_class]
+        else:
+            label_name = f"class_{target_class}" if target_class is not None else "output"
+        
+        return Explanation(
+            explainer_name="IntegratedGradients_Smooth",
+            target_class=label_name,
+            explanation_data={
+                "feature_attributions": attributions,
+                "attributions_raw": avg_attributions.tolist(),
+                "attributions_std": std_attributions.tolist(),
+                "n_samples": n_samples,
+                "noise_scale": noise_scale
+            }
+        )

{explainiverse-0.2.2.dist-info → explainiverse-0.2.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: explainiverse
-Version: 0.2.2
+Version: 0.2.3
 Summary: Unified, extensible explainability framework supporting LIME, SHAP, Anchors, Counterfactuals, PDP, ALE, SAGE, and more
 Home-page: https://github.com/jemsbhai/explainiverse
 License: MIT
@@ -31,7 +31,7 @@ Description-Content-Type: text/markdown
 # Explainiverse
 
 **Explainiverse** is a unified, extensible Python framework for Explainable AI (XAI).  
-It provides a standardized interface for model-agnostic explainability with 9 state-of-the-art XAI methods, evaluation metrics, and a plugin registry for easy extensibility.
+It provides a standardized interface for model-agnostic explainability with 10 state-of-the-art XAI methods, evaluation metrics, and a plugin registry for easy extensibility.
 
 ---
 
@@ -43,6 +43,7 @@ It provides a standardized interface for model-agnostic explainability with 9 st
 - **LIME** - Local Interpretable Model-agnostic Explanations ([Ribeiro et al., 2016](https://arxiv.org/abs/1602.04938))
 - **SHAP** - SHapley Additive exPlanations via KernelSHAP ([Lundberg & Lee, 2017](https://arxiv.org/abs/1705.07874))
 - **TreeSHAP** - Exact SHAP values for tree models, 10x+ faster ([Lundberg et al., 2018](https://arxiv.org/abs/1802.03888))
+- **Integrated Gradients** - Axiomatic attributions for neural networks ([Sundararajan et al., 2017](https://arxiv.org/abs/1703.01365))
 - **Anchors** - High-precision rule-based explanations ([Ribeiro et al., 2018](https://ojs.aaai.org/index.php/AAAI/article/view/11491))
 - **Counterfactual** - DiCE-style diverse counterfactual explanations ([Mothilal et al., 2020](https://arxiv.org/abs/1905.07697))
 
@@ -109,7 +110,7 @@ adapter = SklearnAdapter(model, class_names=iris.target_names.tolist())
 
 # List available explainers
 print(default_registry.list_explainers())
-# ['lime', 'shap', 'treeshap', 'anchors', 'counterfactual', 'permutation_importance', 'partial_dependence', 'ale', 'sage']
+# ['lime', 'shap', 'treeshap', 'integrated_gradients', 'anchors', 'counterfactual', 'permutation_importance', 'partial_dependence', 'ale', 'sage']
 
 # Create and use an explainer
 explainer = default_registry.create(
@@ -128,7 +129,7 @@ print(explanation.explanation_data["feature_attributions"])
 ```python
 # Find local explainers for tabular data
 local_tabular = default_registry.filter(scope="local", data_type="tabular")
-print(local_tabular)  # ['lime', 'shap', 'treeshap', 'anchors', 'counterfactual']
+print(local_tabular)  # ['lime', 'shap', 'treeshap', 'integrated_gradients', 'anchors', 'counterfactual']
 
 # Find explainers optimized for tree models
 tree_explainers = default_registry.filter(model_type="tree")
@@ -200,6 +201,32 @@ predictions, gradients = adapter.predict_with_gradients(X)
 activations = adapter.get_layer_output(X, layer_name="0")
 ```
 
+### Integrated Gradients for Neural Networks
+
+```python
+from explainiverse.explainers import IntegratedGradientsExplainer
+from explainiverse import PyTorchAdapter
+
+# Wrap your PyTorch model
+adapter = PyTorchAdapter(model, task="classification", class_names=class_names)
+
+# Create IG explainer
+explainer = IntegratedGradientsExplainer(
+    model=adapter,
+    feature_names=feature_names,
+    class_names=class_names,
+    n_steps=50  # More steps = more accurate
+)
+
+# Explain a prediction
+explanation = explainer.explain(X_test[0])
+print(explanation.explanation_data["feature_attributions"])
+
+# Check convergence (sum of attributions ≈ F(x) - F(baseline))
+explanation = explainer.explain(X_test[0], return_convergence_delta=True)
+print(f"Convergence delta: {explanation.explanation_data['convergence_delta']}")
+```
+
 ### Using Specific Explainers
 
 ```python
@@ -300,12 +327,12 @@ poetry run pytest tests/test_new_explainers.py -v
 ## Roadmap
 
 - [x] LIME, SHAP (KernelSHAP)
-- [x] TreeSHAP (optimized for tree models) ✅ NEW
+- [x] TreeSHAP (optimized for tree models) ✅
 - [x] Anchors, Counterfactuals
 - [x] Permutation Importance, PDP, ALE, SAGE
 - [x] Explainer Registry with filtering
-- [x] PyTorch Adapter ✅ NEW
-- [ ] Integrated Gradients (gradient-based for neural nets)
+- [x] PyTorch Adapter ✅
+- [x] Integrated Gradients ✅ NEW
 - [ ] GradCAM for CNNs
 - [ ] TensorFlow adapter
 - [ ] Interactive visualization dashboard

{explainiverse-0.2.2.dist-info → explainiverse-0.2.3.dist-info}/RECORD

@@ -1,4 +1,4 @@
-explainiverse/__init__.py,sha256=-4H6WbfGwpeoNpO9w0CEahKQBPsvIYe_lK5e10cZWD0,1612
+explainiverse/__init__.py,sha256=NmrLPOGZZPZTq1vY0G4gid5ZJWxsVGd3CfTXVIDvjaQ,1612
 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=GTilJAR1VF_OgWG88qZoqlqefHaSXB3i9iOwCJkyHTg,13318
@@ -6,12 +6,12 @@ explainiverse/adapters/sklearn_adapter.py,sha256=pzIBtMuqrG-6ZbUqUCMt7rSk3Ow0Fgr
 explainiverse/core/__init__.py,sha256=P3jHMnH5coFqTTO1w-gT-rurkCM1-9r3pF-055pbXMg,474
 explainiverse/core/explainer.py,sha256=Z9on-9VblYDlQx9oBm1BHpmAf_NsQajZ3qr-u48Aejo,784
 explainiverse/core/explanation.py,sha256=6zxFh_TH8tFHc-r_H5-WHQ05Sp1Kp2TxLz3gyFek5jo,881
-explainiverse/core/registry.py,sha256=_BXWi1fJY3cGjYA1Xn1DwvY91jbpJrpX6_8EVzrRT20,19876
+explainiverse/core/registry.py,sha256=AC8XDIdX2IGyx0KkmDajAjdo5YsrM3dcKvYoQu1vNCk,20711
 explainiverse/engine/__init__.py,sha256=1sZO8nH1mmwK2e-KUavBQm7zYDWUe27nyWoFy9tgsiA,197
 explainiverse/engine/suite.py,sha256=sq8SK_6Pf0qRckTmVJ7Mdosu9bhkjAGPGN8ymLGFP9E,4914
 explainiverse/evaluation/__init__.py,sha256=Y50L_b4HKthg4epwcayPHXh0l4i4MUuzvaNlqPmUNZY,212
 explainiverse/evaluation/metrics.py,sha256=tSBXtyA_-0zOGCGjlPZU6LdGKRH_QpWfgKa78sdlovs,7453
-explainiverse/explainers/__init__.py,sha256=Op-Z_BTJ7BdqA_9gTnruomN2-rKtrkPCt1Zq1iCzxr0,1758
+explainiverse/explainers/__init__.py,sha256=3yhamu1E2hpb0vE_hg3xK621YJdZYcy7gsSGgCT4Km4,1962
 explainiverse/explainers/attribution/__init__.py,sha256=YeVs9bS_IWDtqGbp6T37V6Zp5ZDWzLdAXHxxyFGpiQM,431
 explainiverse/explainers/attribution/lime_wrapper.py,sha256=OnXIV7t6yd-vt38sIi7XmHFbgzlZfCEbRlFyGGd5XiE,3245
 explainiverse/explainers/attribution/shap_wrapper.py,sha256=tKie5AvN7mb55PWOYdMvW0lUAYjfHPzYosEloEY2ZzI,3210
@@ -23,9 +23,11 @@ explainiverse/explainers/global_explainers/ale.py,sha256=tgG3XTppCf8LiD7uKzBt4DI
 explainiverse/explainers/global_explainers/partial_dependence.py,sha256=dH6yMjpwZads3pACR3rSykTbssLGHH7e6HfMlpl-S3I,6745
 explainiverse/explainers/global_explainers/permutation_importance.py,sha256=bcgKz1S_D3lrBMgpqEF_Z6qw8Knxl_cfR50hrSO2tBc,4410
 explainiverse/explainers/global_explainers/sage.py,sha256=57Xw1SK529x5JXWt0TVrcFYUUP3C65LfUwgoM-Z3gaw,5839
+explainiverse/explainers/gradient/__init__.py,sha256=Z4uSZcBhnHGp7DCd7bhcIMj_3f_uuCFw5AGA1JX6myQ,350
+explainiverse/explainers/gradient/integrated_gradients.py,sha256=feBgY3Vw2rDti7fxRZtLkxse75m2dbP_R05ARqo2BRM,13367
 explainiverse/explainers/rule_based/__init__.py,sha256=gKzlFCAzwurAMLJcuYgal4XhDj1thteBGcaHWmN7iWk,243
 explainiverse/explainers/rule_based/anchors_wrapper.py,sha256=ML7W6aam-eMGZHy5ilol8qupZvNBJpYAFatEEPnuMyo,13254
-explainiverse-0.2.2.dist-info/LICENSE,sha256=28rbHe8rJgmUlRdxJACfq1Sj-MtCEhyHxkJedQd1ZYA,1070
-explainiverse-0.2.2.dist-info/METADATA,sha256=kis3ejJCLRhBJWf5p13FzY2ZeSbnWfJxk6LS1hd7A1w,9497
-explainiverse-0.2.2.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-explainiverse-0.2.2.dist-info/RECORD,,
+explainiverse-0.2.3.dist-info/LICENSE,sha256=28rbHe8rJgmUlRdxJACfq1Sj-MtCEhyHxkJedQd1ZYA,1070
+explainiverse-0.2.3.dist-info/METADATA,sha256=TGuHUB9HZEcTbkQ7vmXl6ygm9arV5tlzufCHMoFqmdk,10465
+explainiverse-0.2.3.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+explainiverse-0.2.3.dist-info/RECORD,,