Upload 5 files

Dockerfile

@@ -0,0 +1,24 @@
+FROM python:3.9-slim
+
+# 2️⃣ Set working directory
+WORKDIR /app
+
+# 3️⃣ Install required system dependencies (fixes libGL and libgthread errors)
+RUN apt-get update && \
+    apt-get install -y libgl1-mesa-glx libglib2.0-0 && \
+    rm -rf /var/lib/apt/lists/*
+
+# 4️⃣ Copy requirements
+COPY requirements.txt .
+
+# 5️⃣ Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# 6️⃣ Copy all files from the root of your project
+COPY . .
+
+# 7️⃣ Expose the port
+EXPOSE 7860
+
+# 8️⃣ Command to run the app
+CMD ["python", "app.py"]

app.py

@@ -0,0 +1,212 @@
+from flask import Flask, request, jsonify, send_file
+from PIL import Image
+import torch
+import torch.nn.functional as F
+from torchvision import transforms
+import os
+import numpy as np
+from datetime import datetime
+import sqlite3
+import torch.nn as nn
+import cv2
+
+# ✅ New Grad-CAM++ imports
+from pytorch_grad_cam import GradCAMPlusPlus
+from pytorch_grad_cam.utils.model_targets import ClassifierOutputTarget
+from pytorch_grad_cam.utils.image import show_cam_on_image
+
+# ✅ Import Hugging Face-style GLAM EfficientNet model
+from glam_efficientnet_model import GLAMEfficientNetForClassification, GLAMEfficientNetConfig
+
+app = Flask(__name__)
+
+# ✅ Directory and database path
+OUTPUT_DIR = '/tmp/results'
+if not os.path.exists(OUTPUT_DIR):
+    os.makedirs(OUTPUT_DIR)
+
+DB_PATH = os.path.join(OUTPUT_DIR, 'results.db')
+
+
+def init_db():
+    """Initialize SQLite database for storing results."""
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    cursor.execute("""
+        CREATE TABLE IF NOT EXISTS results (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            image_filename TEXT,
+            prediction TEXT,
+            confidence REAL,
+            gradcam_filename TEXT,
+            gradcam_gray_filename TEXT,
+            timestamp TEXT
+        )
+    """)
+    conn.commit()
+    conn.close()
+
+
+init_db()
+
+# ✅ Load GLAM EfficientNet Model
+config = GLAMEfficientNetConfig()
+model = GLAMEfficientNetForClassification(config)
+model.load_state_dict(torch.load('efficientnet_glam_best.pt', map_location='cpu'))
+model.eval()
+
+# ✅ Class Names
+CLASS_NAMES = ["Advanced", "Early", "Normal"]
+
+# ✅ Transformation for input images
+transform = transforms.Compose([
+    transforms.Resize(256),
+    transforms.CenterCrop(224),
+    transforms.ToTensor(),
+    transforms.Normalize(mean=[0.485, 0.456, 0.406],
+                         std=[0.229, 0.224, 0.225]),
+])
+
+
+@app.route('/')
+def home():
+    """Check that the API is working."""
+    return "Glaucoma Detection Flask API (EfficientNet + GLAM) is running!"
+
+
+@app.route("/test_file")
+def test_file():
+    """Check if the .pt model file is present and readable."""
+    filepath = "efficientnet_glam_best.pt"
+    if os.path.exists(filepath):
+        return f"✅ Model file found at: {filepath}"
+    else:
+        return "❌ Model file NOT found."
+
+
+@app.route('/predict', methods=['POST'])
+def predict():
+    """Perform prediction and save results (including Grad-CAM++) to the database."""
+    if 'file' not in request.files:
+        return jsonify({'error': 'No file uploaded'}), 400
+
+    uploaded_file = request.files['file']
+    if uploaded_file.filename == '':
+        return jsonify({'error': 'No file selected'}), 400
+
+    try:
+        # ✅ Save the uploaded image
+        timestamp = int(datetime.now().timestamp())
+        uploaded_filename = f"uploaded_{timestamp}.png"
+        uploaded_file_path = os.path.join(OUTPUT_DIR, uploaded_filename)
+        uploaded_file.save(uploaded_file_path)
+
+        # ✅ Perform prediction
+        img = Image.open(uploaded_file_path).convert('RGB')
+        input_tensor = transform(img).unsqueeze(0)
+
+        # ✅ Get prediction
+        output = model(input_tensor)  # Dict with "logits"
+        probabilities = F.softmax(output["logits"], dim=1).cpu().detach().numpy()[0]
+        class_index = np.argmax(probabilities)
+        result = CLASS_NAMES[class_index]
+        confidence = float(probabilities[class_index])
+
+        # ✅ Grad-CAM++ setup
+        # IMPORTANT: Choose the target layer from the GLAM EfficientNet model.
+        # For example, use the final convolutional block:
+        target_layer = model.features[-1]
+        cam_model = GradCAMPlusPlus(model=model, target_layers=[target_layer])
+
+        # ✅ Get Grad-CAM++ map
+        cam_output = cam_model(input_tensor=input_tensor, targets=[ClassifierOutputTarget(class_index)])[0]
+
+        # ✅ Create RGB overlay
+        original_img = np.asarray(img.resize((224, 224)), dtype=np.float32) / 255.0
+        overlay = show_cam_on_image(original_img, cam_output, use_rgb=True)
+
+        # ✅ Create grayscale version
+        cam_normalized = np.uint8(255 * cam_output)
+
+        # ✅ Save overlay
+        gradcam_filename = f"gradcam_{timestamp}.png"
+        gradcam_file_path = os.path.join(OUTPUT_DIR, gradcam_filename)
+        cv2.imwrite(gradcam_file_path, cv2.cvtColor(overlay, cv2.COLOR_RGB2BGR))
+
+        # ✅ Save grayscale
+        gray_filename = f"gradcam_gray_{timestamp}.png"
+        gray_file_path = os.path.join(OUTPUT_DIR, gray_filename)
+        cv2.imwrite(gray_file_path, cam_normalized)
+
+        # ✅ Save results to database
+        conn = sqlite3.connect(DB_PATH)
+        cursor = conn.cursor()
+        cursor.execute("""
+            INSERT INTO results (image_filename, prediction, confidence, gradcam_filename, gradcam_gray_filename, timestamp) 
+            VALUES (?, ?, ?, ?, ?, ?)
+        """, (uploaded_filename, result, confidence, gradcam_filename, gray_filename, datetime.now().isoformat()))
+        conn.commit()
+        conn.close()
+
+        # ✅ Return results
+        return jsonify({
+            'prediction': result,
+            'confidence': confidence,
+            'normal_probability': float(probabilities[0]),
+            'early_glaucoma_probability': float(probabilities[1]),
+            'advanced_glaucoma_probability': float(probabilities[2]),
+            'gradcam_image': gradcam_filename,
+            'gradcam_gray_image': gray_filename,
+            'image_filename': uploaded_filename
+        })
+
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+
+
+@app.route('/results', methods=['GET'])
+def results():
+    """List all results from the SQLite database."""
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    cursor.execute("SELECT * FROM results ORDER BY timestamp DESC")
+    results_data = cursor.fetchall()
+    conn.close()
+
+    results_list = []
+    for record in results_data:
+        results_list.append({
+            'id': record[0],
+            'image_filename': record[1],
+            'prediction': record[2],
+            'confidence': record[3],
+            'gradcam_filename': record[4],
+            'gradcam_gray_filename': record[5],
+            'timestamp': record[6]
+        })
+
+    return jsonify(results_list)
+
+
+@app.route('/gradcam/<filename>')
+def get_gradcam(filename):
+    """Serve the Grad-CAM overlay image."""
+    filepath = os.path.join(OUTPUT_DIR, filename)
+    if os.path.exists(filepath):
+        return send_file(filepath, mimetype='image/png')
+    else:
+        return jsonify({'error': 'File not found'}), 404
+
+
+@app.route('/image/<filename>')
+def get_image(filename):
+    """Serve the original uploaded image."""
+    filepath = os.path.join(OUTPUT_DIR, filename)
+    if os.path.exists(filepath):
+        return send_file(filepath, mimetype='image/png')
+    else:
+        return jsonify({'error': 'File not found'}), 404
+
+
+if __name__ == '__main__':
+    app.run(host='0.0.0.0', port=7860)

efficientnet_glam_best.pt

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

glam_efficient_model.py

@@ -0,0 +1,103 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from transformers import PreTrainedModel, PretrainedConfig
+from transformers import EfficientNetModel
+from typing import Optional, Union
+
+
+# --------------------------------------------------
+# Import your GLAM, SwinWindowAttention blocks here
+# --------------------------------------------------
+# from .glam_module import GLAM
+# from .swin_module import SwinWindowAttention
+
+
+class GLAMEfficientNetConfig(PretrainedConfig):
+    """Hugging Face-style configuration for GLAM EfficientNet."""
+    model_type = "glam_efficientnet"
+
+    def __init__(self,
+                 num_classes: int = 3,
+                 embed_dim: int = 512,
+                 num_heads: int = 8,
+                 window_size: int = 7,
+                 reduction_ratio: int = 8,
+                 dropout: float = 0.5,
+                 **kwargs):
+        super().__init__(**kwargs)
+        self.num_classes = num_classes
+        self.embed_dim = embed_dim
+        self.num_heads = num_heads
+        self.window_size = window_size
+        self.reduction_ratio = reduction_ratio
+        self.dropout = dropout
+
+
+class GLAMEfficientNetForClassification(PreTrainedModel):
+    """Hugging Face-style Model for EfficientNet + GLAM + Swin Architecture."""
+
+    config_class = GLAMEfficientNetConfig
+
+    def __init__(self, config: GLAMEfficientNetConfig):
+        super().__init__(config)
+
+        # 1) EfficientNet Backbone
+        self.features = EfficientNetModel.from_pretrained("google/efficientnet-b0").features
+        self.conv1x1 = nn.Conv2d(1280, config.embed_dim, kernel_size=1)
+
+        # 2) Swin Attention Block
+        self.swin_attn = SwinWindowAttention(
+            embed_dim=config.embed_dim,
+            window_size=config.window_size,
+            num_heads=config.num_heads,
+            dropout=config.dropout
+        )
+        self.pre_attn_norm = nn.LayerNorm(config.embed_dim)
+        self.post_attn_norm = nn.LayerNorm(config.embed_dim)
+
+        # 3) GLAM Block
+        self.glam = GLAM(in_channels=config.embed_dim, reduction_ratio=config.reduction_ratio)
+
+        # 4) Self-Adaptive Gating
+        self.gate_fc = nn.Linear(config.embed_dim, 1)
+
+        # Final classification
+        self.dropout = nn.Dropout(config.dropout)
+        self.classifier = nn.Linear(config.embed_dim, config.num_classes)
+
+    def forward(self, pixel_values, labels=None, **kwargs):
+        # 1) Extract EfficientNet Features
+        feats = self.features(pixel_values).last_hidden_state
+        feats = self.conv1x1(feats)
+
+        B, C, H, W = feats.shape
+
+        # 2) Transformer Branch
+        x_perm = feats.permute(0, 2, 3, 1).contiguous()
+        x_norm = self.pre_attn_norm(x_perm).permute(0, 3, 1, 2).contiguous()
+        x_norm = self.dropout(x_norm)
+
+        T_out = self.swin_attn(x_norm)
+
+        T_out = self.post_attn_norm(T_out.permute(0, 2, 3, 1).contiguous())
+        T_out = T_out.permute(0, 3, 1, 2).contiguous()
+
+        # 3) GLAM Branch
+        G_out = self.glam(feats)
+
+        # 4) Self-Adaptive Gating
+        gap_feats = F.adaptive_avg_pool2d(feats, (1, 1)).view(B, C)
+        g = torch.sigmoid(self.gate_fc(gap_feats)).view(B, 1, 1, 1)
+
+        F_out = g * T_out + (1 - g) * G_out
+
+        # 5) Final Pooling + Classifier
+        pooled = F.adaptive_avg_pool2d(F_out, (1, 1)).view(B, -1)
+        logits = self.classifier(self.dropout(pooled))
+
+        loss = None
+        if labels is not None:
+            loss = F.cross_entropy(logits, labels)
+
+        return {"loss": loss, "logits": logits}

requirements.txt

@@ -0,0 +1,10 @@
+Flask
+torch
+torchvision
+Pillow
+numpy
+opencv-python
+
+firebase-admin
+psycopg2-binary
+grad-cam