Update main.py

main.py

@@ -1,12 +1,13 @@
 import os
 import sys
+import math
 from typing import Optional, Dict, Any
 
 import numpy as np
 from numpy.linalg import norm
 from scipy.linalg import expm
 
-from fastapi import FastAPI
+from fastapi import FastAPI, HTTPException
 from pydantic import BaseModel
 
 from sentence_transformers import SentenceTransformer
@@ -16,11 +17,12 @@ import joblib
 # ============================
 # Configuración de modelos
 # ============================
+
 ENCODER_MODEL_ID = "antonypamo/RRFSAVANTMADE"
 META_LOGIT_REPO = "antonypamo/RRFSavantMetaLogit"
 META_LOGIT_FILENAME = os.environ.get(
     "META_LOGIT_FILENAME",
-    "logreg_rrf_savant_15.joblib",   # <-- aquí apuntas al nuevo modelo
+    "logreg_rrf_savant_15.joblib",   # <-- nuevo modelo 15 features
 )
 
 print("🔄 [Startup] Cargando encoder RRFSAVANTMADE...", flush=True)
@@ -38,14 +40,17 @@ try:
         filename=META_LOGIT_FILENAME,
         token=os.environ.get("HF_TOKEN"),  # si el repo es público, puede ser None
     )
-    print("🔄 [Startup] Cargando modelo meta-logit...", flush=True)
+    print(f"🔄 [Startup] Cargando modelo meta-logit '{META_LOGIT_FILENAME}'...", flush=True)
     meta_logit = joblib.load(meta_logit_path)
+    try:
+        print(f"🔎 [Startup] Meta-logit espera {meta_logit.n_features_in_} features.", flush=True)
+    except Exception:
+        print("⚠️ [Startup] No se pudo leer n_features_in_.", flush=True)
     print("✅ [Startup] Meta-logit cargado.", flush=True)
 except Exception as e:
     print(f"❌ [Startup] Error al cargar meta-logit: {e}", file=sys.stderr, flush=True)
     raise
 
-
 # ============================
 # Geometría icosaédrica Φ12.0
 # ============================
@@ -197,12 +202,14 @@ def get_embedding(text: str) -> np.ndarray:
 
 
 def compute_rrf_features(prompt: str, answer: str) -> Dict[str, float]:
+    # Embeddings
     e_p = get_embedding(prompt)
     e_a = get_embedding(answer)
 
     cosine_pa = float(np.dot(e_p, e_a))
     len_ratio = len(answer) / (len(prompt) + 1.0)
 
+    # Simulación Dirac shell determinista (semilla por prompt+answer)
     rng = np.random.default_rng(abs(hash(prompt + answer)) % (2 ** 32))
     vec = rng.normal(0, 1, (2 * N,)) + 1j * rng.normal(0, 1, (2 * N,))
     vec /= np.sqrt(np.vdot(vec, vec))
@@ -228,7 +235,8 @@ def compute_rrf_features(prompt: str, answer: str) -> Dict[str, float]:
     E_mean = float(np.mean(energy))
     E_std = float(np.std(energy))
 
-    return {
+    # Núcleo de 7 features
+    feats: Dict[str, float] = {
         "cosine_pa": cosine_pa,
         "len_ratio": len_ratio,
         "dirac_entropy_final": S_final,
@@ -238,6 +246,19 @@ def compute_rrf_features(prompt: str, answer: str) -> Dict[str, float]:
         "dirac_energy_std": E_std,
     }
 
+    # Derivadas para llegar a 15 (igual que en el CSV)
+    S_max = math.log(N)
+    feats["entropy_norm"]      = feats["dirac_entropy_final"] / S_max
+    feats["entropy_abs_delta"] = abs(feats["dirac_entropy_delta"])
+    feats["chirality_abs"]     = abs(feats["dirac_chirality_final"])
+    feats["energy_abs_mean"]   = abs(feats["dirac_energy_mean"])
+    feats["energy_std_sq"]     = feats["dirac_energy_std"] ** 2
+    feats["cosine_sq"]         = feats["cosine_pa"] ** 2
+    feats["len_log"]           = math.log1p(feats["len_ratio"])
+    feats["len_inv"]           = 1.0 / (1.0 + feats["len_ratio"])
+
+    return feats
+
 
 def features_to_vector(feats: Dict[str, float]) -> np.ndarray:
     keys = [
@@ -248,6 +269,14 @@ def features_to_vector(feats: Dict[str, float]) -> np.ndarray:
         "dirac_chirality_final",
         "dirac_energy_mean",
         "dirac_energy_std",
+        "entropy_norm",
+        "entropy_abs_delta",
+        "chirality_abs",
+        "energy_abs_mean",
+        "energy_std_sq",
+        "cosine_sq",
+        "len_log",
+        "len_inv",
     ]
     return np.array([feats[k] for k in keys], dtype=float)
 
@@ -259,13 +288,12 @@ def compute_scores_srff_crff_ephi(prompt: str, answer: str):
     proba = meta_logit.predict_proba(x)[0]
     p_good = float(proba[1])
 
+    # Definimos SRRF/CRRF/E_phi a partir de p_good y entropía
     SRRF = p_good
     CRRF = p_good * feats["cosine_pa"]
 
-    S_final = feats["dirac_entropy_final"]
-    S_max = np.log(N)
-    norm_entropy = float(S_final / S_max)
-
+    S_max = math.log(N)
+    norm_entropy = float(feats["dirac_entropy_final"] / S_max)
     E_phi = 0.5 * (SRRF + norm_entropy)
 
     scores = {
@@ -285,58 +313,58 @@ class EvaluateRequest(BaseModel):
     answer: str
     model_label: Optional[str] = None
 
-
 class EvaluateResponse(BaseModel):
     scores: Dict[str, float]
     features: Dict[str, float]
     sim_summary: Dict[str, Any]
 
-
 app = FastAPI(
     title="Savant RRF Φ12.0 API",
     description="Dirac-Resonant conceptual quality layer for LLM-generated text.",
     version="1.0.0",
 )
 
-
 @app.get("/")
 def root():
     return {"message": "Savant RRF Φ12.0 API running", "docs": "/docs"}
 
-
 @app.get("/health")
 def health():
     return {"status": "ok"}
 
-
 @app.post("/evaluate", response_model=EvaluateResponse)
 def evaluate(req: EvaluateRequest):
-    scores, feats = compute_scores_srff_crff_ephi(req.prompt, req.answer)
-
-    H = build_dirac_hamiltonian(
-        m=0.25, v=1.0, sigma=0.618,
-        alpha_log=0.10, q=1.0,
-        flux_vector=(0.0, 0.0, 0.0),
-        gauge_scale=0.0,
-    )
-    rng = np.random.default_rng(abs(hash(req.prompt + req.answer + "sim")) % (2 ** 32))
-    vec = rng.normal(0, 1, (2 * N,)) + 1j * rng.normal(0, 1, (2 * N,))
-    vec /= np.sqrt(np.vdot(vec, vec))
-    psi0 = vec
-    sim = evolve_dirac_shell(psi0, H, dt=0.05, steps=60, record_every=20)
-
-    sim_summary = {
-        "entropy_initial": float(sim["entropy"][0]),
-        "entropy_final": float(sim["entropy"][-1]),
-        "chirality_initial": float(sim["chirality"][0]),
-        "chirality_final": float(sim["chirality"][-1]),
-        "energy_mean": float(np.mean(sim["energy"])),
-        "energy_std": float(np.std(sim["energy"])),
-        "N_sites": int(N),
-    }
-
-    return EvaluateResponse(
-        scores=scores,
-        features=feats,
-        sim_summary=sim_summary,
-    )
+    try:
+        scores, feats = compute_scores_srff_crff_ephi(req.prompt, req.answer)
+
+        # resumen de una simulación adicional (fresca) solo para info
+        H = build_dirac_hamiltonian(
+            m=0.25, v=1.0, sigma=0.618,
+            alpha_log=0.10, q=1.0,
+            flux_vector=(0.0, 0.0, 0.0),
+            gauge_scale=0.0,
+        )
+        rng = np.random.default_rng(abs(hash(req.prompt + req.answer + "sim")) % (2 ** 32))
+        vec = rng.normal(0, 1, (2 * N,)) + 1j * rng.normal(0, 1, (2 * N,))
+        vec /= np.sqrt(np.vdot(vec, vec))
+        psi0 = vec
+        sim = evolve_dirac_shell(psi0, H, dt=0.05, steps=60, record_every=20)
+
+        sim_summary = {
+            "entropy_initial": float(sim["entropy"][0]),
+            "entropy_final": float(sim["entropy"][-1]),
+            "chirality_initial": float(sim["chirality"][0]),
+            "chirality_final": float(sim["chirality"][-1]),
+            "energy_mean": float(np.mean(sim["energy"])),
+            "energy_std": float(np.std(sim["energy"])),
+            "N_sites": int(N),
+        }
+
+        return EvaluateResponse(
+            scores=scores,
+            features=feats,
+            sim_summary=sim_summary,
+        )
+    except Exception as e:
+        print(f"❌ [Runtime] Error en /evaluate: {e}", file=sys.stderr, flush=True)
+        raise HTTPException(status_code=500, detail="Internal server error")