Upload 8 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+coatnet_retina_app/model.keras.keras filter=lfs diff=lfs merge=lfs -text

coatnet_retina_app/README.md

@@ -0,0 +1,7 @@
+
+# 🧠 Retinal Disease Classifier with CoAtNet
+
+Upload a retinal image to classify it into 8 diseases using a fine-tuned CoAtNet model.
+Includes Grad-CAM and LIME explanations.
+
+Built with Streamlit • Deployable on Hugging Face Spaces.

coatnet_retina_app/app.py

@@ -0,0 +1,38 @@
+
+import streamlit as st
+import tensorflow as tf
+import numpy as np
+from PIL import Image
+import os
+
+from utils.gradcam import generate_gradcam
+from utils.lime_explainer import explain_with_lime
+from preprocessing.preprocess import preprocess_image
+
+@st.cache_resource
+def load_model():
+    return tf.keras.models.load_model("model.keras")
+
+model = load_model()
+
+class_names = ["Normal", "Diabetes", "Glaucoma", "Cataract", "AMD", "Hypertension", "Myopia", "Others"]
+
+st.title("🧠 Retinal Disease Classifier (CoAtNet)")
+uploaded_file = st.file_uploader("Upload a retinal image", type=["jpg", "png", "jpeg"])
+
+if uploaded_file:
+    image = Image.open(uploaded_file).convert("RGB")
+    st.image(image, caption="Input Image", use_column_width=True)
+
+    img_array = preprocess_image(image)
+    pred = model.predict(np.expand_dims(img_array, axis=0))
+    predicted_class = class_names[np.argmax(pred)]
+    st.success(f"✅ Predicted Disease: **{predicted_class}**")
+
+    st.subheader("🔍 Grad-CAM Explanation")
+    gradcam = generate_gradcam(model, img_array)
+    st.image(gradcam, caption="Grad-CAM", use_column_width=True)
+
+    st.subheader("🔍 LIME Explanation")
+    lime_expl = explain_with_lime(model, img_array)
+    st.image(lime_expl, caption="LIME Explanation", use_column_width=True)

coatnet_retina_app/model.keras.keras

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ce970139e4fd81f52f923a9b302276a97f99dd9b3b6a85861ec3fcabbe09ef6d
+size 133360977

coatnet_retina_app/preprocessing/preprocess.py

@@ -0,0 +1,40 @@
+
+import cv2
+import numpy as np
+
+def crop_circle(img):
+    h, w = img.shape[:2]
+    center = (w // 2, h // 2)
+    radius = min(center[0], center[1])
+    Y, X = np.ogrid[:h, :w]
+    dist = np.sqrt((X - center[0]) ** 2 + (Y - center[1]) ** 2)
+    mask = dist <= radius
+    if img.ndim == 3:
+        mask = np.stack([mask] * 3, axis=-1)
+    img[~mask] = 0
+    return img
+
+def apply_clahe(img):
+    lab = cv2.cvtColor(img, 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))
+    return cv2.cvtColor(merged, cv2.COLOR_LAB2RGB)
+
+def sharpen_image(img, sigma=10):
+    blur = cv2.GaussianBlur(img, (0, 0), sigma)
+    return cv2.addWeighted(img, 4, blur, -4, 128)
+
+def resize_normalize(img, size=(224, 224)):
+    img = cv2.resize(img, size)
+    img = img / 255.0
+    return img
+
+def preprocess_image(image):
+    img = np.array(image)
+    img = crop_circle(img)
+    img = apply_clahe(img)
+    img = sharpen_image(img)
+    img = resize_normalize(img)
+    return img.astype(np.float32)

coatnet_retina_app/requirements.txt

@@ -0,0 +1,9 @@
+
+streamlit
+tensorflow==2.11.0
+opencv-python-headless
+lime
+scikit-image
+numpy
+matplotlib
+Pillow

coatnet_retina_app/utils/gradcam.py

@@ -0,0 +1,28 @@
+
+import numpy as np
+import tensorflow as tf
+import cv2
+import matplotlib.cm as cm
+
+def find_last_conv_layer(model):
+    for layer in reversed(model.layers):
+        if isinstance(layer, tf.keras.layers.Conv2D) or 'mhsa_output' in layer.name:
+            return layer.name
+    raise ValueError("No suitable conv layer found.")
+
+def generate_gradcam(model, img_array):
+    layer_name = find_last_conv_layer(model)
+    grad_model = tf.keras.models.Model([model.inputs], [model.get_layer(layer_name).output, model.output])
+    with tf.GradientTape() as tape:
+        conv_outputs, predictions = grad_model(tf.expand_dims(img_array, axis=0))
+        loss = predictions[:, tf.argmax(predictions[0])]
+    grads = tape.gradient(loss, conv_outputs)
+    pooled_grads = tf.reduce_mean(grads, axis=(0, 1, 2))
+    heatmap = conv_outputs[0] @ pooled_grads[..., tf.newaxis]
+    heatmap = tf.squeeze(heatmap)
+    heatmap = tf.maximum(heatmap, 0) / tf.math.reduce_max(heatmap)
+    heatmap = cv2.resize(heatmap.numpy(), (224, 224))
+    heatmap = np.uint8(255 * heatmap)
+    heatmap = cv2.applyColorMap(heatmap, cv2.COLORMAP_JET)
+    superimposed_img = cv2.addWeighted(np.uint8(img_array * 255), 0.5, heatmap, 0.5, 0)
+    return superimposed_img

coatnet_retina_app/utils/lime_explainer.py

@@ -0,0 +1,23 @@
+
+import numpy as np
+from lime import lime_image
+from skimage.segmentation import mark_boundaries
+
+explainer = lime_image.LimeImageExplainer()
+
+def explain_with_lime(model, img_array):
+    def predict_fn(images): return model.predict(np.array(images), verbose=0)
+    explanation = explainer.explain_instance(
+        image=img_array,
+        classifier_fn=predict_fn,
+        top_labels=1,
+        hide_color=0,
+        num_samples=1000
+    )
+    temp, mask = explanation.get_image_and_mask(
+        label=explanation.top_labels[0],
+        positive_only=True,
+        num_features=10,
+        hide_rest=False
+    )
+    return mark_boundaries(temp, mask)