Update app.py

app.py

@@ -1,63 +1,96 @@
+import os
+import json
+import numpy as np
 import gradio as gr
 import tensorflow as tf
-import numpy as np
-import json
 
-# ========== 1. Load model and stats once at startup ==========
-MODEL_PATH = "best_model_converted.keras"
-STATS_PATH = "Means & Std for Excel.json"
+# ---------- CONFIG ----------
+MODEL_PATH = "best_model.h5"                 # <- you converted & uploaded this
+STATS_PATH = "Means & Std for Excel.json"    # <- keep exact filename
+CLASSES = ["Top", "Mid-Top", "Mid", "Mid-Low", "Low"]  # your group order
+# ----------------------------
 
 print("Loading model and stats...")
-model = tf.keras.models.load_model(MODEL_PATH)
+model = tf.keras.models.load_model(MODEL_PATH, compile=False)
+
 with open(STATS_PATH, "r") as f:
     stats = json.load(f)
 
-# Feature order inferred from the JSON keys (keep stable)
+# Feature order: use the order from JSON to remain consistent
 FEATURES = list(stats.keys())
-CLASSES = ["Top", "Mid-Top", "Mid", "Mid-Low", "Low"]
+print("Feature order:", FEATURES)
+
+def _zscore(val: float, mean: float, sd: float) -> float:
+    # Robust z-score (avoid division by zero)
+    try:
+        v = float(val)
+    except (TypeError, ValueError):
+        v = 0.0
+    return 0.0 if (sd is None or sd == 0) else (v - mean) / sd
 
-# ========== 2. Define prediction function ==========
-def predict_ratios(input_dict):
+def predict_core(ratios: dict):
     """
-    input_dict: dictionary of {indicator_name: value}
-    returns: dict with probabilities and predicted class
+    ratios: dict mapping feature name -> raw numeric ratio.
+    Returns a dict with predicted_state, probabilities, z_scores, missing.
     """
-    # Build z-score vector in model’s feature order
+    # Validate presence
+    missing = [f for f in FEATURES if f not in ratios]
+    # Build z-score vector in the exact FEATURE order
     zscores = []
-    zscore_dict = {}
-
-    for feat in FEATURES:
-        val = float(input_dict.get(feat, 0))
-        mean = stats[feat]["mean"]
-        std = stats[feat]["std"]
-        z = 0.0 if std == 0 else (val - mean) / std
+    zscores_dict = {}
+    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)
-        zscore_dict[feat] = z
+        zscores_dict[f] = z
 
     X = np.array([zscores], dtype=np.float32)
-
-    # Predict
     probs = model.predict(X, verbose=0)[0]
     pred_idx = int(np.argmax(probs))
     pred_state = CLASSES[pred_idx]
 
     return {
-        "predicted_state": pred_state,
+        "input_ok": len(missing) == 0,
+        "missing": missing,
+        "z_scores": zscores_dict,
         "probabilities": {CLASSES[i]: float(probs[i]) for i in range(len(CLASSES))},
-        "z_scores": zscore_dict
+        "predicted_state": pred_state
     }
 
-# ========== 3. Gradio interface ==========
-# Build input components automatically for manual testing in the browser.
-inputs = [gr.Number(label=f) for f in FEATURES]
+# ---------- Gradio adapter ----------
+def predict_from_json(payload, x_api_key: str = ""):
+    """
+    Gradio will pass the JSON from the UI or /run/predict.
+    We accept either:
+      { ...feature: value... }
+    or   [ { ...feature: value... } ]  (unwrap common API client shape)
+    """
+    # Optional simple API key
+    if API_KEY and x_api_key.strip() != API_KEY:
+        return {"error": "Unauthorized: missing or invalid X-API-Key header"}
+
+    # Unwrap if list-of-one was sent
+    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: expected a JSON object mapping feature -> value."}
+
+    return predict_core(payload)
 
+# Minimal UI: a single JSON box for quick manual tests.
 iface = gr.Interface(
-    fn=lambda *vals: predict_ratios({f: v for f, v in zip(FEATURES, vals)}),
-    inputs=inputs,
+    fn=predict_from_json,
+    inputs=gr.JSON(label="ratios JSON (dict of feature -> value)"),
     outputs="json",
     title="Static Fingerprint Model API",
-    description="Enter ratios below or call via POST /run/predict"
+    description=(
+        "POST JSON to /run/predict with a dict of your 21 ratios. "
+        "Server normalises using saved means/stds and returns probabilities + state."
+    )
 )
 
-# Launch app
-iface.launch()
+if __name__ == "__main__":
+    iface.launch()