deploy cardioguard

README.md

@@ -1,11 +1,10 @@
 ---
 title: CardioGuard AI
-emoji: 🦀
-colorFrom: pink
+emoji: 🫀
+colorFrom: blue
 colorTo: red
-sdk: docker
+sdk: gradio
+sdk_version: 4.44.0
+app_file: app.py
 pinned: false
-short_description: Here you can find the Multi-Classification for Heart Disease
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---

app.py

@@ -0,0 +1,37 @@
+import gradio as gr
+from PIL import Image
+import numpy as np
+
+from app.predictor import predict_disease
+from app.gradcam import generate_gradcam
+from app.predictor import compute_ai_risk
+
+def predict(image):
+    # 1️⃣ Disease prediction
+    label, confidence, tensor, original = predict_disease(image)
+
+    # 2️⃣ GradCAM heatmap
+    heatmap = generate_gradcam(tensor, original)
+
+    # 3️⃣ Risk prediction
+    risk = compute_ai_risk(label, confidence, heatmap)
+
+    report = f"""
+    🫀 AI Clinical Report
+    
+    Disease: {label}
+    Confidence: {round(confidence*100,2)} %
+    Risk Level: {risk}
+    """
+
+    return heatmap, report
+
+demo = gr.Interface(
+    fn=predict,
+    inputs=gr.Image(type="pil"),
+    outputs=[gr.Image(), gr.Textbox()],
+    title="CardioGuard AI",
+    description="Upload Chest X-ray to detect heart disease"
+)
+
+demo.launch()

app/main.py

@@ -0,0 +1,58 @@
+print("STEP 1: main.py starting import")
+
+from fastapi import FastAPI, UploadFile, File
+print("STEP 2: fastapi imported")
+
+from app.model_loader import load_all_models
+print("STEP 3: model_loader imported")
+
+from app.predictor import run_full_pipeline
+print("STEP 4: predictor imported")
+
+
+
+from fastapi import FastAPI, UploadFile, File
+import numpy as np
+import cv2
+
+from app.model_loader import load_all_models
+from app.predictor import run_full_pipeline
+
+app = FastAPI(title="CardioGuard AI API")
+
+# 🔥 LOAD MODELS WHEN SERVER STARTS
+@app.on_event("startup")
+def startup_event():
+    load_all_models()
+
+
+# 🩺 Health check route
+@app.get("/")
+def root():
+    return {"message": "CardioGuard API is running"}
+
+
+# ❤️‍🔥 Prediction Route
+@app.post("/predict")
+async def predict_xray(file: UploadFile = File(...)):
+
+    image_bytes = await file.read()
+
+    # convert bytes → PIL image
+    from PIL import Image
+    import io
+    image = Image.open(io.BytesIO(image_bytes)).convert("RGB")
+
+    result = run_full_pipeline(image)
+
+    # convert heatmap image → base64 (so frontend can display)
+    import base64
+    _, buffer = cv2.imencode(".png", result["heatmap"])
+    heatmap_base64 = base64.b64encode(buffer).decode("utf-8")
+
+    return {
+        "disease": result["disease"],
+        "confidence": result["confidence"],
+        "risk": result["risk"],
+        "heatmap": heatmap_base64
+    }

app/model_loader.py

@@ -0,0 +1,52 @@
+import torch
+from torchvision import models
+from safetensors.torch import load_file
+from huggingface_hub import hf_hub_download
+import joblib
+
+# ---------------- GLOBAL MODELS ---------------- #
+cnn_model = None
+kmeans_model = None
+scaler = None
+
+
+class DenseNet121_CheXpert(torch.nn.Module):
+    def __init__(self, num_labels=14):
+        super().__init__()
+        self.densenet = models.densenet121(weights=None)
+        num_features = self.densenet.classifier.in_features
+        self.densenet.classifier = torch.nn.Linear(num_features, num_labels)
+
+    def forward(self, x):
+        return self.densenet(x)
+
+
+# ---------------- LOAD FUNCTION ---------------- #
+
+def load_all_models():
+    global cnn_model, kmeans_model, scaler
+
+    print("Downloading DenseNet...")
+
+    local_path = hf_hub_download(
+        repo_id="itsomk/chexpert-densenet121",
+        filename="pytorch_model.safetensors"
+    )
+
+    print("Loading CNN...")
+    state = load_file(local_path)
+
+    cnn_model = DenseNet121_CheXpert()
+    cnn_model.load_state_dict(state, strict=False)
+    cnn_model.eval()
+
+    print("Loading KMeans + Scaler...")
+
+    kmeans_model = joblib.load("models/risk_model.pkl")
+    scaler = joblib.load("models/risk_scaler.pkl")
+
+    print("ALL MODELS READY 🚀")
+
+
+# ---------------- AUTO LOAD (IMPORTANT FIX) ---------------- #
+

app/predictor.py

@@ -0,0 +1,193 @@
+import torch
+import numpy as np
+import cv2
+from PIL import Image
+import torch.nn.functional as F
+from torchvision import transforms
+
+# ---------------- LOAD MODELS ---------------- #
+import app.model_loader as model_loader
+
+
+# ---------------- IMAGE PREPROCESS ---------------- #
+
+preprocess = transforms.Compose([
+    transforms.Resize((224, 224)),
+    transforms.ToTensor(),
+    transforms.Normalize(
+        mean=[0.485, 0.456, 0.406],
+        std=[0.229, 0.224, 0.225]
+    )
+])
+
+CARDIOMEGALY_INDEX = 2
+PNEUMOTHORAX_INDEX = 9
+THRESHOLD = 0.96
+
+
+# ---------------- DISEASE PREDICTION ---------------- #
+
+def predict_disease(image: Image.Image):
+    img = image.convert("RGB")
+    x = preprocess(img).unsqueeze(0)
+
+    with torch.no_grad():
+        logits = model_loader.cnn_model(x)
+        probs = torch.sigmoid(logits).squeeze()
+
+    cardiomegaly_score = probs[CARDIOMEGALY_INDEX].item()
+    pneumothorax_score = probs[PNEUMOTHORAX_INDEX].item()
+
+    if cardiomegaly_score < THRESHOLD and pneumothorax_score < THRESHOLD:
+        predicted_label = "No Finding"
+        confidence = max(1 - cardiomegaly_score, 1 - pneumothorax_score)
+    else:
+        if cardiomegaly_score > pneumothorax_score:
+            predicted_label = "Cardiomegaly"
+            confidence = cardiomegaly_score
+        else:
+            predicted_label = "Pneumothorax (Pleural Effusion)"
+            confidence = pneumothorax_score
+
+    return predicted_label, confidence, x, img
+
+
+import torch
+import torch.nn.functional as F
+import numpy as np
+import cv2
+from PIL import Image
+import app.model_loader as model_loader
+
+
+# ---------------- GRAD-CAM CLASS ---------------- #
+
+class GradCAM:
+    def __init__(self, model, target_layer):
+        self.model = model
+        self.gradients = None
+        self.activations = None
+
+        # safer hooks (avoid full_backward_hook crash)
+        target_layer.register_forward_hook(self.forward_hook)
+        target_layer.register_backward_hook(self.backward_hook)
+
+    def forward_hook(self, module, input, output):
+        self.activations = output.detach()
+
+    def backward_hook(self, module, grad_input, grad_output):
+        self.gradients = grad_output[0].detach()
+
+    def generate_cam(self, input_tensor, target_class):
+
+        input_tensor = input_tensor.clone().requires_grad_(True)
+
+        output = self.model(input_tensor)
+
+        self.model.zero_grad(set_to_none=True)
+
+        class_score = output[0, target_class]
+
+        class_score.backward(retain_graph=True)
+
+        gradients = self.gradients[0]
+        activations = self.activations[0]
+
+        weights = torch.mean(gradients, dim=(1, 2))
+
+        cam = torch.zeros(activations.shape[1:], dtype=torch.float32)
+
+        for i, w in enumerate(weights):
+            cam += w * activations[i]
+
+        cam = F.relu(cam)
+        cam -= cam.min()
+
+        if cam.max() != 0:
+            cam /= cam.max()
+
+        return cam.cpu().numpy()
+
+
+# ---------------- HEATMAP GENERATION ---------------- #
+
+def generate_heatmap(x, img, predicted_label):
+
+    target_layer = model_loader.cnn_model.densenet.features.norm5
+
+    gradcam = GradCAM(model_loader.cnn_model, target_layer)
+
+    if predicted_label == "Cardiomegaly":
+        target_class = 2
+    elif predicted_label == "Pneumothorax (Pleural Effusion)":
+        target_class = 9
+    else:
+        target_class = 2
+
+    cam = gradcam.generate_cam(x, target_class)
+
+    # resize CAM
+    heatmap = cv2.resize(cam, (img.size[0], img.size[1]))
+
+    heatmap = np.uint8(255 * heatmap)
+    heatmap = cv2.applyColorMap(heatmap, cv2.COLORMAP_JET)
+
+    # convert image
+    img_cv = cv2.cvtColor(np.array(img), cv2.COLOR_RGB2BGR)
+
+    # overlay
+    overlay = cv2.addWeighted(img_cv, 0.6, heatmap, 0.4, 0)
+
+    return overlay, cam
+
+
+# ---------------- CLINICAL RISK ENGINE ---------------- #
+
+def clinical_risk_label(predicted_label, confidence, cam):
+    cam_score = float(np.mean(cam))
+
+    if predicted_label == "No Finding":
+        if confidence >= 0.70:
+            return "LOW RISK"
+        else:
+            return "MEDIUM RISK (Low confidence normal)"
+
+    if confidence >= 0.85 or cam_score >= 0.20 or (confidence >= 0.70 and cam_score >= 0.15):
+        return "HIGH RISK"
+
+    if 0.50 <= confidence < 0.85 or 0.10 <= cam_score < 0.20:
+        return "MEDIUM RISK"
+
+    return "LOW RISK (Early detection)"
+
+
+def compute_ai_risk(confidence, cam, predicted_label):
+    cam_score = float(np.mean(cam))
+    disease_flag = 0 if predicted_label == "No Finding" else 1
+
+    patient_vector = np.array([[confidence, cam_score, disease_flag]], dtype=np.float32)
+
+    patient_vector = model_loader.scaler.transform(patient_vector)
+    cluster = model_loader.kmeans_model.predict(patient_vector)[0]
+
+    if cluster == 0:
+        return "LOW RISK 🟢"
+    elif cluster == 1:
+        return "MEDIUM RISK 🟡"
+    else:
+        return "HIGH RISK 🔴"
+
+
+# ---------------- FULL PIPELINE ---------------- #
+
+def run_full_pipeline(image: Image.Image):
+    predicted_label, confidence, x, img = predict_disease(image)
+    overlay, cam = generate_heatmap(x, img, predicted_label)
+    risk = clinical_risk_label(predicted_label, confidence, cam)
+
+    return {
+        "disease": predicted_label,
+        "confidence": float(confidence),
+        "risk": risk,
+        "heatmap": overlay
+    }

app/train_risk_model.py

@@ -0,0 +1,33 @@
+import numpy as np
+from sklearn.preprocessing import StandardScaler
+from sklearn.cluster import KMeans
+import joblib
+import os
+
+print("Training Risk Model...")
+
+os.makedirs("models", exist_ok=True)
+
+np.random.seed(42)
+n_samples = 500
+
+conf_population = np.random.uniform(0.4, 0.98, n_samples)
+cam_population = np.random.uniform(0.05, 0.35, n_samples)
+disease_population = np.random.randint(0, 2, n_samples)
+
+training_vectors = np.column_stack([
+    conf_population,
+    cam_population,
+    disease_population
+]).astype(np.float32)
+
+scaler = StandardScaler()
+training_vectors = scaler.fit_transform(training_vectors).astype(np.float32)
+
+kmeans = KMeans(n_clusters=3, random_state=42, n_init=10)
+kmeans.fit(training_vectors)
+
+joblib.dump(kmeans, "models/risk_model.pkl")
+joblib.dump(scaler, "models/risk_scaler.pkl")
+
+print("✅ Risk model saved successfully!")

models/risk_model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:229952cd47d9b96973ba4aefc1c8ee7cf72b2454becf259e731fd23d121d7d2d
+size 2807

models/risk_scaler.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7612911534660e3ac165e31533555286e8f60ce8756625c0c2f3f7cb45d5f546
+size 671

requirements.txt

@@ -0,0 +1,10 @@
+torch
+torchvision
+scikit-learn
+joblib
+numpy
+pillow
+opencv-python-headless
+gradio
+huggingface_hub
+safetensors