Update app.py

app.py

@@ -1,120 +1,155 @@
+import os
 import json
+from pathlib import Path
+
 import numpy as np
 import tensorflow as tf
 import gradio as gr
 from fastapi import FastAPI, Request
 from fastapi.middleware.cors import CORSMiddleware
 
-# ---------- CONFIG ----------
-MODEL_PATH = "best_model.h5"                 # or best_model.keras if that’s what you uploaded
-STATS_PATH = "Means & Std for Excel.json"    # exact filename
+# ---------- CONFIG (edit these names if yours differ) ----------
+MODEL_PATH = os.environ.get("MODEL_PATH", "best_model.h5")          # or "best_model.keras"
+STATS_PATH = os.environ.get("STATS_PATH", "Means & Std for Excel.json")
 CLASSES = ["Top", "Mid-Top", "Mid", "Mid-Low", "Low"]
-# ----------------------------
+# --------------------------------------------------------------
 
-print("Loading model and stats...")
-model = tf.keras.models.load_model(MODEL_PATH, compile=False)
-with open(STATS_PATH, "r") as f:
-    stats = json.load(f)
+# Global handles (lazy init)
+_model = None
+_stats = None
+_features = None
 
-FEATURES = list(stats.keys())
-print("Feature order:", FEATURES)
+def _exists(p): return Path(p).exists()
 
-def _z(val):  # safe z-score
+def _safe_float(x, default=0.0):
     try:
-        v = float(val)
+        return float(x)
     except Exception:
-        v = 0.0
-    return v
+        return default
 
 def _zscore(val, mean, sd):
-    v = _z(val)
+    v = _safe_float(val, 0.0)
     return 0.0 if (sd is None or sd == 0) else (v - mean) / sd
 
 def coral_probs_from_logits(logits_np):
-    import tensorflow as tf
-    logits = tf.convert_to_tensor(logits_np, dtype=tf.float32)  # (1, K-1)
-    sig = tf.math.sigmoid(logits)                               # (1, K-1)
+    logits = tf.convert_to_tensor(logits_np, dtype=tf.float32)  # (N, K-1)
+    sig = tf.math.sigmoid(logits)
     left  = tf.concat([tf.ones_like(sig[:, :1]), sig], axis=1)
     right = tf.concat([sig, tf.zeros_like(sig[:, :1])], axis=1)
     probs = tf.clip_by_value(left - right, 1e-12, 1.0)
     return probs.numpy()
 
+def lazy_init():
+    """Load model + stats on first use; never crash the process."""
+    global _model, _stats, _features
+    if _model is not None and _stats is not None and _features is not None:
+        return
+
+    problems = []
+    if not _exists(MODEL_PATH):
+        problems.append(f"Model file not found: {MODEL_PATH}")
+    if not _exists(STATS_PATH):
+        problems.append(f"Stats JSON not found: {STATS_PATH}")
+    if problems:
+        # Don’t raise—let callers see the reason in the response
+        raise RuntimeError("; ".join(problems))
+
+    try:
+        _model = tf.keras.models.load_model(MODEL_PATH, compile=False)
+    except Exception as e:
+        raise RuntimeError(f"Failed to load model: {type(e).__name__}: {e}")
+
+    try:
+        with open(STATS_PATH, "r") as f:
+            _stats = json.load(f)
+    except Exception as e:
+        raise RuntimeError(f"Failed to read stats JSON: {type(e).__name__}: {e}")
+
+    # Fixed feature order = keys order in JSON
+    _features = list(_stats.keys())
+    print("Feature order:", _features)
+
 def predict_core(ratios: dict):
-    # build z vector in fixed order
-    zscores = []
-    z_map = {}
-    for f in FEATURES:
-        mean = stats[f]["mean"]
-        sd   = stats[f]["std"]
-        val  = ratios.get(f, 0.0)
-        z    = _zscore(val, mean, sd)
-        zscores.append(z)
-        z_map[f] = z
-
-    X = np.array([zscores], dtype=np.float32)
-    y = model.predict(X, verbose=0)
-
-    # handle either softmax K or CORAL K-1
+    lazy_init()  # may raise RuntimeError with a clear message
+
+    zvec = []
+    zmap = {}
+    for f in _features:
+        mean = _stats[f]["mean"]
+        sd   = _stats[f]["std"]
+        z    = _zscore(ratios.get(f, 0.0), mean, sd)
+        zvec.append(z)
+        zmap[f] = z
+
+    X = np.array([zvec], dtype=np.float32)
+    y = _model.predict(X, verbose=0)
+
+    # Softmax (K) or CORAL (K-1)
     if y.ndim == 2 and y.shape[1] == len(CLASSES):
         probs = y[0]
     elif y.ndim == 2 and y.shape[1] == len(CLASSES) - 1:
         probs = coral_probs_from_logits(y)[0]
     else:
-        # fallback: normalize positive scores
-        s = y[0].astype(np.float64)
-        if s.ndim == 0:
-            s = np.array([float(s)], dtype=np.float64)
-        s = np.maximum(s, 0.0)
+        s = np.maximum(y[0].astype(np.float64).ravel(), 0.0)
         probs = s / s.sum() if s.sum() > 0 else np.ones(len(CLASSES)) / len(CLASSES)
 
     pred_idx = int(np.argmax(probs))
-    pred_state = CLASSES[pred_idx]
     return {
         "input_ok": True,
-        "missing": [f for f in FEATURES if f not in ratios],
-        "z_scores": z_map,
+        "missing": [f for f in _features if f not in ratios],
+        "z_scores": zmap,
         "probabilities": {CLASSES[i]: float(probs[i]) for i in range(len(CLASSES))},
-        "predicted_state": pred_state
+        "predicted_state": CLASSES[pred_idx]
     }
 
 def predict_from_json(payload):
-    # accept raw dict OR list-of-one dict
+    # Accept raw dict or list-of-one
     if isinstance(payload, list) and len(payload) == 1 and isinstance(payload[0], dict):
         payload = payload[0]
     if not isinstance(payload, dict):
-        return {"error": "Invalid payload: send a JSON object mapping feature->value."}
-    return predict_core(payload)
+        return {"error": "Invalid payload. Send a JSON object mapping feature->value."}
+    try:
+        return predict_core(payload)
+    except RuntimeError as e:
+        # File/boot issues come here (and we still return 200 JSON)
+        return {"error": str(e)}
+    except Exception as e:
+        return {"error": f"{type(e).__name__}: {e}"}
 
 # ------------------ FastAPI + Gradio ------------------
-# ------------------ FastAPI + Gradio ------------------
-from fastapi import FastAPI, Request
-from fastapi.middleware.cors import CORSMiddleware
-import gradio as gr
-
 app = FastAPI()
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"], allow_methods=["*"], allow_headers=["*"],
 )
 
-# Plain handler we’ll reuse
+@app.get("/health")
+def health():
+    return {
+        "ok": True,
+        "model_exists": _exists(MODEL_PATH),
+        "stats_exists": _exists(STATS_PATH),
+        "model_loaded": (_model is not None),
+        "stats_loaded": (_stats is not None)
+    }
+
+# Plain REST endpoints for Excel (we expose several to be future-proof)
+from fastapi import Request
+
 async def _handle_predict(req: Request):
-    body = await req.json()
-    # accept either raw dict or {"data":[{...}]}
+    try:
+        body = await req.json()
+    except Exception:
+        return {"error": "Invalid JSON"}
+    # raw dict or {"data":[{...}]}
     if isinstance(body, dict) and "data" in body and isinstance(body["data"], list) and body["data"]:
         body = body["data"][0]
-    if not isinstance(body, dict):
-        return {"error": "Invalid payload. Send a JSON object of feature->value or {'data':[that_object]}."}
-    try:
-        return predict_from_json(body)
-    except Exception as e:
-        return {"error": f"{type(e).__name__}: {e}"}
+    return predict_from_json(body)
 
 @app.post("/predict")
 async def predict_main(req: Request):
     return await _handle_predict(req)
 
-# Be generous: also accept your older paths
 @app.post("/run/predict")
 async def predict_compat1(req: Request):
     return await _handle_predict(req)
@@ -123,11 +158,7 @@ async def predict_compat1(req: Request):
 async def predict_compat2(req: Request):
     return await _handle_predict(req)
 
-@app.get("/health")
-def health():
-    return {"ok": True}
-
-# Mount the Gradio UI at root
+# UI at root (keeps your browser demo)
 ui = gr.Interface(
     fn=predict_from_json,
     inputs=gr.JSON(label="ratios JSON (dict of feature -> value)"),
@@ -137,7 +168,7 @@ ui = gr.Interface(
 )
 app = gr.mount_gradio_app(app, ui, path="/")
 
-# DEBUG: print available routes so we can see them in the logs
+# Print routes in logs for visibility
 for r in app.router.routes:
     try:
         print("ROUTE:", r.path)