| """Write the dataset card (hf/dataset/README.md) and the Space's README from the exported results. |
| |
| python scripts/figures.py && python scripts/export.py && python scripts/card.py |
| |
| Every number in the card comes from hf/numbers.json, hf/space/data.json or training/kaggle/analysis.json. |
| """ |
|
|
| import json |
| from pathlib import Path |
|
|
| ROOT = Path(__file__).resolve().parent.parent |
| HF = ROOT / "hf" |
| DATASET_URL = "https://huggingface.co/datasets/JagritGumber/shortlist" |
| SPACE_URL = "https://huggingface.co/spaces/JagritGumber/shortlist" |
| RFC_URL = "https://github.com/openenv/OpenEnv/blob/main/rfcs/008-environment-auto-validation.md" |
| OPENENV_COMMIT = "739b44b525d174700c11c328618a5ba41d5f428f" |
|
|
| NAMES = {"connect4_env": "Connect 4", "connect4_env-patched": "Connect 4, with Beam's fix", "chess_env": "Chess", |
| "maze_env": "Maze (`maze_env`)", "fraud_triage_env": "Fraud triage", "wildfire_env": "Wildfire", "snake_env": "Snake", |
| "grid_world_env": "Grid world", "pelican_svg_env": "Pelican on a bicycle (SVG)", |
| "dipg_safety_env": "DIPG medical safety", "sophistry_bench_sprint_env": "Sophistry bench"} |
| OPENSPIEL = {"tic_tac_toe": "Tic-tac-toe", "kuhn_poker": "Kuhn poker", "cliff_walking": "Cliff walking"} |
| GROUPS = [("worth", "Worth training on"), ("hard", "Too hard for the small model now"), ("nograd", "No gradient"), |
| ("easy", "Too easy for Beam"), ("unsure", "Skill doesn't show yet"), ("weak", "Weak signal"), |
| ("reach", "Out of reach for Beam"), ("flat", "Flat reward"), ("incomplete", "Couldn't be judged")] |
| LEARNED = {"skill and format": "Partly skill, partly format", "mostly format": "Mostly format", "gamed": "Gamed the grader", |
| "no real gain": "No real gain", "no change": "No change"} |
| AUDIT = {"learned_skill": "learned the skill", "learned_format": "learned the format", "gamed_grader": "gamed the grader", |
| "no_change": "no change"} |
| EFFORT = {"beam-low": "low", "beam-medium": "medium", "beam-high": "high", "beam-xhigh": "extra-high", "beam-max": "max"} |
|
|
|
|
| def name(suite: str) -> str: |
| if suite.startswith("rg-"): |
| return suite[3:].replace("_", " ").capitalize() |
| if suite.startswith("os-"): |
| return OPENSPIEL.get(suite[3:], suite[3:].replace("_", " ").capitalize()) |
| if suite.startswith("hub-"): |
| return f"`{suite[4:].replace('__', '/')}` (Hub)" |
| return NAMES.get(suite, suite) |
|
|
|
|
| def pct(x: float | None) -> str: |
| return "–" if x is None else f"{x * 100:.0f}%" |
|
|
|
|
| def pct1(x: float | None) -> str: |
| return "–" if x is None else f"{x * 100:g}%" |
|
|
|
|
| def pval(p: float) -> str: |
| return "<0.001" if p < 0.001 else f"{p:.3f}" |
|
|
|
|
| def verdict_tables(verdicts: list[dict]) -> str: |
| out = [] |
| parts = [("For the small model (Qwen3-0.6B)", [v for v in verdicts if v["group"] != "broken" and v.get("judged_for") == "small model"]), |
| ("For Beam (no small model played these)", [v for v in verdicts if v["group"] != "broken" and v.get("judged_for") != "small model"])] |
| for title, items in parts: |
| out.append(f"**{title}**\n\n| Verdict | Count | Environments |\n|---|---|---|") |
| for key, label in GROUPS: |
| rows = [v for v in items if v["group"] == key] |
| if rows: |
| envs = ", ".join(name(v["suite"]) + (" *" if v.get("provisional") else "") + (" †" if v.get("gameable") else "") |
| for v in rows) |
| out.append(f"| {label} | {len(rows)} | {envs} |") |
| out.append("") |
| broken = [v for v in verdicts if v["group"] == "broken"] |
| out.append(f"**Broken as shipped** ({len(broken)}): " + "; ".join(f"{name(v['suite'])}: {v['verdict'].split(': ', 1)[-1]}" for v in broken) + ".") |
| out.append("\n\\* provisional: fewer than 4 tasks, so a first pass rather than a final call. " |
| "† can be gamed: a no-skill answer pays more than the small model earns now (see below; added after training).") |
| return "\n".join(out) |
|
|
|
|
| def training_table(t: dict) -> str: |
| rows = ["| Family | Predicted | Mean reward before → after (p) | Accuracy before → after | What the model learned | Beam's blind audit |", |
| "|---|---|---|---|---|---|"] |
| for r in t["rows"]: |
| pred = ("reward rises" if r["prediction"] == "improves" else r["prediction"]) + (" ✓" if r["held"] else " ✗") |
| learned = r["learned_text"].split(": ", 1)[-1] if r["learned_text"].startswith(("Partly", "Mostly")) else r["learned_text"] |
| rows.append(f"| {r['family']} | {pred} | {r['reward_before']:.3f} → {r['reward_after']:.3f} ({pval(r['p'])}) | " |
| f"{pct1(r['accuracy_before'])} → {pct1(r['accuracy_after'])} | **{LEARNED[r['learned']]}.** {learned[0].upper() + learned[1:]} | " |
| f"{AUDIT.get(r['beam_audit'], r['beam_audit'])} |") |
| return "\n".join(rows) |
|
|
|
|
| def effort_table(effort: list[dict]) -> str: |
| rows = ["| Task suite | Share solved on the first try, by effort |", "|---|---|"] |
| names = [name(e["suite"]) for e in effort] |
| for e in effort: |
| label = name(e["suite"]) + (" (Reasoning Gym)" if e["suite"].startswith("rg-") and names.count(name(e["suite"])) > 1 else "") |
| rows.append(f"| {label} | " + " · ".join(f"{EFFORT[p]} {pct(r['solved'])}" for p, r in e["rungs"].items()) + " |") |
| return "\n".join(rows) |
|
|
|
|
| def gaming_table(gaming: list[dict]) -> str: |
| rows = ["| Family | Best no-skill answer | Its score (200 held-out tasks) | Small model now | Can be gamed |", "|---|---|---|---|---|"] |
| for g in sorted(gaming, key=lambda x: -x["best"]["score"]): |
| rows.append(f"| {g['family']} | {g['best']['label']} | {g['best']['score']:.3f} | {g['learner_mean']:.3f} | " |
| f"{'**yes**' if g['gameable'] else 'no'} |") |
| return "\n".join(rows) |
|
|
|
|
| def forward_section(f: dict | None) -> str: |
| if not f: |
| return "" |
| g, ev = f["evidence"]["gaming_check"], f["evidence"] |
| top = list(g["most_common_correct_answers_on_training_tasks"].items()) |
| res = {c["id"]: c for c in (f["result"] or {}).get("claims", [])} |
| lines = [f"The check flags maze. On the {g['training_tasks']} training tasks the most common correct answers are " |
| f"\"{top[0][0]}\" ({top[0][1]} tasks) and \"{top[1][0]}\" ({top[1][1]}), and answering \"{g['constant_answer']}\" to every " |
| f"held-out task scores {g['its_held_out_score']:.3f}, while the small model earns " |
| f"{ev['small_model_mean_reward_on_ladder']:.3f}. So before any maze training we published four claims " |
| f"(`training/maze/predictions.json`, {f['written_at']}, SHA-256 `{f['sha256']}`). The method is unchanged.", "", |
| "| Claim | Test | Result |", "|---|---|---|"] |
| for c in f["claims"]: |
| r = res.get(c["id"]) |
| status = ("**held**" if r["held"] else "**failed**") + f": {r['measured']}" if r else "pending" |
| lines.append(f"| {c['id']}. {c['claim']} | {c['test']} | {status} |") |
| r = f["result"] |
| if r: |
| held = sum(c["held"] for c in r["claims"]) |
| lines += ["", f"**{held} of {len(r['claims'])} claims held.** The model collapsed ({r['collapsed_share']:.0%} of its answers are one " |
| f"text) and learned no maze-solving ({r['exact_before']} exact answers before training, {r['exact_after']} after), but " |
| f"not onto \"5\". It found a different route, one the check didn't try: maze's grader (Reasoning Gym's default " |
| f"`score_answer`) pays `len(answer) / len(reply)` whenever the right answer appears anywhere in the reply, so the " |
| f"model writes a grid of the numbers {r['collapsed_answer_numbers']}. That grid contains the answer to all " |
| f"{r['held_out_answers_inside_it']} held-out tasks and earns about {r['its_mean_score_if_given_everywhere']:.3f} on each, " |
| f"so reward rose from {r['reward_before']:.3f} to {r['reward_after']:.3f} with no skill at all. The warning held; the " |
| f"guess at which cheat was wrong, and the miss is a second loophole in the same grader. Files: `training/maze/results/`."] |
| return "\n".join(lines) |
|
|
|
|
| def census_table(c: dict) -> str: |
| rows = ["| What happened | Spaces | Share |", "|---|---|---|"] |
| rows += [f"| {g['group'][0].upper() + g['group'][1:]} | {g['count']} | {g['share'] * 100:.1f}% |" for g in c["groups"]] |
| return "\n".join(rows) |
|
|
|
|
| CARD = """--- |
| pretty_name: Shortlist |
| language: |
| - en |
| tags: |
| - openenv |
| - reinforcement-learning |
| - rl-environments |
| - grpo |
| - evaluation |
| - beam |
| size_categories: |
| - 1K<n<10K |
| license: cc-by-4.0 |
| --- |
| |
| # Shortlist: which open RL environments can a model learn from? |
| |
| OpenEnv's [RFC 008]({rfc}) reserves the statistical learnability checks for whoever runs a validation hub, and |
| ships no runner for them. Shortlist is that runner. Beam plays each environment at every rung of a capability |
| ladder: doing nothing, acting at random, a small model, then Beam itself from low to max reasoning effort. Where |
| the rungs spread out, a model can learn; where they pile up, it can't. The checks turn that into a verdict per |
| environment, and a GRPO training run tests whether the verdicts hold. |
| |
| **Results page:** [{space}]({space}). This repo holds the data, the code and the training proof behind it. |
| |
| ## At a glance |
| |
| - **{env} environments, {suites} task suites, {episodes:,} episodes**: {beam_ep} played by Beam |
| ({tokens:,} output tokens), {small_ep} by the small model (Qwen3-0.6B), the rest by the two model-free players. |
| - **Verdicts predict where reward moves, not whether the skill is learned.** {held} of {families} pre-registered |
| predictions held when Qwen3-0.6B was trained with GRPO. But in {routes} of the {rose} families where reward rose, |
| the model got there by gaming the grader or learning the answer format, not the skill. Beam's blind audit matched |
| our reading on four families, caught the word-sorting echo before we did, and was stricter on basic arithmetic. |
| - **So the shortlist now checks whether a reward can be gamed.** {gameable} of {gaming_families} Reasoning Gym families pay |
| more for an answer that needs no skill than the small model earns now, including two the training run didn't |
| cover: maze (always "5" scores {maze_score}) and game of life (an empty board scores {gol_score}). This check was added after |
| training. Maze was then a forward test, published before training: it collapsed with no skill, as predicted (3 of 4 |
| claims held), but onto a different cheat than the one we named. |
| - **Three defects in shipped environments**, each flagged by Beam's play on the ladder: Connect 4 (no opponent; |
| Beam diagnosed it and wrote the fix), DIPG (its answer markers are Beam's own control tokens), Pelican (the vision |
| judge is off by default, so any two-wheeled drawing scores 1.0). |
| - **Effort is a ladder too.** On {eff_suites} suites, Beam's highest effort solved more tasks than low effort on |
| {eff_more}, as many on {eff_same}, and fewer on {eff_less}. |
| - **Hub census.** Of {spaces} OpenEnv Spaces checked, {passes} ({passes_share}) run and pass the floor checks; |
| {dn1} pay 1 or more for doing nothing. |
| |
| ## How Beam is used |
| |
| Beam (`Beam-1.0-501B-A23B`, through Reflection's OpenAI-compatible API) does five jobs. Each is a script in |
| `code/`, and every output it produced is in this repo. |
| |
| 1. **Plays the top rungs of the ladder.** Beam acts through one tool built from the environment's own action |
| schema, after reading the environment's README, at low, medium, high or max reasoning effort. Its rungs are the |
| reference that shows a task can be done. {beam_ep} episodes, {tokens:,} output tokens. |
| (`code/shortlist/policies.py`, `code/scripts/ladder.py`, `episodes.jsonl`) |
| 2. **Diagnoses and fixes broken environments.** When a check fails, Beam gets the ladder's numbers and the |
| environment's source, explains the failure and writes the patch. For Connect 4 it found there was no opponent: |
| as shipped, doing nothing won {c4_null}, random play {c4_random} and Beam {c4_beam}. On Beam's fixed copy, doing |
| nothing won {c4f_null}, random play {c4f_random} and Beam {c4f_beam}. (`code/scripts/fix.py`, `fixes/`) |
| 3. **Writes setups for environments it has never seen.** For {community} Hub environments, Beam read the README, |
| the action schema and the first observation, and wrote the setup Shortlist plays: episode length, how to |
| score, what counts as solved and the maximum reward, each backed by a quote from the README. |
| (`code/scripts/setup_env.py`, `census/setups/`) |
| 4. **Gives a ladder of skill inside one model.** Its effort settings let one model fill several rungs, so |
| difficulty separation can be measured without a zoo of models. (`effort` in the results page data) |
| 5. **Audits the training run.** Given each grader's source, one question, and a few answers from before and after |
| training, but not our conclusions, Beam (high effort) judged whether the model learned the skill, the format, or |
| a loophole. (`code/training/audit_with_beam.py`, `training/beam_audit.json`) |
| |
| One finding is about Beam itself: DIPG only scores answers wrapped in `<|channel|>analysis<|message|>` … `<|end|>`, |
| which are single control tokens in Beam's Harmony-style chat format. When Beam writes them inside an answer they |
| arrive mangled, so every answer took the −10 format penalty ({dipg_default} cleared the format check). With square-bracket markers, a setting |
| DIPG already has, {dipg_sq} cleared it. |
| |
| ## The ladder and the checks |
| |
| | Rung | Player | |
| |---|---| |
| | Does nothing | Always takes the first allowed action. No model. | |
| | Acts at random | Picks a random valid action. No model. | |
| | Small model | Qwen3-0.6B, thinking off, served by llama.cpp (Q8_0). Reasoning Gym only: the model you would train. | |
| | Beam, low → max | `Beam-1.0-501B-A23B` at each reasoning effort. | |
| |
| The checks, in `code/shortlist/checks.py`: |
| |
| - **Floor gap** (`semantic.floor_gap`): doing nothing or acting at random must not already earn the top reward. |
| - **Reward reachability**: the strongest rung earns reward. |
| - **Difficulty separation**: the strongest rung beats the floor (one-sided bootstrap, p ≤ 0.05). |
| - **Headroom**: the best rung leaves room below the known maximum. |
| - **Variance**: replaying one task varies less than the strongest rung's gain over the floor. |
| - **Adversarial floor** (RFC 008 #26, Reasoning Gym only, added after training): no answer that needs no skill pays |
| more than the learner earns now and at least a tenth of the top reward. The RFC leaves the procedure open; ours |
| (`code/shortlist/gaming.py`) tries a constant answer, the question echoed back, and the task's input played back. |
| - **GRPO signal**: the learner's repeated attempts at one task disagree on at least one task in five. Those are the |
| only tasks a GRPO update learns from. |
| - **For the small model** (`code/shortlist/trainee.py`): worth training if its mean reward is above zero, it solves |
| under 95% on the first try, and its GRPO signal is at least 20%. |
| |
| Verdicts are judged for the small model where it played (Reasoning Gym), and for Beam everywhere else. |
| |
| ## Results |
| |
| ### The shortlist |
| |
| {verdict_tables} |
| |
| Per-suite numbers, every check and its statistics are in `verdicts.json`. |
| |
| ### Does the verdict predict training? |
| |
| The predictions for {families} small-model families were written first. Their SHA-256, |
| `{sha}`, was committed to this repo at {committed} UTC; the first training checkpoint is from |
| {first_ckpt} UTC. Qwen3-0.6B was then trained with GRPO for 100 steps per family (TRL, LoRA r=16, fp32, one Kaggle |
| T4) and scored on the same 200 held-out tasks before and after. |
| |
| {training_table} |
| |
| The pre-registered criterion, "reward rises", held for all {families}. What moved reward was mostly a cheaper route |
| the grader allows: a constant answer, the input played back, or a change of format. The do-nothing and random players |
| can't see those routes, because each needs one specific answer, so a training run needs a second check once it |
| finishes. Beam can run it. Its audit called letter counting and propositional logic gamed, chain sum a format gain, |
| and leg counting unchanged, as we did. It caught the word-sorting echo before we did. On basic arithmetic it was |
| stricter than our lenient re-score, which shows part of that gain is skill. Full write-up: `training/RESULTS.md`. |
| |
| ### Can the reward be gamed? |
| |
| Added after the training run above. Each family's own grader scores three answers that need no skill: the most |
| common correct answer on the 400 training tasks (what GRPO would find), the question echoed back, and the task's |
| input played back where it has one. A family can be gamed when the best of them pays more than the small model earns |
| now and at least a tenth of the top reward. |
| |
| {gaming_table} |
| |
| ### A forward test: maze |
| |
| {forward_section} |
| |
| ### A ladder inside one model |
| |
| Higher efforts played one attempt per task and low effort three, so these are small samples. |
| |
| {effort_table} |
| |
| ### What's on the Hub |
| |
| {spaces} Spaces tagged `openenv`: the most-liked, plus a random sample of the rest. No model was used: each Space |
| was woken, its OpenEnv routes tried, and one do-nothing and two random episodes played. Spaces still asleep got a |
| second try with ten minutes to wake. |
| |
| {census_table} |
| |
| ## Files |
| |
| | Path | What it holds | |
| |---|---| |
| | `episodes.jsonl` | Every episode of the main run, one per line: suite, environment, player (`policy`), task, attempt, each step's action and reward, the return, tokens, and Beam's reasoning (trimmed to 2,000 characters per step). Episodes that failed for harness reasons are left out. | |
| | `pilot_episodes.jsonl` | The earlier pilot runs, before the harness fixes. Not used for any verdict. | |
| | `verdicts.json` | Per task suite: each rung's statistics, every check with its numbers, the verdict and who it was judged for. | |
| | `census/` | The Hub census (`census.jsonl` first pass, `census2.jsonl` second pass), the sample (`chosen.json`) and Beam's setups (`setups/`). | |
| | `fixes/` | For Connect 4: the evidence Beam was given, its reasoning, its reply and the patch. | |
| | `training/` | Pre-registration, predictions and their SHA-256, results, Beam's audit, the lenient re-score, `analysis.json` and `RESULTS.md`. `training/maze/` holds the maze forward test. | |
| | `gaming.json` | The can-it-be-gamed check: every no-skill answer tried, per family, with its score. | |
| | `code/` | The Shortlist package, scripts, training code and the Kaggle notebook. | |
| |
| ## Reproduce |
| |
| Python 3.12, OpenEnv at commit `{openenv_commit}` cloned into `vendor/OpenEnv`, and |
| `pip install -r code/requirements.txt` (each environment's own requirements are also needed to serve it). A Beam |
| key goes in `REFLECTION_API_KEY` (we keep it encrypted with dotenvx). |
| |
| ```bash |
| cd code |
| python scripts/ladder.py --suites maze_env --tiers null,random # floors only, no key needed |
| dotenvx run -- python scripts/ladder.py --suites rg:leg_counting --tiers null,random,beam-low |
| python scripts/report.py runs/<run> # verdicts for a run |
| python scripts/hub_sweep.py --top 150 --random 150 --out runs/hub/sweep # Hub census, no model |
| dotenvx run -- python scripts/setup_env.py --from-census runs/hub/sweep/census.jsonl --limit 20 |
| dotenvx run -- python scripts/fix.py connect4_env --evidence runs/fixes/connect4_env.evidence.md |
| python scripts/figures.py && python scripts/export.py && python scripts/card.py # numbers, page data, this card |
| ``` |
| |
| Training: run `training/shortlist_training_proof.ipynb` on Kaggle (one T4). Part 1 writes the predictions and prints |
| their SHA-256; commit that before Part 2, which refuses to train unless the SHA matches. Then |
| `training/rescore_lenient.py`, `training/audit_with_beam.py` and `training/analysis.py`. |
| |
| ## Limits |
| |
| - Most environments judged for Beam have two to four tasks, so those verdicts are provisional. |
| - One small model, Qwen3-0.6B, and only on Reasoning Gym. |
| - Training ran 100 GRPO steps per family, once each. Only five answers per family were saved after training, so the |
| trained models can't be re-scored leniently, and the trained adapters weren't kept. |
| - The lenient re-score regenerated the untrained model's answers with llama.cpp (Q8_0), not the fp32 weights used |
| in training. The strict scores match closely. |
| - Beam's setups for community environments guess the score range. Where a player scored above the guessed maximum, |
| the guess is ignored. |
| - Two Beam-side rules were added after the first results were in: a guessed maximum that a player beats is |
| ignored, and environments judged for Beam need the same GRPO signal as the small model. Neither touches the |
| pre-registered small-model rule. |
| - The can-be-gamed check covers Reasoning Gym only, tries three cheap strategies, and was added after the training |
| run. A family it passes may still be gameable another way: the maze run found one it didn't try, a reply that |
| contains every likely answer. |
| - The Hub census is a snapshot. Spaces sleep, wake and change. |
| |
| ## License |
| |
| Data: CC BY 4.0. Code (`code/`): Apache-2.0. Content that comes from each environment (its task text and |
| observations, inside the episodes and the census) belongs to that environment's authors and keeps its own license. |
| """ |
|
|
| SPACE_CARD = """--- |
| title: Shortlist |
| emoji: 🪜 |
| colorFrom: pink |
| colorTo: purple |
| sdk: static |
| pinned: false |
| license: apache-2.0 |
| short_description: Which open RL environments can a model learn from? |
| --- |
| |
| Shortlist runs the learnability checks OpenEnv's RFC 008 reserves for validation hubs. Beam plays each environment |
| at every rung of a capability ladder; the checks sort the environments by whether a model can learn from them, and |
| a GRPO training run tests the verdicts. |
| |
| Data, code and the training proof: [{dataset}]({dataset}). |
| """ |
|
|
|
|
| def main() -> None: |
| n = json.loads((HF / "numbers.json").read_text()) |
| d = json.loads((HF / "space" / "data.json").read_text()) |
| t = json.loads((ROOT / "training" / "kaggle" / "analysis.json").read_text()) |
| rose = [r for r in t["rows"] if r["prediction"] == "improves" and r["held"]] |
| c4, c4f = n["connect4"]["as_shipped"], n["connect4"]["with_beams_fix"] |
| won = lambda o: f"{o['won']} of {o['games']}" |
| gate = lambda o: f"{o['cleared_format_gate']} of {o['answers']}" |
| passes = next(g for g in n["census"]["groups"] if g["group"].startswith("runs and passes")) |
| es = n["effort_summary"] |
| gaming = json.loads((HF / "gaming.json").read_text()) |
| af = n["adversarial_floor"] |
| flag = {x["suite"]: x for x in af["flagged"]} |
| card = CARD.format( |
| rfc=RFC_URL, space=SPACE_URL, env=n["environments"], suites=n["task_suites"], episodes=n["episodes"], |
| beam_ep=n["beam_episodes"], small_ep=n["small_episodes"], tokens=n["beam_output_tokens"], |
| held=t["held"], families=t["families"], rose=len(rose), routes=sum(r["learned"] != "skill and format" for r in rose), |
| eff_suites=es["suites"], eff_more=es["higher_solved_more"], eff_same=es["same"], eff_less=es["higher_solved_less"], |
| spaces=n["census"]["spaces"], passes=passes["count"], passes_share=f"{passes['share'] * 100:.1f}%", |
| dn1=n["census"]["do_nothing_at_least_1"], community=n["community_environments"], |
| c4_null=won(c4["null"]), c4_random=won(c4["random"]), c4_beam=won(c4["beam-low"]), |
| c4f_null=won(c4f["null"]), c4f_random=won(c4f["random"]), c4f_beam=won(c4f["beam-low"]), |
| dipg_default=gate(n["dipg"]["default_markers"]), dipg_sq=gate(n["dipg"]["square_brackets"]), |
| sha=t["pre_registration"]["sha256"], committed=t["pre_registration"]["committed_utc"], |
| first_ckpt=t["pre_registration"]["first_checkpoint_utc"], openenv_commit=OPENENV_COMMIT, |
| verdict_tables=verdict_tables(d["verdicts"]), training_table=training_table(t), |
| effort_table=effort_table(d["effort"]), census_table=census_table(n["census"]), |
| gaming_table=gaming_table(gaming), forward_section=forward_section(d.get("forward_test")), |
| gameable=af["gameable"], gaming_families=af["families"], maze_score=f"{flag['rg-maze']['score']:.3f}", |
| gol_score=f"{flag['rg-game_of_life']['score']:.3f}") |
| (HF / "dataset" / "README.md").write_text(card) |
| (HF / "space" / "README.md").write_text(SPACE_CARD.format(dataset=DATASET_URL)) |
| print(f"wrote {HF / 'dataset' / 'README.md'} ({len(card.splitlines())} lines) and the Space README") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
