Upload 4 files

app (1).py

@@ -0,0 +1,76 @@
+import torch
+import torch.nn as nn
+import torchvision.transforms as transforms
+from torchvision.models import vgg16, VGG16_Weights
+from PIL import Image
+import gradio as gr
+import numpy as np
+import cv2
+from gradcam import GradCAM, apply_heatmap
+
+# Categories for classification
+categories = ["COVID", "Lung_Opacity", "Normal", "Viral Pneumonia"]
+
+# Load Pretrained VGG16 Model
+print("Loading Model...")
+device = torch.device("cpu")
+vgg_model = vgg16(weights=VGG16_Weights.IMAGENET1K_V1)
+for param in vgg_model.features.parameters():
+    param.requires_grad = False
+vgg_model.classifier[6] = nn.Linear(4096, 4)
+vgg_model.load_state_dict(torch.load("vgg_xray_model.pth", map_location=device))
+vgg_model = vgg_model.to(device)
+vgg_model.eval()
+print("Model Loaded Successfully!")
+
+# Initialize Grad-CAM with the last convolutional layer
+gradcam = GradCAM(vgg_model, vgg_model.features[-1])
+
+# Image Preprocessing
+transform = transforms.Compose([
+    transforms.Resize((224, 224)),
+    transforms.ToTensor(),
+    transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
+])
+
+# Prediction function with Grad-CAM
+def predict(image):
+    # Preprocess image
+    image_tensor = transform(image).unsqueeze(0).to(device)  # Add batch dimension
+
+    # Perform inference (no gradients)
+    with torch.no_grad():
+        output = vgg_model(image_tensor)
+        _, predicted = torch.max(output, 1)
+        prediction = categories[predicted.item()]
+    
+    # Enable gradients for Grad-CAM
+    image_tensor.requires_grad_()
+    heatmap = gradcam.generate_heatmap(image_tensor, predicted.item())
+
+    # Overlay heatmap (handle failures)
+    try:
+        overlay = apply_heatmap(image, heatmap)
+    except:
+        overlay = image  # Fallback to original image
+
+    return {"prediction": prediction}, overlay
+
+# Gradio Interface
+print("Initializing Gradio Interface...")
+
+interface = gr.Interface(
+    fn=predict,
+    inputs=gr.Image(type="pil"),
+    outputs=[
+        gr.JSON(label="Diagnosis"),  # Explicitly labeled JSON output
+        gr.Image(type="pil", label="Grad-CAM Heatmap")
+    ],
+    title="X-Ray Classifier with Grad-CAM",
+    allow_flagging="never",  # Replace with flagging_mode="never" if using Gradio >=4.0
+    live=True
+)
+
+print("Launching Gradio App...")
+interface.launch(server_name="0.0.0.0", server_port=7860)
+print("Gradio App Running!")

gradcam.py

@@ -0,0 +1,60 @@
+import torch
+import numpy as np
+import cv2
+from PIL import Image
+
+class GradCAM:
+    def __init__(self, model, target_layer):
+        self.model = model
+        self.target_layer = target_layer
+        self.gradients = None
+        self.activations = None
+
+        # Use register_full_backward_hook for PyTorch >=1.8
+        self.target_layer.register_forward_hook(self.save_activations)
+        self.target_layer.register_full_backward_hook(self.save_gradients)
+
+    def save_activations(self, module, input, output):
+        self.activations = output
+
+    def save_gradients(self, module, grad_input, grad_output):
+        self.gradients = grad_output[0]  # grad_output is a tuple
+
+    def generate_heatmap(self, image_tensor, class_index=None):
+        # Ensure gradients are enabled
+        with torch.set_grad_enabled(True):
+            output = self.model(image_tensor)  # No unsqueeze needed
+
+            if class_index is None:
+                class_index = output.argmax()
+
+            score = output[:, class_index]
+            self.model.zero_grad()
+            score.backward(retain_graph=True)  # Compute gradients
+
+        # Move data to CPU and convert to numpy
+        gradients = self.gradients.cpu().numpy()
+        activations = self.activations.cpu().numpy()
+
+        # Compute weights and heatmap
+        weights = np.mean(gradients, axis=(2, 3))  # Shape: [batch, channels]
+        cam = np.sum(weights[:, :, None, None] * activations, axis=1)  # Weighted sum
+        cam = np.maximum(cam, 0)  # ReLU
+        cam = cam[0]  # Remove batch dimension
+
+        # Normalize heatmap
+        cam = (cam - np.min(cam)) / (np.max(cam) - np.min(cam) + 1e-8)
+        return cam
+
+def apply_heatmap(image_pil, heatmap):
+    """Overlay Grad-CAM heatmap on the original image"""
+    if heatmap is None:  # Fallback if heatmap fails
+        return image_pil
+
+    image_cv = np.array(image_pil)
+    image_cv = cv2.cvtColor(image_cv, cv2.COLOR_RGB2BGR)
+    heatmap = cv2.resize(heatmap, (image_cv.shape[1], image_cv.shape[0]))
+    heatmap = np.uint8(255 * heatmap)
+    heatmap = cv2.applyColorMap(heatmap, cv2.COLORMAP_JET)
+    overlay = cv2.addWeighted(image_cv, 0.5, heatmap, 0.5, 0)
+    return Image.fromarray(cv2.cvtColor(overlay, cv2.COLOR_BGR2RGB))

requirements (1).txt

@@ -0,0 +1,5 @@
+torch
+torchvision
+gradio==5.23.3
+opencv-python-headless
+anyio==3.6.2

vgg_xray_model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:492760a84b353e77027e0ddef767d976c240c97acbc41f3e88d6fa0267e85443
+size 537119090