Update app.py

app.py

@@ -1,175 +1,119 @@
-# app.py
 import os
 import json
-from pathlib import Path
-from typing import Any, Dict, List, Tuple
+import traceback
+from typing import Any, Dict
 
 import numpy as np
 import tensorflow as tf
+import joblib
 from fastapi import FastAPI, Request
+from fastapi.responses import JSONResponse
 from fastapi.middleware.cors import CORSMiddleware
 
-# ----------------- PATHS & CONFIG -----------------
-BASE_DIR = Path(__file__).resolve().parent
-
-# Prefer env vars, fall back to files next to app.py
-MODEL_PATH  = os.getenv("MODEL_PATH")  or str(BASE_DIR / "best_model.keras")
-if not Path(MODEL_PATH).exists():
-    # fallback to .h5 if .keras not present
-    alt = BASE_DIR / "best_model.h5"
-    if alt.exists():
-        MODEL_PATH = str(alt)
-
-STATS_PATH    = os.getenv("STATS_PATH")    or str(BASE_DIR / "means_std.json")
-IMPUTER_PATH  = os.getenv("IMPUTER_PATH")  or str(BASE_DIR / "imputer.joblib")
-SCALER_PATH   = os.getenv("SCALER_PATH")   or str(BASE_DIR / "scaler.joblib")
-
-CLASSES = ["Top", "Mid-Top", "Mid", "Mid-Low", "Low"]  # ordinal: 0..4
-
-# IMPORTANT — exact feature order used during training
-FEATURE_ORDER: List[str] = [
-    "autosuf_oper",
-    "improductiva",
-    "gastos_fin_over_avg_cart",
-    "_equity",
-    "grado_absorcion",
-    "_cartera_bruta",
-    "gastos_oper_over_ing_oper",
-    "cartera_vencida_ratio",
-    "roe_pre_tax",
-    "_assets",
-    "_liab",
-    "equity_over_assets",
-    "_margen_bruto",
-    "prov_over_cartera",
-    "gastos_oper_over_cart",
-    "ing_cartera_over_ing_total",
-    "debt_to_equity",
-    "prov_gasto_over_cart",
-    "cov_improductiva",
-    "rend_cart_over_avg_cart",
-    "roa_pre_tax",
-]
-
-print("Resolved paths:")
-print("  MODEL_PATH :", MODEL_PATH)
-print("  STATS_PATH :", STATS_PATH)
-print("  IMPUTER_PATH:", IMPUTER_PATH)
-print("  SCALER_PATH :", SCALER_PATH)
-
-# ----------------- LOAD ARTIFACTS -----------------
+# -------------------- CONFIG --------------------
+MODEL_PATH = os.getenv("MODEL_PATH", "best_model.h5")
+STATS_PATH = os.getenv("STATS_PATH", "means_std.json")
+IMPUTER_PATH = os.getenv("IMPUTER_PATH", "imputer.joblib")
+SCALER_PATH = os.getenv("SCALER_PATH", "scaler.joblib")
+
+CLASSES = ["Top", "Mid-Top", "Mid", "Mid-Low", "Low"]
+# ------------------------------------------------
+
 print("Loading model / imputer / scaler...")
-# If the model used custom losses/metrics you’d pass custom_objects here.
+
+# ---- Model ----
 model = tf.keras.models.load_model(MODEL_PATH, compile=False)
 
-# Optional: imputer & scaler from training pipeline
-imputer = None
-scaler = None
+# ---- Stats ----
+with open(STATS_PATH, "r") as f:
+    stats: Dict[str, Dict[str, float]] = json.load(f)
+
+FEATURES = list(stats.keys())
+
+# ---- Optional artifacts ----
 try:
-    import joblib  # in requirements
-    if Path(IMPUTER_PATH).exists():
-        imputer = joblib.load(IMPUTER_PATH)
-        print("Loaded imputer:", IMPUTER_PATH)
-    if Path(SCALER_PATH).exists():
-        scaler = joblib.load(SCALER_PATH)
-        print("Loaded scaler :", SCALER_PATH)
-except Exception as e:
-    print("Imputer/scaler not loaded:", e)
-
-# Optional: stats fallback for manual z-scoring
-stats: Dict[str, Dict[str, float]] = {}
-if Path(STATS_PATH).exists():
-    with open(STATS_PATH, "r") as f:
-        stats = json.load(f)
-        print("Loaded means/std from:", STATS_PATH)
-
-# ----------------- HELPERS -----------------
+    imputer = joblib.load(IMPUTER_PATH)
+    print("Imputer loaded.")
+except Exception:
+    imputer = None
+    print("⚠️ No imputer found — skipping median imputation.")
+
+try:
+    scaler = joblib.load(SCALER_PATH)
+    print("Scaler loaded.")
+except Exception:
+    scaler = None
+    print("⚠️ No scaler found — using manual z-scoring.")
+
+# -------------------- HELPERS --------------------
 def coerce_float(val: Any) -> float:
-    """
-    Accepts numeric or strings like:
-      '49.709,14' -> 49709.14 ; '49,709.14' -> 49709.14 ; '0,005' -> 0.005
-    """
-    if isinstance(val, (int, float, np.number)):
+    """Convert strings like '49.709,14' or '0,005' to float."""
+    if isinstance(val, (int, float)):
         return float(val)
-    s = str(val).strip()
+    s = str(val).strip().replace(" ", "")
     if s == "":
-        raise ValueError("empty")
-    s = s.replace(" ", "")
-    has_dot, has_comma = "." in s, "," in s
-    if has_dot and has_comma:
+        return 0.0
+    if "," in s and "." in s:
         if s.rfind(",") > s.rfind("."):
-            s = s.replace(".", "")
-            s = s.replace(",", ".")
+            s = s.replace(".", "").replace(",", ".")
         else:
             s = s.replace(",", "")
-    elif has_comma and not has_dot:
+    elif "," in s:
         s = s.replace(",", ".")
-    return float(s)
+    try:
+        return float(s)
+    except Exception:
+        return 0.0
 
-def build_matrix_from_payload(payload: Dict[str, Any]) -> Tuple[np.ndarray, Dict[str, float], List[str]]:
-    """
-    Returns:
-      X (1, 21) ready for model (imputed+scaled if artifacts exist; else z-scored via stats),
-      z_detail (dict feature -> standardized value used),
-      missing list (features not present in payload)
-    """
-    raw = []
-    missing: List[str] = []
-    for f in FEATURE_ORDER:
+
+def _z(val: Any, mean: float, sd: float) -> float:
+    try:
+        v = coerce_float(val)
+    except Exception:
+        return 0.0
+    if not sd or sd == 0:
+        return 0.0
+    return (v - mean) / sd
+
+
+def coral_probs_from_logits(logits_np: np.ndarray) -> np.ndarray:
+    """Convert (N, K−1) logits to (N, K) probabilities for CORAL ordinal output."""
+    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 build_matrix_from_payload(payload: Dict[str, Any]):
+    """Builds a z-scored matrix and returns (X, z_detail, missing)."""
+    z = []
+    z_detail = {}
+    missing = []
+    for f in FEATURES:
+        mean = stats[f]["mean"]
+        sd = stats[f]["std"]
         if f in payload:
-            try:
-                raw.append(coerce_float(payload[f]))
-            except Exception:
-                raw.append(np.nan)
+            zf = _z(payload[f], mean, sd)
         else:
-            raw.append(np.nan)
+            zf = _z(0.0, mean, sd)
             missing.append(f)
+        z.append(zf)
+        z_detail[f] = zf
 
-    arr = np.array([raw], dtype=np.float32)  # shape (1, 21)
+    X = np.array([z], dtype=np.float32)
 
-    # primary path: use imputer + scaler if both available
-    if imputer is not None and scaler is not None:
-        arr_imp = imputer.transform(arr)   # median impute
-        arr_std = scaler.transform(arr_imp)  # z-score to training distribution
-        z_row = arr_std[0].tolist()
-        z_detail = {f: float(z_row[i]) for i, f in enumerate(FEATURE_ORDER)}
-        return arr_std.astype(np.float32), z_detail, missing
+    if imputer is not None:
+        X = imputer.transform(X)
+    if scaler is not None:
+        X = scaler.transform(X)
 
-    # fallback path: manual z-score using means_std.json
-    z_vals = []
-    z_detail = {}
-    for i, f in enumerate(FEATURE_ORDER):
-        v = arr[0, i]
-        if f in stats and "mean" in stats[f] and "std" in stats[f] and stats[f]["std"]:
-            mean = float(stats[f]["mean"])
-            std = float(stats[f]["std"])
-            vv = 0.0 if np.isnan(v) else float(v)
-            z = (vv - mean) / std
-        else:
-            z = 0.0  # safest fallback
-        z_vals.append(z)
-        z_detail[f] = float(z)
-    return np.array([z_vals], dtype=np.float32), z_detail, missing
+    return X, z_detail, missing
 
-def coral_probs_from_logits(logits_np: np.ndarray) -> np.ndarray:
-    """
-    CORAL decode: (N, K-1) logits -> (N, K) probs.
-    Adds a small monotonicity fix (non-increasing thresholds).
-    """
-    logits = tf.convert_to_tensor(logits_np, dtype=tf.float32)  # (N, K-1)
-    sig = tf.math.sigmoid(logits)  # p(y>k)
-    # Enforce non-increasing along thresholds (numerical guard)
-    sig = tf.clip_by_value(sig, 1e-12, 1.0 - 1e-12)
-    sig_sorted = tf.minimum(sig, tf.math.cummin(sig, axis=1, exclusive=False))
-    left  = tf.concat([tf.ones_like(sig_sorted[:, :1]), sig_sorted], axis=1)
-    right = tf.concat([sig_sorted, tf.zeros_like(sig_sorted[:, :1])], axis=1)
-    probs = tf.clip_by_value(left - right, 1e-12, 1.0)
-    # Normalize row just in case
-    probs = probs / tf.reduce_sum(probs, axis=1, keepdims=True)
-    return probs.numpy()
 
-# ----------------- FASTAPI -----------------
-app = FastAPI(title="Static Fingerprint API", version="1.0.0")
+# -------------------- APP INIT --------------------
+app = FastAPI(title="Static Fingerprint API", version="1.1.0")
 
 app.add_middleware(
     CORSMiddleware,
@@ -179,6 +123,7 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
+# -------------------- ROUTES --------------------
 @app.get("/")
 def root():
     return {
@@ -186,68 +131,78 @@ def root():
         "try": ["GET /health", "POST /predict"],
     }
 
+
 @app.get("/health")
 def health():
     return {
         "status": "ok",
+        "model_file": MODEL_PATH,
+        "stats_file": STATS_PATH,
+        "features": FEATURES,
         "classes": CLASSES,
-        "feature_order": FEATURE_ORDER,
-        "paths": {
-            "model": MODEL_PATH,
-            "stats": STATS_PATH if Path(STATS_PATH).exists() else None,
-            "imputer": IMPUTER_PATH if Path(IMPUTER_PATH).exists() else None,
-            "scaler": SCALER_PATH if Path(SCALER_PATH).exists() else None,
-            "base_dir_files": [p.name for p in BASE_DIR.iterdir()],
-        },
-        "has_imputer": imputer is not None,
-        "has_scaler": scaler is not None,
+        "imputer_loaded": imputer is not None,
+        "scaler_loaded": scaler is not None,
     }
 
+
 @app.post("/echo")
 async def echo(req: Request):
+    """Echoes back any JSON payload (debug)."""
     payload = await req.json()
     return {"received": payload}
 
+
 @app.post("/predict")
 async def predict(req: Request):
     """
-    Body: JSON dict mapping feature -> value (raw numbers). Example:
+    POST JSON mapping each feature to a numeric value.
+    Example:
     {
       "autosuf_oper": 1.0,
       "cov_improductiva": 0.9,
       ...
     }
     """
-    payload = await req.json()
-    if not isinstance(payload, dict):
-        return {"error": "Expected a JSON object mapping feature -> value."}
-
-    X, z_detail, missing = build_matrix_from_payload(payload)   # shape (1, 21)
-
-    raw = model.predict(X, verbose=0)
-
-    # Auto-detect output head: CORAL (K-1) or softmax (K)
-    decode_mode = "auto_coral"
-    if raw.ndim == 2 and raw.shape[1] == (len(CLASSES) - 1):
-        probs = coral_probs_from_logits(raw)[0]
-        decode_mode = "auto_coral_monotone"
-    else:
-        # assume logits for K classes
-        logits = tf.convert_to_tensor(raw, dtype=tf.float32)
-        probs = tf.nn.softmax(logits, axis=1).numpy()[0]
-        decode_mode = "softmax"
-
-    pred_idx = int(np.argmax(probs))
-    out = {
-        "input_ok": (len(missing) == 0),
-        "missing": missing,
-        "z_scores": z_detail,
-        "probabilities": {CLASSES[i]: float(probs[i]) for i in range(len(CLASSES))},
-        "predicted_state": CLASSES[pred_idx],
-        "debug": {
-            "raw_shape": list(raw.shape),
-            "decode_mode": decode_mode,
-            "raw_first_row": [float(x) for x in raw[0].tolist()],
-        },
-    }
-    return out
+    try:
+        payload = await req.json()
+        if not isinstance(payload, dict):
+            return JSONResponse(
+                status_code=400,
+                content={"error": "Expected a JSON object mapping feature -> value."},
+            )
+
+        X, z_detail, missing = build_matrix_from_payload(payload)
+        raw = model.predict(X, verbose=0)
+
+        # Detect output type (CORAL or softmax)
+        if raw.ndim == 2 and raw.shape[1] == (len(CLASSES) - 1):
+            probs = coral_probs_from_logits(raw)[0]
+            decode_mode = "auto_coral_monotone"
+        else:
+            logits = tf.convert_to_tensor(raw, dtype=tf.float32)
+            probs = tf.nn.softmax(logits, axis=1).numpy()[0]
+            decode_mode = "softmax"
+
+        probs = probs / np.sum(probs)
+        pred_idx = int(np.argmax(probs))
+
+        return {
+            "input_ok": (len(missing) == 0),
+            "missing": missing,
+            "z_scores": z_detail,
+            "probabilities": {CLASSES[i]: float(probs[i]) for i in range(len(CLASSES))},
+            "predicted_state": CLASSES[pred_idx],
+            "debug": {
+                "raw_shape": list(raw.shape),
+                "decode_mode": decode_mode,
+                "raw_first_row": [float(x) for x in raw[0].tolist()],
+            },
+        }
+
+    except Exception as e:
+        tb = traceback.format_exc()
+        print("🔥 ERROR in /predict:", tb)
+        return JSONResponse(
+            status_code=500,
+            content={"error": str(e), "traceback": tb},
+        )