Update app.py

app.py

@@ -2,12 +2,12 @@ import json
 import numpy as np
 import tensorflow as tf
 import gradio as gr
+from fastapi import FastAPI
 
-# ---------------- CONFIG ----------------
-MODEL_PATH = "best_model.h5"  # or "best_model.keras" if that’s the saved file
+# --- CONFIG ---
+MODEL_PATH = "best_model.h5"                # or .keras
 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)
@@ -17,78 +17,64 @@ with open(STATS_PATH, "r") as f:
 FEATURES = list(stats.keys())
 print("Feature order:", FEATURES)
 
-
-def coral_probs_from_logits(logits_np):
-    """Convert CORAL logits to probabilities if model output is ordinal."""
-    logits = tf.convert_to_tensor(logits_np, dtype=tf.float32)
-    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 zscore(val, mean, sd):
-    """Z-score normalization (gracefully handles 0 std)."""
+def _z(x, m, s):
     try:
-        val = float(val)
-        if sd == 0 or sd is None:
-            return 0.0
-        return (val - mean) / sd
-    except Exception:
-        return 0.0
-
-
-def predict_from_json(ratios):
-    """Main callable function for Gradio."""
-    if isinstance(ratios, list) and len(ratios) == 1 and isinstance(ratios[0], dict):
-        ratios = ratios[0]
-    if not isinstance(ratios, dict):
-        return {"error": "Invalid input, must be dict of feature->value"}
-
-    # Compute z-scores
-    zvec = []
-    zmap = {}
+        x = float(x)
+    except:
+        x = 0.0
+    return 0.0 if s == 0 else (x - m) / s
+
+def _predict_core(ratios: dict):
+    missing = [f for f in FEATURES if f not in ratios]
+    zs = []
+    zdict = {}
     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)
-
-    # Handle output shape
-    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]
+        std = stats[f]["std"]
+        z = _z(ratios.get(f, 0.0), mean, std)
+        zs.append(z)
+        zdict[f] = z
+    X = np.array([zs], dtype=np.float32)
+
+    raw = model.predict(X, verbose=0)[0]
+    if len(raw) == len(CLASSES):
+        probs = np.clip(raw, 0.0, 1.0)
+        probs /= probs.sum()
+    elif len(raw) == len(CLASSES) - 1:  # CORAL-style
+        sig = 1 / (1 + np.exp(-raw))
+        left = np.concatenate([[1.0], sig])
+        right = np.concatenate([sig, [0.0]])
+        probs = left - right
     else:
-        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 = CLASSES[int(np.argmax(probs))]
+        raise ValueError("Unexpected output length")
 
+    pred_idx = int(np.argmax(probs))
     return {
-        "input_ok": True,
-        "missing": [f for f in FEATURES if f not in ratios],
-        "z_scores": zmap,
+        "input_ok": len(missing) == 0,
+        "missing": missing,
         "probabilities": {CLASSES[i]: float(probs[i]) for i in range(len(CLASSES))},
-        "predicted_state": pred,
+        "predicted_state": CLASSES[pred_idx],
     }
 
+def predict_from_json(payload):
+    if isinstance(payload, list) and len(payload) == 1 and isinstance(payload[0], dict):
+        payload = payload[0]
+    if not isinstance(payload, dict):
+        return {"error": "Expected a JSON object mapping feature->value."}
+    return _predict_core(payload)
 
-# ----------------- GRADIO APP -----------------
+# ---- GRADIO INTERFACE ----
 iface = gr.Interface(
     fn=predict_from_json,
     inputs=gr.JSON(label="ratios JSON (dict of feature -> value)"),
     outputs="json",
     title="Static Fingerprint Model API",
-    description=(
-        "POST JSON to `/run/predict` with a dict of your 21 ratios. "
-        "Server normalises using saved means/stds and returns probabilities + predicted state."
-    ),
+    description="POST JSON to /run/predict with your 21 ratios."
 )
 
-iface.launch()
+app = FastAPI()
+app = gr.mount_gradio_app(app, iface, path="/")
+
+@app.get("/health")
+def health(): 
+    return {"status": "ok"}