Add the can-it-be-gamed check, the maze forward test notebook, license, and wording fixes
2c7f145 verified | """Every number that appears in the post, the Space and the README, computed from the recorded data. | |
| python scripts/figures.py # writes hf/numbers.json and prints it | |
| Nothing in the write-up is typed by hand: it is read from this file. Episodes our own harness failed on | |
| (model-server timeouts, API connection drops) are excluded everywhere, as they are in the verdicts. | |
| """ | |
| from __future__ import annotations | |
| import importlib.util | |
| import json | |
| import sys | |
| from collections import Counter, defaultdict | |
| from pathlib import Path | |
| ROOT = Path(__file__).resolve().parent.parent | |
| sys.path.insert(0, str(ROOT)) | |
| from shortlist.checks import check_suite, harness_error # noqa: E402 | |
| RUN = ROOT / "runs" / "day2" # the clean run with the fixed harness (and later passes into it) | |
| PILOT_DIPG = ROOT / "runs" / "day1c" # the DIPG marker experiment | |
| EXPERIMENTS = ("dipg_safety_env-plain", "dipg_safety_env-brackets") # reported inside the DIPG finding, not as suites | |
| PLAYERS = ["null", "random", "small", "beam-low", "beam-medium", "beam-high", "beam-max"] | |
| def load(run: Path) -> dict[str, list[dict]]: | |
| out = {} | |
| for path in sorted(run.glob("*.jsonl")): | |
| out[path.stem] = [r for r in (json.loads(l) for l in path.read_text().splitlines() if l.strip()) if not harness_error(r)] | |
| return out | |
| def census() -> dict: | |
| spec = importlib.util.spec_from_file_location("hub_sweep", ROOT / "scripts" / "hub_sweep.py") | |
| hs = importlib.util.module_from_spec(spec) | |
| spec.loader.exec_module(hs) | |
| rows = hs.merged(ROOT / "runs" / "hub" / "sweep") | |
| label = {"passes floor checks": "runs and passes the floor checks", | |
| "suspicious floor": "scores above zero for doing nothing", | |
| "no standard API": "running, but no standard OpenEnv API", | |
| "broken": "broken (build or runtime error on the Hub)", | |
| "paused by owner": "paused by its owner", | |
| "asleep, didn't wake": "asleep, no answer within 10 minutes", | |
| "doesn't start": "not yet re-checked (first pass: no answer within 150 s)", | |
| "crashes": "crashes on reset or step", | |
| "refuses a session": "refuses a session"} | |
| counts = Counter(r["class"] for r in rows) | |
| n = len(rows) | |
| groups = [{"group": label.get(k, k), "count": v, "share": round(v / n, 3)} for k, v in counts.most_common()] | |
| floors = [] | |
| for r in rows: | |
| if r["class"] == "suspicious floor": | |
| null = next((f["return"] for f in r.get("floor", []) if f["policy"] == "null"), None) | |
| floors.append({"space": r["id"], "do_nothing_score": null}) | |
| floors.sort(key=lambda x: -(x["do_nothing_score"] or 0)) | |
| rechecked = (ROOT / "runs" / "hub" / "sweep" / "census2.jsonl") | |
| return {"spaces": n, "groups": groups, "sum_of_shares": round(sum(g["share"] for g in groups), 3), | |
| "do_nothing_highest": floors[:5], | |
| "do_nothing_at_least_1": sum(1 for f in floors if (f["do_nothing_score"] or 0) >= 1), | |
| "second_pass_done": len(rechecked.read_text().splitlines()) if rechecked.exists() else 0} | |
| def adversarial_floor() -> dict | None: | |
| """The can-it-be-gamed check (shortlist/gaming.py) over the small model's families.""" | |
| path = ROOT / "hf" / "gaming.json" | |
| if not path.exists(): | |
| return None | |
| g = json.loads(path.read_text()) | |
| return {"families": len(g), "gameable": sum(x["gameable"] for x in g), | |
| "flagged": [{"suite": x["suite"], "strategy": x["best"]["strategy"], "label": x["best"]["label"], "answer": x["best"]["answer"], | |
| "score": x["best"]["score"], "learner_mean": x["learner_mean"]} for x in g if x["gameable"]]} | |
| def main() -> None: | |
| data = load(RUN) | |
| verdicts = {s: check_suite(s, rows) for s, rows in data.items() if rows} | |
| shown = {s: v for s, v in verdicts.items() if s not in EXPERIMENTS} | |
| rows_shown = [r for s, rows in data.items() if s not in EXPERIMENTS for r in rows] | |
| played = {p: sum(1 for s in shown if any(r["policy"] == p and not r.get("error") for r in data[s])) for p in PLAYERS} | |
| by_group: dict[str, Counter] = defaultdict(Counter) | |
| for v in shown.values(): | |
| key = v.get("judged_for") or "floor players" | |
| by_group[v.get("group", "?")][key + (" (provisional)" if v.get("provisional") else "")] += 1 | |
| def wins(suite): | |
| out = {} | |
| for p in ("null", "random", "beam-low"): | |
| rs = [r for r in data.get(suite, []) if r["policy"] == p and not r.get("error")] | |
| if rs: | |
| out[p] = {"won": sum(r["return"] >= 1 for r in rs), "games": len(rs)} | |
| return out | |
| def gate(rows): | |
| rs = [r for r in rows if r["policy"].startswith("beam") and not r.get("error")] | |
| return {"cleared_format_gate": sum(r["return"] > -10 for r in rs), "answers": len(rs), | |
| "fully_correct": sum(r["return"] >= 10 for r in rs), | |
| "mean_score": round(sum(r["return"] for r in rs) / max(1, len(rs)), 2)} | |
| pilot = load(PILOT_DIPG) if PILOT_DIPG.exists() else {} | |
| small_vs_beam = [] | |
| for s, v in sorted(shown.items()): | |
| t = v["tiers"] | |
| if "small" in t and "beam-low" in t: | |
| small_vs_beam.append({"suite": s, "beam_low_solved": t["beam-low"].get("pass@1"), | |
| "small_solved": t["small"].get("pass@1"), "small_mean": round(t["small"]["mean"], 3), | |
| "small_grpo_signal": t["small"].get("grpo_signal"), "verdict": v["verdict"]}) | |
| effort = [] | |
| for s, v in sorted(shown.items()): | |
| t = v["tiers"] | |
| rungs = {p: {"solved": t[p].get("pass@1"), "mean": round(t[p]["mean"], 3), "episodes": t[p]["episodes"]} | |
| for p in PLAYERS if p.startswith("beam") and p in t} | |
| if len(rungs) > 1: | |
| effort.append({"suite": s, "rungs": rungs}) | |
| # Low effort against the highest effort tried, by share solved on the first try. | |
| pairs = [(e["rungs"]["beam-low"]["solved"], list(e["rungs"].values())[-1]["solved"]) for e in effort | |
| if "beam-low" in e["rungs"] and e["rungs"]["beam-low"]["solved"] is not None] | |
| effort_summary = {"suites": len(effort), "compared": len(pairs), | |
| "higher_solved_more": sum(hi > lo + 1e-9 for lo, hi in pairs), | |
| "same": sum(abs(hi - lo) <= 1e-9 for lo, hi in pairs), | |
| "higher_solved_less": sum(hi < lo - 1e-9 for lo, hi in pairs)} | |
| training = {} | |
| tdir = ROOT / "training" / "kaggle" / "results" | |
| if (tdir / "results.json").exists(): | |
| res = json.loads((tdir / "results.json").read_text()) | |
| training = {"families": len(res), "held": sum(r["held"] for r in res), | |
| "rows": [{k: r[k] for k in ("family", "prediction", "shortlist_verdict", "improved", "held")} | | |
| {"before": r["before"]["mean_score"], "after": r["after"]["mean_score"], "p": r["gain"]["p"]} for r in res]} | |
| out = { | |
| "environments": len({v["env"] for v in shown.values()}), | |
| "task_suites": len(shown), | |
| "community_environments": sum(1 for s in shown if s.startswith("hub-")), | |
| "episodes": len(rows_shown), | |
| "beam_episodes": sum(1 for r in rows_shown if r["policy"].startswith("beam")), | |
| "small_episodes": sum(1 for r in rows_shown if r["policy"] == "small"), | |
| "beam_output_tokens": sum(r["tokens"]["completion"] for r in rows_shown if r["policy"].startswith("beam")), | |
| "suites_played_by": played, | |
| "verdict_groups": {g: dict(c) for g, c in sorted(by_group.items())}, | |
| "connect4": {"as_shipped": wins("connect4_env"), "with_beams_fix": wins("connect4_env-patched")}, | |
| "dipg": {"default_markers": gate(data.get("dipg_safety_env", [])), | |
| "square_brackets": gate(data.get("dipg_safety_env-brackets", [])), | |
| "pilot": {k: gate(v) for k, v in pilot.items() if k.startswith("dipg")}}, | |
| "small_vs_beam": small_vs_beam, | |
| "effort_ladder": effort, | |
| "effort_summary": effort_summary, | |
| "adversarial_floor": adversarial_floor(), | |
| "census": census(), | |
| "training": training, | |
| } | |
| (ROOT / "hf").mkdir(exist_ok=True) | |
| (ROOT / "hf" / "numbers.json").write_text(json.dumps(out, indent=2)) | |
| print(json.dumps(out, indent=1)) | |
| if __name__ == "__main__": | |
| main() | |