Download 06-note-improver/eval_note_improver.py from derebellon/athenea-eval: direct link, hf CLI and curl.
- Browser
- Download file 9.08 kB
-
https://huggingface.co/datasets/derebellon/athenea-eval/resolve/main/06-note-improver/eval_note_improver.py
- Command line
-
hf download hf://datasets/derebellon/athenea-eval/06-note-improver/eval_note_improver.py
-
curl -L -o eval_note_improver.py https://huggingface.co/datasets/derebellon/athenea-eval/resolve/main/06-note-improver/eval_note_improver.py
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() | |