| |
| """Compound causal test: apply ALL fired rubrics' fixes to one program at once. |
| |
| python3 compound_patch.py --decisions data/canon_pr_decisions_lib38.jsonl \ |
| --library data/canon_lib38_frozen.jsonl --out data/canon_compound.json |
| |
| WHY THIS EXISTS. The single-patch experiment (counterfactual.py) asks whether |
| ONE rubric's fix moves the score. That is the right attribution standard for |
| per-rubric precision, but it structurally under-credits two real situations: |
| fixes that compound (each individually below the noise floor, jointly above |
| it) and diagnostic fixes whose value is enabling the NEXT change. This runs |
| the complementary experiment: for each held-out program, one editor pass |
| applies every fix the judge fired on it, then one re-run and one official |
| re-grade. Improvement above the floor means the fired set collectively |
| explains a real part of the gap even where no single member does. |
| |
| Per-program, not per-rubric: a positive here cannot say WHICH rubric earned |
| it. Report alongside, never instead of, the single-patch numbers. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import shutil |
| import sys |
| from pathlib import Path |
|
|
| sys.path.insert(0, str(Path(__file__).resolve().parent)) |
|
|
| import collect as collect_mod |
| import split as split_mod |
| from common import append_jsonl, read_jsonl, write_json |
| from counterfactual import patched_program |
|
|
|
|
| def main() -> int: |
| ap = argparse.ArgumentParser(description=__doc__, |
| formatter_class=argparse.RawDescriptionHelpFormatter) |
| ap.add_argument("--decisions", default="data/canon_pr_decisions_lib38.jsonl") |
| ap.add_argument("--pool", default="data/canon_eval_scored.jsonl") |
| ap.add_argument("--library", default="data/canon_lib38_frozen.jsonl") |
| ap.add_argument("--edit-model", default="claude-opus-5") |
| ap.add_argument("--python", default=".venv/bin/python") |
| ap.add_argument("--timeout", type=int, default=1500) |
| ap.add_argument("--root", default="/tmp/rubric_gen_compound") |
| ap.add_argument("--noise", default="data/noise_floor.json") |
| ap.add_argument("--log", default="data/canon_compound_runs.jsonl") |
| ap.add_argument("--out", default="data/canon_compound.json") |
| ap.add_argument("--data-dir", default="/workspace/edwardosunny/mle-bench/data") |
| args = ap.parse_args() |
|
|
| import os |
| python = os.path.abspath(shutil.which(args.python) or args.python) |
| from mlebench.registry import registry as _registry |
| registry = _registry.set_data_dir(Path(args.data_dir)) |
| sp = split_mod.get() |
|
|
| states = {s["state_id"]: s for s in read_jsonl(args.pool) |
| if (s.get("grading") or {}).get("graded")} |
| for comp in sorted({s["competition"] for s in states.values()}): |
| sp.assert_evaluation_only(comp) |
| library = {r["id"]: r for r in read_jsonl(args.library)} |
|
|
| from eval_precision_recall import JUDGE_VERSION |
| fires_by_state: dict[str, list[dict]] = {} |
| for d in read_jsonl(args.decisions): |
| if (d.get("fires") and d.get("judge_version") == JUDGE_VERSION |
| and d.get("family") == "conceptual" |
| and not d["rubric_id"].startswith("ctrl_") |
| and d["state_id"] in states): |
| cand = library.get(d["rubric_id"].rsplit("__", 1)[-1]) |
| if cand and (cand.get("proposed_patch") or "").strip(): |
| fires_by_state.setdefault(d["state_id"], []).append(cand) |
|
|
| try: |
| floor = json.loads(Path(args.noise).read_text())["global_rel_floor_p95"] |
| except Exception: |
| floor = 0.0154 |
|
|
| done = {r["state_id"] for r in read_jsonl(args.log)} |
| todo = [(sid, cands) for sid, cands in sorted(fires_by_state.items()) |
| if sid not in done] |
| print(f"{len(fires_by_state)} programs with fires; {len(todo)} to run") |
|
|
| for sid, cands in todo: |
| state = states[sid] |
| criterion = (f"The following {len(cands)} issues were all identified " |
| f"in this program:\n" + |
| "\n".join(f"{i+1}. {c['criterion']}" |
| for i, c in enumerate(cands))) |
| patch = ("Apply ALL of the following fixes together:\n" + |
| "\n".join(f"{i+1}. {c['proposed_patch']}" |
| for i, c in enumerate(cands))) |
| source = collect_mod.relocalize_submission(state["code"], state) |
| new_code = patched_program(source, criterion, patch, |
| model=args.edit_model, code_cap=16000) |
| if new_code: |
| new_code = collect_mod.relocalize_submission(new_code, state) |
| row = {"state_id": sid, "competition": state["competition"], |
| "n_fixes": len(cands), |
| "rubric_ids": [c["id"] for c in cands]} |
| if not new_code or new_code.strip() == source.strip(): |
| row.update({"outcome": "edit_failed"}) |
| append_jsonl(args.log, row); print(sid, "edit_failed"); continue |
| workdir = Path(args.root) / state["competition"] / sid[:12] |
| shutil.rmtree(workdir, ignore_errors=True) |
| ex = collect_mod.execute(new_code, workdir, python=python, |
| timeout=args.timeout) |
| row.update({"seconds": ex.get("seconds"), |
| "stderr_tail": (ex.get("stderr") or "")[-1200:]}) |
| if not ex["clean"]: |
| row.update({"outcome": "patched_run_failed", |
| "exception": ex.get("exception_class")}) |
| append_jsonl(args.log, row); print(sid, "run failed"); continue |
| from mlebench.grade import grade_csv |
| try: |
| rep = grade_csv(workdir / "submission.csv", |
| registry.get_competition(state["competition"])) |
| except Exception as exc: |
| row.update({"outcome": "grade_failed", "reason": str(exc)[:120]}) |
| append_jsonl(args.log, row); continue |
| before = state["grading"]["score"] |
| lb = bool(rep.is_lower_better) |
| delta = (before - rep.score) if lb else (rep.score - before) |
| rel = delta / max(abs(before), 1e-9) |
| row.update({"outcome": "measured", "score_before": before, |
| "score_after": rep.score, "rel_improvement": round(rel, 6), |
| "passes": rel > floor}) |
| append_jsonl(args.log, row) |
| print(f"{sid} {state['competition'][:22]} n={len(cands)} " |
| f"{before:.4f}->{rep.score:.4f} rel={rel:+.4f} " |
| f"{'PASS' if row['passes'] else ''}", flush=True) |
|
|
| rows = read_jsonl(args.log) |
| measured = [r for r in rows if r.get("outcome") == "measured"] |
| passed = [r for r in measured if r["passes"]] |
| report = {"programs_with_fires": len(fires_by_state), |
| "measured": len(measured), "improved_above_floor": len(passed), |
| "noise_floor": floor, |
| "per_program": [{k: r.get(k) for k in |
| ("state_id", "competition", "n_fixes", |
| "outcome", "rel_improvement", "passes")} |
| for r in rows], |
| "note": "Compound test: all fired fixes applied at once, one " |
| "re-run, official re-grade. Complements the per-rubric " |
| "single-patch numbers; cannot attribute credit to " |
| "individual rubrics."} |
| write_json(args.out, report) |
| print(json.dumps({k: v for k, v in report.items() if k != "per_program"}, |
| indent=1)) |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
