| |
| """Build the two tables the v1.0.0 staging tree was missing: |
| |
| data/enforcement_events.parquet -- Arm C / C' validation attempts, rejections |
| and regenerations, one row per attempt |
| data/adjudication.parquet -- the model-adjudication study as a table |
| |
| Both are derived from experiments/results/FROZEN/ (hash-verified first, the |
| same discipline as build_artifact.py: refuse to build on a mismatch) and from |
| adjudication/{ITEMS_blinded,VERDICTS,KEY}.jsonl. |
| |
| Deterministic: rows are sorted by a stable key, so a rebuild is byte-identical. |
| """ |
| import json, os, sys, hashlib |
| import pandas as pd |
|
|
| HERE = os.path.dirname(os.path.abspath(__file__)) |
| ART = os.path.dirname(HERE) |
| PROJ = os.path.dirname(ART) |
| FROZEN = os.path.join(PROJ, "experiments", "results", "FROZEN") |
|
|
|
|
| def sha256_file(p): |
| h = hashlib.sha256() |
| with open(p, "rb") as f: |
| for b in iter(lambda: f.read(1 << 20), b""): |
| h.update(b) |
| return h.hexdigest() |
|
|
|
|
| def verify_frozen(): |
| man = json.load(open(os.path.join(FROZEN, "MANIFEST.json"))) |
| bad = [] |
| for fn, meta in man["files"].items(): |
| got = sha256_file(os.path.join(FROZEN, fn)) |
| print(f" {fn:22s} {'OK' if got == meta['sha256'] else 'MISMATCH'}") |
| if got != meta["sha256"]: |
| bad.append(fn) |
| if bad: |
| sys.exit(f"FROZEN hash mismatch in {bad}; refusing to build") |
| return man |
|
|
|
|
| def load_rows(): |
| rows = [] |
| for fn in ("campaign_v2", "actor3", "armCp"): |
| with open(os.path.join(FROZEN, f"{fn}.jsonl")) as f: |
| for line in f: |
| rows.append(json.loads(line)) |
| return rows |
|
|
|
|
| def actor(r): |
| return r["actor_model"].split("/")[-1] |
|
|
|
|
| |
| def build_enforcement(rows): |
| out = [] |
| for r in rows: |
| tkey = f"{r['problem_uid']}|{r['arm']}|{actor(r)}" |
| for i, e in enumerate(r.get("regeneration_events") or []): |
| vr = e.get("validation_result") or {} |
| ok = bool(vr.get("ok", True)) |
| viol = vr.get("violated_constraint") |
| if viol is None: |
| viol = e.get("violated_constraint") |
| allv = vr.get("all_violations") or [] |
| out.append(dict( |
| trajectory_key=tkey, |
| problem_uid=r["problem_uid"], |
| arm=r["arm"], |
| actor_model=actor(r), |
| event_index=i, |
| role=e.get("role"), |
| outer_round=e.get("outer_round"), |
| inner_round=e.get("inner_round"), |
| attempt_index=e.get("attempt_index"), |
| validation_ok=ok, |
| was_rejected=(not ok), |
| was_regenerated=bool(e.get("regenerated", False)), |
| violated_constraint=viol, |
| validation_detail=vr.get("detail"), |
| n_violations=len(allv), |
| all_violations=json.dumps(allv) if allv else None, |
| soft_signals=json.dumps(vr.get("soft_signals") or []) or None, |
| rejected_output_truncated_2000chars=e.get("raw_output_truncated_2000chars"), |
| finish_reason=e.get("finish_reason"), |
| used_reasoning_fallback=bool(e.get("used_reasoning_fallback", False)), |
| latency_s=e.get("latency_s"), |
| prompt_sha256_12=e.get("prompt_sha256_12"), |
| prompt_chars=e.get("prompt_chars"), |
| timestamp=e.get("timestamp"), |
| )) |
| df = pd.DataFrame(out).sort_values( |
| ["trajectory_key", "event_index"], kind="mergesort").reset_index(drop=True) |
| return df |
|
|
|
|
| |
| def build_adjudication(): |
| adj = os.path.join(ART, "adjudication") |
| items = {} |
| with open(os.path.join(adj, "ITEMS_blinded.jsonl")) as f: |
| for line in f: |
| d = json.loads(line) |
| items[d["tid"]] = d |
| key = {} |
| with open(os.path.join(adj, "KEY.jsonl")) as f: |
| for line in f: |
| d = json.loads(line) |
| key[d["tid"]] = d |
|
|
| out = [] |
| with open(os.path.join(adj, "VERDICTS.jsonl")) as f: |
| for line in f: |
| v = json.loads(line) |
| tid = v["tid"] |
| k = key.get(tid, {}) |
| p = v.get("parsed") or {} |
| q = {f"q{i}": p.get(f"Q{i}") for i in range(1, 6)} |
| |
| out.append(dict( |
| item_id=tid, |
| repetition_index=v.get("rep"), |
| judge_model=v.get("model"), |
| judge_temperature=v.get("temperature"), |
| rubric_version="RUBRIC_v1", |
| rubric_sha256_12=v.get("rubric_sha"), |
| prompt_sha256_12=v.get("prompt_sha"), |
| judged_at_utc=v.get("utc"), |
| raw_judge_output=v.get("raw"), |
| judge_error=v.get("error"), |
| parse_ok=bool(p), |
| q1_semantic_redundancy=q["q1"], |
| q2_functional_redundancy=q["q2"], |
| q3_new_information=q["q3"], |
| q4_answer_influence=q["q4"], |
| q5_division_of_labour_present=q["q5"], |
| judge_reason=p.get("reason"), |
| |
| problem_uid=k.get("problem_uid"), |
| arm=k.get("arm"), |
| actor_model=k.get("actor"), |
| run_id=k.get("run_id"), |
| config_version=k.get("config_version"), |
| trajectory_correct=k.get("correct"), |
| automated_collapse_label=k.get("auto_collapse"), |
| trajectory_key=( |
| f"{k['problem_uid']}|{k['arm']}|{k['actor']}" |
| if k.get("problem_uid") and k.get("arm") and k.get("actor") |
| else None), |
| )) |
| df = pd.DataFrame(out).sort_values( |
| ["item_id", "repetition_index"], kind="mergesort").reset_index(drop=True) |
| return df |
|
|
|
|
| def main(): |
| print("verifying FROZEN snapshot before deriving anything") |
| verify_frozen() |
| rows = load_rows() |
| print(f" loaded {len(rows)} trajectories") |
|
|
| enf = build_enforcement(rows) |
| adj = build_adjudication() |
|
|
| os.makedirs(os.path.join(ART, "data"), exist_ok=True) |
| p1 = os.path.join(ART, "data", "enforcement_events.parquet") |
| p2 = os.path.join(ART, "data", "adjudication.parquet") |
| enf.to_parquet(p1, index=False, compression="snappy") |
| adj.to_parquet(p2, index=False, compression="snappy") |
|
|
| print(f"\nenforcement_events.parquet {enf.shape[0]:>7} rows, {enf.shape[1]} cols") |
| print(" by arm:", enf.arm.value_counts().to_dict()) |
| print(" rejections (validation_ok=False):", int((~enf.validation_ok).sum())) |
| print(f"adjudication.parquet {adj.shape[0]:>7} rows, {adj.shape[1]} cols") |
| print(" distinct items:", adj.item_id.nunique(), |
| "| reps:", sorted(adj.repetition_index.dropna().unique().tolist()), |
| "| judge:", adj.judge_model.dropna().unique().tolist()) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
