#!/usr/bin/env python3 """Evalúa el MEJORADOR DE REDACCIÓN clínica (componente 06). Compara dos "mejoradores" que reescriben una nota desordenada en una nota clínica adecuada: - lulu : el modelo clínico de David (Lulu 0.5B). NOTA: Lulu fue entrenado para extracción/JSON, NO para reescribir notas → aquí es un baseline OFF-TASK (se espera que rinda bajo; es dato válido: la reescritura es tarea de LLM grande, Lulu brilla en extracción/clasif.). - cloud : LLM "nube" como baseline fuerte. OpenAI sin créditos → usamos gpt-oss-120b (Groq). Dos condiciones: SIN plantilla y CON plantilla (estructura clínica objetivo). Dos métricas, deliberadamente separadas: 1. PRESERVACIÓN OBJETIVA (número duro, sin LLM): ¿todas las cifras y términos-clave del original aparecen en la mejora? Ancla la credibilidad de "no pierde información". 2. RÚBRICA 0-5 (LLM-as-judge, 3 jueces cross-provider: Qwen + gpt-oss (Groq) + Gemini-flash): preservación, formato clínico, sin alucinación, legibilidad, seguridad. Se promedian. También exporta un subconjunto de CALIBRACIÓN (original + mejoras) para que Opus (Hera) puntúe y ancle la escala. Uso: python eval_note_improver.py --n 40 --out results_pilot.json --calib calib_subset.jsonl """ import argparse, json, os, re, sys, time sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "common")) import llm # noqa: E402 LULU = {"base": "Qwen/Qwen2.5-0.5B-Instruct", "repo": "derebellon/edeus-lulu", "subfolder": "out_qwen_base"} TEMPLATE = """ESTRUCTURA OBJETIVO (usa estas secciones en este orden): MOTIVO DE CONSULTA: ANTECEDENTES: EXAMEN FÍSICO (signos vitales): PARACLÍNICOS: DIAGNÓSTICOS: PLAN / TRATAMIENTO:""" POLISH_SYS = ("Eres un médico que mejora la redacción de notas clínicas. Reescribe la nota " "desordenada en una nota clínica clara y bien estructurada, en español. NO inventes " "información ni cifras: usa SOLO lo que está en la nota original, pero preséntalo " "ordenado, legible y con terminología clínica adecuada. Conserva TODAS las cifras, " "dosis y valores exactamente como están. Devuelve solo la nota mejorada.") JUDGE_SYS = ("Eres un evaluador clínico. Puntúa la NOTA MEJORADA respecto a la NOTA ORIGINAL en 5 " "dimensiones, cada una 0-5 (0=inaceptable, 5=excelente). Devuelve SOLO JSON: " '{"preservacion_info":0-5,"formato_clinico":0-5,"sin_alucinacion":0-5,' '"legibilidad":0-5,"seguridad_clinica":0-5}. ' "preservacion_info: ¿todos los hechos/cifras del original están en la mejora? " "sin_alucinacion: ¿NO agrega datos/dx/dosis ausentes del original? (0 si inventa). " "formato_clinico: estructura/terminología correcta. legibilidad: claridad. " "seguridad_clinica: no cambia sentido/unidades/negaciones de forma riesgosa.") def load_lulu(device="cpu"): import torch from transformers import AutoModelForCausalLM, AutoTokenizer from peft import PeftModel hf = json.load(open("/huggingface.json"))["token"] tok = AutoTokenizer.from_pretrained(LULU["base"], trust_remote_code=True, token=hf) if tok.pad_token is None: tok.pad_token = tok.eos_token m = AutoModelForCausalLM.from_pretrained(LULU["base"], torch_dtype=torch.float32, token=hf) m = PeftModel.from_pretrained(m, LULU["repo"], subfolder=LULU["subfolder"], token=hf).merge_and_unload().eval().to(device) return m, tok def improve_lulu(model, tok, messy, template, device="cpu"): import torch sysmsg = POLISH_SYS + ("\n" + TEMPLATE if template else "") p = tok.apply_chat_template([{"role": "system", "content": sysmsg}, {"role": "user", "content": messy}], tokenize=False, add_generation_prompt=True) ids = tok(p, return_tensors="pt", truncation=True, max_length=1200).to(device) with torch.no_grad(): out = model.generate(**ids, max_new_tokens=400, do_sample=False, pad_token_id=tok.eos_token_id) return tok.decode(out[0][ids["input_ids"].shape[1]:], skip_special_tokens=True).strip() def improve_cloud(messy, template): # Baseline "LLM nube" = GPT-4.1 (OpenAI, créditos recargados): el modelo grande de producción. sysmsg = POLISH_SYS + ("\n" + TEMPLATE if template else "") return llm.call_gpt(sysmsg, messy, model="gpt-4.1", max_tokens=700) def preservation(facts, improved): """Número duro: fracción de hechos cuyo término-cabeza + TODAS sus cifras siguen presentes.""" imp = improved.lower() ok = 0 for fact in facts: fl = fact.lower() nums = re.findall(r"\d+(?:[.,]\d+)?", fl) head = re.findall(r"[a-záéíóúñ]{4,}", fl) head_ok = (head[0] in imp) if head else True nums_ok = all(n in imp for n in nums) ok += int(head_ok and nums_ok) return round(ok / len(facts), 3) if facts else None DIMS = ["preservacion_info", "formato_clinico", "sin_alucinacion", "legibilidad", "seguridad_clinica"] def judge_one(judge_fn, original, improved, model=None): u = f"NOTA ORIGINAL:\n{original}\n\nNOTA MEJORADA:\n{improved}" try: r = judge_fn(JUDGE_SYS, u, json_mode=True, **({"model": model} if model else {}), max_tokens=200) return {d: float(r.get(d)) for d in DIMS if isinstance(r.get(d), (int, float))} except Exception: return {} def judges(original, improved): """Jueces del hot-path: Qwen (Alibaba) + gpt-oss (OpenAI-oss), vía Groq (rápidos). Se EXCLUYE GPT-4.1 porque es el mejorador 'cloud' (evita auto-juicio). Gemini-flash quedó RATE-LIMITED (429, ~39s/fallo) → fuera del hot-path. El ancla CROSS-PROVIDER la aporta Opus (Claude, vía Hera) sobre el subconjunto de calibración `calib_subset.jsonl`.""" scores = [] for fn, mdl in [(llm.call_groq, "qwen/qwen3.8-27b"), (llm.call_groq, "openai/gpt-oss-120b")]: s = judge_one(fn, original, improved, mdl) if len(s) == len(DIMS): scores.append(s) if not scores: return {d: None for d in DIMS}, 0 avg = {d: round(sum(s[d] for s in scores) / len(scores), 2) for d in DIMS} return avg, len(scores) def main(): ap = argparse.ArgumentParser() ap.add_argument("--n", type=int, default=40) ap.add_argument("--notes", default=os.path.join(os.path.dirname(__file__), "messy_notes.jsonl")) ap.add_argument("--out", default=os.path.join(os.path.dirname(__file__), "results_pilot.json")) ap.add_argument("--calib", default=os.path.join(os.path.dirname(__file__), "calib_subset.jsonl")) ap.add_argument("--calib_n", type=int, default=18) args = ap.parse_args() rows = [json.loads(l) for l in open(args.notes) if l.strip()][:args.n] print(f"[load] Lulu 0.5B · n={len(rows)}") model, tok = load_lulu() print("[load] listo") conds = ["no_template", "with_template"] agg = {f"{imp}_{c}": {"preservation": [], **{d: [] for d in DIMS}} for imp in ("lulu", "cloud") for c in conds} calib = [] t0 = time.time() for i, r in enumerate(rows): for c in conds: tmpl = (c == "with_template") lu = improve_lulu(model, tok, r["messy_note"], tmpl) cl = improve_cloud(r["messy_note"], tmpl) for imp, txt in (("lulu", lu), ("cloud", cl)): key = f"{imp}_{c}" agg[key]["preservation"].append(preservation(r["facts"], txt)) js, _ = judges(r["messy_note"], txt) for d in DIMS: if js[d] is not None: agg[key][d].append(js[d]) if i < args.calib_n and c == "no_template": calib.append({"id": r["id"], "original": r["messy_note"], "lulu": lu, "cloud": cl}) print(f" [{i+1}/{len(rows)}] ({time.time()-t0:.0f}s)") def mean(xs): xs = [x for x in xs if x is not None] return round(sum(xs) / len(xs), 3) if xs else None res = {"n": len(rows), "judges": "Qwen3-27b + gpt-oss-120b (Groq, promedio; GPT excluido=mejorador cloud; Gemini rate-limited; Opus ancla la escala vía calib_subset)", "note": "Lulu = baseline OFF-TASK (entrenado para extracción, no reescritura). cloud = GPT-4.1.", "results": {}} for key, d in agg.items(): res["results"][key] = {"preservation_objective": mean(d["preservation"]), **{dim: mean(d[dim]) for dim in DIMS}, "rubric_overall": mean([v for dim in DIMS for v in [mean(d[dim])] if v is not None])} json.dump(res, open(args.out, "w"), indent=2, ensure_ascii=False) with open(args.calib, "w") as f: for c in calib: f.write(json.dumps(c, ensure_ascii=False) + "\n") print("\n===== NOTE-IMPROVER (piloto) =====") print(json.dumps(res, indent=2, ensure_ascii=False)) print(f"\ncalibración Opus -> {args.calib} ({len(calib)} notas)") if __name__ == "__main__": main()