Update app.py

app.py

@@ -2,72 +2,139 @@ import tensorflow as tf
 import gradio as gr
 import numpy as np
 from PIL import Image
-from fastapi import FastAPI, UploadFile, File
 import io
-
-gpus = tf.config.list_physical_devices('GPU')
-if gpus:
-    tf.config.experimental.set_memory_growth(gpus[0], True)
+import os
 
 IMG_SIZE = 224
 
-# ===== LOAD MODEL =====
-model = tf.keras.models.load_model("model.keras", compile=False)
+# ===== DETECT GPU/CPU =====
+try:
+    gpus = tf.config.list_physical_devices('GPU')
+    if gpus:
+        # Coba atur memory growth, tapi jangan crash jika gagal
+        try:
+            tf.config.experimental.set_memory_growth(gpus[0], True)
+        except:
+            pass
+        print("GPU available")
+    else:
+        print("Using CPU")
+except:
+    print("GPU configuration skipped")
 
 DR_CLASSES = ["No DR","Mild","Moderate","Severe","Proliferative DR"]
 DME_CLASSES = ["No DME","Low Risk","High Risk"]
 
+# ===== LOAD MODEL (with error handling) =====
+MODEL_PATH = "model.keras"
+
+# Cek apakah model file ada
+if not os.path.exists(MODEL_PATH):
+    # Fallback untuk demo jika model tidak ada
+    print(f"Warning: {MODEL_PATH} not found. Using mock predictions.")
+    model = None
+else:
+    try:
+        # Load dengan opsi yang lebih kompatibel
+        model = tf.keras.models.load_model(
+            MODEL_PATH, 
+            compile=False,
+            safe_mode=False  # Untuk compatibility
+        )
+        print("Model loaded successfully")
+    except Exception as e:
+        print(f"Error loading model: {e}")
+        model = None
+
 # ===== PREPROCESS =====
 def preprocess(img):
     img = img.resize((IMG_SIZE, IMG_SIZE))
+    # Pastikan 3 channel
+    if img.mode != 'RGB':
+        img = img.convert('RGB')
     arr = np.array(img) / 255.0
-    return np.expand_dims(arr,0).astype(np.float32)
+    return np.expand_dims(arr, 0).astype(np.float32)
 
-# ===== CORE PREDICT =====
+# ===== CORE PREDICT (with fallback) =====
 def core_predict(img):
-    x = preprocess(img)
-    preds = model.predict(x)
-
-    if isinstance(preds, dict):
-        dr = preds["dr_head"][0]
-        dme = preds["dme_head"][0]
-    else:
-        dr = preds[0][0]
-        dme = preds[1][0]
-
-    dr = tf.nn.softmax(dr).numpy()
-    dme = tf.nn.softmax(dme).numpy()
-
-    return {
-        "dr": {
-            "label": DR_CLASSES[int(np.argmax(dr))],
-            "confidence": float(np.max(dr)*100)
-        },
-        "dme": {
-            "label": DME_CLASSES[int(np.argmax(dme))],
-            "confidence": float(np.max(dme)*100)
+    # Jika model tidak ada, return mock predictions untuk demo
+    if model is None:
+        return {
+            "dr": {
+                "label": "No DR",
+                "confidence": 85.5,
+                "note": "Mock prediction - model not loaded"
+            },
+            "dme": {
+                "label": "No DME",
+                "confidence": 90.2,
+                "note": "Mock prediction - model not loaded"
+            }
+        }
+    
+    try:
+        x = preprocess(img)
+        preds = model.predict(x, verbose=0)  # verbose=0 untuk suppress output
+        
+        # Handle different model output formats
+        if isinstance(preds, dict):
+            dr = preds.get("dr_head", preds.get("DR", preds.get("output_0")))
+            dme = preds.get("dme_head", preds.get("DME", preds.get("output_1")))
+        elif isinstance(preds, list) and len(preds) >= 2:
+            dr = preds[0]
+            dme = preds[1]
+        else:
+            dr = preds[:, :5] if preds.shape[1] >= 5 else preds
+            dme = preds[:, 5:] if preds.shape[1] >= 8 else preds
+        
+        # Pastikan shape benar
+        dr = dr[0] if len(dr.shape) > 1 else dr
+        dme = dme[0] if len(dme.shape) > 1 else dme
+        
+        # Apply softmax
+        dr_probs = tf.nn.softmax(dr).numpy()
+        dme_probs = tf.nn.softmax(dme).numpy()
+        
+        return {
+            "dr": {
+                "label": DR_CLASSES[int(np.argmax(dr_probs))],
+                "confidence": float(np.max(dr_probs) * 100)
+            },
+            "dme": {
+                "label": DME_CLASSES[int(np.argmax(dme_probs))],
+                "confidence": float(np.max(dme_probs) * 100)
+            }
+        }
+        
+    except Exception as e:
+        return {
+            "error": str(e),
+            "note": "Prediction failed"
         }
-    }
-
-# ===== FASTAPI =====
-app = FastAPI()
-
-@app.post("/predict")
-async def api_predict(file: UploadFile = File(...)):
-    image = await file.read()
-    img = Image.open(io.BytesIO(image)).convert("RGB")
-    return core_predict(img)
 
-# ===== GRADIO =====
+# ===== GRADIO INTERFACE =====
 def gradio_predict(img):
+    if img is None:
+        return {"error": "No image provided"}
     return core_predict(img)
 
+# Buat Gradio interface dengan tema yang lebih sederhana
 demo = gr.Interface(
     fn=gradio_predict,
-    inputs=gr.Image(type="pil"),
-    outputs="json",
-    title="DR & DME Detection"
+    inputs=gr.Image(type="pil", label="Upload Retina Image"),
+    outputs=gr.JSON(label="Prediction Results"),
+    title="Diabetic Retinopathy & DME Detection",
+    description="Upload a retina fundus image to detect Diabetic Retinopathy (DR) and Diabetic Macular Edema (DME)",
+    examples=[
+        ["sample1.jpg"],  # Pastikan file contoh ada
+        ["sample2.jpg"]
+    ] if os.path.exists("sample1.jpg") else None,
+    allow_flagging="never"
 )
 
-# Mount Gradio ke FastAPI
-app = gr.mount_gradio_app(app, demo, path="/")
+# Untuk Hugging Face, cukup export demo
+if __name__ == "__main__":
+    demo.launch(debug=True)
+else:
+    # Untuk Hugging Face deployment
+    demo.launch = lambda *args, **kwargs: demo