| """Build the Hugging Face dataset folder and the Space's data file from the recorded runs. |
| |
| python scripts/figures.py && python scripts/export.py |
| |
| The clean run (runs/day2) is the result; the earlier runs (day1, day1b, day1c) are the pilot and are published |
| separately. Writes: |
| hf/dataset/episodes.jsonl every clean-run episode (reasoning trimmed to 2,000 characters per step) |
| hf/dataset/pilot_episodes.jsonl the pilot runs, before the harness fixes |
| hf/dataset/verdicts.json the learnability checks and verdict per task suite |
| hf/dataset/census/ the Hub census (both passes) and Beam-written community setups |
| hf/dataset/fixes/ Beam's diagnosis, reasoning and patch for each fixed environment |
| hf/space/data.json what the Space shows (numbers from hf/numbers.json) |
| """ |
|
|
| import base64 |
| import json |
| import shutil |
| import sys |
| from collections import defaultdict |
| from pathlib import Path |
|
|
| sys.path.insert(0, str(Path(__file__).resolve().parent.parent)) |
| from shortlist.checks import check_suite, harness_error, score, suite_config |
| from shortlist.serve import ROOT |
|
|
| HF = ROOT / "hf" |
|
|
|
|
| def load(runs: list[Path]) -> dict[str, list[dict]]: |
| pooled: dict[str, list[dict]] = defaultdict(list) |
| for run in runs: |
| for path in sorted(run.glob("*.jsonl")): |
| for line in path.read_text().splitlines(): |
| if line.strip(): |
| r = json.loads(line) |
| r["run"] = run.name |
| pooled[path.stem].append(r) |
| return pooled |
|
|
|
|
| def trim(r: dict) -> dict: |
| r = dict(r) |
| r.pop("traceback", None) |
| steps = [] |
| for s in r.get("steps", []): |
| s = dict(s) |
| if "beam" in s: |
| b = dict(s["beam"]) |
| if b.get("reasoning"): |
| b["reasoning"] = b["reasoning"][:2000] |
| s["beam"] = b |
| steps.append(s) |
| r["steps"] = steps |
| return r |
|
|
|
|
| def connect4_story(numbers: dict) -> dict: |
| reply = (ROOT / "runs/fixes/connect4_env.beam-reply.md").read_text() |
| return {"env": "connect4_env", "as_shipped": numbers["connect4"]["as_shipped"], |
| "with_beams_fix": numbers["connect4"]["with_beams_fix"], "diagnosis": reply.split("### FILE:")[0].strip()} |
|
|
|
|
| def dipg_story(pooled: dict[str, list[dict]]) -> dict | None: |
| """How often Beam's answer clears DIPG's format gate under each marker style.""" |
| variants = [("dipg_safety_env", "Harmony markers (default)", "<|channel|>analysis<|message|> … <|end|>"), |
| ("dipg_safety_env-plain", "Angle-bracket markers", "<analysis> … <end>"), |
| ("dipg_safety_env-brackets", "Square-bracket markers", "[analysis] … [end]")] |
| out = [] |
| for suite, label, example in variants: |
| rows = [r for r in pooled.get(suite, []) if r["policy"].startswith("beam") and not r.get("error")] |
| if rows: |
| passed = sum(r["return"] > -10 for r in rows) |
| out.append({"suite": suite, "label": label, "example": example, "passed": passed, "answers": len(rows)}) |
| return {"variants": out} if out else None |
|
|
|
|
| def rail(v: dict, rows: list[dict]) -> dict: |
| """Place each rung's mean score on one axis: 0 = the worst episode seen, 1 = the best possible (or best episode seen).""" |
| tiers = v["tiers"] |
| scores = [score(r) for r in rows if not r.get("error")] or [0.0] |
| cfg = suite_config(v["suite"]) |
| cfg_top = cfg.max_score if cfg and not v.get("declared_max_wrong") else None |
| hi = cfg_top if cfg_top is not None else max(scores) |
| lo = min(scores) |
| if hi - lo < 1e-9: |
| if cfg_top is not None and not cfg.setup_by: |
| lo = hi - 1.0 |
| else: |
| cfg_top = None |
| span = (hi - lo) or 1.0 |
| order = ["null", "random", "small", "beam-low", "beam-medium", "beam-high", "beam-xhigh", "beam-max"] |
| return {"rungs": [{"policy": p, "x": round((tiers[p]["mean"] - lo) / span, 4), "mean": tiers[p]["mean"], |
| "solved": tiers[p].get("pass@1"), "grpo": tiers[p].get("grpo_signal"), "n": tiers[p]["episodes"]} |
| for p in order if p in tiers], |
| "top_known": cfg_top is not None} |
|
|
|
|
| def pelicans(rows: list[dict]) -> list[dict]: |
| out = [] |
| for r in rows: |
| if not r["policy"].startswith("beam") or not r.get("steps"): |
| continue |
| raw = (r["steps"][0].get("action") or {}).get("response", "") |
| start, end = raw.find("<svg"), raw.rfind("</svg>") |
| if start < 0 or end < 0: |
| continue |
| svg = raw[start:end + len("</svg>")] |
| head = svg[:svg.find(">") + 1] |
| if "xmlns=" not in head: |
| svg = svg.replace("<svg", '<svg xmlns="http://www.w3.org/2000/svg"', 1) |
| fo = r.get("final_observation", {}) |
| out.append({"svg_b64": base64.b64encode(svg.encode()).decode(), "reward": r["return"], |
| "structure": fo.get("structure_score"), "judged": fo.get("judged"), "policy": r["policy"]}) |
| return out |
|
|
|
|
| def main() -> None: |
| clean = load([ROOT / "runs" / "day2"]) |
| clean = {k: [r for r in v if not harness_error(r)] for k, v in clean.items()} |
| pilot = load([ROOT / "runs" / d for d in ("day1", "day1b", "day1c")]) |
| numbers = json.loads((HF / "numbers.json").read_text()) |
| verdicts = [check_suite(s, rows) for s, rows in sorted(clean.items()) if rows] |
| gaming = {g["suite"]: g for g in json.loads((HF / "gaming.json").read_text())} if (HF / "gaming.json").exists() else {} |
| for x in verdicts: |
| g = gaming.get(x["suite"]) |
| if g: |
| b = g["best"] |
| x["checks"]["statistical.adversarial_floor"] = { |
| "pass": not g["gameable"], "strategy": b["strategy"], "label": b["label"], "answer": b["answer"], "score": b["score"], |
| "learner_mean": g["learner_mean"], "added_after_training": True} |
| x["gameable"] = g["gameable"] |
| for d in ("fixes", "census", "census/setups"): |
| (HF / "dataset" / d).mkdir(parents=True, exist_ok=True) |
| (HF / "space").mkdir(parents=True, exist_ok=True) |
|
|
| for name, pooled in (("episodes.jsonl", clean), ("pilot_episodes.jsonl", pilot)): |
| with (HF / "dataset" / name).open("w") as f: |
| for suite, rows in sorted(pooled.items()): |
| for r in rows: |
| f.write(json.dumps(trim(r), default=str) + "\n") |
| (HF / "dataset" / "verdicts.json").write_text(json.dumps(verdicts, indent=2)) |
| for p in (ROOT / "runs" / "fixes").glob("*.*"): |
| if p.is_file(): |
| shutil.copy(p, HF / "dataset" / "fixes" / p.name) |
| for p in ("census.jsonl", "census2.jsonl", "chosen.json"): |
| if (ROOT / "runs" / "hub" / "sweep" / p).exists(): |
| shutil.copy(ROOT / "runs" / "hub" / "sweep" / p, HF / "dataset" / "census" / p) |
| for p in (ROOT / "runs" / "hub" / "setups").glob("*.json"): |
| shutil.copy(p, HF / "dataset" / "census" / "setups" / p.name) |
|
|
| shown = [x for x in verdicts if not x["suite"].startswith("dipg_safety_env-")] |
| training = json.loads((ROOT / "training" / "kaggle" / "analysis.json").read_text()) |
| maze_dir = ROOT / "training" / "maze" |
| forward = None |
| if (maze_dir / "predictions.json").exists(): |
| pred = json.loads((maze_dir / "predictions.json").read_text()) |
| forward = {"family": "maze", "written_at": pred["written_at"], "claims": pred["predictions"][0]["claims"], |
| "evidence": pred["predictions"][0]["evidence_before_training"], |
| "sha256": (maze_dir / "predictions.sha256").read_text().split()[0], |
| "result": json.loads((maze_dir / "results" / "analysis.json").read_text()) if (maze_dir / "results" / "analysis.json").exists() else None} |
| data = { |
| "numbers": {k: numbers[k] for k in ("environments", "task_suites", "community_environments", "episodes", |
| "beam_episodes", "small_episodes", "beam_output_tokens", "suites_played_by")}, |
| "verdicts": [{**{k: v for k, v in x.items() if k != "error_examples"}, "rail": rail(x, clean[x["suite"]])} for x in shown], |
| "connect4": connect4_story(numbers), "dipg": numbers["dipg"], "effort": numbers["effort_ladder"], "effort_summary": numbers["effort_summary"], |
| "census": numbers["census"], "training": training, "forward_test": forward, |
| "pelicans": pelicans(clean.get("pelican_svg_env", [])), |
| "links": {"dataset": "https://huggingface.co/datasets/JagritGumber/shortlist", |
| "code": "https://huggingface.co/datasets/JagritGumber/shortlist/tree/main/code", |
| "patch": "https://huggingface.co/datasets/JagritGumber/shortlist/blob/main/fixes/connect4_env.patch", |
| "training": "https://huggingface.co/datasets/JagritGumber/shortlist/blob/main/training/RESULTS.md", |
| "rfc": "https://github.com/openenv/OpenEnv/blob/main/rfcs/008-environment-auto-validation.md"}, |
| } |
| (HF / "space" / "data.json").write_text(json.dumps(data, indent=1, default=str)) |
| print(json.dumps(data["numbers"]), f"\nverdicts: {len(shown)} pelicans: {len(data['pelicans'])} training rows: {len(training['rows'])}") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
