Update app.py

app.py

@@ -1,44 +1,51 @@
 import os
+import math
+from typing import Optional, Dict, Any, List
+
 import numpy as np
 from numpy.linalg import norm
 from scipy.linalg import expm
+
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel, Field
+
 from sentence_transformers import SentenceTransformer
 from huggingface_hub import hf_hub_download
 import joblib
 
-from fastapi import FastAPI
-from pydantic import BaseModel, Field
-from typing import Optional, Dict, Any, List
+# ============================
+# Configuración de modelos
+# ============================
 
-# NOTE: HF_TOKEN is expected to be set as an environment variable in a real deployment
-# For local testing, you might set it here or pass it directly
-HF_TOKEN = os.environ.get("HF_TOKEN", "") # Use environment variable, default to empty
+HF_TOKEN = os.environ.get("HF_TOKEN", "")
 os.environ["HF_TOKEN"] = HF_TOKEN
 
-ENCODER_MODEL_ID = "antonypamo/RRFSAVANTMADE"        # encoder RRF
-META_LOGIT_REPO = "antonypamo/RRFSavantMetaLogit"    # repo del meta-logit
-META_LOGIT_FILENAME = "logreg_rrf_savant.joblib"  # NUEVO archivo del meta-logit en HF
+ENCODER_MODEL_ID    = "antonypamo/RRFSAVANTMADE"
+META_LOGIT_REPO     = "antonypamo/RRFSavantMetaLogit"
+META_LOGIT_FILENAME = "logreg_rrf_savant_15.joblib"  # versión 15 features
 
-print("🔄 Cargando encoder RRFSAVANTMADE...")
+print("🔄 [Startup] Cargando encoder RRFSAVANTMADE...", flush=True)
 encoder = SentenceTransformer(ENCODER_MODEL_ID)
+print("✅ [Startup] Encoder cargado.", flush=True)
 
-print("🔄 Descargando meta-logit v2 desde HF Hub...")
+print("🔄 [Startup] Descargando meta-logit desde HF Hub...", flush=True)
 meta_logit_path = hf_hub_download(
     repo_id=META_LOGIT_REPO,
     filename=META_LOGIT_FILENAME,
-    token=os.environ.get("HF_TOKEN")
+    token=HF_TOKEN if HF_TOKEN else None,
 )
-
-print("🔄 Cargando modelo meta-logit v2...")
+print(f"🔄 [Startup] Cargando modelo meta-logit '{META_LOGIT_FILENAME}'...", flush=True)
 meta_logit = joblib.load(meta_logit_path)
-
-print("✅ Encoder y meta-logit v2 cargados correctamente.")
+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)
 
 
-# =========================
-# Geometría icosaédrica
-# (Copied from cell lyVrwdhgIOlq)
-# =========================
+# ============================
+# Geometría icosaédrica Φ12.0
+# ============================
 
 phi = (1 + np.sqrt(5)) / 2
 nodes = np.array([
@@ -49,19 +56,21 @@ nodes = np.array([
 nodes /= norm(nodes, axis=1, keepdims=True)
 N = nodes.shape[0]  # 12 nodos
 
-# Pauli
 sigma_x = np.array([[0, 1], [1, 0]], dtype=complex)
 sigma_y = np.array([[0, -1j], [1j, 0]], dtype=complex)
 sigma_z = np.array([[1, 0], [0, -1]], dtype=complex)
 
+
 def kron_IN(M, N_sites):
     return np.kron(M, np.eye(N_sites, dtype=complex))
 
+
 def site_op(block_2x2, i, j, N_sites):
     K = np.zeros((N_sites, N_sites), dtype=complex)
     K[i, j] = 1.0
     return np.kron(K, block_2x2)
 
+
 def geodesic_kernel(nodes, sigma=0.618, alpha_log=0.10):
     diff = nodes[:, None, :] - nodes[None, :, :]
     dist = norm(diff, axis=-1)
@@ -78,6 +87,7 @@ def geodesic_kernel(nodes, sigma=0.618, alpha_log=0.10):
     row_sums[row_sums == 0] = 1.0
     return W / row_sums
 
+
 def u1_edge_phases(nodes, flux_vector=(0.0, 0.0, 0.0), q=1.0, gauge_scale=1.0):
     A = gauge_scale * np.asarray(flux_vector, dtype=float)
     midpoints = (nodes[:, None, :] + nodes[None, :, :]) / 2.0
@@ -85,6 +95,7 @@ def u1_edge_phases(nodes, flux_vector=(0.0, 0.0, 0.0), q=1.0, gauge_scale=1.0):
     theta = 0.5 * (theta - theta.T)
     return theta * q
 
+
 def build_dirac_hamiltonian(
     m=0.25,
     v=1.0,
@@ -92,7 +103,7 @@ def build_dirac_hamiltonian(
     alpha_log=0.10,
     q=1.0,
     flux_vector=(0.0, 0.0, 0.0),
-    gauge_scale=0.0
+    gauge_scale=0.0,
 ):
     W = geodesic_kernel(nodes, sigma=sigma, alpha_log=alpha_log)
 
@@ -103,10 +114,8 @@ def build_dirac_hamiltonian(
     else:
         U = np.ones((N, N), dtype=complex)
 
-    # Término de masa
     H = np.kron(np.eye(N, dtype=complex), m * sigma_z)
 
-    # Término cinético acoplado
     diff = nodes[:, None, :] - nodes[None, :, :]
     dist = norm(diff, axis=-1) + 1e-12
     d_hat = diff / dist[..., None]
@@ -121,27 +130,31 @@ def build_dirac_hamiltonian(
                  nvec[2] * sigma_z)
             H += v * W[i, j] * U[i, j] * site_op(S, i, j, N)
 
-    # Hermitizar por seguridad numérica
     H = 0.5 * (H + H.conj().T)
     return H
 
+
 def site_probs(psi):
     N2 = psi.shape[0]
     n = N2 // 2
     psi_mat = psi.reshape(n, 2)
     return np.sum(np.abs(psi_mat)**2, axis=1).real
 
+
 def chirality(psi):
     S = kron_IN(sigma_z, N)
     return float(np.vdot(psi, S @ psi).real)
 
+
 def energy_expectation(psi, H):
     return float(np.vdot(psi, H @ psi).real)
 
+
 def spatial_entropy(p):
     p = np.clip(p, 1e-12, 1.0)
     return float(-np.sum(p * np.log(p)).real)
 
+
 def evolve_dirac_shell(psi0, H, dt=0.05, steps=200, record_every=20):
     U = expm(-1j * dt * H)
     psi = psi0.copy()
@@ -172,30 +185,28 @@ def evolve_dirac_shell(psi0, H, dt=0.05, steps=200, record_every=20):
     }
 
 
-# =========================
-# Feature extraction and scoring
-# (Copied from cell DiknqWJZIZ5q)
-# =========================
+# ============================
+# Core RRF: embeddings + features + scores
+# ============================
 
 def get_embedding(text: str) -> np.ndarray:
     emb = encoder.encode([text], convert_to_numpy=True, normalize_embeddings=True)
     return emb[0]
 
-def compute_rrf_features(prompt: str, answer: str) -> dict:
-    # Embeddings RRF
+
+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)
 
-    # Estado inicial ligado al texto (seed reproducible)
     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))
     psi0 = vec
 
-    # Hamiltoniano Dirac Φ12.0
     H = build_dirac_hamiltonian(
         m=0.25, v=1.0, sigma=0.618,
         alpha_log=0.10, q=1.0,
@@ -203,21 +214,20 @@ def compute_rrf_features(prompt: str, answer: str) -> dict:
         gauge_scale=0.0
     )
 
-    out = evolve_dirac_shell(psi0, H, dt=0.05, steps=200, record_every=20)
+    out = evolve_dirac_shell(psi0, H, dt=0.05, steps=100, record_every=25)
 
-    probs = out["probs"]
+    entropy = out["entropy"]
     energy = out["energy"]
     chir = out["chirality"]
-    entropy = out["entropy"]
 
-    S_initial = float(entropy[0])
     S_final = float(entropy[-1])
+    S_initial = float(entropy[0])
     S_delta = S_final - S_initial
     C_final = float(chir[-1])
     E_mean = float(np.mean(energy))
     E_std = float(np.std(energy))
 
-    return {
+    feats: Dict[str, float] = {
         "cosine_pa": cosine_pa,
         "len_ratio": len_ratio,
         "dirac_entropy_final": S_final,
@@ -227,7 +237,21 @@ def compute_rrf_features(prompt: str, answer: str) -> dict:
         "dirac_energy_std": E_std,
     }
 
-def features_to_vector(feats: dict) -> np.ndarray:
+    # Derivadas extra para llegar a 15 features
+    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 = [
         "cosine_pa",
         "len_ratio",
@@ -236,24 +260,30 @@ def features_to_vector(feats: dict) -> 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)
 
+
 def compute_scores_srff_crrf_ephi(prompt: str, answer: str):
     feats = compute_rrf_features(prompt, answer)
     x = features_to_vector(feats).reshape(1, -1)
 
-    # meta-logit v2: pipeline (scaler + logistic regression)
     proba = meta_logit.predict_proba(x)[0]
     p_good = float(proba[1])
 
     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 = {
@@ -265,16 +295,9 @@ def compute_scores_srff_crrf_ephi(prompt: str, answer: str):
     return scores, feats
 
 
-# =========================
-# FastAPI App
-# (Copied from cell LwlyX4-LIgKK)
-# =========================
-
-app = FastAPI(
-    title="Savant RRF Φ12.0 API",
-    description="Evaluación conceptual resonante para texto generado por LLMs (SRRF / CRRF / E_phi).",
-    version="1.0.0",
-)
+# ============================
+# FastAPI app
+# ============================
 
 class EvaluateRequest(BaseModel):
     prompt: str = Field(..., description="Pregunta / instrucción original.")
@@ -283,41 +306,173 @@ class EvaluateRequest(BaseModel):
         None, description="Etiqueta opcional del modelo que generó la respuesta."
     )
 
+
 class EvaluateResponse(BaseModel):
     scores: Dict[str, float]
     features: Dict[str, float]
     sim_summary: Dict[str, Any]
 
-@app.post("/evaluate", response_model=EvaluateResponse)
-def evaluate_endpoint(req: EvaluateRequest):
-    scores, feats = compute_scores_srff_crrf_ephi(req.prompt, req.answer)
 
-    # mini-sim extra para resumen diagnóstico simple
-    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
+class QualityRemoteRequest(EvaluateRequest):
+    """Alias de EvaluateRequest para /quality_remote."""
+    pass
+
+
+class RerankRequest(BaseModel):
+    """
+    Petición para /v1/rerank
+    """
+    query: str = Field(..., description="Query de búsqueda o pregunta del usuario.")
+    documents: List[str] = Field(..., description="Lista de documentos candidatos a rerankear.")
+    alpha: float = Field(
+        0.2,
+        description="Peso de la corrección log_rdf en el score_final. 0 = solo cosine, 1 = solo log_rdf."
     )
-    rng = np.random.default_rng(abs(hash(req.prompt + req.answer)) % (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
+    query_embedding_norm: bool = Field(
+        True,
+        description="Si True, normaliza el embedding de query (útil para cosine)."
+    )
+
+
+class RerankDocumentResult(BaseModel):
+    id: int = Field(..., description="Índice del documento en la lista de entrada.")
+    score_cosine: float
+    score_log_rdf: float
+    score_final: float
+    rank: int
 
-    sim = evolve_dirac_shell(psi0, H, dt=0.05, steps=100, record_every=25)
 
-    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),
+class RerankResponse(BaseModel):
+    model_id: str
+    alpha: float
+    query_embedding_norm: bool
+    results: List[RerankDocumentResult]
+
+
+app = FastAPI(
+    title="Savant RRF Φ12.0 API",
+    description="Dirac-Resonant conceptual quality + reranking para texto generado por LLMs.",
+    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",
+        "encoder_model_id": ENCODER_MODEL_ID,
+        "meta_logit_filename": META_LOGIT_FILENAME,
+        "N_sites": N,
+    }
+
+
+@app.post("/evaluate", response_model=EvaluateResponse)
+def evaluate_endpoint(req: EvaluateRequest):
+    try:
+        scores, feats = compute_scores_srff_crrf_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,
+        )
+    except Exception as e:
+        print(f"❌ [Runtime] Error en /evaluate: {e}", flush=True)
+        raise HTTPException(status_code=500, detail="Internal server error")
+
+
+@app.post("/quality_remote", response_model=EvaluateResponse)
+def quality_remote(req: QualityRemoteRequest):
+    """Alias remoto de /evaluate."""
+    return evaluate_endpoint(req)
+
+
+def _compute_rerank_scores(query: str, docs: List[str], alpha: float, norm_query: bool) -> List[RerankDocumentResult]:
+    q_emb = encoder.encode([query], convert_to_numpy=True, normalize_embeddings=norm_query)[0]
+
+    results = []
+    for idx, text in enumerate(docs):
+        d_emb = encoder.encode([text], convert_to_numpy=True, normalize_embeddings=True)[0]
+        score_cosine = float(np.dot(q_emb, d_emb))
+
+        val = max(score_cosine, 0.0) + 1e-6
+        score_log_rdf = float(np.log1p(val))
+
+        score_final = (1.0 - alpha) * score_cosine + alpha * score_log_rdf
+
+        results.append(
+            {
+                "id": idx,
+                "score_cosine": score_cosine,
+                "score_log_rdf": score_log_rdf,
+                "score_final": score_final,
+            }
+        )
+
+    results_sorted = sorted(results, key=lambda r: r["score_final"], reverse=True)
+    reranked = []
+    for rank, r in enumerate(results_sorted, start=1):
+        reranked.append(
+            RerankDocumentResult(
+                id=r["id"],
+                score_cosine=r["score_cosine"],
+                score_log_rdf=r["score_log_rdf"],
+                score_final=r["score_final"],
+                rank=rank,
+            )
+        )
+    return reranked
+
+
+@app.post("/v1/rerank", response_model=RerankResponse)
+def rerank_endpoint(req: RerankRequest):
+    """
+    Endpoint Savant Seek:
+    POST /v1/rerank
+    {
+        "query": "...",
+        "documents": ["doc1", "doc2", ...],
+        "alpha": 0.2,
+        "query_embedding_norm": true
     }
+    """
+    results = _compute_rerank_scores(
+        query=req.query,
+        docs=req.documents,
+        alpha=req.alpha,
+        norm_query=req.query_embedding_norm,
+    )
 
-    return EvaluateResponse(
-        scores=scores,
-        features=feats,
-        sim_summary=sim_summary,
+    return RerankResponse(
+        model_id=ENCODER_MODEL_ID,
+        alpha=req.alpha,
+        query_embedding_norm=req.query_embedding_norm,
+        results=results,
     )