m

app.py

@@ -14,19 +14,28 @@ import os
 import tempfile
 import base64
 
+# Add at the top with other constants
+MODEL_OPTIONS = {
+    "Default (ferferefer/segformer)": "ferferefer/segformer",
+    "Pamixsun": "pamixsun/segformer_for_optic_disc_cup_segmentation"
+}
+
 # --- GlaucomaModel Class ---
 class GlaucomaModel(object):
     def __init__(self, 
                  cls_model_path="pamixsun/swinv2_tiny_for_glaucoma_classification", 
-                 seg_model_path='pamixsun/segformer_for_optic_disc_cup_segmentation',
+                 seg_model_path=None,  # Make this optional
                  device=torch.device('cpu')):
         self.device = device
-        # Classification model for glaucoma
+        # Classification model for glaucoma (always the same)
         self.cls_extractor = AutoImageProcessor.from_pretrained(cls_model_path)
         self.cls_model = Swinv2ForImageClassification.from_pretrained(cls_model_path).to(device).eval()
-        # Segmentation model for optic disc and cup
-        self.seg_extractor = AutoImageProcessor.from_pretrained(seg_model_path)
-        self.seg_model = SegformerForSemanticSegmentation.from_pretrained(seg_model_path).to(device).eval()
+        
+        # Segmentation model - use provided path or default
+        seg_path = seg_model_path or MODEL_OPTIONS["Pamixsun"]  # Default to Pamixsun if none provided
+        self.seg_extractor = AutoImageProcessor.from_pretrained(seg_path)
+        self.seg_model = SegformerForSemanticSegmentation.from_pretrained(seg_path).to(device).eval()
+        
         # Mapping for class labels
         self.cls_id2label = self.cls_model.config.id2label
 
@@ -104,15 +113,15 @@ def add_mask(image, mask, classes, colors, alpha=0.5):
 def get_confidence_level(confidence):
     """Enhanced confidence descriptions for segmentation"""
     if confidence >= 90:
-        return "Excellent (Very clear boundaries)"
+        return "Excellent (Model is very certain about the detected boundaries)"
     elif confidence >= 75:
-        return "Good (Clear boundaries)"
+        return "Good (Model is confident about most of the detected area)"
     elif confidence >= 60:
-        return "Fair (Visible but some unclear areas)"
+        return "Fair (Model has some uncertainty in parts of the detection)"
     elif confidence >= 45:
-        return "Poor (Difficult to determine)"
+        return "Poor (Model is uncertain about many detected areas)"
     else:
-        return "Very Poor (Not reliable)"
+        return "Very Poor (Model's detection is highly uncertain)"
 
 def process_batch(model, images_data, progress_bar=None):
     results = []
@@ -190,7 +199,14 @@ def main():
     st.title("Glaucoma Screening from Retinal Fundus Images")
     st.write("Upload retinal images for automated glaucoma detection and optic disc/cup segmentation")
     
-    # Sidebar using old method
+    # Add model selection in sidebar before file upload
+    st.sidebar.title("Model Settings")
+    selected_model = st.sidebar.selectbox(
+        "Select Segmentation Model",
+        list(MODEL_OPTIONS.keys()),
+        index=1  # Default to Pamixsun
+    )
+    
     st.sidebar.title("Upload Images")
     st.set_option('deprecation.showfileUploaderEncoding', False)  # Important for old versions
     uploaded_files = st.sidebar.file_uploader(
@@ -208,15 +224,27 @@ def main():
     """)
     
     if uploaded_files:
-        st.write("Loading AI models...")
-        
         try:
-            model = GlaucomaModel(device=torch.device("cuda:0" if torch.cuda.is_available() else "cpu"))
+            # Enhanced model loading feedback
+            st.write("🤖 Initializing AI models...")
+            st.write(f"• Loading classification model: pamixsun/swinv2_tiny_for_glaucoma_classification")
+            st.write(f"• Loading segmentation model: {selected_model}")
+            
+            # Initialize model with selected segmentation model
+            model = GlaucomaModel(
+                device=torch.device("cuda:0" if torch.cuda.is_available() else "cpu"),
+                seg_model_path=MODEL_OPTIONS[selected_model]
+            )
+            
+            # Show model loading completion
+            st.write("✅ Models loaded successfully")
+            st.write(f"🖥️ Using: {'GPU' if torch.cuda.is_available() else 'CPU'} for processing")
+            st.write("---")
             
             for file in uploaded_files:
                 try:
-                    # Process each image
-                    st.write(f"Processing: {file.name}")
+                    # Process each image with enhanced feedback
+                    st.write(f"📸 Processing image: {file.name}")
                     image = Image.open(file).convert('RGB')
                     image_np = np.array(image)
                     
@@ -232,11 +260,41 @@ def main():
                     st.write(f"• Finding: {model.cls_id2label[disease_idx]}")
                     st.write(f"• AI Confidence: {cls_conf:.1f}% ({get_confidence_level(cls_conf)})")
                     
-                    # Segmentation confidence section
-                    st.write("\n🔍 **Segmentation Quality:**")
+                    # Enhanced Segmentation confidence section with detailed explanations
+                    st.write("\n🔍 **Understanding Segmentation Confidence:**")
+                    st.write("""
+                    Segmentation confidence shows how certain the AI is about each pixel it classified:
+                    • For the Optic Cup (central depression):
+                      - Measures the AI's certainty that the red-colored pixels are truly part of the cup
+                      - Higher confidence means clearer cup boundaries and more reliable VCDR
+                      
+                    • For the Optic Disc (entire circular area):
+                      - Indicates how sure the AI is about the green-outlined disc boundary
+                      - Higher confidence suggests better disc margin visibility
+                    
+                    Confidence scores are calculated by averaging the model's certainty 
+                    for each pixel it identified as cup or disc. A score of 100% would mean 
+                    the model is absolutely certain about every pixel's classification.
+                    """)
+                    
+                    st.write("\n📊 **Current Segmentation Confidence Scores:**")
                     st.write(f"• Optic Cup Detection: {cup_conf:.1f}% - {get_confidence_level(cup_conf)}")
                     st.write(f"• Optic Disc Detection: {disc_conf:.1f}% - {get_confidence_level(disc_conf)}")
                     
+                    # Add interpretation guidance
+                    if cup_conf >= 75 and disc_conf >= 75:
+                        st.write("✅ High confidence scores indicate reliable measurements")
+                    elif cup_conf < 60 or disc_conf < 60:
+                        st.write("""
+                        ⚠️ Lower confidence scores might be due to:
+                        • Image quality issues (blur, poor contrast)
+                        • Unusual anatomical variations
+                        • Pathological changes affecting visibility
+                        • Poor image centering or focus
+                        
+                        Consider retaking the image if possible.
+                        """)
+                    
                     # Clinical metrics
                     st.write("\n📏 **Clinical Measurements:**")
                     st.write(f"• Cup-to-Disc Ratio (VCDR): {vcdr:.3f}")