Update app.py

app.py

@@ -5,12 +5,14 @@ import csv, os, time
 import gradio as gr
 import matplotlib.pyplot as plt
 
+# ==========================
+# Config & estilos
+# ==========================
 DEFAULT_COLS = [
     "Código", "Indicador", "Score (0–4)",
     "Entailment medio", "Evidencias (hipótesis)", "Descripción"
 ]
 
-# --------- UI: meta y estilos ---------
 CUSTOM_CSS = """
 #app {max-width: 1200px; margin: 0 auto;}
 .badge {
@@ -26,7 +28,9 @@ CUSTOM_CSS = """
 .small {font-size: 12px; opacity: .9;}
 """
 
-# Nombres y descripciones cortas (IPMA ICB4 4.4.5.x)
+# ==========================
+# Metadatos IPMA ICB4 4.4.5.x
+# ==========================
 INDICATOR_META = {
     "4.4.5.1": ("Iniciativa y ayuda proactiva",
                 "Inicia acciones sin que se lo pidan; ofrece ayuda, anticipa y equilibra riesgos."),
@@ -40,16 +44,30 @@ INDICATOR_META = {
                 "Toma decisiones bajo incertidumbre; explica razones; revisa con nueva evidencia; comunica con claridad.")
 }
 
-# --- Carga perezosa de modelos (se inicializan al primer uso) ---
+# ==========================
+# Modelos (CPU Basic friendly)
+# ==========================
 _llm = None
 _llm_tok = None
 _gen = None
-_nli = None
-
-# === Modelos (ligeros + robustos para CPU Basic) ===
-LLM_ID = "Qwen/Qwen2.5-0.5B-Instruct"  # multilingüe y compacto
-# NLI que puntúa bien en ES
-NLI_ID = "MoritzLaurer/mDeBERTa-v3-base-xnli-multilingual-nli-2mil7"
+_nli_cache: Dict[str, object] = {}  # cache de pipelines NLI por model_id
+
+LLM_ID = "Qwen/Qwen2.5-0.5B-Instruct"  # LLM pequeño multilingüe para extraer STAR
+
+# Selector de NLI con configuración asociada
+MODEL_CHOICES = {
+    "Velocidad (MiniLM)": {
+        "id": "MoritzLaurer/multilingual-MiniLMv2-L12-mnli-xnli",
+        "calibrate": True,
+        "thresholds": (0.70, 0.50, 0.30, 0.15)  # 4,3,2,1
+    },
+    "Precisión (DeBERTa)": {
+        "id": "MoritzLaurer/mDeBERTa-v3-base-xnli-multilingual-nli-2mil7",
+        "calibrate": False,
+        "thresholds": (0.80, 0.60, 0.40, 0.20)
+    }
+}
+DEFAULT_MODEL_KEY = "Velocidad (MiniLM)"  # por defecto en Spaces gratis
 
 STAR_PROMPT = """Eres evaluador ICB4. Toma el texto del candidato y devuélvelo en formato STAR como JSON válido con claves:
 "situation" (<=3 frases), "task" (<=2 frases), "action" (lista de viñetas, verbos de acción), "result" (lista de viñetas, resultados/indicadores/aprendizajes).
@@ -91,18 +109,17 @@ HYP: Dict[str, List[str]] = {
     ]
 }
 
-# --------- Modelos ---------
+# ==========================
+# Carga perezosa de modelos
+# ==========================
 def lazy_load_llm():
-    """Crea pipeline de generación sin flags que generen warnings en CPU."""
+    """Pipeline de generación (Qwen 0.5B) para extraer STAR."""
     global _llm, _llm_tok, _gen
+    from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
     if _gen is not None:
         return _gen
-    from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
     _llm_tok = AutoTokenizer.from_pretrained(LLM_ID)
-    _llm = AutoModelForCausalLM.from_pretrained(
-        LLM_ID,
-        device_map="auto"
-    )
+    _llm = AutoModelForCausalLM.from_pretrained(LLM_ID, device_map="auto")
     _gen = pipeline(
         "text-generation",
         model=_llm,
@@ -113,22 +130,24 @@ def lazy_load_llm():
     )
     return _gen
 
-def lazy_load_nli():
-    """NLI robusto (scores completos) + truncation para textos largos."""
-    global _nli
-    if _nli is not None:
-        return _nli
+def lazy_load_nli(model_id: str):
+    """NLI con salida completa y truncado seguro. Cachea por model_id."""
     from transformers import pipeline
-    _nli = pipeline(
+    if model_id in _nli_cache:
+        return _nli_cache[model_id]
+    nli = pipeline(
         "text-classification",
-        model=NLI_ID,
-        tokenizer=NLI_ID,
-        return_all_scores=True,   # lista completa de {label, score}
-        truncation=True
+        model=model_id,
+        tokenizer=model_id,
+        return_all_scores=True,   # {label, score} para todas las clases
+        truncation=True           # evita degradación por textos largos
     )
-    return _nli
+    _nli_cache[model_id] = nli
+    return nli
 
-# --------- Utilidades ---------
+# ==========================
+# Utilidades extracción STAR
+# ==========================
 def extract_json_block(text: str) -> str:
     start = text.find("{")
     end = text.rfind("}")
@@ -186,9 +205,17 @@ def extract_star(user_text: str) -> Dict:
         "result": [str(r).strip(" •-") for r in data["result"] if str(r).strip()],
     }
 
-def nli_entails(premise: str, hypothesis: str) -> float:
-    """Devuelve probabilidad de ENTAILMENT (0..1)."""
-    nli = lazy_load_nli()
+# ==========================
+# NLI + scoring (dinámico por modelo)
+# ==========================
+def calibrate_prob(p: float, use_calibration: bool) -> float:
+    """Calibración leve solo para MiniLM (p**0.9)."""
+    p = max(0.0, min(1.0, float(p)))
+    return (p ** 0.9) if use_calibration else p
+
+def nli_entails(premise: str, hypothesis: str, model_id: str) -> float:
+    """Probabilidad de ENTAILMENT (0..1) robusta a variantes de salida."""
+    nli = lazy_load_nli(model_id)
 
     def _trim(s: str, limit=900):
         s = (s or "").strip()
@@ -221,40 +248,49 @@ def nli_entails(premise: str, hypothesis: str) -> float:
                 return 0.0
     return 0.0
 
-def map_prob_to_score(p: float) -> int:
-    if p >= 0.80: return 4
-    if p >= 0.60: return 3
-    if p >= 0.40: return 2
-    if p >= 0.20: return 1
+def map_prob_to_score(p: float, thresholds: Tuple[float, float, float, float]) -> int:
+    t4, t3, t2, t1 = thresholds
+    if p >= t4: return 4
+    if p >= t3: return 3
+    if p >= t2: return 2
+    if p >= t1: return 1
     return 0
 
-def score_indicator(premise: str, hyps: List[str]) -> Tuple[int, List[Tuple[str, float]], float]:
-    probs = [(h, nli_entails(premise, h)) for h in hyps]
+def score_indicator(premise: str, hyps: List[str], model_id: str, use_calibration: bool,
+                    thresholds: Tuple[float, float, float, float]) -> Tuple[int, List[Tuple[str, float]], float]:
+    raw = [(h, nli_entails(premise, h, model_id)) for h in hyps]
+    probs = [(h, calibrate_prob(p, use_calibration)) for h, p in raw]
     avg = sum(p for _, p in probs) / max(1, len(probs))
-    score = map_prob_to_score(avg)
+    score = map_prob_to_score(avg, thresholds)
     probs_sorted = sorted(probs, key=lambda x: x[1], reverse=True)[:2]
     return score, probs_sorted, avg
 
-def evaluate(texto: str):
-    """Orquestación completa con salida: status_msg, fig_plot, table_dict."""
+# ==========================
+# Evaluación orquestada
+# ==========================
+def evaluate(texto: str, model_key: str):
+    """Devuelve: status_msg, matplotlib_fig, {"columns":[...], "data":[...] }."""
     try:
         if not texto or not texto.strip():
             return "Introduce un caso en formato STAR (o texto libre).", None, {"columns": [], "data": []}
 
+        # Config del modelo seleccionado
+        cfg = MODEL_CHOICES.get(model_key, MODEL_CHOICES[DEFAULT_MODEL_KEY])
+        model_id = cfg["id"]
+        use_calibration = cfg["calibrate"]
+        thresholds = cfg["thresholds"]
+
         star = extract_star(texto)
 
-        # Limita premisa a 6 acciones + 4 resultados (mejor señal para NLI)
+        # Limita premisa para dar señal clara al NLI (6 A + 4 R)
         actions = (star.get("action", []) or [])[:6]
         results = (star.get("result", []) or [])[:4]
         premise = " ".join(actions) + " " + " ".join(results)
 
-        # --- Scoring por indicador ---
-        scores = []
-        table_rows = []
-        per_indicator_values = []
-
+        # Scoring por indicador
+        scores, table_rows, per_indicator_values = [], [], []
         for ind, hyps in HYP.items():
-            s, ev, avg = score_indicator(premise, hyps)
+            s, ev, avg = score_indicator(premise, hyps, model_id, use_calibration, thresholds)
             scores.append(s)
             per_indicator_values.append((ind, s))
             best_evid = " / ".join([h for h, _ in ev])
@@ -263,7 +299,7 @@ def evaluate(texto: str):
 
         overall = round(sum(scores) / max(1, len(scores)), 2)
 
-        # --- Gráfica de barras (0-4) ---
+        # Gráfica
         labels = [f"{k.split('.')[-1]}" for k, _ in per_indicator_values]
         values = [v for _, v in per_indicator_values]
         fig, ax = plt.subplots(figsize=(8.2, 4.0))
@@ -271,19 +307,16 @@ def evaluate(texto: str):
         ax.set_ylim(0, 4)
         ax.set_xlabel("Indicadores 4.4.5.x")
         ax.set_ylabel("Score (0–4)")
-        fig.suptitle(f"ICB4 4.4.5 Leadership — Score global: {overall}", y=0.97)
+        fig.suptitle(f"ICB4 4.4.5 Leadership — Score global: {overall}  |  Modelo: {model_key}", y=0.97)
         fig.subplots_adjust(top=0.86)
         for i, v in enumerate(values):
             ax.text(i, v + 0.08, f"{v}", ha="center", va="bottom")
         fig.tight_layout()
 
-        table = {
-            "columns": DEFAULT_COLS,
-            "data": table_rows
-        }
-
+        table = {"columns": DEFAULT_COLS, "data": table_rows}
         msg = (
             f"Evaluación completada. Score global (0–4): {overall}\n"
+            f"Modelo: {model_key}\n"
             f"Sugerencia: revisa evidencias y ajusta umbrales según tu rúbrica."
         )
         return msg, fig, table
@@ -291,7 +324,9 @@ def evaluate(texto: str):
     except Exception as e:
         return f"⚠️ Error en evaluate(): {type(e).__name__}: {e}", None, {"columns": [], "data": []}
 
-# --------- Helper CSV ---------
+# ==========================
+# CSV helper
+# ==========================
 def make_csv_from_table(table: dict) -> str:
     cols = table.get("columns", [])
     rows = table.get("data", [])
@@ -304,7 +339,9 @@ def make_csv_from_table(table: dict) -> str:
             writer.writerow(r)
     return path if os.path.exists(path) else ""
 
-# --------- UI Gradio (estilo pro, 2 columnas, CSV) ---------
+# ==========================
+# UI (2 columnas + selector modelo + CSV)
+# ==========================
 with gr.Blocks(title="ICB4 4.4.5 Leadership — Evaluación STAR (FRAQX)", css=CUSTOM_CSS, elem_id="app") as demo:
     gr.Markdown(
         """
@@ -312,14 +349,22 @@ with gr.Blocks(title="ICB4 4.4.5 Leadership — Evaluación STAR (FRAQX)", css=C
             <img src="https://huggingface.co/front/assets/huggingface_logo-noborder.svg" height="28">
             <h1 style="margin:0;">ICB4 • 4.4.5 Leadership — Evaluación STAR + NLI</h1>
         </div>
-        <div class="small">Extracción STAR, scoring (4.4.5.1–4.4.5.5), gráfica y reporte descargable.</div>
+        <div class="small">Extracción STAR, scoring (4.4.5.1–4.4.5.5), gráfica y reporte descargable. Elige el modelo NLI según tu prioridad.</div>
         """
     )
 
     with gr.Row(equal_height=True):
-        # -------- Columna izquierda (entrada) --------
+        # Entrada
         with gr.Column(scale=5):
             gr.Markdown("<div class='card'><b>Entrada</b></div>")
+
+            model_key = gr.Dropdown(
+                choices=list(MODEL_CHOICES.keys()),
+                value=DEFAULT_MODEL_KEY,
+                label="Modelo NLI",
+                info="Velocidad (MiniLM) = más rápido | Precisión (DeBERTa) = mejor calidad"
+            )
+
             texto = gr.Textbox(
                 label="Caso (STAR o texto libre)",
                 lines=16,
@@ -344,38 +389,28 @@ with gr.Blocks(title="ICB4 4.4.5 Leadership — Evaluación STAR (FRAQX)", css=C
                 """,
             )
 
-        # -------- Columna derecha (salida) --------
+        # Salida
         with gr.Column(scale=7):
             gr.Markdown("<div class='card'><b>Resultados</b></div>")
             status = gr.Markdown(value="**Estado**: —", elem_id="status_md")
-
-            # Cabecera con badge de score (se llena dinámicamente con Markdown)
             score_badge = gr.Markdown(value="<span class='badge'>Score global: —</span>")
-
-            # Gráfica de barras
             plot = gr.Plot(label="Gráfica de evaluación (0–4)")
-
-            # Tabla explicativa
             table = gr.Dataframe(
                 headers=DEFAULT_COLS,
                 datatype=["str", "str", "number", "str", "str", "str"],
                 interactive=False,
                 label="Detalle por indicador"
             )
-
-            # Acciones de exportación
             with gr.Row():
                 download_btn = gr.Button("Descargar CSV")
                 csv_file = gr.File(label="Archivo CSV", visible=False)
 
-    # -------- Lógica de interacción --------
-    def run_eval(t: str):
-        msg, fig, tbl = evaluate(t)
+    # Lógica
+    def run_eval(t: str, mk: str):
+        msg, fig, tbl = evaluate(t, mk)
 
-        # Estado en Markdown
         status_md = "**Estado**  \n" + (msg or "").replace("\n", "  \n")
 
-        # Badge de score desde el texto
         badge_html = "<span class='badge'>Score global: —</span>"
         try:
             m = re.search(r"Score global \(0–4\):\s*([0-4](?:\.[0-9])?)", msg or "")
@@ -384,7 +419,6 @@ with gr.Blocks(title="ICB4 4.4.5 Leadership — Evaluación STAR (FRAQX)", css=C
         except Exception:
             pass
 
-        # Tabla segura
         cols = (tbl or {}).get("columns") or DEFAULT_COLS
         data = (tbl or {}).get("data") or []
         safe_data = []
@@ -396,7 +430,6 @@ with gr.Blocks(title="ICB4 4.4.5 Leadership — Evaluación STAR (FRAQX)", css=C
                 r = r[:len(cols)]
             safe_data.append(r)
 
-        # Gráfica placeholder si hace falta
         if fig is None:
             fig, ax = plt.subplots(figsize=(6, 2))
             ax.axis("off")
@@ -404,29 +437,15 @@ with gr.Blocks(title="ICB4 4.4.5 Leadership — Evaluación STAR (FRAQX)", css=C
 
         return status_md, badge_html, fig, gr.update(value=safe_data, headers=cols)
 
-    btn.click(
-        fn=run_eval,
-        inputs=[texto],
-        outputs=[status, score_badge, plot, table]
-    )
+    btn.click(fn=run_eval, inputs=[texto, model_key], outputs=[status, score_badge, plot, table])
 
-    # Botón de descarga CSV
-    def export_csv_handler(t: str):
-        _, _, tbl = evaluate(t)
+    def export_csv_handler(t: str, mk: str):
+        _, _, tbl = evaluate(t, mk)
         path = make_csv_from_table(tbl)
         return path, gr.update(visible=True)
 
-    download_btn.click(
-        fn=export_csv_handler,
-        inputs=[texto],
-        outputs=[csv_file, csv_file]
-    )
+    download_btn.click(fn=export_csv_handler, inputs=[texto, model_key], outputs=[csv_file, csv_file])
 
-# --- Lanzamiento con cola (estable para CPU Basic) ---
+# Lanzamiento
 if __name__ == "__main__":
-    demo.queue(
-        max_size=16
-    ).launch(
-        ssr_mode=False,
-        show_error=True
-    )
+    demo.queue(max_size=16).launch(ssr_mode=False, show_error=True)