Evaluator udpdated

app.py

@@ -13,6 +13,7 @@ Requiere:
 
 import os
 import json
+import random
 import gradio as gr
 from dotenv import load_dotenv
 
@@ -28,16 +29,13 @@ load_dotenv()
 
 print(" Inicializando Scriptorium RAG...")
 
-# Cargar corpus desde disco (si existe) + pares de ejemplo embebidos
 loader     = CorpusLoader(os.getenv("CORPUS_PATH", "./corpus"))
 disk_pairs = loader.load()
 all_pairs  = SAMPLE_PAIRS + disk_pairs
 
-# Variable global para el vector store activo
 current_embed_model = "openai"
 vs = VectorStore(embedding_model="openai")
 
-# Auto-indexar solo si el índice está vacío (evita re-indexar en cada arranque)
 if vs.count() == 0:
     print(f"⏳ Índice vacío — indexando {len(all_pairs)} pares, espera...")
     vs.index(all_pairs)
@@ -61,52 +59,51 @@ DEMO_EXAMPLES = [
     "fizo pareçer ante si a los testigos q̃ dixeron ser mayores de veynte annos",
 ]
 
+# ── Caligrafías disponibles en el corpus ──────────────────────────────────────
+
+def get_caligrafias():
+    cals = set()
+    for p in all_pairs:
+        c = p.get("caligrafia", "desconocida")
+        if c: cals.add(c)
+    return ["Todas"] + sorted(cals)
+
+
+# ── Funciones ─────────────────────────────────────────────────────────────────
+
 def cambiar_embedding(embed_model: str):
     global vs, corrector, current_embed_model
-
     if embed_model == current_embed_model:
         return f"ℹ Ya estás usando **{embed_model}**"
-
     try:
         current_embed_model = embed_model
         vs = VectorStore(embedding_model=embed_model)
-
-        # Indexar si la colección está vacía
         if vs.count() == 0:
             vs.index(all_pairs)
             msg = f" Re-indexado con **{embed_model}** · {vs.count()} docs"
         else:
             msg = f" Cargado índice existente **{embed_model}** · {vs.count()} docs"
-
-        # Recrear el corrector con el nuevo vector store
         corrector = RAGCorrector(vs)
         return msg
-
     except Exception as e:
         return f" Error cambiando embedding: {e}"
 
 
-
-# ── Función principal ─────────────────────────────────────────────────────────
-
 def corregir(htr_text: str, top_k: int, mostrar_prompt: bool, model: str):
     if not htr_text.strip():
-        return "", "", "", "", " Introduce un texto HTR para corregir."
-
+        return "", "", "", "", " Introduce un texto HTR para corregir.", ""
     if not os.getenv("OPENAI_API_KEY"):
-        return "", "", "", "", " Falta OPENAI_API_KEY en el fichero .env"
-
+        return "", "", "", "", " Falta OPENAI_API_KEY en el fichero .env", ""
     try:
-        result = corrector.correct(htr_text, top_k=int(top_k), model= model)
+        result = corrector.correct(htr_text, top_k=int(top_k), model=model)
     except Exception as e:
-        return "", "", "", "", f" Error al llamar a la API: {e}"
+        return "", "", "", "", f" Error al llamar a la API: {e}", ""
 
     corrected  = result["corrected"]
     retrieved  = result["retrieved"]
     htr_errors = result["htr_errors"]
     grafia_w   = result["grafia_warns"]
 
-    # ── Panel de documentos recuperados ──────────────────────────────────────
     docs_md = f"### Top-{len(retrieved)} documentos recuperados\n\n"
     for i, doc in enumerate(retrieved, 1):
         docs_md += (
@@ -119,25 +116,25 @@ def corregir(htr_text: str, top_k: int, mostrar_prompt: bool, model: str):
             docs_md += f"- **Correcciones:** {', '.join(doc['corrections'])}\n"
         docs_md += "\n---\n"
 
-    # ── Panel de análisis ─────────────────────────────────────────────────────
     analysis_md = "### Análisis del texto\n\n"
-
     if htr_errors:
         analysis_md += "**⚠ Posibles errores HTR detectados:**\n"
         for e in htr_errors:
-            analysis_md += f"- `{e['htr']}` → `{e['gt']}`: {e['context']}  \n  *Ej: {e['example']}*\n"
+            examples = e.get("examples", e.get("example", ""))
+            if isinstance(examples, list):
+                examples = "; ".join(examples[:2])
+            sev = e.get("severity", "")
+            sev_label = f" `[{sev.upper()}]`" if sev else ""
+            analysis_md += f"- `{e['htr']}` → `{e['gt']}`{sev_label}: {e['context']}  \n  *Ej: {examples}*\n"
         analysis_md += "\n"
-
     if grafia_w:
         analysis_md += "**✦ Alertas de grafía (NO modernizar):**\n"
         for g in grafia_w:
             analysis_md += f"- `{g['modern']}` → mantener `{g['ancient']}`: {g['rule']}\n"
         analysis_md += "\n"
-
     if not htr_errors and not grafia_w:
         analysis_md += "*No se detectaron patrones conocidos de error en el texto.*\n"
 
-    # Diff visual (diferencias)
     diff_md = "### Diferencias HTR → Corregido\n\n"
     orig_words = htr_text.split()
     corr_words = corrected.split()
@@ -155,11 +152,6 @@ def corregir(htr_text: str, top_k: int, mostrar_prompt: bool, model: str):
     diff_md += " ".join(diff_parts)
     diff_md += f"\n\n*{changed} palabra(s) modificada(s) de {len(orig_words)} totales.*"
 
-    # ── Prompt (opcional) ─────────────────────────────────────────────────────
-    #prompt_md = ""
-    #if mostrar_prompt:
-    #    prompt_md = f"```\nSYSTEM:\n{result.get('_system', '(ver rag_corrector.py)')}\n\nUSER:\n{result['prompt']}\n```"
-
     status = f" Corrección completada con **{result['model']}** · {vs.count()} docs en índice"
 
     prompt_visible = ""
@@ -173,49 +165,174 @@ def corregir(htr_text: str, top_k: int, mostrar_prompt: bool, model: str):
 
     return corrected, docs_md, analysis_md, diff_md, status, prompt_visible
 
+
 def evaluar_par(htr_text: str, gt_text: str):
     if not htr_text.strip() or not gt_text.strip():
         return "⚠ Introduce tanto el texto HTR como el groundtruth."
     try:
-        result = corrector.correct(htr_text)
+        result  = corrector.correct(htr_text)
         metrics = evaluator.evaluate_pair(htr_text, result["corrected"], gt_text)
-        m = metrics
-        mod = m["modernism"]
-        report = (
-            f"### Métricas de evaluación\n\n"
-            f"| Métrica | Antes (HTR) | Después (RAG) | Mejora |\n"
-            f"|---------|------------|---------------|--------|\n"
-            f"| **CER** | {m['cer_before']:.2%} | {m['cer_after']:.2%} | {m['cer_improvement']:+.2%} |\n"
-            f"| **WER** | {m['wer_before']:.2%} | {m['wer_after']:.2%} | {m['wer_improvement']:+.2%} |\n\n"
-            f"**Detector de modernismos:** score={mod['score']:.2f}  "
-            f"({mod['count']} problema(s) detectado(s))\n"
-        )
-        if mod["issues"]:
-            report += "\nFormas modernas introducidas incorrectamente:\n"
-            for iss in mod["issues"]:
-                report += f"- `{iss['modern']}` (debería ser `{iss['ancient']}`): {iss['rule']}\n"
-
-        report += f"\n**Texto corregido por RAG:**\n> {result['corrected']}"
+        report  = evaluator.format_pair_report(metrics)
+        report += f"\n\n**Texto corregido por RAG:**\n> {result['corrected']}"
         return report
     except Exception as e:
         return f" Error: {e}"
 
 
-def add_to_corpus(htr_text: str, gt_text: str, doc_type: str, region: str, date: str, caligrafia: str):
+def evaluar_batch(n_samples: int, caligrafia_filtro: str, model: str):
+    """
+    Evalúa el sistema sobre N pares aleatorios del corpus que tengan GT.
+    Muestra las tres comparaciones: GT vs HTR, GT vs Corregido, HTR vs Corregido.
+    """
+    # Filtrar pares con HTR y GT no vacíos
+    pares_validos = [
+        p for p in all_pairs
+        if p.get("htr", "").strip() and p.get("gt", "").strip()
+    ]
+
+    # Filtrar por caligrafía si se especifica
+    if caligrafia_filtro and caligrafia_filtro != "Todas":
+        pares_validos = [
+            p for p in pares_validos
+            if p.get("caligrafia", "") == caligrafia_filtro
+        ]
+
+    if not pares_validos:
+        return "⚠ No hay pares con GT disponibles para evaluar con ese filtro."
+
+    # Muestra aleatoria
+    n = min(int(n_samples), len(pares_validos))
+    muestra = random.sample(pares_validos, n)
+
+    yield f"⏳ Evaluando {n} pares con modelo **{model}**...\n\n"
+
+    results = []
+    errores = []
+    for i, pair in enumerate(muestra, 1):
+        try:
+            out     = corrector.correct(pair["htr"], model=model)
+            metrics = evaluator.evaluate_pair(
+                htr=pair["htr"],
+                corrected=out["corrected"],
+                gt=pair["gt"],
+            )
+            metrics["id"]        = pair.get("id", f"par_{i}")
+            metrics["htr"]       = pair["htr"]
+            metrics["corrected"] = out["corrected"]
+            metrics["gt"]        = pair["gt"]
+            metrics["caligrafia"]= pair.get("caligrafia", "desconocida")
+            results.append(metrics)
+        except Exception as e:
+            errores.append(f"  - {pair.get('id','?')}: {e}")
+
+        # Progreso intermedio cada 5 pares
+        if i % 5 == 0:
+            yield f"⏳ Procesados {i}/{n}...\n\n"
+
+    if not results:
+        yield "❌ No se obtuvieron resultados.\n" + "\n".join(errores)
+        return
+
+    # ── Resumen global ────────────────────────────────────────────────────────
+    def avg(key):
+        return sum(r[key] for r in results) / len(results)
+
+    n_res       = len(results)
+    mejorados   = sum(1 for r in results if r["cer_improvement"] >  0.02)
+    empeorados  = sum(1 for r in results if r["cer_improvement"] < -0.02)
+    sin_cambio  = n_res - mejorados - empeorados
+
+    md  = f"## 📊 Evaluación por lotes — {n_res} pares\n\n"
+    if caligrafia_filtro != "Todas":
+        md += f"**Filtro caligrafía:** {caligrafia_filtro}  |  "
+    md += f"**Modelo:** {model}\n\n"
+    md += "---\n\n"
+
+    # Comparación 1 — GT vs HTR
+    md += "### ① Error de partida  (GT vs HTR original)\n\n"
+    md += f"| CER medio | WER medio |\n|---|---|\n"
+    md += f"| {avg('cer_before'):.2%} | {avg('wer_before'):.2%} |\n\n"
+
+    # Comparación 2 — GT vs Corregido
+    md += "### ② Error final  (GT vs Texto corregido)\n\n"
+    md += f"| CER medio | WER medio | Mejora CER | Mejora WER |\n|---|---|---|---|\n"
+    md += (
+        f"| {avg('cer_after'):.2%} "
+        f"| {avg('wer_after'):.2%} "
+        f"| {avg('cer_improvement'):+.2%} "
+        f"| {avg('wer_improvement'):+.2%} |\n\n"
+    )
+    md += (
+        f"| ✓ Mejorados | ✗ Empeorados | ~ Sin cambio |\n|---|---|---|\n"
+        f"| {mejorados} ({mejorados/n_res:.0%}) "
+        f"| {empeorados} ({empeorados/n_res:.0%}) "
+        f"| {sin_cambio} ({sin_cambio/n_res:.0%}) |\n\n"
+    )
+
+    # Comparación 3 — HTR vs Corregido (modernismos)
+    md += "### ③ Modernismos introducidos  (HTR vs Corregido)\n\n"
+    md += f"Score promedio: **{avg('modernism_score'):.2%}** (1.0 = sin modernismos)\n\n"
+    modernismos_total = sum(r["modernism"]["count"] for r in results)
+    if modernismos_total == 0:
+        md += "✓ El LLM no introdujo modernismos en ningún par.\n\n"
+    else:
+        md += f"✗ {modernismos_total} modernismo(s) introducidos en total.\n\n"
+
+    # ── Desglose por caligrafía ───────────────────────────────────────────────
+    from collections import defaultdict
+    by_cal = defaultdict(list)
+    for r in results:
+        by_cal[r["caligrafia"]].append(r)
+
+    if len(by_cal) > 1:
+        md += "### Desglose por caligrafía\n\n"
+        md += "| Caligrafía | N | CER antes | CER después | Mejora CER | Modernismos |\n"
+        md += "|---|---|---|---|---|---|\n"
+        for cal, rs in sorted(by_cal.items()):
+            a_cer  = sum(r["cer_before"] for r in rs) / len(rs)
+            d_cer  = sum(r["cer_after"]  for r in rs) / len(rs)
+            imp    = a_cer - d_cer
+            mods   = sum(r["modernism"]["count"] for r in rs)
+            md += f"| {cal} | {len(rs)} | {a_cer:.2%} | {d_cer:.2%} | {imp:+.2%} | {mods} |\n"
+        md += "\n"
+
+    # ── Detalle por par ───────────────────────────────────────────────────────
+    md += "### Detalle por par\n\n"
+    md += "| ID | Cal | CER antes | CER después | Mejora | Veredicto | Modernismos |\n"
+    md += "|---|---|---|---|---|---|---|\n"
+    for r in results:
+        md += (
+            f"| `{r['id'][:25]}` "
+            f"| {r['caligrafia'][:12]} "
+            f"| {r['cer_before']:.2%} "
+            f"| {r['cer_after']:.2%} "
+            f"| {r['cer_improvement']:+.2%} "
+            f"| {r['verdict']} "
+            f"| {r['modernism']['count']} |\n"
+        )
+
+    # Errores
+    if errores:
+        md += f"\n\n⚠ {len(errores)} pares fallaron:\n" + "\n".join(errores)
+
+    yield md
+
+
+def add_to_corpus(htr_text, gt_text, doc_type, region, date, caligrafia):
     if not htr_text.strip() or not gt_text.strip():
         return "⚠ HTR y GT son obligatorios."
     try:
-        pair_id = f"user_{abs(hash(htr_text)) % 100000:05d}"
+        pair_id  = f"user_{abs(hash(htr_text)) % 100000:05d}"
         new_pair = {
-            "id":      pair_id,
-            "htr":     htr_text.strip(),
-            "gt":      gt_text.strip(),
-            "type":    doc_type or "desconocido",
-            "region":  region or "desconocida",
-            "date":    date or "",
-            "caligrafia": caligrafia or "desconocida",
+            "id":          pair_id,
+            "htr":         htr_text.strip(),
+            "gt":          gt_text.strip(),
+            "type":        doc_type or "desconocido",
+            "region":      region   or "desconocida",
+            "date":        date     or "",
+            "caligrafia":  caligrafia or "desconocida",
             "corrections": [],
-            "source":  "user_added",
+            "source":      "user_added",
         }
         added = vs.index([new_pair])
         if added:
@@ -244,7 +361,6 @@ with gr.Blocks(
     """,
 ) as demo:
 
-    # ── Header ────────────────────────────────────────────────────────────────
     gr.HTML("""
     <div class="header">
       <h1>RAG CODEX for Historical Spanish</h1>
@@ -270,46 +386,29 @@ with gr.Blocks(
                         )
                         model_selector = gr.Dropdown(
                             label="Modelo LLM",
-                            choices=[
-                                "llama-3.3-70b-versatile",
-                                "openai/gpt-oss-120b",
-                            ],
+                            choices=["llama-3.3-70b-versatile", "openai/gpt-oss-120b"],
                             value="llama-3.3-70b-versatile",
                         )
                         embedding_selector = gr.Dropdown(
                             label="Modelo de Embedding",
-                            choices=[
-                                "openai",    # text-embedding-3-small
-                                "mpnet",     # paraphrase-multilingual-mpnet-base-v2
-                                "mt5",
-                            ],
+                            choices=["openai", "mpnet", "mt5"],
                             value="openai",
                         )
-
                         show_prompt = gr.Checkbox(label="Show RAG prompt", value=False)
                     btn_corregir = gr.Button("✦ Correct with RAG", variant="primary")
-
-                    gr.Examples(
-                        examples=DEMO_EXAMPLES,
-                        inputs=htr_input,
-                        label="Demonstration examples",
-                    )
+                    gr.Examples(examples=DEMO_EXAMPLES, inputs=htr_input, label="Demonstration examples")
 
                 with gr.Column(scale=2):
-                    corrected_out = gr.Textbox(
-                        label="Corrected text (RAG output)",
-                        lines=6,
-                        interactive=False,
-                    )
-                    status_out = gr.Markdown(elem_classes=["status-bar"])
+                    corrected_out = gr.Textbox(label="Corrected text (RAG output)", lines=6, interactive=False)
+                    status_out    = gr.Markdown(elem_classes=["status-bar"])
 
             with gr.Row():
                 with gr.Column():
-                    docs_out = gr.Markdown(label="Documents recovered from the corpus")
+                    docs_out     = gr.Markdown(label="Documents recovered from the corpus")
                 with gr.Column():
                     analysis_out = gr.Markdown(label="Pattern analysis")
 
-            diff_out = gr.Markdown(label="Word-by-word differences")
+            diff_out   = gr.Markdown(label="Word-by-word differences")
             prompt_out = gr.Markdown(label="Prompt sent to the LLM", visible=True)
 
             btn_corregir.click(
@@ -317,17 +416,15 @@ with gr.Blocks(
                 inputs=[htr_input, top_k_slider, show_prompt, model_selector],
                 outputs=[corrected_out, docs_out, analysis_out, diff_out, status_out, prompt_out],
             )
-
             embed_status = gr.Markdown()
-            embedding_selector.change(
-                fn=cambiar_embedding,
-                inputs=[embedding_selector],
-                outputs=[embed_status],
-            )
+            embedding_selector.change(fn=cambiar_embedding, inputs=[embedding_selector], outputs=[embed_status])
 
-        # ── Pestaña 2: Evaluación ─────────────────────────────────────────────
+        # ── Pestaña 2: Evaluación individual ─────────────────────────────────
         with gr.TabItem(" Evaluation with GT"):
-            gr.Markdown("Compare the RAG correction against the actual groundtruth to measure CER/WER and detect modernisms.")
+            gr.Markdown(
+                "Compara la corrección del RAG con el groundtruth real para medir "
+                "CER/WER y detectar modernismos introducidos por el LLM."
+            )
             with gr.Row():
                 eval_htr = gr.Textbox(label="HTR text", lines=4)
                 eval_gt  = gr.Textbox(label="Groundtruth (reference)", lines=4)
@@ -335,30 +432,68 @@ with gr.Blocks(
             eval_out = gr.Markdown()
             btn_eval.click(fn=evaluar_par, inputs=[eval_htr, eval_gt], outputs=eval_out)
 
-        # ── Pestaña 3: Añadir al corpus ───────────────────────────────────────
+        # ── Pestaña 3: Evaluación por lotes ──────────────────────────────────
+        with gr.TabItem("📊 Batch Evaluation"):
+            gr.Markdown(
+                "Evalúa el sistema sobre una muestra aleatoria del corpus. "
+                "Muestra las tres comparaciones: **GT vs HTR** (error de partida), "
+                "**GT vs Corregido** (error final) y **HTR vs Corregido** (modernismos)."
+            )
+            with gr.Row():
+                batch_n = gr.Slider(
+                    minimum=5, maximum=100, value=20, step=5,
+                    label="Número de pares a evaluar",
+                )
+                batch_cal = gr.Dropdown(
+                    label="Filtrar por caligrafía",
+                    choices=get_caligrafias(),
+                    value="Todas",
+                )
+                batch_model = gr.Dropdown(
+                    label="Modelo LLM",
+                    choices=["llama-3.3-70b-versatile", "openai/gpt-oss-120b"],
+                    value="llama-3.3-70b-versatile",
+                )
+
+            with gr.Row():
+                gr.Markdown(
+                    f"ℹ Corpus disponible: **{len([p for p in all_pairs if p.get('gt','').strip()])} "
+                    f"pares con GT** de {len(all_pairs)} totales."
+                )
+
+            btn_batch = gr.Button("▶ Ejecutar evaluación por lotes", variant="primary")
+            batch_out = gr.Markdown()
+
+            btn_batch.click(
+                fn=evaluar_batch,
+                inputs=[batch_n, batch_cal, batch_model],
+                outputs=batch_out,
+            )
+
+        # ── Pestaña 4: Añadir al corpus ───────────────────────────────────────
         with gr.TabItem("➕ Add to corpus"):
             gr.Markdown("Add new pairs to the vector store to improve the RAG continuously.")
             with gr.Row():
-                add_htr    = gr.Textbox(label="Texto HTR", lines=4)
-                add_gt     = gr.Textbox(label="Groundtruth corregido", lines=4)
+                add_htr = gr.Textbox(label="Texto HTR", lines=4)
+                add_gt  = gr.Textbox(label="Groundtruth corregido", lines=4)
             with gr.Row():
-                add_type   = gr.Textbox(label="Document type", placeholder="notarial / judicial / eclesiastico")
-                add_region = gr.Textbox(label="Region", placeholder="Castilla, Andalucía…")
-                add_date   = gr.Textbox(label="Date", placeholder="1542")
+                add_type      = gr.Textbox(label="Document type", placeholder="notarial / judicial / eclesiastico")
+                add_region    = gr.Textbox(label="Region", placeholder="Castilla, Andalucía…")
+                add_date      = gr.Textbox(label="Date", placeholder="1542")
                 add_caligrafia = gr.Dropdown(
                     label="Caligrafía",
-                    choices=["desconocida", "procesal", "encadenada", "italica"],
+                    choices=["desconocida", "Procesal", "Encadenada", "Italica_cursiva", "Redonda"],
                     value="desconocida",
-                ) 
-            btn_add  = gr.Button("Add to corpus", variant="primary")
-            add_out  = gr.Markdown()
+                )
+            btn_add = gr.Button("Add to corpus", variant="primary")
+            add_out = gr.Markdown()
             btn_add.click(
                 fn=add_to_corpus,
                 inputs=[add_htr, add_gt, add_type, add_region, add_date, add_caligrafia],
                 outputs=add_out,
             )
 
-        # ── Pestaña 4: Info del sistema ───────────────────────────────────────
+        # ── Pestaña 5: Info del sistema ───────────────────────────────────────
         with gr.TabItem("ℹ System"):
             gr.Markdown(f"""
 ## System status
@@ -381,28 +516,22 @@ Texto HTR
    │        │
    │        └─► Búsqueda top-k en ChromaDB ──► Few-shot dinámico
    │
-   └─► Prompt constructor ──► GPT-4o ──► Texto corregido
+   └─► Prompt constructor ──► LLM ──► Texto corregido
 ```
 
-## Formato del corpus
+## Evaluación por lotes
 
-Para añadir tu corpus, crea `./corpus/` con ficheros JSON:
-```json
-[
-  {{"id": "doc001", "htr": "texto htr...", "gt": "groundtruth...",
-    "type": "notarial", "region": "Castilla", "date": "1542"}},
-  ...
-]
-```
-O CSV con columnas: `id, htr, gt, type, region, date`
+Las tres comparaciones:
+1. **GT vs HTR** — error de partida (cuánto se equivocó el HTR)
+2. **GT vs Corregido** — error final (cuánto mejoró el RAG)
+3. **HTR vs Corregido** — modernismos (qué cambió el LLM que no debía)
 """)
 
 if __name__ == "__main__":
     demo.launch(
         server_name="0.0.0.0",
         server_port=7860,
-        auth=("admin", "admin"),   # ← autenticación básica (opcional)
-
+        auth=("admin", "admin"),
         share=False,
         show_error=True,
     )