Update app.py

app.py

@@ -9,23 +9,18 @@ from datetime import datetime
 import sqlite3
 import torch.nn as nn
 import cv2
+import json
 
-# ✅ New Grad-CAM++ imports
+# 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
-from glam_module import GLAM
-from swin_module import SwinWindowAttention
-
 app = Flask(__name__)
 
-# ✅ Directory and database path
+# ✅ Directory and database
 OUTPUT_DIR = '/tmp/results'
-if not os.path.exists(OUTPUT_DIR):
-    os.makedirs(OUTPUT_DIR)
+os.makedirs(OUTPUT_DIR, exist_ok=True)
 
 DB_PATH = os.path.join(OUTPUT_DIR, 'results.db')
 
@@ -51,18 +46,30 @@ def init_db():
 
 init_db()
 
-# ✅ Load GLAM EfficientNet Model
-config = GLAMEfficientNetConfig()
-model = GLAMEfficientNetForClassification(
-    config, glam_module_cls=GLAM, swin_module_cls=SwinWindowAttention
+
+# ✅ Import your EfficientNetB0_TransformerGLAM model
+from efficientnet_transformer_glam import EfficientNetb0_TransformerGLAM  # Ensure this is in the path
+
+
+# ✅ Instantiate the model
+model = EfficientNetb0_TransformerGLAM(
+    num_classes=3,
+    embed_dim=512,
+    num_heads=8,
+    mlp_dim=512,
+    dropout=0.5,
+    window_size=7,
+    reduction_ratio=8
 )
-model.load_state_dict(torch.load('efficientnet_glam_best.pt', map_location='cpu'))
+
+# ✅ Load the trained checkpoint
+model.load_state_dict(torch.load('densenet169_seed40_best.pt', map_location='cpu'))
 model.eval()
 
 # ✅ Class Names
 CLASS_NAMES = ["Advanced", "Early", "Normal"]
 
-# ✅ Transformation for input images
+# ✅ Transforms
 transform = transforms.Compose([
     transforms.Resize(256),
     transforms.CenterCrop(224),
@@ -74,27 +81,26 @@ transform = transforms.Compose([
 @app.route('/')
 def home():
     """Check that the API is working."""
-    return "Glaucoma Detection Flask API (GLAM EfficientNet) is running!"
+    return "Glaucoma Detection Flask API (EfficientNetB0_TransformerGLAM Model) is running!"
 
 @app.route("/test_file")
 def test_file():
     """Check if the .pt model file is present and readable."""
-    filepath = "efficientnet_glam_best.pt"
+    filepath = "densenet169_seed40_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
+        return jsonify({'error': 'No file uploaded.'}), 400
 
     uploaded_file = request.files['file']
     if uploaded_file.filename == '':
-        return jsonify({'error': 'No file selected'}), 400
+        return jsonify({'error': 'No file selected.'}), 400
 
     try:
         # ✅ Save the uploaded image
@@ -107,20 +113,20 @@ def predict():
         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]
+        # Model Inference
+        with torch.no_grad():
+            output = model(input_tensor)
+        probabilities = F.softmax(output, dim=1).cpu().numpy()[0]
         class_index = np.argmax(probabilities)
         result = CLASS_NAMES[class_index]
         confidence = float(probabilities[class_index])
 
         # ✅ Grad-CAM++ setup
-        # Target the final convolutional output. In GLAM EfficientNet, this is `model.features`
-        target_layer = dict(model.features.named_modules())["features.7"]  # ✅ Adjust as needed
+        target_layer = model.feature_extractor[-1]  # Final block of EfficientNet feature extractor
         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]
+        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
@@ -196,7 +202,7 @@ def get_gradcam(filename):
     if os.path.exists(filepath):
         return send_file(filepath, mimetype='image/png')
     else:
-        return jsonify({'error': 'File not found'}), 404
+        return jsonify({'error': 'File not found.'}), 404
 
 
 @app.route('/image/<filename>')
@@ -206,8 +212,9 @@ def get_image(filename):
     if os.path.exists(filepath):
         return send_file(filepath, mimetype='image/png')
     else:
-        return jsonify({'error': 'File not found'}), 404
+        return jsonify({'error': 'File not found.'}), 404
 
 
 if __name__ == '__main__':
     app.run(host='0.0.0.0', port=7860)
+