Update app.py

app.py

@@ -10,20 +10,17 @@ from keras.layers import BatchNormalization, DepthwiseConv2D, TFSMLayer
 
 # --- Fix deserialization issues ---
 original_bn = BatchNormalization.from_config
-BatchNormalization.from_config = classmethod(
-    lambda cls, config, *a, **k: original_bn(config if not isinstance(config.get("axis"), list) else {**config, "axis": config["axis"][0]}, *a, **k)
-)
+BatchNormalization.from_config = classmethod(lambda cls, config, *a, **k: original_bn(config if not isinstance(config.get("axis"), list) else {**config, "axis": config["axis"][0]}, *a, **k))
+
 original_dw = DepthwiseConv2D.from_config
-DepthwiseConv2D.from_config = classmethod(
-    lambda cls, config, *a, **k: original_dw({k: v for k, v in config.items() if k != "groups"}, *a, **k)
-)
+DepthwiseConv2D.from_config = classmethod(lambda cls, config, *a, **k: original_dw({k: v for k, v in config.items() if k != "groups"}, *a, **k))
 
 # --- Constants ---
 IMG_SIZE = (224, 224)
 CLASS_NAMES = ['Normal', 'Diabetes', 'Glaucoma', 'Cataract', 'AMD', 'Hypertension', 'Myopia', 'Others']
 LIME_EXPLAINER = lime_image.LimeImageExplainer()
 
-# --- Load model ---
+# --- Load model from TFSMLayer ---
 @st.cache_resource
 def load_model():
     model_path = "Model"
@@ -31,17 +28,18 @@ def load_model():
         st.error(f"Model folder '{model_path}' not found.")
         st.stop()
     try:
-        return tf.keras.Sequential([TFSMLayer(model_path, call_endpoint="serving_default")])
+        model = tf.keras.Sequential([TFSMLayer(model_path, call_endpoint="serving_default")])
+        return model
     except Exception as e:
         st.error(f"Error loading model: {e}")
         st.stop()
 
-# --- Preprocess + Visualization ---
+# --- Preprocessing with Visualization ---
 def preprocess_with_steps(img):
     h, w = img.shape[:2]
     center, radius = (w // 2, h // 2), min(w, h) // 2
     Y, X = np.ogrid[:h, :w]
-    dist = np.sqrt((X - center[0])**2 + (Y - center[1])**2)
+    dist = np.sqrt((X - center[0]) ** 2 + (Y - center[1]) ** 2)
     mask = dist <= radius
     circ = cv2.bitwise_and(img, img, mask=mask.astype(np.uint8))
 
@@ -62,13 +60,13 @@ def preprocess_with_steps(img):
     st.pyplot(fig)
     return resized
 
-# --- Prediction ---
+# --- Prediction Function ---
 def predict(images, model):
     images = np.array(images)
     preds = model.predict(images, verbose=0)
     return list(preds.values())[0] if isinstance(preds, dict) else preds
 
-# --- LIME Display ---
+# --- LIME Visualization ---
 def show_lime(img, model, pred_idx, pred_label):
     with st.spinner("🟡 LIME explanation is loading..."):
         explanation = LIME_EXPLAINER.explain_instance(
@@ -79,45 +77,41 @@ def show_lime(img, model, pred_idx, pred_label):
             num_samples=1000
         )
         temp, mask = explanation.get_image_and_mask(label=pred_idx, positive_only=True, num_features=10, hide_rest=False)
-        return mark_boundaries(temp, mask)
 
-# --- UI ---
-st.set_page_config(page_title="🧠 Retina Disease Classifier", layout="wide")
+        fig, ax = plt.subplots(1, 1, figsize=(6, 5))
+        ax.imshow(mark_boundaries(temp, mask))
+        ax.set_title(f"LIME Explanation: {pred_label}")
+        ax.axis("off")
+        st.pyplot(fig)
+
+# --- 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()
 
 with st.sidebar:
-    uploaded_files = st.file_uploader("📂 Upload multiple retinal images", type=["jpg", "jpeg", "png"], accept_multiple_files=True)
+    uploaded_files = st.file_uploader("📂 Upload retinal images", type=["jpg", "jpeg", "png"], accept_multiple_files=True)
 
+# -- Optional: Show preprocessing for any selected image --
 if uploaded_files:
-    # Display prediction + preprocessing for each image
-    for file in uploaded_files:
-        st.markdown(f"### 🖼️ Image: **{file.name}**")
-        img_bytes = file.read()
-        bgr = cv2.imdecode(np.frombuffer(img_bytes, np.uint8), cv2.IMREAD_COLOR)
+    st.markdown("## 🧪 View Preprocessing of a Selected Image")
+    selected_file_name = st.selectbox("Select an image to view preprocessing", [f.name for f in uploaded_files])
+    if selected_file_name:
+        selected_file = next(f for f in uploaded_files if f.name == selected_file_name)
+        bgr = cv2.imdecode(np.frombuffer(selected_file.read(), np.uint8), cv2.IMREAD_COLOR)
         rgb = cv2.cvtColor(bgr, cv2.COLOR_BGR2RGB)
 
-        st.subheader("🔍 Preprocessing Steps")
-        preprocessed = preprocess_with_steps(rgb)
-        input_tensor = np.expand_dims(preprocessed, axis=0)
+        st.subheader(f"🔍 Preprocessing Steps for {selected_file_name}")
+        _ = preprocess_with_steps(rgb)
 
-        preds = predict(input_tensor, model)
-        pred_idx = np.argmax(preds)
-        pred_label = CLASS_NAMES[pred_idx]
-        confidence = np.max(preds) * 100
-
-        st.success(f"✅ Prediction: **{pred_label}** ({confidence:.2f}%)")
-
-        lime_image_result = show_lime(preprocessed, model, pred_idx, pred_label)
-        st.image(lime_image_result, caption=f"LIME: {pred_label}", use_column_width=True)
-
-    # Grid view of LIME explanations
-    st.markdown("## 🧪 All LIME Explanations (Grid View)")
+# -- Predict & Show LIME for All Uploaded Images --
+if uploaded_files:
+    st.markdown("## 🧪 Predictions and LIME Explanations for All Images")
     cols = st.columns(min(4, len(uploaded_files)))
+
     for i, file in enumerate(uploaded_files):
-        img_bytes = file.read()
-        bgr = cv2.imdecode(np.frombuffer(img_bytes, np.uint8), cv2.IMREAD_COLOR)
+        bgr = cv2.imdecode(np.frombuffer(file.read(), np.uint8), cv2.IMREAD_COLOR)
         rgb = cv2.cvtColor(bgr, cv2.COLOR_BGR2RGB)
         img = cv2.resize(rgb, IMG_SIZE) / 255.0
         input_tensor = np.expand_dims(img, axis=0)
@@ -125,8 +119,17 @@ if uploaded_files:
         preds = predict(input_tensor, model)
         pred_idx = np.argmax(preds)
         pred_label = CLASS_NAMES[pred_idx]
+        confidence = np.max(preds) * 100
 
-        lime_img = show_lime(img, model, pred_idx, pred_label)
         with cols[i % len(cols)]:
-            st.markdown(f"**{file.name}**<br>🧠 *{pred_label}*", unsafe_allow_html=True)
-            st.image(lime_img, use_column_width=True)
+            st.markdown(f"**{file.name}**<br>🧠 *{pred_label}* ({confidence:.2f}%)", unsafe_allow_html=True)
+            with st.spinner("🟡 LIME explanation is loading..."):
+                explanation = LIME_EXPLAINER.explain_instance(
+                    image=img,
+                    classifier_fn=lambda imgs: predict(imgs, model),
+                    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)
+                st.image(mark_boundaries(temp, mask), use_column_width=True)