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

explainiverse/explainers/gradient/gradcam.py

@@ -0,0 +1,390 @@
+# src/explainiverse/explainers/gradient/gradcam.py
+"""
+GradCAM and GradCAM++ - Visual Explanations for CNNs.
+
+GradCAM produces visual explanations by highlighting important regions
+in an image that contribute to the model's prediction. It uses gradients
+flowing into the final convolutional layer to produce a coarse localization map.
+
+GradCAM++ improves upon GradCAM by using a weighted combination of positive
+partial derivatives, providing better localization for multiple instances
+of the same class.
+
+References:
+    GradCAM: Selvaraju et al., 2017 - "Grad-CAM: Visual Explanations from
+    Deep Networks via Gradient-based Localization"
+    https://arxiv.org/abs/1610.02391
+    
+    GradCAM++: Chattopadhay et al., 2018 - "Grad-CAM++: Generalized Gradient-based
+    Visual Explanations for Deep Convolutional Networks"
+    https://arxiv.org/abs/1710.11063
+
+Example:
+    from explainiverse.explainers.gradient import GradCAMExplainer
+    from explainiverse.adapters import PyTorchAdapter
+    
+    # For a CNN model
+    adapter = PyTorchAdapter(cnn_model, task="classification")
+    
+    explainer = GradCAMExplainer(
+        model=adapter,
+        target_layer="layer4",  # Last conv layer
+        class_names=class_names
+    )
+    
+    explanation = explainer.explain(image)
+    heatmap = explanation.explanation_data["heatmap"]
+"""
+
+import numpy as np
+from typing import List, Optional, Tuple, Union
+
+from explainiverse.core.explainer import BaseExplainer
+from explainiverse.core.explanation import Explanation
+
+
+class GradCAMExplainer(BaseExplainer):
+    """
+    GradCAM and GradCAM++ explainer for CNNs.
+    
+    Produces visual heatmaps showing which regions of an input image
+    are most important for the model's prediction.
+    
+    Attributes:
+        model: PyTorchAdapter wrapping a CNN model
+        target_layer: Name of the convolutional layer to use
+        class_names: List of class names
+        method: "gradcam" or "gradcam++"
+    """
+    
+    def __init__(
+        self,
+        model,
+        target_layer: str,
+        class_names: Optional[List[str]] = None,
+        method: str = "gradcam"
+    ):
+        """
+        Initialize the GradCAM explainer.
+        
+        Args:
+            model: A PyTorchAdapter wrapping a CNN model.
+            target_layer: Name of the target convolutional layer.
+                         Usually the last conv layer before the classifier.
+                         Use adapter.list_layers() to see available layers.
+            class_names: List of class names for classification.
+            method: "gradcam" for standard GradCAM, "gradcam++" for improved version.
+        """
+        super().__init__(model)
+        
+        # Validate model has layer access
+        if not hasattr(model, 'get_layer_gradients'):
+            raise TypeError(
+                "Model adapter must have get_layer_gradients() method. "
+                "Use PyTorchAdapter for PyTorch models."
+            )
+        
+        self.target_layer = target_layer
+        self.class_names = list(class_names) if class_names else None
+        self.method = method.lower()
+        
+        if self.method not in ["gradcam", "gradcam++"]:
+            raise ValueError(f"Method must be 'gradcam' or 'gradcam++', got '{method}'")
+    
+    def _compute_gradcam(
+        self,
+        activations: np.ndarray,
+        gradients: np.ndarray
+    ) -> np.ndarray:
+        """
+        Compute standard GradCAM heatmap.
+        
+        GradCAM = ReLU(sum_k(alpha_k * A^k))
+        where alpha_k = global_avg_pool(gradients for channel k)
+        """
+        # Global average pooling of gradients to get weights
+        # activations shape: (batch, channels, height, width)
+        # gradients shape: (batch, channels, height, width)
+        
+        # For each channel, compute the average gradient (importance weight)
+        weights = np.mean(gradients, axis=(2, 3), keepdims=True)  # (batch, channels, 1, 1)
+        
+        # Weighted combination of activation maps
+        cam = np.sum(weights * activations, axis=1)  # (batch, height, width)
+        
+        # Apply ReLU (we only care about positive influence)
+        cam = np.maximum(cam, 0)
+        
+        return cam
+    
+    def _compute_gradcam_plusplus(
+        self,
+        activations: np.ndarray,
+        gradients: np.ndarray
+    ) -> np.ndarray:
+        """
+        Compute GradCAM++ heatmap.
+        
+        GradCAM++ uses higher-order derivatives to weight the gradients,
+        providing better localization especially for multiple instances.
+        """
+        # First derivative
+        grad_2 = gradients ** 2
+        grad_3 = gradients ** 3
+        
+        # Sum over spatial dimensions for denominator
+        sum_activations = np.sum(activations, axis=(2, 3), keepdims=True)
+        
+        # Avoid division by zero
+        eps = 1e-8
+        
+        # Alpha coefficients (pixel-wise weights)
+        alpha_num = grad_2
+        alpha_denom = 2 * grad_2 + sum_activations * grad_3 + eps
+        alpha = alpha_num / alpha_denom
+        
+        # Set alpha to 0 where gradients are 0
+        alpha = np.where(gradients != 0, alpha, 0)
+        
+        # Weights are sum of (alpha * ReLU(gradients))
+        weights = np.sum(alpha * np.maximum(gradients, 0), axis=(2, 3), keepdims=True)
+        
+        # Weighted combination
+        cam = np.sum(weights * activations, axis=1)
+        
+        # Apply ReLU
+        cam = np.maximum(cam, 0)
+        
+        return cam
+    
+    def _normalize_heatmap(self, heatmap: np.ndarray) -> np.ndarray:
+        """Normalize heatmap to [0, 1] range."""
+        heatmap = heatmap.squeeze()
+        
+        min_val = heatmap.min()
+        max_val = heatmap.max()
+        
+        if max_val - min_val > 1e-8:
+            heatmap = (heatmap - min_val) / (max_val - min_val)
+        else:
+            heatmap = np.zeros_like(heatmap)
+        
+        return heatmap
+    
+    def _resize_heatmap(
+        self,
+        heatmap: np.ndarray,
+        target_size: Tuple[int, int]
+    ) -> np.ndarray:
+        """
+        Resize heatmap to match input image size.
+        
+        Uses simple bilinear-like interpolation without requiring scipy/cv2.
+        """
+        h, w = heatmap.shape
+        target_h, target_w = target_size
+        
+        # Create coordinate grids
+        y_ratio = h / target_h
+        x_ratio = w / target_w
+        
+        y_coords = np.arange(target_h) * y_ratio
+        x_coords = np.arange(target_w) * x_ratio
+        
+        # Get integer indices and fractions
+        y_floor = np.floor(y_coords).astype(int)
+        x_floor = np.floor(x_coords).astype(int)
+        
+        y_ceil = np.minimum(y_floor + 1, h - 1)
+        x_ceil = np.minimum(x_floor + 1, w - 1)
+        
+        y_frac = y_coords - y_floor
+        x_frac = x_coords - x_floor
+        
+        # Bilinear interpolation
+        resized = np.zeros((target_h, target_w))
+        for i in range(target_h):
+            for j in range(target_w):
+                top_left = heatmap[y_floor[i], x_floor[j]]
+                top_right = heatmap[y_floor[i], x_ceil[j]]
+                bottom_left = heatmap[y_ceil[i], x_floor[j]]
+                bottom_right = heatmap[y_ceil[i], x_ceil[j]]
+                
+                top = top_left * (1 - x_frac[j]) + top_right * x_frac[j]
+                bottom = bottom_left * (1 - x_frac[j]) + bottom_right * x_frac[j]
+                
+                resized[i, j] = top * (1 - y_frac[i]) + bottom * y_frac[i]
+        
+        return resized
+    
+    def explain(
+        self,
+        image: np.ndarray,
+        target_class: Optional[int] = None,
+        resize_to_input: bool = True
+    ) -> Explanation:
+        """
+        Generate GradCAM explanation for an image.
+        
+        Args:
+            image: Input image as numpy array. Expected shapes:
+                   - (C, H, W) for single image
+                   - (1, C, H, W) for batched single image
+                   - (H, W, C) will be transposed automatically
+            target_class: Class to explain. If None, uses predicted class.
+            resize_to_input: If True, resize heatmap to match input size.
+        
+        Returns:
+            Explanation object with heatmap and metadata.
+        """
+        image = np.array(image, dtype=np.float32)
+        
+        # Handle different input shapes
+        if image.ndim == 3:
+            # Could be (C, H, W) or (H, W, C)
+            if image.shape[0] in [1, 3, 4]:  # Likely (C, H, W)
+                image = image[np.newaxis, ...]  # Add batch dim
+            else:  # Likely (H, W, C)
+                image = np.transpose(image, (2, 0, 1))[np.newaxis, ...]
+        elif image.ndim == 4:
+            pass  # Already (N, C, H, W)
+        else:
+            raise ValueError(f"Expected 3D or 4D input, got shape {image.shape}")
+        
+        input_size = (image.shape[2], image.shape[3])  # (H, W)
+        
+        # Get activations and gradients for target layer
+        activations, gradients = self.model.get_layer_gradients(
+            image,
+            layer_name=self.target_layer,
+            target_class=target_class
+        )
+        
+        # Ensure 4D: (batch, channels, height, width)
+        if activations.ndim == 2:
+            # Fully connected layer output, reshape
+            side = int(np.sqrt(activations.shape[1]))
+            activations = activations.reshape(1, 1, side, side)
+            gradients = gradients.reshape(1, 1, side, side)
+        elif activations.ndim == 3:
+            activations = activations[np.newaxis, ...]
+            gradients = gradients[np.newaxis, ...]
+        
+        # Compute CAM based on method
+        if self.method == "gradcam":
+            cam = self._compute_gradcam(activations, gradients)
+        else:  # gradcam++
+            cam = self._compute_gradcam_plusplus(activations, gradients)
+        
+        # Normalize to [0, 1]
+        heatmap = self._normalize_heatmap(cam)
+        
+        # Optionally resize to input size
+        if resize_to_input and heatmap.shape != input_size:
+            heatmap = self._resize_heatmap(heatmap, input_size)
+        
+        # Determine target class info
+        if target_class is None:
+            predictions = self.model.predict(image)
+            target_class = int(np.argmax(predictions))
+        
+        if self.class_names and target_class < len(self.class_names):
+            label_name = self.class_names[target_class]
+        else:
+            label_name = f"class_{target_class}"
+        
+        return Explanation(
+            explainer_name=f"GradCAM" if self.method == "gradcam" else "GradCAM++",
+            target_class=label_name,
+            explanation_data={
+                "heatmap": heatmap.tolist(),
+                "heatmap_shape": list(heatmap.shape),
+                "target_layer": self.target_layer,
+                "method": self.method,
+                "input_shape": list(image.shape)
+            }
+        )
+    
+    def explain_batch(
+        self,
+        images: np.ndarray,
+        target_class: Optional[int] = None
+    ) -> List[Explanation]:
+        """
+        Generate explanations for multiple images.
+        
+        Args:
+            images: Batch of images (N, C, H, W).
+            target_class: Target class for all images.
+        
+        Returns:
+            List of Explanation objects.
+        """
+        images = np.array(images)
+        
+        return [
+            self.explain(images[i], target_class=target_class)
+            for i in range(images.shape[0])
+        ]
+    
+    def get_overlay(
+        self,
+        image: np.ndarray,
+        heatmap: np.ndarray,
+        alpha: float = 0.5,
+        colormap: str = "jet"
+    ) -> np.ndarray:
+        """
+        Create an overlay of the heatmap on the original image.
+        
+        This is a simple implementation without matplotlib/cv2 dependencies.
+        For better visualizations, use the heatmap with your preferred
+        visualization library.
+        
+        Args:
+            image: Original image (H, W, 3) in [0, 255] or [0, 1] range.
+            heatmap: GradCAM heatmap (H, W) in [0, 1] range.
+            alpha: Transparency of the heatmap overlay.
+            colormap: Color scheme (currently only "jet" supported).
+        
+        Returns:
+            Overlaid image as numpy array (H, W, 3) in [0, 1] range.
+        """
+        image = np.array(image)
+        heatmap = np.array(heatmap)
+        
+        # Normalize image to [0, 1]
+        if image.max() > 1:
+            image = image / 255.0
+        
+        # Handle channel-first format
+        if image.ndim == 3 and image.shape[0] in [1, 3]:
+            image = np.transpose(image, (1, 2, 0))
+        
+        # Simple jet colormap approximation
+        def jet_colormap(x):
+            """Simple jet colormap: blue -> cyan -> green -> yellow -> red"""
+            r = np.clip(1.5 - np.abs(4 * x - 3), 0, 1)
+            g = np.clip(1.5 - np.abs(4 * x - 2), 0, 1)
+            b = np.clip(1.5 - np.abs(4 * x - 1), 0, 1)
+            return np.stack([r, g, b], axis=-1)
+        
+        # Apply colormap to heatmap
+        colored_heatmap = jet_colormap(heatmap)
+        
+        # Ensure same size
+        if colored_heatmap.shape[:2] != image.shape[:2]:
+            colored_heatmap = self._resize_heatmap(
+                colored_heatmap.mean(axis=-1),
+                image.shape[:2]
+            )
+            colored_heatmap = jet_colormap(colored_heatmap)
+        
+        # Blend
+        if image.ndim == 2:
+            image = np.stack([image] * 3, axis=-1)
+        
+        overlay = (1 - alpha) * image + alpha * colored_heatmap
+        overlay = np.clip(overlay, 0, 1)
+        
+        return overlay

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: explainiverse
-Version: 0.2.3
+Version: 0.2.5
 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 10 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 11 state-of-the-art XAI methods, evaluation metrics, and a plugin registry for easy extensibility.
 
 ---
 
@@ -44,6 +44,7 @@ It provides a standardized interface for model-agnostic explainability with 10 s
 - **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))
+- **GradCAM/GradCAM++** - Visual explanations for CNNs ([Selvaraju et al., 2017](https://arxiv.org/abs/1610.02391))
 - **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))
 
@@ -110,7 +111,7 @@ adapter = SklearnAdapter(model, class_names=iris.target_names.tolist())
 
 # List available explainers
 print(default_registry.list_explainers())
-# ['lime', 'shap', 'treeshap', 'integrated_gradients', 'anchors', 'counterfactual', 'permutation_importance', 'partial_dependence', 'ale', 'sage']
+# ['lime', 'shap', 'treeshap', 'integrated_gradients', 'gradcam', 'anchors', 'counterfactual', 'permutation_importance', 'partial_dependence', 'ale', 'sage']
 
 # Create and use an explainer
 explainer = default_registry.create(
@@ -131,9 +132,9 @@ print(explanation.explanation_data["feature_attributions"])
 local_tabular = default_registry.filter(scope="local", data_type="tabular")
 print(local_tabular)  # ['lime', 'shap', 'treeshap', 'integrated_gradients', 'anchors', 'counterfactual']
 
-# Find explainers optimized for tree models
-tree_explainers = default_registry.filter(model_type="tree")
-print(tree_explainers)  # ['treeshap']
+# Find explainers for images/CNNs
+image_explainers = default_registry.filter(data_type="image")
+print(image_explainers)  # ['lime', 'integrated_gradients', 'gradcam']
 
 # Get recommendations
 recommendations = default_registry.recommend(
@@ -227,6 +228,35 @@ explanation = explainer.explain(X_test[0], return_convergence_delta=True)
 print(f"Convergence delta: {explanation.explanation_data['convergence_delta']}")
 ```
 
+### GradCAM for CNN Visual Explanations
+
+```python
+from explainiverse.explainers import GradCAMExplainer
+from explainiverse import PyTorchAdapter
+
+# Wrap your CNN model
+adapter = PyTorchAdapter(cnn_model, task="classification", class_names=class_names)
+
+# Find the last convolutional layer
+layers = adapter.list_layers()
+target_layer = "layer4"  # Adjust based on your model architecture
+
+# Create GradCAM explainer
+explainer = GradCAMExplainer(
+    model=adapter,
+    target_layer=target_layer,
+    class_names=class_names,
+    method="gradcam"  # or "gradcam++" for improved version
+)
+
+# Explain an image prediction
+explanation = explainer.explain(image)  # image shape: (C, H, W) or (N, C, H, W)
+heatmap = explanation.explanation_data["heatmap"]
+
+# Create overlay visualization
+overlay = explainer.get_overlay(original_image, heatmap, alpha=0.5)
+```
+
 ### Using Specific Explainers
 
 ```python
@@ -332,8 +362,8 @@ poetry run pytest tests/test_new_explainers.py -v
 - [x] Permutation Importance, PDP, ALE, SAGE
 - [x] Explainer Registry with filtering
 - [x] PyTorch Adapter ✅
-- [x] Integrated Gradients ✅ NEW
-- [ ] GradCAM for CNNs
+- [x] Integrated Gradients ✅
+- [x] GradCAM/GradCAM++ for CNNs ✅ NEW
 - [ ] TensorFlow adapter
 - [ ] Interactive visualization dashboard
 

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

@@ -1,4 +1,4 @@
-explainiverse/__init__.py,sha256=NmrLPOGZZPZTq1vY0G4gid5ZJWxsVGd3CfTXVIDvjaQ,1612
+explainiverse/__init__.py,sha256=UZDDS7fWplzGgUdRw_Fi9I6WmTGZ1QM3fo3ZPOPujg8,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=AC8XDIdX2IGyx0KkmDajAjdo5YsrM3dcKvYoQu1vNCk,20711
+explainiverse/core/registry.py,sha256=f1GAo2tg6Sjyz-uOPyLukYYSUgMmpb95pI3B6O-5jjo,22992
 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=3yhamu1E2hpb0vE_hg3xK621YJdZYcy7gsSGgCT4Km4,1962
+explainiverse/explainers/__init__.py,sha256=d7DTbUXzdVdN0l5GQnoJ4zzutI0TXNvx0UzwNXoWY9w,2207
 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,11 +23,13 @@ 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/__init__.py,sha256=ZJtESEQ8NcZwyZ09jA3Gkjw93pAloL_vfn07LTLVIzM,603
+explainiverse/explainers/gradient/deeplift.py,sha256=MWOlslizUeoZs31moy2iBgp02N08nBsVU-RoEpODg3M,27775
+explainiverse/explainers/gradient/gradcam.py,sha256=ywW_8PhALwegkpSUDQMFvvVFkA5NnMMW6BB5tb3i8bw,13721
 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.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,,
+explainiverse-0.2.5.dist-info/LICENSE,sha256=28rbHe8rJgmUlRdxJACfq1Sj-MtCEhyHxkJedQd1ZYA,1070
+explainiverse-0.2.5.dist-info/METADATA,sha256=ih7rkKiPaVBmdYHwMRKB3QfrOaCm68m3iHztt6SO5S0,11483
+explainiverse-0.2.5.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+explainiverse-0.2.5.dist-info/RECORD,,