Update app.py

app.py

@@ -45,28 +45,21 @@ def coerce_float(val: Any) -> float:
     if s == "":
         raise ValueError("empty")
 
-    # remove spaces
     s = s.replace(" ", "")
-
     has_dot = "." in s
     has_comma = "," in s
 
     if has_dot and has_comma:
-        # Decide which is decimal separator by last occurrence
         last_dot = s.rfind(".")
         last_comma = s.rfind(",")
         if last_comma > last_dot:
-            # decimal is comma, thousands is dot
             s = s.replace(".", "")
             s = s.replace(",", ".")
         else:
-            # decimal is dot, thousands is comma
             s = s.replace(",", "")
     elif has_comma and not has_dot:
-        # likely decimal is comma
         s = s.replace(",", ".")
-    # dots only or pure digits -> leave as is
-
+    # dots only or digits -> leave
     return float(s)
 
 
@@ -80,14 +73,52 @@ def _z(val: Any, mean: float, sd: float) -> float:
     return (v - mean) / sd
 
 
-def coral_probs_from_logits(logits_np: np.ndarray) -> np.ndarray:
-    """(N, K-1) logits -> (N, K) probabilities for CORAL ordinal output."""
-    logits = tf.convert_to_tensor(logits_np, dtype=tf.float32)
-    sig = tf.math.sigmoid(logits)  # (N, K-1)
-    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()
+# ---------- CORAL utilities ----------
+def enforce_nonincreasing(sig_vec: np.ndarray) -> np.ndarray:
+    """
+    Given a 1D array of cumulative probs s (should be non-increasing for CORAL),
+    enforce s[0] >= s[1] >= ... >= s[K-1] using a simple PAV algorithm.
+    """
+    s = sig_vec.astype(float).copy()
+    n = len(s)
+    blocks = [[i] for i in range(n)]
+    vals = s.tolist()
+
+    i = 0
+    while i < len(vals) - 1:
+        if vals[i] < vals[i + 1]:  # violation: should be non-increasing
+            merged_idx = blocks[i] + blocks[i + 1]
+            avg = (
+                (vals[i] * len(blocks[i]) + vals[i + 1] * len(blocks[i + 1]))
+                / (len(blocks[i]) + len(blocks[i + 1]))
+            )
+            blocks[i] = merged_idx
+            vals[i] = avg
+            del blocks[i + 1]
+            del vals[i + 1]
+            if i > 0:
+                i -= 1
+        else:
+            i += 1
+
+    out = np.zeros(n, dtype=float)
+    for v, idxs in zip(vals, blocks):
+        for j in idxs:
+            out[j] = v
+    return np.clip(out, 1e-12, 1 - 1e-12)
+
+
+def coral_probs_from_logits_monotone(logits_np: np.ndarray) -> np.ndarray:
+    """
+    CORAL decoding with monotonicity enforcement so class probs are valid (sum=1, nonnegative).
+    """
+    sig = 1.0 / (1.0 + np.exp(-logits_np))  # sigmoid
+    sig_m = enforce_nonincreasing(sig[0])  # enforce order
+    left = np.concatenate([np.array([1.0], dtype=float), sig_m])
+    right = np.concatenate([sig_m, np.array([0.0], dtype=float)])
+    probs = np.clip(left - right, 1e-12, 1.0)
+    probs = probs / probs.sum()  # normalize
+    return probs
 
 
 # ------------- FastAPI app ----------------
@@ -132,18 +163,12 @@ async def echo(req: Request):
 async def predict(req: Request):
     """
     Body: a single JSON dict mapping feature -> 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."}
 
-    # Build z-scores in strict model order
+    # --- Build z-scores in strict model order ---
     z = []
     z_detail = {}
     missing = []
@@ -154,35 +179,32 @@ async def predict(req: Request):
             zf = _z(payload[f], mean, sd)
         else:
             missing.append(f)
-            zf = _z(0.0, mean, sd)  # treat missing as 0 input
+            zf = _z(0.0, mean, sd)
         z.append(zf)
         z_detail[f] = zf
 
     X = np.array([z], dtype=np.float32)
     raw = model.predict(X, verbose=0)
-
-    # ---------------- DEBUG INFO ----------------
     raw_shape = tuple(raw.shape)
-    # --------------------------------------------
 
-    # Decode: CORAL vs Softmax
+    # --- Decode ---
     probs = None
     decode_mode = "auto"
     try:
         if FORCE_CORAL:
-            decode_mode = "forced_coral"
-            probs = coral_probs_from_logits(raw)[0]
+            decode_mode = "forced_coral_monotone"
+            probs = coral_probs_from_logits_monotone(raw)
         else:
             if raw.ndim == 2 and raw.shape[1] == (len(CLASSES) - 1):
-                decode_mode = "auto_coral"
-                probs = coral_probs_from_logits(raw)[0]
+                decode_mode = "auto_coral_monotone"
+                probs = coral_probs_from_logits_monotone(raw)
             else:
                 decode_mode = "auto_softmax_or_logits"
                 probs = raw[0]
                 s = float(np.sum(probs))
-                if s > 0:  # defensive normalize
+                if s > 0:
                     probs = probs / s
-    except Exception as e:
+    except Exception:
         decode_mode = "fallback_raw_norm"
         probs = raw[0]
         s = float(np.sum(probs))
@@ -191,26 +213,23 @@ async def predict(req: Request):
 
     pred_idx = int(np.argmax(probs))
 
+    # --- Response ---
     resp = {
         "input_ok": (len(missing) == 0),
         "missing": missing,
         "z_scores": z_detail,
-        "probabilities": {
-            CLASSES[i]: float(probs[i]) for i in range(len(CLASSES))
-        },
+        "probabilities": {CLASSES[i]: float(probs[i]) for i in range(len(CLASSES))},
         "predicted_state": CLASSES[pred_idx],
     }
 
-    # Include debug fields so we can see shape & decode path
+    # --- Debug block ---
     if RETURN_DEBUG:
         resp["debug"] = {
             "raw_shape": raw_shape,
             "decode_mode": decode_mode,
             "raw_first_row": [
                 float(x)
-                for x in (
-                    raw[0].tolist() if raw.ndim >= 2 else [float(raw)]
-                )
+                for x in (raw[0].tolist() if raw.ndim >= 2 else [float(raw)])
             ],
         }