Update app.py

app.py

@@ -2,79 +2,73 @@ 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 .keras
-STATS_PATH = "Means & Std for Excel.json"
+# ==== CONFIG ====
+MODEL_PATH = "best_model.h5"
+STATS_PATH = "means_std.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)
 
 FEATURES = list(stats.keys())
 print("Feature order:", FEATURES)
 
-def _z(x, m, s):
+def zscore(val, mean, sd):
     try:
-        x = float(x)
-    except:
-        x = 0.0
-    return 0.0 if s == 0 else (x - m) / s
+        val = float(val)
+    except Exception:
+        return 0.0
+    if sd == 0 or sd is None:
+        return 0.0
+    return (val - mean) / sd
+
+def coral_probs_from_logits(logits_np):
+    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 predict_from_json(input_json):
+    # Expect a dictionary with feature:value pairs
+    if not isinstance(input_json, dict):
+        return {"error": "Expected JSON object mapping feature -> value."}
 
-def _predict_core(ratios: dict):
-    missing = [f for f in FEATURES if f not in ratios]
-    zs = []
-    zdict = {}
+    # Prepare data
+    z_list = []
     for f in FEATURES:
-        mean = stats[f]["mean"]
-        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)
+        v = input_json.get(f, 0)
+        z = zscore(v, stats[f]["mean"], stats[f]["std"])
+        z_list.append(z)
+    X = np.array([z_list], 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
+    raw = model.predict(X, verbose=0)
+    if raw.shape[1] == len(CLASSES) - 1:
+        probs = coral_probs_from_logits(raw)[0]
     else:
-        raise ValueError("Unexpected output length")
+        probs = raw[0]
 
     pred_idx = int(np.argmax(probs))
-    return {
-        "input_ok": len(missing) == 0,
-        "missing": missing,
+    output = {
         "probabilities": {CLASSES[i]: float(probs[i]) for i in range(len(CLASSES))},
         "predicted_state": CLASSES[pred_idx],
     }
+    return output
 
-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 INTERFACE ----
-iface = gr.Interface(
+# ==== Gradio UI ====
+demo = gr.Interface(
     fn=predict_from_json,
-    inputs=gr.JSON(label="ratios JSON (dict of feature -> value)"),
+    inputs=gr.JSON(label="Feature dictionary (JSON)"),
     outputs="json",
-    title="Static Fingerprint Model API",
-    description="POST JSON to /run/predict with your 21 ratios."
+    title="Static Fingerprint Predictor",
+    description="POST JSON to /run/predict with your feature values."
 )
 
-app = FastAPI()
-app = gr.mount_gradio_app(app, iface, path="/")
-
-@app.get("/health")
-def health(): 
-    return {"status": "ok"}
+if __name__ == "__main__":
+    demo.launch()