code/Abforge_Training/scripts/build_release_outputs.py

#!/usr/bin/env python
"""Reorganize ablationbench_200 model results into the HF-release `outputs/` tree.

Layout (sibling to the repo's train/ and eval/):
    outputs/
    leaderboard.csv                         # one row per model: task1 (C score/recall/precision/f) + task2 (design)
    models.csv                              # provenance: display, slug, backend_model, source
    task{1,2}/generations/<slug>.jsonl      # raw model outputs (infer), joined to bench by meta.pdf_url (NO GT)
    task{1,2}/judge_claude-sonnet-4-6/<slug>.jsonl   # structured judge scores+rationale (NO raw blobs, NO GT)

Reads from $WORK_ROOT/infer/. GT lives in eval/ablationbench_200.jsonl (join by pdf_url).
"""
import json, os, csv, glob

WORK = os.environ.get("WORK_ROOT", "/gpfs/radev/scratch/cohan/yz979/xucai/Abforge_Training")
INFER = f"{WORK}/infer"
OUT = f"{WORK}/hf_upload/outputs"
JUDGE = "claude-sonnet-4-6"

# raw file-tag -> (slug, display).  abforge_task{1,2}* collapse to one model per stage.
MAP = {
    "abforge_task1": ("abforge", "ABForge"),           "abforge_task2": ("abforge", "ABForge"),
    "abforge_task1_sft": ("abforge-sft", "ABForge (SFT)"), "abforge_task2_sft": ("abforge-sft", "ABForge (SFT)"),
    "abforge_task1_rl": ("abforge-rl", "ABForge (RL)"),    "abforge_task2_rl": ("abforge-rl", "ABForge (RL)"),
    "gpt5.4_codex": ("gpt-5.4", "GPT-5.4"),
    "gpt5_mini_chatanywhere": ("gpt-5-mini", "GPT-5-mini"),
    "claude_opus_4.6": ("claude-opus-4.6", "Claude Opus 4.6"),
    "claude_sonnet_4.6": ("claude-sonnet-4.6", "Claude Sonnet 4.6"),
    "deepseek-r1-0528": ("deepseek-r1-0528", "DeepSeek-R1-0528"),
    "deepseek-v3.2": ("deepseek-v3.2", "DeepSeek-V3.2"),
    "gemini-3-flash": ("gemini-3-flash", "Gemini 3 Flash"),
    "gemini-3.1-pro-high-anti": ("gemini-3.1-pro", "Gemini 3.1 Pro"),
    "gemma3_12b_openrouter": ("gemma-3-12b", "Gemma 3 12B"),
    "llama4_maverick_openrouter": ("llama-4-maverick", "Llama 4 Maverick"),
    "llama4_scout_groq": ("llama-4-scout", "Llama 4 Scout"),
    "qwen3-30b-a3b": ("qwen3-30b-a3b", "Qwen3-30B-A3B"),
    "qwen3.5_9b_silicon": ("qwen3.5-9b", "Qwen3.5-9B"),
    "qwen3_32b": ("qwen3-32b", "Qwen3-32B"),
    "qwen3_8b_base": ("qwen3-8b", "Qwen3-8B"),
}

# clean model table (no per-call backend ids): slug -> (provider, hf_model for our models)
META = {
    "abforge":     ("ABForge (ours)", "SlowGuess/ABForge-Qwen3-8B-Task1; SlowGuess/ABForge-Qwen3-8B-Task2"),
    "abforge-sft": ("ABForge (ours)", "SlowGuess/ABForge-Qwen3-8B-Task1-SFT; SlowGuess/ABForge-Qwen3-8B-Task2-SFT"),
    "abforge-rl":  ("ABForge (ours)", "SlowGuess/ABForge-Qwen3-8B-Task1-RL; SlowGuess/ABForge-Qwen3-8B-Task2-RL"),
    "gpt-5.4": ("OpenAI", ""), "gpt-5-mini": ("OpenAI", ""),
    "claude-opus-4.6": ("Anthropic", ""), "claude-sonnet-4.6": ("Anthropic", ""),
    "gemini-3-flash": ("Google", ""), "gemini-3.1-pro": ("Google", ""), "gemma-3-12b": ("Google", ""),
    "deepseek-r1-0528": ("DeepSeek", ""), "deepseek-v3.2": ("DeepSeek", ""),
    "llama-4-maverick": ("Meta", ""), "llama-4-scout": ("Meta", ""),
    "qwen3-30b-a3b": ("Alibaba", ""), "qwen3.5-9b": ("Alibaba", ""),
    "qwen3-32b": ("Alibaba", ""), "qwen3-8b": ("Alibaba", ""),
}

def load(p): return [json.loads(l) for l in open(p) if l.strip()] if os.path.isfile(p) else []
def pdf(r): return (r.get("meta") or {}).get("pdf_url", "")
def title(r): return (r.get("meta") or {}).get("title", "")
def backend(r):
    for k in ("codex_model", "cici_model", "bailian_model", "local_model_path"):
        if r.get(k):
            v = r[k]
            return os.path.basename(v.rstrip("/")) if isinstance(v, str) and v.startswith("/") else v
    return ""

def wjsonl(path, rows):
    os.makedirs(os.path.dirname(path), exist_ok=True)
    with open(path, "w", encoding="utf-8") as f:
        for r in rows: f.write(json.dumps(r, ensure_ascii=False) + "\n")

GEN_KEEP_T1 = lambda r, disp: {"pdf_url": pdf(r), "title": title(r), "model": disp, "response": r.get("infer_task1_response", "")}
GEN_KEEP_T2 = lambda r, disp: {"pdf_url": pdf(r), "title": title(r), "model": disp, "response": r.get("infer_task2_response", "")}
JUDGE_T1 = ["n_gt","n_pred","pred_bullets","matches","unmatched_gt","n_matched_full","n_matched_partial",
            "n_matched","weighted_match_sum","match_rate","count_penalty","adjusted_score",
            "pred_scores","bullet_scores","precision","f_score","paper_score"]
JUDGE_T2 = ["num_rubric_items","eval_details","design_score","score_diagnostics"]

board = {}   # slug -> {display, t1:{...}, t2:{...}}
prov  = {}   # slug -> {display, backend, source}

def avg(rows, k):
    v=[r[k] for r in rows if isinstance(r.get(k),(int,float))]
    return round(sum(v)/len(v),4) if v else ""

for task, infer_suf, gen, judge_src_suf, judge_keep, scorekeys in [
    ("task1", "_infer_task1.jsonl", GEN_KEEP_T1, "_prec_task1.jsonl", JUDGE_T1, ("paper_score","adjusted_score","match_rate","precision","f_score")),
    ("task2", "_infer_task2.jsonl", GEN_KEEP_T2, "_eval_v2.jsonl",   JUDGE_T2, ("design_score",)),
]:
    for inf in sorted(glob.glob(f"{INFER}/{task}_*_ablationbench200{infer_suf}")):
        tag = os.path.basename(inf)[len(task)+1:-len("_ablationbench200"+infer_suf)]
        if tag not in MAP:
            print(f"  [skip unmapped] {tag}"); continue
        slug, disp = MAP[tag]
        irows = load(inf)
        # generations
        wjsonl(f"{OUT}/{task}/generations/{slug}.jsonl", [gen(r, disp) for r in irows])
        # judge
        jsrc = load(f"{INFER}/{task}_{tag}_ablationbench200{judge_src_suf}")
        jrows = [{**{"pdf_url": pdf(r)}, **{k: r[k] for k in judge_keep if k in r}} for r in jsrc]
        wjsonl(f"{OUT}/{task}/judge_{JUDGE}/{slug}.jsonl", jrows)
        # leaderboard + provenance
        b = board.setdefault(slug, {"display": disp})
        b[task] = {sk: avg(jsrc, sk) for sk in scorekeys}
        b[task]["n"] = len(jsrc)
        prov.setdefault(slug, {"display": disp, "backend": backend(irows[0]) if irows else "", "source": ""})
        print(f"  {task} {disp:18} gen={len(irows)} judge={len(jsrc)}")

# leaderboard.csv (wide: one row per model)
os.makedirs(OUT, exist_ok=True)
with open(f"{OUT}/leaderboard.csv","w",newline="") as f:
    w=csv.writer(f)
    w.writerow(["model","slug","t1_c_score","t1_adjusted","t1_recall","t1_precision","t1_f_score","t2_design","n"])
    for slug,b in sorted(board.items(), key=lambda kv: -(kv[1].get("task1",{}).get("paper_score") or 0 if isinstance(kv[1].get("task1",{}).get("paper_score"),(int,float)) else 0)):
        t1=b.get("task1",{}); t2=b.get("task2",{})
        w.writerow([b["display"],slug,t1.get("paper_score",""),t1.get("adjusted_score",""),t1.get("match_rate",""),
                    t1.get("precision",""),t1.get("f_score",""),t2.get("design_score",""),
                    t1.get("n",t2.get("n",""))])

with open(f"{OUT}/models.csv","w",newline="") as f:
    w=csv.writer(f); w.writerow(["model","slug","provider","hf_model"])
    for slug,b in sorted(board.items(), key=lambda kv: kv[1]["display"]):
        prov_name, hf = META.get(slug, ("", ""))
        w.writerow([b["display"], slug, prov_name, hf])

print(f"\nDONE -> {OUT}")