Update app.py

app.py

@@ -9,137 +9,134 @@ from skimage.segmentation import mark_boundaries
 from keras.layers import BatchNormalization, DepthwiseConv2D, TFSMLayer
 
 # --- Fix deserialization issues ---
-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"}))
+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))
+
+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))
 
 # --- Constants ---
 IMG_SIZE = (224, 224)
 CLASS_NAMES = ['Normal', 'Diabetes', 'Glaucoma', 'Cataract', 'AMD', 'Hypertension', 'Myopia', 'Others']
+LIME_EXPLAINER = lime_image.LimeImageExplainer()
 
+# --- Load model from TFSMLayer ---
 @st.cache_resource
 def load_model():
     model_path = "Model"
-    model = tf.keras.Sequential([
-        TFSMLayer(model_path, call_endpoint="serving_default")
-    ])
-    return model
-
-def preprocess_image(img):
+    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: {e}")
+        st.stop()
+
+# --- Preprocessing with Visualization ---
+def preprocess_with_steps(img):
     h, w = img.shape[:2]
-    center = (w // 2, h // 2)
-    radius = min(center[0], center[1])
+    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)
     mask = dist <= radius
     circ = cv2.bitwise_and(img, img, mask=mask.astype(np.uint8))
 
     lab = cv2.cvtColor(circ, cv2.COLOR_RGB2LAB)
-    l, a, b = cv2.split(lab)
-    clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
-    cl = clahe.apply(l)
-    merged = cv2.merge((cl, a, b))
+    cl = cv2.createCLAHE(clipLimit=2.0).apply(lab[:, :, 0])
+    merged = cv2.merge((cl, lab[:, :, 1], lab[:, :, 2]))
     clahe_img = cv2.cvtColor(merged, cv2.COLOR_LAB2RGB)
 
-    blur = cv2.GaussianBlur(clahe_img, (0, 0), 10)
-    sharp = cv2.addWeighted(clahe_img, 4, blur, -4, 128)
-
+    sharp = cv2.addWeighted(clahe_img, 4, cv2.GaussianBlur(clahe_img, (0, 0), 10), -4, 128)
     resized = cv2.resize(sharp, IMG_SIZE) / 255.0
-    return resized, [img, circ, clahe_img, resized]
-
-explanation_text = {
-    '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."
-}
-
-explainer = lime_image.LimeImageExplainer()
-
-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"]
     fig, axs = plt.subplots(1, 4, figsize=(20, 5))
-    for i, img in enumerate(stages):
-        axs[i].imshow(img)
-        axs[i].set_title(titles[i])
-        axs[i].axis('off')
+    for ax, image, title in zip(axs, [img, circ, clahe_img, resized],
+                                 ["Original", "Circular Crop", "CLAHE", "Sharpen + Resize"]):
+        ax.imshow(image)
+        ax.set_title(title)
+        ax.axis("off")
     st.pyplot(fig)
-    plt.close()
+    return resized
 
-def show_lime_explanation(img, pred_idx, pred_label):
-    with st.spinner("🟡 LIME Explanation is Loading..."):
-        explanation = explainer.explain_instance(
+# --- 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 Visualization ---
+def show_lime(img, model, pred_idx, pred_label):
+    with st.spinner("🟡 LIME explanation is loading..."):
+        explanation = LIME_EXPLAINER.explain_instance(
             image=img,
-            classifier_fn=predict_fn,
+            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)
-        fig, ax = plt.subplots(figsize=(6, 5))
+
+        fig, ax = plt.subplots(1, 1, figsize=(6, 5))
         ax.imshow(mark_boundaries(temp, mask))
-        ax.axis('off')
-        ax.set_title(f"LIME: {pred_label}")
+        ax.set_title(f"LIME Explanation: {pred_label}")
+        ax.axis("off")
         st.pyplot(fig)
-        plt.close()
 
 # --- 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)
 
+with st.sidebar:
+    uploaded_files = st.file_uploader("📂 Upload retinal images", type=["jpg", "jpeg", "png"], accept_multiple_files=True)
+    selected_filename = None
+    if uploaded_files:
+        filenames = [f.name for f in uploaded_files]
+        selected_filename = st.selectbox("🎯 Select an image to explain", filenames)
+
+# -- Predict & Display for Selected Image --
+if uploaded_files and selected_filename:
+    file = next(f for f in uploaded_files if f.name == selected_filename)
+    bgr = cv2.imdecode(np.frombuffer(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)
+
+    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}%)")
+    show_lime(preprocessed, model, pred_idx, pred_label)
+
+# -- Show LIME for all images --
 if uploaded_files:
-    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))
+    st.markdown("## 🧪 LIME Explanations for All Images")
+    cols = st.columns(min(4, 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)
+        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)
+
+        preds = predict(input_tensor, model)
         pred_idx = np.argmax(preds)
         pred_label = CLASS_NAMES[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)
+        with cols[i % len(cols)]:
+            st.markdown(f"**{file.name}**<br>🧠 *{pred_label}*", unsafe_allow_html=True)
+            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)