Update app.py

app.py

@@ -1,134 +1,158 @@
 import os
 import base64
-from typing import List, Dict, Any
-
+import logging
 import numpy as np
 import cv2
 import requests
+from typing import List, Dict, Any
+
+import keras
 from fastapi import FastAPI, File, UploadFile, HTTPException
-from huggingface_hub import hf_hub_download  # NEW
+from huggingface_hub import hf_hub_download
 
+# ─── Logging & Backend ────────────────────────────────────────────────────────
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 os.environ["KERAS_BACKEND"] = "jax"
-import keras
+os.environ["JAX_PLATFORM_NAME"] = "cpu"  # Fast startup, no GPU needed
 
-# ─── Config ───────────────────────────────────────────────────────────────────
-API_KEY = os.environ["ROBOFLOW_API_KEY"]
-WORKFLOW_URL = "https://serverless.roboflow.com/YOUR_WORKSPACE/YOUR_WORKFLOW"  # adjust
+# ─── Config (use Space Secrets for API_KEY) ───────────────────────────────────
+API_KEY = os.getenv("ROBOFLOW_API_KEY")  # Set in Space Settings → Secrets
+WORKFLOW_URL = "https://serverless.roboflow.com/my-workspace-iy9ll/find-teeth"  # From your SDK
 IMG_SIZE = 256
-THRESHOLD = 0.05  # ideally derived from healthy images [file:1]
+THRESHOLD = 0.05  # mean+2*std from healthy images [file:1]
 
-# ─── Load model once at startup ───────────────────────────────────────────────
 MODEL_REPO = "sairamv1/TeethCariesDetection_CNNAutoencoder"
-MODEL_FILENAME = "autoencoder.keras"  # or whatever file you uploaded
-
-local_model_path = hf_hub_download(
-    repo_id=MODEL_REPO,
-    filename=MODEL_FILENAME,
-)
-
-MODEL = keras.saving.load_model(local_model_path)
-
-app = FastAPI()
-
-
-def first(seq):
-    """Return first element or None."""
+MODEL_FILENAME = "model.keras"  # Change if your file is named differently
+
+# ─── Load Model at Startup ────────────────────────────────────────────────────
+MODEL = None
+try:
+    logger.info("🚀 Downloading model...")
+    local_model_path = hf_hub_download(
+        repo_id=MODEL_REPO,
+        filename=MODEL_FILENAME,
+        cache_dir="/tmp"
+    )
+    logger.info(f"📥 Model at: {local_model_path}")
+    
+    logger.info("🔄 Loading Keras model...")
+    MODEL = keras.saving.load_model(local_model_path)
+    logger.info("✅ Model loaded successfully!")
+except Exception as e:
+    logger.error(f"❌ Model error: {e}")
+    MODEL = None
+
+app = FastAPI(title="Teeth Caries Detection API")
+
+def first(seq: Any) -> Any:
     return seq[0] if seq else None
 
+@app.get("/")
+async def root():
+    return {
+        "status": "alive ✅",
+        "model_loaded": MODEL is not None,
+        "endpoints": ["/analyze"],
+        "tooth_size": f"{IMG_SIZE}x{IMG_SIZE}",
+        "threshold": THRESHOLD
+    }
 
 @app.post("/analyze")
 async def analyze(file: UploadFile = File(...)):
-    # ── Read & decode image ───────────────────────────────────────────────────
+    if MODEL is None:
+        raise HTTPException(status_code=500, detail="Model failed to load at startup")
+    
+    # 1. Decode image
     contents = await file.read()
     nparr = np.frombuffer(contents, np.uint8)
     img = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
     if img is None:
-        raise HTTPException(status_code=400, detail="Invalid image file")
-
+        raise HTTPException(status_code=400, detail="Invalid image")
+    
     img_h, img_w = img.shape[:2]
 
-    # ── 1. Call Roboflow ──────────────────────────────────────────────────────
+    # 2. Roboflow workflow
     image_base64 = base64.b64encode(contents).decode("utf-8")
     try:
         response = requests.post(
             WORKFLOW_URL,
-            json={
-                "api_key": API_KEY,
-                "inputs": {"image": {"type": "base64", "value": image_base64}},
-            },
-            timeout=60,
+            params={"api_key": API_KEY},
+            json={"inputs": {"image": {"type": "base64", "value": image_base64}}},
+            timeout=60
         )
         response.raise_for_status()
-    except requests.exceptions.Timeout:
-        raise HTTPException(status_code=504, detail="Roboflow request timed out")
-    except requests.exceptions.RequestException as e:
-        raise HTTPException(status_code=502, detail=f"Roboflow error: {e}")
-
-    result = response.json()
-    item0 = first(result)
-    if not item0:
-        return {"tooth_count": 0, "results": []}
-
-    outputs = first(item0.get("outputs", []))
-    pred_blob = outputs.get("predictions", {}) if outputs else {}
-    predictions_list: List[Dict[str, Any]] = (
-        pred_blob.get("predictions", []) if isinstance(pred_blob, dict) else (pred_blob or [])
-    )
+    except Exception as e:
+        raise HTTPException(status_code=502, detail=f"Roboflow error: {str(e)}")
+
+    # 3. Parse predictions (flexible for different response formats)
+    result_json = response.json()
+    predictions_list = []
+    try:
+        if isinstance(result_json, list):
+            outputs = first(result_json).get("outputs", {})
+        else:
+            outputs = result_json.get("outputs", [{}])[0]
+        pred_blob = outputs.get("predictions", {})
+        predictions_list = pred_blob.get("predictions", []) if isinstance(pred_blob, dict) else pred_blob
+    except:
+        predictions_list = []
 
     if not predictions_list:
-        return {"tooth_count": 0, "results": []}
+        return {"status": "success", "tooth_count": 0, "results": [], "message": "No teeth detected"}
 
-    # ── 2. Prepare batch ──────────────────────────────────────────────────────
+    # 4. Crop + preprocess teeth
     batch_images = []
     metadata = []
-
-    for i, det in enumerate(predictions_list):
+    for i, det in enumerate(predictions_list[:5]):  # Max 5 teeth
         xc, yc, w, h = det["x"], det["y"], det["width"], det["height"]
-        x1 = max(0, int(round(xc - w / 2)))
-        y1 = max(0, int(round(yc - h / 2)))
-        x2 = min(img_w, int(round(xc + w / 2)))
-        y2 = min(img_h, int(round(yc + h / 2)))
-
+        x1, y1 = max(0, int(xc - w/2)), max(0, int(yc - h/2))
+        x2, y2 = min(img_w, int(xc + w/2)), min(img_h, int(yc + h/2))
+        
         crop = img[y1:y2, x1:x2]
-        if crop.size == 0:
-            continue
+        if crop.size == 0: continue
 
-        # Grayscale + CLAHE
+        # Grayscale + CLAHE enhancement
         gray = cv2.cvtColor(crop, cv2.COLOR_BGR2GRAY)
-        clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
+        clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
         gray = clahe.apply(gray)
 
-        # Resize with padding (preserve aspect ratio)
-        ch, cw = gray.shape[:2]
+        # Resize with padding (preserves aspect ratio)
+        ch, cw = gray.shape
         scale = IMG_SIZE / max(ch, cw)
-        new_w, new_h = max(1, int(round(cw * scale))), max(1, int(round(ch * scale)))
+        new_w, new_h = max(1, int(cw * scale)), max(1, int(ch * scale))
         resized = cv2.resize(gray, (new_w, new_h), interpolation=cv2.INTER_AREA)
-
+        
         canvas = np.zeros((IMG_SIZE, IMG_SIZE), dtype=np.uint8)
-        y0, x0 = (IMG_SIZE - new_h) // 2, (IMG_SIZE - new_w) // 2
-        canvas[y0 : y0 + new_h, x0 : x0 + new_w] = resized
-
+        y0, x0 = (IMG_SIZE - new_h)//2, (IMG_SIZE - new_w)//2
+        canvas[y0:y0+new_h, x0:x0+new_w] = resized
+        
+        # Normalize to [0,1] + channel dim
         final_img = (canvas.astype(np.float32) / 255.0)[..., np.newaxis]
         batch_images.append(final_img)
-        metadata.append({"id": i, "box": [x1, y1, x2, y2]})
+        metadata.append({"id": i, "box": [x1,y1,x2,y2]})
 
     if not batch_images:
-        return {"tooth_count": 0, "results": []}
-
-    # ── 3. Batch inference ────────────────────────────────────────────────────
-    batch_array = np.array(batch_images)  # (N, 256, 256, 1)
-    reconstructions = MODEL.predict(batch_array)
+        return {"status": "success", "tooth_count": 0, "results": []}
 
-    # ── 4. Anomaly scores ─────────────────────────────────────────────────────
-    errors = np.mean(np.abs(batch_array - reconstructions), axis=(1, 2, 3))
+    # 5. Autoencoder inference + anomaly scoring
+    batch_array = np.array(batch_images)
+    reconstructions = MODEL.predict(batch_array, verbose=0)
+    errors = np.mean(np.abs(batch_array - reconstructions), axis=(1,2,3))
 
-    final_results = []
+    results = []
     for idx, score in enumerate(errors):
-        final_results.append({
+        results.append({
             "tooth_index": metadata[idx]["id"],
             "score": float(score),
-            "is_anomaly": bool(score > THRESHOLD),
-            "bounding_box": metadata[idx]["box"],
+            "is_anomaly": score > THRESHOLD,
+            "confidence": float(1.0 - score),  # Lower error = higher confidence healthy
+            "bounding_box": metadata[idx]["box"]
         })
 
-    return {"tooth_count": len(final_results), "results": final_results}
+    return {
+        "status": "success",
+        "tooth_count": len(results),
+        "results": results,
+        "threshold_used": THRESHOLD
+    }