| |
| """Score the divergence A/B: unique full-pass solution density per problem, stay-close vs diversify. |
| |
| Input: each arm's run_squeeze_evolve output JSONL (outputs/ab_diversify/<arm>_out.jsonl), records |
| {id, question, candidates:[response,...]}. With loops=2 + update=replace, `candidates` is the FINAL |
| (loop-1) recombination population. We grade every candidate's extracted code on the FULL codeforces |
| system tests (pool test_cases via lcb_exec_harness, cached + timeout-retry), dedup the full-pass set by |
| whitespace-normalized code per problem, and report unique-full-pass / problem (the metric the divergence |
| operator targets) plus raw, dedup ratio, and coverage. Diversify should beat stay-close on unique density. |
| """ |
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import re |
| import sys |
| from concurrent.futures import ThreadPoolExecutor |
| from pathlib import Path |
|
|
| _S = Path(__file__).resolve().parent |
| sys.path.insert(0, str(_S)) |
| from lcb_grading import GradingCache, run_harness_cached |
|
|
| HARNESS = _S / "lcb_exec_harness.py" |
| _CODE = re.compile(r"```(?:python|py)?\s*\n?(.*?)```", re.DOTALL) |
| _LIKE = re.compile(r"\b(def|import|class|for|while|print|input|return)\b|=") |
|
|
|
|
| def extract_code(t): |
| bs = [b.strip() for b in _CODE.findall(t or "")] |
| if bs: |
| for b in reversed(bs): |
| if _LIKE.search(b): |
| return b |
| return bs[-1] |
| return t.strip() if t and _LIKE.search(t) else None |
|
|
|
|
| def _norm(c): |
| return re.sub(r"\s+", " ", c).strip() if c else "" |
|
|
|
|
| def grade_arm(path, pool, cache, workers, tle): |
| recs = [json.loads(l) for l in open(path)] |
| per = {} |
| jobs = [] |
| for r in recs: |
| pid = r["id"] |
| s = pool.get(pid) |
| if not s: |
| continue |
| tj = s if isinstance(s, str) else json.dumps(s) |
| n = len(json.loads(tj)["inputs"]) |
| tl = float(json.loads(tj).get("time_limit", tle)) |
| per[pid] = {"n_cand": 0, "hashes": []} |
| for cand in (r.get("candidates") or []): |
| per[pid]["n_cand"] += 1 |
| jobs.append((pid, extract_code(cand), tj, n, tl)) |
|
|
| def run(j): |
| pid, code, tj, n, tl = j |
| if not code: |
| return pid, None |
| v = run_harness_cached(HARNESS, code, tj, n, tl=tl, cache=cache) |
| return pid, (_norm(code) if (v and v.get("passed")) else None) |
|
|
| with ThreadPoolExecutor(max_workers=workers) as ex: |
| for pid, h in ex.map(run, jobs): |
| if h: |
| per[pid]["hashes"].append(h) |
| return per |
|
|
|
|
| def metrics(per): |
| probs = list(per) |
| n = len(probs) |
| raw = sum(len(per[p]["hashes"]) for p in probs) |
| uniq = sum(len(set(per[p]["hashes"])) for p in probs) |
| cov = sum(1 for p in probs if per[p]["hashes"]) |
| return { |
| "problems": n, |
| "raw_fullpass": raw, |
| "unique_fullpass": uniq, |
| "unique_per_problem": round(uniq / max(1, n), 3), |
| "raw_per_problem": round(raw / max(1, n), 3), |
| "dedup_ratio": round(uniq / max(1, raw), 3), |
| "coverage_problems": cov, |
| "unique_per_solved_problem": round(uniq / max(1, cov), 3), |
| } |
|
|
|
|
| def main() -> int: |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--stayclose", default="outputs/ab_diversify/stayclose_out.jsonl") |
| ap.add_argument("--diversify", default="outputs/ab_diversify/diversify_out.jsonl") |
| ap.add_argument("--canonical", default="outputs/ab_diversify/canonical_out.jsonl") |
| ap.add_argument("--canonical-fb", default="outputs/ab_diversify/canonical_fb_out.jsonl") |
| ap.add_argument("--pool", default="data/openthoughts114k_codeforces_stdin_clean.jsonl") |
| ap.add_argument("--out", default="outputs/ab_diversify/ab_summary.json") |
| ap.add_argument("--workers", type=int, default=64) |
| ap.add_argument("--tle", type=float, default=6.0) |
| a = ap.parse_args() |
|
|
| pool = {} |
| for l in open(a.pool): |
| r = json.loads(l) |
| pool[r["seed_id"]] = r["test_cases"] |
| cache = GradingCache("outputs/grading_cache/ab_diversify.jsonl") |
|
|
| res = {} |
| for arm, path in (("canonical", a.canonical), ("canonical_fb", a.canonical_fb), |
| ("stayclose", a.stayclose), ("diversify", a.diversify)): |
| if not Path(path).exists(): |
| print(f"WARN: {path} missing — skipping {arm}") |
| continue |
| per = grade_arm(path, pool, cache, a.workers, a.tle) |
| res[arm] = metrics(per) |
| print(f"{arm}: {json.dumps(res[arm])}", flush=True) |
|
|
| present = {k: res[k] for k in ("canonical", "canonical_fb", "stayclose", "diversify") if k in res} |
| if len(present) >= 2: |
| res["compare_unique_per_problem"] = {k: v["unique_per_problem"] for k, v in present.items()} |
| res["compare_dedup_ratio"] = {k: v["dedup_ratio"] for k, v in present.items()} |
| res["compare_coverage"] = {k: v["coverage_problems"] for k, v in present.items()} |
|
|
| def _d(x, y): |
| if x in present and y in present: |
| return round(present[x]["unique_per_problem"] - present[y]["unique_per_problem"], 3) |
| return None |
| res["delta_unique_per_problem"] = { |
| "diversify_minus_stayclose": _d("diversify", "stayclose"), |
| "stayclose_minus_canonical_fb": _d("stayclose", "canonical_fb"), |
| "diversify_minus_canonical_fb": _d("diversify", "canonical_fb"), |
| "canonical_fb_minus_canonical": _d("canonical_fb", "canonical"), |
| } |
| Path(a.out).parent.mkdir(parents=True, exist_ok=True) |
| Path(a.out).write_text(json.dumps(res, indent=2)) |
| print(json.dumps(res, indent=2)) |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
