athenea-eval / 06-note-improver /eval_note_improver.py
derebellon's picture
Athenea evaluation suite — scripts, datasets, results per component
55a1b1a verified
Raw History Blame Contribute Delete
9.08 kB
#!/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("<secrets>/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()