complete Phase 1 - core ViT auditing toolkit implementation

requirements.txt

@@ -1,16 +1,10 @@
-# Core ML & Data
-torch>=2.0.0
-torchvision>=0.15.0
-transformers>=4.30.0
-numpy
-
-# Explainable AI
-captum>=0.6.0
-
-# Dashboard & Visualization
-gradio>=3.40.0
-Pillow>=9.0.0
+# requirements.txt - UPDATED FOR CURRENT PYTORCH VERSIONS
+torch>=2.2.0,<2.9.0
+torchvision>=0.17.0,<0.19.0
+transformers>=4.35.0
+captum>=0.7.0
+gradio>=4.19.0
+Pillow>=10.0.0
 matplotlib>=3.7.0
-
-# Utilities (for potential image handling)
-requests>=2.25.0
+numpy>=1.24.0
+requests>=2.28.0

src/explainer.py

@@ -0,0 +1,270 @@
+# src/explainer.py
+
+import torch
+import numpy as np
+import matplotlib.pyplot as plt
+from PIL import Image
+import captum
+from captum.attr import LayerGradCam, GradientShap
+from captum.attr import visualization as viz
+import torch.nn.functional as F
+
+class ViTWrapper(torch.nn.Module):
+    """
+    Wrapper class to make Hugging Face ViT compatible with Captum.
+    This returns raw tensors instead of Hugging Face output objects.
+    """
+    def __init__(self, model):
+        super().__init__()
+        self.model = model
+        
+    def forward(self, x):
+        # Hugging Face models expect pixel_values key
+        outputs = self.model(pixel_values=x)
+        return outputs.logits
+
+class AttentionHook:
+    """Hook to capture attention weights from ViT model"""
+    def __init__(self):
+        self.attention_weights = None
+        
+    def __call__(self, module, input, output):
+        # For ViT, attention weights are usually the second output
+        if len(output) >= 2:
+            self.attention_weights = output[1]  # attention weights
+        else:
+            self.attention_weights = None
+
+def explain_attention(model, processor, image, layer_index=6, head_index=0):
+    """
+    Extract and visualize attention weights using hooks.
+    """
+    try:
+        device = next(model.parameters()).device
+        
+        # Preprocess image
+        inputs = processor(images=image, return_tensors="pt")
+        inputs = {k: v.to(device) for k, v in inputs.items()}
+        
+        # Register hook to capture attention
+        hook = AttentionHook()
+        
+        # Try different layer access patterns
+        try:
+            # For standard ViT structure
+            target_layer = model.vit.encoder.layer[layer_index].attention.attention
+            handle = target_layer.register_forward_hook(hook)
+        except:
+            try:
+                # Alternative structure
+                target_layer = model.vit.encoder.layers[layer_index].attention.attention
+                handle = target_layer.register_forward_hook(hook)
+            except:
+                raise ValueError(f"Could not access layer {layer_index} for attention hook")
+        
+        # Forward pass to capture attention
+        with torch.no_grad():
+            _ = model(**inputs)
+        
+        # Remove hook
+        handle.remove()
+        
+        if hook.attention_weights is None:
+            raise ValueError("No attention weights captured by hook")
+        
+        # Get attention weights
+        attention_weights = hook.attention_weights  # Shape: (batch, heads, seq_len, seq_len)
+        attention_map = attention_weights[0, head_index]  # Shape: (seq_len, seq_len)
+        
+        # Remove CLS token attention to other tokens
+        patch_attention = attention_map[1:, 1:]  # Remove CLS token rows and columns
+        
+        # Create visualization
+        fig, ax = plt.subplots(figsize=(8, 6))
+        
+        # Display attention matrix
+        im = ax.imshow(patch_attention.cpu().numpy(), cmap='viridis', aspect='auto')
+        
+        ax.set_title(f'Attention Map - Layer {layer_index}, Head {head_index}', fontsize=14, fontweight='bold')
+        ax.set_xlabel('Key Patches')
+        ax.set_ylabel('Query Patches')
+        
+        # Add colorbar
+        plt.colorbar(im, ax=ax)
+        
+        plt.tight_layout()
+        return fig
+        
+    except Exception as e:
+        print(f"Error in attention visualization: {str(e)}")
+        # Return a simple error plot
+        fig, ax = plt.subplots(figsize=(8, 6))
+        ax.text(0.5, 0.5, f"Attention visualization failed:\n{str(e)}", 
+                ha='center', va='center', transform=ax.transAxes, fontsize=10)
+        ax.set_title('Attention Visualization Error')
+        return fig
+
+def explain_gradcam(model, processor, image, target_layer_index=-2):
+    """
+    Generate GradCAM heatmap for the predicted class.
+    """
+    try:
+        device = next(model.parameters()).device
+        
+        # Preprocess image
+        inputs = processor(images=image, return_tensors="pt")
+        input_tensor = inputs['pixel_values'].to(device)
+        
+        # Get prediction
+        with torch.no_grad():
+            outputs = model(input_tensor)
+            predicted_class = outputs.logits.argmax(dim=1).item()
+        
+        # Get the target layer
+        try:
+            target_layer = model.vit.encoder.layer[target_layer_index].attention.attention
+        except:
+            target_layer = model.vit.encoder.layers[target_layer_index].attention.attention
+        
+        # Create wrapped model for Captum compatibility
+        wrapped_model = ViTWrapper(model)
+        
+        # Initialize GradCAM with wrapped model
+        gradcam = LayerGradCam(wrapped_model, target_layer)
+        
+        # Generate attribution - handle tuple output
+        attribution = gradcam.attribute(input_tensor, target=predicted_class)
+        
+        # FIX: Handle tuple output by taking the first element
+        if isinstance(attribution, tuple):
+            attribution = attribution[0]
+        
+        # Convert attribution to heatmap
+        attribution = attribution.squeeze().cpu().detach().numpy()
+        
+        # Normalize attribution
+        if attribution.max() > attribution.min():
+            attribution = (attribution - attribution.min()) / (attribution.max() - attribution.min())
+        else:
+            attribution = np.zeros_like(attribution)
+        
+        # Resize heatmap to match original image
+        original_size = image.size
+        heatmap = Image.fromarray((attribution * 255).astype(np.uint8))
+        heatmap = heatmap.resize(original_size, Image.Resampling.LANCZOS)
+        heatmap = np.array(heatmap)
+        
+        # Create visualization figure
+        fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(15, 5))
+        
+        # Original image
+        ax1.imshow(image)
+        ax1.set_title('Original Image')
+        ax1.axis('off')
+        
+        # Heatmap
+        ax2.imshow(heatmap, cmap='hot')
+        ax2.set_title('GradCAM Heatmap')
+        ax2.axis('off')
+        
+        # Overlay
+        ax3.imshow(image)
+        ax3.imshow(heatmap, cmap='hot', alpha=0.5)
+        ax3.set_title('Overlay')
+        ax3.axis('off')
+        
+        plt.tight_layout()
+        
+        # Create overlay image for dashboard
+        heatmap_rgb = (plt.cm.hot(heatmap / 255.0)[:, :, :3] * 255).astype(np.uint8)
+        overlay_img = Image.fromarray(heatmap_rgb)
+        overlay_img = overlay_img.resize(original_size, Image.Resampling.LANCZOS)
+        
+        # Blend with original
+        original_rgba = image.convert('RGBA')
+        overlay_rgba = overlay_img.convert('RGBA')
+        blended = Image.blend(original_rgba, overlay_rgba, alpha=0.5)
+        
+        return fig, blended.convert('RGB')
+        
+    except Exception as e:
+        print(f"Error in GradCAM: {str(e)}")
+        fig, ax = plt.subplots(figsize=(8, 6))
+        ax.text(0.5, 0.5, f"GradCAM failed:\n{str(e)}", 
+                ha='center', va='center', transform=ax.transAxes, fontsize=10)
+        ax.set_title('GradCAM Error')
+        return fig, image
+
+def explain_gradient_shap(model, processor, image, n_samples=5):
+    """
+    Generate GradientSHAP explanations.
+    """
+    try:
+        device = next(model.parameters()).device
+        
+        # Preprocess image
+        inputs = processor(images=image, return_tensors="pt")
+        input_tensor = inputs['pixel_values'].to(device)
+        
+        # Get prediction
+        with torch.no_grad():
+            outputs = model(input_tensor)
+            predicted_class = outputs.logits.argmax(dim=1).item()
+        
+        # Create baseline (black image)
+        baseline = torch.zeros_like(input_tensor)
+        
+        # Create wrapped model for Captum compatibility
+        wrapped_model = ViTWrapper(model)
+        
+        # Initialize GradientSHAP with wrapped model
+        gradient_shap = GradientShap(wrapped_model)
+        
+        # Generate attribution
+        attribution = gradient_shap.attribute(
+            input_tensor,
+            baselines=baseline,
+            n_samples=n_samples,
+            target=predicted_class
+        )
+        
+        # Summarize attribution across channels
+        attribution = attribution.squeeze().sum(dim=0).cpu().detach().numpy()
+        
+        # Normalize
+        if attribution.max() > attribution.min():
+            attribution = (attribution - attribution.min()) / (attribution.max() - attribution.min())
+        else:
+            attribution = np.zeros_like(attribution)
+        
+        # Create visualization
+        fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(15, 5))
+        
+        # Original image
+        ax1.imshow(image)
+        ax1.set_title('Original Image')
+        ax1.axis('off')
+        
+        # SHAP attribution
+        im = ax2.imshow(attribution, cmap='coolwarm')
+        ax2.set_title('GradientSHAP Attribution')
+        ax2.axis('off')
+        plt.colorbar(im, ax=ax2)
+        
+        # Overlay
+        ax3.imshow(image, alpha=0.7)
+        im_overlay = ax3.imshow(attribution, cmap='coolwarm', alpha=0.5)
+        ax3.set_title('Attribution Overlay')
+        ax3.axis('off')
+        plt.colorbar(im_overlay, ax=ax3)
+        
+        plt.tight_layout()
+        return fig
+        
+    except Exception as e:
+        print(f"Error in GradientSHAP: {str(e)}")
+        fig, ax = plt.subplots(figsize=(8, 6))
+        ax.text(0.5, 0.5, f"GradientSHAP failed:\n{str(e)}", 
+                ha='center', va='center', transform=ax.transAxes, fontsize=10)
+        ax.set_title('GradientSHAP Error')
+        return fig

src/model_loader.py

@@ -0,0 +1,44 @@
+# src/model_loader.py
+
+from transformers import ViTImageProcessor, ViTForImageClassification
+import torch
+
+def load_model_and_processor(model_name="google/vit-base-patch16-224"):
+    """
+    Load a Vision Transformer model and its corresponding processor from Hugging Face.
+    """
+    try:
+        print(f"Loading model {model_name}...")
+        
+        # Load processor and model with eager attention implementation
+        processor = ViTImageProcessor.from_pretrained(model_name)
+        
+        # Force eager attention implementation to get attention weights
+        model = ViTForImageClassification.from_pretrained(
+            model_name,
+            attn_implementation="eager"  # This enables attention output
+        )
+        
+        # Now we can safely set output_attentions
+        model.config.output_attentions = True
+        
+        # Set device
+        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        model = model.to(device)
+        
+        # Set model to evaluation mode
+        model.eval()
+        
+        print(f"✅ Model and processor loaded successfully on {device}!")
+        print(f"   Using attention implementation: {model.config._attn_implementation}")
+        return model, processor
+        
+    except Exception as e:
+        print(f"Error loading model {model_name}: {str(e)}")
+        raise
+
+# Supported models
+SUPPORTED_MODELS = {
+    "ViT-Base": "google/vit-base-patch16-224",
+    "ViT-Large": "google/vit-large-patch16-224",
+}

src/predictor.py

@@ -0,0 +1,86 @@
+# src/predictor.py
+
+import torch
+import torch.nn.functional as F
+from PIL import Image
+import matplotlib.pyplot as plt
+import numpy as np
+
+def predict_image(image, model, processor, top_k=5):
+    """
+    Perform inference on an image and return top-k predictions.
+    
+    Args:
+        image (PIL.Image): Input image to classify.
+        model: Loaded ViT model.
+        processor: Loaded ViT processor.
+        top_k (int): Number of top predictions to return.
+    
+    Returns:
+        tuple: (top_probs, top_indices, top_labels) - Probabilities, class indices, and label names.
+    """
+    try:
+        # Get the device from the model
+        device = next(model.parameters()).device
+        
+        # Preprocess the image - note: current processors return pixel_values
+        inputs = processor(images=image, return_tensors="pt")
+        inputs = {k: v.to(device) for k, v in inputs.items()}
+        
+        # Perform inference
+        with torch.no_grad():
+            outputs = model(**inputs)
+            logits = outputs.logits
+            
+        # Apply softmax to get probabilities
+        probabilities = F.softmax(logits, dim=-1)[0]
+        
+        # Get top-k predictions
+        top_probs, top_indices = torch.topk(probabilities, top_k)
+        
+        # Convert to Python lists and numpy arrays
+        top_probs = top_probs.cpu().numpy()
+        top_indices = top_indices.cpu().numpy()
+        
+        # Get human-readable labels
+        top_labels = [model.config.id2label[idx] for idx in top_indices]
+        
+        return top_probs, top_indices, top_labels
+        
+    except Exception as e:
+        print(f"Error during prediction: {str(e)}")
+        raise
+
+def create_prediction_plot(probs, labels):
+    """
+    Create a clean, professional bar chart for top predictions.
+    
+    Args:
+        probs (np.array): Array of probabilities.
+        labels (list): List of label names.
+    
+    Returns:
+        matplotlib.figure.Figure: The generated plot figure.
+    """
+    fig, ax = plt.subplots(figsize=(8, 4))
+    
+    # Create horizontal bar chart
+    y_pos = np.arange(len(labels))
+    bars = ax.barh(y_pos, probs, color='skyblue', alpha=0.8)
+    ax.set_yticks(y_pos)
+    ax.set_yticklabels(labels, fontsize=10)
+    ax.set_xlabel('Confidence', fontsize=12)
+    ax.set_title('Top Predictions', fontsize=14, fontweight='bold')
+    
+    # Add probability text on bars
+    for i, (bar, prob) in enumerate(zip(bars, probs)):
+        width = bar.get_width()
+        ax.text(width + 0.01, bar.get_y() + bar.get_height()/2, 
+                f'{prob:.2%}', va='center', fontsize=9)
+    
+    # Set x-axis limit and style
+    ax.set_xlim(0, max(probs) * 1.15)  # Add some padding for text
+    ax.grid(axis='x', alpha=0.3, linestyle='--')
+    
+    plt.tight_layout()
+    return fig

src/utils.py

@@ -0,0 +1,143 @@
+# src/utils.py
+
+import numpy as np
+import matplotlib.pyplot as plt
+from PIL import Image
+import torch
+
+def preprocess_image(image, target_size=224):
+    """
+    Preprocess image for ViT model.
+    
+    Args:
+        image: PIL Image or file path
+        target_size: Target size for resizing
+    
+    Returns:
+        PIL.Image: Preprocessed image
+    """
+    if isinstance(image, str):
+        # If it's a file path, load the image
+        image = Image.open(image)
+    
+    # Convert to RGB if necessary
+    if image.mode != 'RGB':
+        image = image.convert('RGB')
+    
+    # Resize image
+    image = image.resize((target_size, target_size))
+    
+    return image
+
+def normalize_heatmap(heatmap):
+    """
+    Normalize heatmap to [0, 1] range.
+    
+    Args:
+        heatmap: numpy array of heatmap values
+    
+    Returns:
+        numpy.array: Normalized heatmap
+    """
+    if heatmap.max() > heatmap.min():
+        return (heatmap - heatmap.min()) / (heatmap.max() - heatmap.min())
+    else:
+        return np.zeros_like(heatmap)
+
+def overlay_heatmap(image, heatmap, alpha=0.5, colormap='hot'):
+    """
+    Overlay heatmap on original image.
+    
+    Args:
+        image: PIL Image
+        heatmap: numpy array of heatmap values
+        alpha: Transparency for heatmap overlay
+        colormap: Matplotlib colormap name
+    
+    Returns:
+        PIL.Image: Image with heatmap overlay
+    """
+    # Normalize heatmap
+    heatmap = normalize_heatmap(heatmap)
+    
+    # Convert heatmap to RGB using colormap
+    cmap = plt.get_cmap(colormap)
+    heatmap_rgb = (cmap(heatmap)[:, :, :3] * 255).astype(np.uint8)
+    
+    # Resize heatmap to match image size
+    heatmap_img = Image.fromarray(heatmap_rgb)
+    heatmap_img = heatmap_img.resize(image.size, Image.Resampling.LANCZOS)
+    
+    # Blend images
+    original_rgba = image.convert('RGBA')
+    heatmap_rgba = heatmap_img.convert('RGBA')
+    blended = Image.blend(original_rgba, heatmap_rgba, alpha)
+    
+    return blended.convert('RGB')
+
+def create_comparison_figure(original_image, explanation_images, explanation_titles):
+    """
+    Create a comparison figure showing original image and multiple explanations.
+    
+    Args:
+        original_image: PIL Image
+        explanation_images: List of explanation images
+        explanation_titles: List of titles for each explanation
+    
+    Returns:
+        matplotlib.figure.Figure: Comparison figure
+    """
+    num_explanations = len(explanation_images)
+    fig, axes = plt.subplots(1, num_explanations + 1, figsize=(4 * (num_explanations + 1), 4))
+    
+    # Plot original image
+    axes[0].imshow(original_image)
+    axes[0].set_title('Original Image', fontweight='bold')
+    axes[0].axis('off')
+    
+    # Plot explanations
+    for i, (exp_img, title) in enumerate(zip(explanation_images, explanation_titles)):
+        axes[i + 1].imshow(exp_img)
+        axes[i + 1].set_title(title, fontweight='bold')
+        axes[i + 1].axis('off')
+    
+    plt.tight_layout()
+    return fig
+
+def tensor_to_image(tensor):
+    """
+    Convert PyTorch tensor to PIL Image.
+    
+    Args:
+        tensor: PyTorch tensor of shape (C, H, W) or (B, C, H, W)
+    
+    Returns:
+        PIL.Image: Converted image
+    """
+    if tensor.dim() == 4:
+        tensor = tensor.squeeze(0)
+    
+    # Denormalize if needed and convert to numpy
+    tensor = tensor.cpu().detach()
+    if tensor.min() < 0 or tensor.max() > 1:
+        # Assume it's normalized, denormalize to [0, 1]
+        tensor = (tensor - tensor.min()) / (tensor.max() - tensor.min())
+    
+    numpy_image = tensor.permute(1, 2, 0).numpy()
+    numpy_image = (numpy_image * 255).astype(np.uint8)
+    
+    return Image.fromarray(numpy_image)
+
+def get_top_predictions_dict(probs, labels, top_k=5):
+    """
+    Convert top predictions to dictionary for Gradio Label component.
+    
+    Args:
+        probs: Array of probabilities
+        labels: List of label names
+        top_k: Number of top predictions to include
+    
+    Returns:
+        dict: Dictionary of {label: probability} for top-k predictions
+    """
+    return {label: float(prob) for label, prob in zip(labels[:top_k], probs[:top_k])}

tests/test_phase1_complete.py

@@ -0,0 +1,178 @@
+# test_phase1_complete.py
+
+import sys
+import os
+sys.path.append(os.path.join(os.path.dirname(__file__), 'src'))
+
+from model_loader import load_model_and_processor, SUPPORTED_MODELS
+from predictor import predict_image, create_prediction_plot
+from explainer import explain_attention, explain_gradcam, explain_gradient_shap
+from utils import preprocess_image, create_comparison_figure, get_top_predictions_dict
+from PIL import Image
+import matplotlib.pyplot as plt
+import numpy as np
+
+def test_phase1_complete():
+    """
+    Complete Phase 1 Test - Tests all components together.
+    """
+    print("🧪 ViT Auditing Toolkit - Phase 1 Complete Test")
+    print("=" * 50)
+    
+    try:
+        # Test 1: Model Loading
+        print("1. Testing Model Loading...")
+        model, processor = load_model_and_processor()
+        print(f"   ✅ Loaded: {SUPPORTED_MODELS['ViT-Base']}")
+        
+        # Test 2: Create test image using utils
+        print("2. Testing Image Preprocessing...")
+        # Create a more realistic test image
+        test_image = Image.new('RGB', (300, 200), color=(150, 75, 75))
+        # Add different colored regions
+        for x in range(50, 150):
+            for y in range(50, 150):
+                test_image.putpixel((x, y), (75, 150, 75))  # Green rectangle
+        for x in range(180, 280):
+            for y in range(30, 100):
+                test_image.putpixel((x, y), (75, 75, 150))  # Blue rectangle
+        
+        # Preprocess using utils
+        processed_image = preprocess_image(test_image, target_size=224)
+        print(f"   ✅ Original size: {test_image.size}, Processed: {processed_image.size}")
+        
+        # Test 3: Prediction Pipeline
+        print("3. Testing Prediction Pipeline...")
+        probs, indices, labels = predict_image(processed_image, model, processor, top_k=5)
+        pred_fig = create_prediction_plot(probs, labels)
+        
+        # Test utils function
+        pred_dict = get_top_predictions_dict(probs, labels)
+        print(f"   ✅ Top prediction: {labels[0]} ({probs[0]:.2%})")
+        
+        # Test 4: Attention Explanation
+        print("4. Testing Attention Visualization...")
+        attention_fig = explain_attention(model, processor, processed_image, layer_index=6, head_index=0)
+        print("   ✅ Attention visualization generated")
+        
+        # Test 5: GradCAM Explanation
+        print("5. Testing GradCAM...")
+        gradcam_fig, gradcam_overlay = explain_gradcam(model, processor, processed_image)
+        print("   ✅ GradCAM visualization generated")
+        
+        # Test 6: GradientSHAP Explanation
+        print("6. Testing GradientSHAP...")
+        shap_fig = explain_gradient_shap(model, processor, processed_image, n_samples=3)
+        print("   ✅ GradientSHAP visualization generated")
+        
+        # Test 7: Utils - Comparison Figure
+        print("7. Testing Utils - Comparison Figure...")
+        comparison_fig = create_comparison_figure(
+            processed_image,
+            [gradcam_overlay],
+            ['GradCAM Overlay']
+        )
+        print("   ✅ Comparison figure generated")
+        
+        # Display Results
+        print("\n📊 DISPLAYING RESULTS:")
+        print("=" * 30)
+        
+        # Show prediction results
+        plt.figure(pred_fig.number)
+        plt.suptitle("1. Model Predictions", fontweight='bold', y=1.02)
+        plt.show()
+        
+        # Show attention results
+        plt.figure(attention_fig.number)
+        plt.suptitle("2. Attention Visualization", fontweight='bold', y=1.02)
+        plt.show()
+        
+        # Show GradCAM results
+        plt.figure(gradcam_fig.number)
+        plt.suptitle("3. GradCAM Explanation", fontweight='bold', y=1.02)
+        plt.show()
+        
+        # Show SHAP results
+        plt.figure(shap_fig.number)
+        plt.suptitle("4. GradientSHAP Explanation", fontweight='bold', y=1.02)
+        plt.show()
+        
+        # Show comparison
+        plt.figure(comparison_fig.number)
+        plt.suptitle("5. Comparison View", fontweight='bold', y=1.02)
+        plt.show()
+        
+        # Summary
+        print("\n🎉 PHASE 1 COMPLETE SUMMARY:")
+        print("=" * 35)
+        print("✅ Model Loading & Preprocessing")
+        print("✅ Prediction Pipeline with Visualization") 
+        print("✅ Attention Visualization")
+        print("✅ GradCAM Explanations")
+        print("✅ GradientSHAP Explanations")
+        print("✅ Utility Functions")
+        print(f"✅ All components integrated successfully!")
+        print("\n🚀 Ready for Phase 2: Dashboard Integration!")
+        
+        return True
+        
+    except Exception as e:
+        print(f"\n❌ Phase 1 Test Failed: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+def test_individual_components():
+    """
+    Test individual components for debugging.
+    """
+    print("\n🔧 Individual Component Tests:")
+    print("-" * 30)
+    
+    try:
+        # Test model loading
+        model, processor = load_model_and_processor()
+        print("✅ Model loading: PASS")
+        
+        # Test image creation
+        test_img = Image.new('RGB', (224, 224), color='red')
+        print("✅ Image creation: PASS")
+        
+        # Test prediction
+        probs, indices, labels = predict_image(test_img, model, processor)
+        print("✅ Prediction: PASS")
+        
+        # Test attention
+        attn_fig = explain_attention(model, processor, test_img)
+        print("✅ Attention: PASS")
+        
+        # Test GradCAM
+        gc_fig, gc_img = explain_gradcam(model, processor, test_img)
+        print("✅ GradCAM: PASS")
+        
+        # Test SHAP
+        shap_fig = explain_gradient_shap(model, processor, test_img, n_samples=2)
+        print("✅ GradientSHAP: PASS")
+        
+        # Test utils
+        from utils import normalize_heatmap
+        test_heatmap = np.random.rand(10, 10)
+        normalized = normalize_heatmap(test_heatmap)
+        print("✅ Utils: PASS")
+        
+        print("\n🎉 All individual components working!")
+        
+    except Exception as e:
+        print(f"❌ Component test failed: {e}")
+
+if __name__ == "__main__":
+    # Run complete test
+    success = test_phase1_complete()
+    
+    if success:
+        # Run quick individual tests
+        test_individual_components()
+    else:
+        print("\n⚠️  Running individual component tests for debugging...")
+        test_individual_components()