Add GRAD-CAM++, and LayerCAM visualizations

app.py

@@ -22,8 +22,8 @@ from transformers import (
     AutoImageProcessor
 )
 
-# GRAD-CAM
-from pytorch_grad_cam import GradCAM
+# GRAD-CAM variants
+from pytorch_grad_cam import GradCAM, GradCAMPlusPlus, LayerCAM
 from pytorch_grad_cam.utils.image import show_cam_on_image
 from pytorch_grad_cam.utils.model_targets import ClassifierOutputTarget
 
@@ -113,13 +113,13 @@ def get_target_layers(model):
     return [model.convnextv2.encoder.stages[-1].layers[-1]]
 
 
-def apply_gradcam(
+def apply_cam_methods(
     pixel_values: torch.Tensor,
     original_image: np.ndarray,
     target_class: Optional[int] = None
-) -> Tuple[np.ndarray, int, float]:
+) -> Tuple[np.ndarray, np.ndarray, np.ndarray, int, float]:
     """
-    Apply GRAD-CAM to visualize model attention.
+    Apply GRAD-CAM, GRAD-CAM++, and LayerCAM to visualize model attention.
 
     Args:
         pixel_values: Preprocessed image tensor
@@ -127,7 +127,7 @@ def apply_gradcam(
         target_class: Target class index (None for predicted class)
 
     Returns:
-        Tuple of (visualization, predicted_class, confidence)
+        Tuple of (gradcam_viz, gradcam_pp_viz, layercam_viz, predicted_class, confidence)
     """
     # Wrap the model
     wrapped_model = ConvNeXtGradCAMWrapper(model)
@@ -135,8 +135,10 @@ def apply_gradcam(
     # Get target layers
     target_layers = get_target_layers(model)
 
-    # Initialize GRAD-CAM
-    cam = GradCAM(model=wrapped_model, target_layers=target_layers)
+    # Initialize all CAM methods
+    gradcam = GradCAM(model=wrapped_model, target_layers=target_layers)
+    gradcam_pp = GradCAMPlusPlus(model=wrapped_model, target_layers=target_layers)
+    layercam = LayerCAM(model=wrapped_model, target_layers=target_layers)
 
     # Get prediction
     model.eval()
@@ -150,26 +152,41 @@ def apply_gradcam(
     if target_class is None:
         target_class = predicted_class
 
-    # Create target for GRAD-CAM
+    # Create target for CAM methods
     targets = [ClassifierOutputTarget(target_class)]
 
-    # Generate GRAD-CAM
-    grayscale_cam = cam(input_tensor=pixel_values, targets=targets)
-    grayscale_cam = grayscale_cam[0, :]
+    # Generate all CAM visualizations
+    grayscale_gradcam = gradcam(input_tensor=pixel_values, targets=targets)[0, :]
+    grayscale_gradcam_pp = gradcam_pp(input_tensor=pixel_values, targets=targets)[0, :]
+    grayscale_layercam = layercam(input_tensor=pixel_values, targets=targets)[0, :]
 
     # Resize original image to match CAM dimensions
-    cam_h, cam_w = grayscale_cam.shape
+    cam_h, cam_w = grayscale_gradcam.shape
     rgb_image_for_overlay = cv2.resize(original_image, (cam_w, cam_h)).astype(np.float32) / 255.0
 
-    # Create visualization
-    visualization = show_cam_on_image(
+    # Create visualizations for all methods
+    viz_gradcam = show_cam_on_image(
         rgb_image_for_overlay,
-        grayscale_cam,
+        grayscale_gradcam,
+        use_rgb=True,
+        colormap=cv2.COLORMAP_JET
+    )
+    
+    viz_gradcam_pp = show_cam_on_image(
+        rgb_image_for_overlay,
+        grayscale_gradcam_pp,
+        use_rgb=True,
+        colormap=cv2.COLORMAP_JET
+    )
+    
+    viz_layercam = show_cam_on_image(
+        rgb_image_for_overlay,
+        grayscale_layercam,
         use_rgb=True,
         colormap=cv2.COLORMAP_JET
     )
 
-    return visualization, predicted_class, float(probabilities[predicted_class].item())
+    return viz_gradcam, viz_gradcam_pp, viz_layercam, predicted_class, float(probabilities[predicted_class].item())
 
 
 # ========== GRADIO INTERFACE FUNCTIONS ==========
@@ -212,16 +229,16 @@ def predict_basic(image):
 
 def predict_with_explainability(image):
     """
-    Prediction with GRAD-CAM explainability.
+    Prediction with multiple CAM explainability methods.
     
     Args:
         image: PIL Image or numpy array
         
     Returns:
-        Tuple of (probabilities_dict, gradcam_image, info_text)
+        Tuple of (probabilities_dict, gradcam_image, gradcam_pp_image, layercam_image, info_text)
     """
     if image is None:
-        return None, None, "Please upload an image."
+        return None, None, None, None, "Please upload an image."
     
     try:
         # Convert to PIL Image if needed
@@ -239,8 +256,10 @@ def predict_with_explainability(image):
             probabilities = F.softmax(logits, dim=-1)[0]
             predicted_class = logits.argmax(-1).item()
         
-        # Apply GRAD-CAM
-        visualization, pred_class, confidence = apply_gradcam(pixel_values, original_image)
+        # Apply all CAM methods
+        viz_gradcam, viz_gradcam_pp, viz_layercam, pred_class, confidence = apply_cam_methods(
+            pixel_values, original_image
+        )
         
         # Format probabilities for Gradio
         probs_dict = {DISPLAY_NAMES[i]: float(probabilities[i]) for i in range(len(DISPLAY_NAMES))}
@@ -248,13 +267,13 @@ def predict_with_explainability(image):
         # Create info text
         info_text = f"**Predicted Class:** {DISPLAY_NAMES[predicted_class]}\n\n"
         info_text += f"**Confidence:** {confidence*100:.2f}%\n\n"
-        info_text += "The heatmap shows regions the model focused on for classification."
+        info_text += "The heatmaps show regions the model focused on for classification using different visualization methods."
         
-        return probs_dict, visualization, info_text
+        return probs_dict, viz_gradcam, viz_gradcam_pp, viz_layercam, info_text
     
     except Exception as e:
         print(f"Error in prediction with explainability: {e}")
-        return None, None, f"Error: {str(e)}"
+        return None, None, None, None, f"Error: {str(e)}"
 
 
 # ========== GRADIO INTERFACE ==========
@@ -306,8 +325,8 @@ with gr.Blocks(css=custom_css, title="Project Phoenix - Cervical Cancer Cell Cla
             )
         
         # Tab 2: Prediction with Explainability
-        with gr.TabItem("🔍 Prediction + Explainability (GRAD-CAM)"):
-            gr.Markdown("Upload an image to classify and visualize model attention using GRAD-CAM.")
+        with gr.TabItem("🔍 Prediction + Explainability (CAM Methods)"):
+            gr.Markdown("Upload an image to classify and visualize model attention using GRAD-CAM, GRAD-CAM++, and LayerCAM.")
             
             with gr.Row():
                 with gr.Column():
@@ -316,13 +335,16 @@ with gr.Blocks(css=custom_css, title="Project Phoenix - Cervical Cancer Cell Cla
                 
                 with gr.Column():
                     output_label_explain = gr.Label(label="Classification Results", num_top_classes=5)
-                    output_gradcam = gr.Image(label="GRAD-CAM Heatmap")
+                    with gr.Row():
+                        output_gradcam = gr.Image(label="GRAD-CAM")
+                        output_gradcam_pp = gr.Image(label="GRAD-CAM++")
+                        output_layercam = gr.Image(label="LayerCAM")
                     output_info = gr.Markdown(label="Analysis")
             
             predict_btn_explain.click(
                 fn=predict_with_explainability,
                 inputs=input_image_explain,
-                outputs=[output_label_explain, output_gradcam, output_info],
+                outputs=[output_label_explain, output_gradcam, output_gradcam_pp, output_layercam, output_info],
                 api_name="predict_with_explainability",
                 queue=False
             )