Update app.py

app.py

@@ -4,47 +4,26 @@ import cv2
 import tensorflow as tf
 import streamlit as st
 import matplotlib.pyplot as plt
-import matplotlib.cm as cm
 from lime import lime_image
 from skimage.segmentation import mark_boundaries
 from keras.layers import BatchNormalization, DepthwiseConv2D, TFSMLayer
 
 # --- Fix deserialization issues ---
-original_bn_from_config = BatchNormalization.from_config
-def patched_bn_from_config(cls, config, *args, **kwargs):
-    if "axis" in config and isinstance(config["axis"], (list, tuple)):
-        config["axis"] = config["axis"][0]
-    return original_bn_from_config(config, *args, **kwargs)
-BatchNormalization.from_config = classmethod(patched_bn_from_config)
-
-original_dwconv_from_config = DepthwiseConv2D.from_config
-def patched_dwconv_from_config(cls, config, *args, **kwargs):
-    if "groups" in config:
-        config.pop("groups")
-    return original_dwconv_from_config(config, *args, **kwargs)
-DepthwiseConv2D.from_config = classmethod(patched_dwconv_from_config)
+BatchNormalization.from_config = classmethod(lambda cls, config, *args, **kwargs: BatchNormalization.from_config.__func__(cls, {**config, "axis": config["axis"][0] if isinstance(config["axis"], (list, tuple)) else config["axis"]}))
+DepthwiseConv2D.from_config = classmethod(lambda cls, config, *args, **kwargs: DepthwiseConv2D.from_config.__func__(cls, {k: v for k, v in config.items() if k != "groups"}))
 
 # --- Constants ---
 IMG_SIZE = (224, 224)
 CLASS_NAMES = ['Normal', 'Diabetes', 'Glaucoma', 'Cataract', 'AMD', 'Hypertension', 'Myopia', 'Others']
 
-# --- Load model ---
 @st.cache_resource
 def load_model():
     model_path = "Model"
-    if not os.path.exists(model_path):
-        st.error(f"❌ Model folder '{model_path}' not found!")
-        st.stop()
-    try:
-        model = tf.keras.Sequential([
-            TFSMLayer(model_path, call_endpoint="serving_default")
-        ])
-        return model
-    except Exception as e:
-        st.error(f"❌ Error loading model: {str(e)}")
-        st.stop()
-
-# --- Preprocessing function ---
+    model = tf.keras.Sequential([
+        TFSMLayer(model_path, call_endpoint="serving_default")
+    ])
+    return model
+
 def preprocess_image(img):
     h, w = img.shape[:2]
     center = (w // 2, h // 2)
@@ -67,92 +46,100 @@ def preprocess_image(img):
     resized = cv2.resize(sharp, IMG_SIZE) / 255.0
     return resized, [img, circ, clahe_img, resized]
 
-# --- LIME explainer ---
-explainer = lime_image.LimeImageExplainer()
-
-def predict_fn(images):
-    images = np.array(images)
-    preds = model.predict(images, verbose=0)
-    if isinstance(preds, dict):
-        preds = list(preds.values())[0]
-    return preds
-
-# --- Explanation text ---
 explanation_text = {
-    'Normal': "Healthy optic disc and macula.",
-    'Diabetes': "Retinal vessel changes suggest Diabetes.",
-    'Glaucoma': "Optic disc cupping detected.",
-    'Cataract': "Blurring suggests Cataract.",
-    'AMD': "Degeneration signs in macula.",
-    'Hypertension': "Hemorrhages suggest Hypertension.",
-    'Myopia': "Fundus tilt suggests Myopia.",
-    'Others': "Non-specific features detected."
+    'Normal': "Model predicted Normal based on healthy optic disc and macula.",
+    'Diabetes': "Detected retinal blood vessel changes suggestive of Diabetes.",
+    'Glaucoma': "Detected increased cupping in the optic disc indicating Glaucoma.",
+    'Cataract': "Image blur indicated potential Cataract.",
+    'AMD': "Degeneration signs in macula indicate AMD.",
+    'Hypertension': "Blood vessel narrowing/hemorrhages indicate Hypertension.",
+    'Myopia': "Tilted disc and fundus shape suggest Myopia.",
+    'Others': "Non-specific features detected, marked as Others."
 }
 
-# --- Display results ---
-def display_all_results(image_name, orig_img, processed_img, stages, pred_label, confidence, pred_idx):
-    st.header(f"🖼️ Image: `{image_name}`")
+explainer = lime_image.LimeImageExplainer()
 
-    # Show preprocessing
-    st.subheader("🔍 Preprocessing Steps")
-    fig, axs = plt.subplots(1, 4, figsize=(20, 5))
+def predict_fn(images):
+    preds = model.predict(np.array(images))
+    return list(preds.values())[0] if isinstance(preds, dict) else preds
+
+def show_preprocessing_steps(stages):
     titles = ["Original", "Circular Crop", "CLAHE", "Sharpen + Resize"]
-    for i, (img, title) in enumerate(zip(stages, titles)):
+    fig, axs = plt.subplots(1, 4, figsize=(20, 5))
+    for i, img in enumerate(stages):
         axs[i].imshow(img)
-        axs[i].set_title(title)
+        axs[i].set_title(titles[i])
         axs[i].axis('off')
     st.pyplot(fig)
     plt.close()
 
-    st.success(f"✅ Prediction: **{pred_label}** with confidence **{confidence:.2f}%**")
-
-    # LIME
+def show_lime_explanation(img, pred_idx, pred_label):
     with st.spinner("🟡 LIME Explanation is Loading..."):
         explanation = explainer.explain_instance(
-            image=processed_img,
+            image=img,
             classifier_fn=predict_fn,
             top_labels=1,
             hide_color=0,
             num_samples=1000
         )
         temp, mask = explanation.get_image_and_mask(label=pred_idx, positive_only=True, num_features=10, hide_rest=False)
-        fig, axs = plt.subplots(1, 2, figsize=(12, 5))
-        axs[0].imshow(processed_img)
-        axs[0].set_title("Processed Image")
-        axs[1].imshow(mark_boundaries(temp, mask))
-        axs[1].set_title("LIME Explanation")
-        for ax in axs:
-            ax.axis("off")
-        plt.figtext(0.5, 0.01, explanation_text.get(pred_label, ""), ha="center", fontsize=10)
+        fig, ax = plt.subplots(figsize=(6, 5))
+        ax.imshow(mark_boundaries(temp, mask))
+        ax.axis('off')
+        ax.set_title(f"LIME: {pred_label}")
         st.pyplot(fig)
         plt.close()
 
-# --- App UI ---
-st.set_page_config(page_title="🧠 Retina Disease Classifier", layout="centered")
+# --- Streamlit UI ---
+st.set_page_config(page_title="🧠 Retina Classifier - Multi Image LIME", layout="wide")
 st.title("🧠 Retina Disease Classifier with LIME Explanation")
 
 model = load_model()
-
-uploaded_files = st.file_uploader(
-    "Upload one or more retinal images",
-    type=["jpg", "jpeg", "png"],
-    accept_multiple_files=True
-)
+uploaded_files = st.file_uploader("Upload one or more retinal images", type=["jpg", "jpeg", "png"], accept_multiple_files=True)
 
 if uploaded_files:
-    for uploaded_file in uploaded_files:
-        file_bytes = np.asarray(bytearray(uploaded_file.read()), dtype=np.uint8)
-        bgr_img = cv2.imdecode(file_bytes, cv2.IMREAD_COLOR)
-        rgb_img = cv2.cvtColor(bgr_img, cv2.COLOR_BGR2RGB)
-
-        processed_img, stages = preprocess_image(rgb_img)
-        input_tensor = np.expand_dims(processed_img, axis=0)
-
-        preds = model.predict(input_tensor)
-        if isinstance(preds, dict):
-            preds = list(preds.values())[0]
+    filenames = [file.name for file in uploaded_files]
+    selected_file = st.selectbox("Select image to analyze:", filenames)
+    
+    # Show individual image analysis
+    for file in uploaded_files:
+        if file.name == selected_file:
+            file_bytes = np.asarray(bytearray(file.read()), dtype=np.uint8)
+            img = cv2.imdecode(file_bytes, cv2.IMREAD_COLOR)
+            rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+            processed, stages = preprocess_image(rgb)
+            show_preprocessing_steps(stages)
+
+            input_tensor = np.expand_dims(processed, axis=0)
+            preds = predict_fn(input_tensor)
+            pred_idx = np.argmax(preds)
+            pred_label = CLASS_NAMES[pred_idx]
+            confidence = np.max(preds) * 100
+            st.success(f"✅ Prediction: **{pred_label}** ({confidence:.2f}%)")
+            show_lime_explanation(processed, pred_idx, pred_label)
+            break
+
+    st.markdown("---")
+    st.subheader("📊 LIME Explanations for All Uploaded Images")
+    cols = st.columns(len(uploaded_files))
+    for i, file in enumerate(uploaded_files):
+        file.seek(0)
+        file_bytes = np.asarray(bytearray(file.read()), dtype=np.uint8)
+        img = cv2.imdecode(file_bytes, cv2.IMREAD_COLOR)
+        rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+        processed, _ = preprocess_image(rgb)
+        input_tensor = np.expand_dims(processed, axis=0)
+        preds = predict_fn(input_tensor)
         pred_idx = np.argmax(preds)
         pred_label = CLASS_NAMES[pred_idx]
-        confidence = np.max(preds) * 100
 
-        display_all_results(uploaded_file.name, rgb_img, processed_img, stages, pred_label, confidence, pred_idx)
+        explanation = explainer.explain_instance(
+            image=processed,
+            classifier_fn=predict_fn,
+            top_labels=1,
+            hide_color=0,
+            num_samples=1000
+        )
+        temp, mask = explanation.get_image_and_mask(label=pred_idx, positive_only=True, num_features=10, hide_rest=False)
+        with cols[i]:
+            st.image(mark_boundaries(temp, mask), caption=f"{file.name}\n({pred_label})", use_column_width=True)