Download code/prepare_minigrid_fairness.py from zhangdw/minigrid: direct link, hf CLI and curl.
- Browser
- Download file 10.9 kB
-
https://huggingface.co/datasets/zhangdw/minigrid/resolve/main/code/prepare_minigrid_fairness.py
- Command line
-
hf download hf://datasets/zhangdw/minigrid/code/prepare_minigrid_fairness.py
-
curl -L -o prepare_minigrid_fairness.py https://huggingface.co/datasets/zhangdw/minigrid/resolve/main/code/prepare_minigrid_fairness.py
10.9 kB
| """Freeze MiniGrid tasks, select Hamilton-stratified evaluation, and audit restores. | |
| Run with python -m examples.data_preprocess.prepare_minigrid_fairness --output DIR. | |
| The seed pool is fixed before any model calls; all eligible remaining tasks train. | |
| """ | |
| from __future__ import annotations | |
| import argparse | |
| import hashlib | |
| import json | |
| import math | |
| from collections import defaultdict | |
| from pathlib import Path | |
| from agent_system.environments.minigrid_fairness import ( | |
| ENV_ID, | |
| GYMNASIUM_VERSION, | |
| MINIGRID_VERSION, | |
| PROTOCOL, | |
| STATE_SCHEMA, | |
| canonical_json, | |
| new_env, | |
| restore, | |
| shortest_solution, | |
| snapshot, | |
| split_group_id, | |
| task_id, | |
| validate_task, | |
| ) | |
| SELECTION_VERSION = "minigrid-eval-256-v1" | |
| CANDIDATE_SEEDS = 4096 | |
| def sha(path): | |
| return hashlib.sha256(Path(path).read_bytes()).hexdigest() | |
| def write_json(path, value): | |
| Path(path).write_text(json.dumps(value, sort_keys=True, indent=2) + "\n") | |
| def write_rows(path, rows): | |
| Path(path).write_text("".join(canonical_json(row) + "\n" for row in rows)) | |
| def read_rows(path): | |
| return [json.loads(line) for line in Path(path).read_text().splitlines()] | |
| def select(candidates): | |
| if len(candidates) < 256: | |
| raise ValueError("Candidate pool cannot supply 256 evaluation tasks") | |
| lengths = sorted(row["metadata"]["shortest_length"] for row in candidates) | |
| boundaries = [lengths[math.ceil(len(lengths) * q / 4) - 1] for q in (1, 2, 3)] | |
| strata = defaultdict(list) | |
| for row in candidates: | |
| m = row["metadata"] | |
| index = sum(m["shortest_length"] > boundary for boundary in boundaries) | |
| strata[(index, m["wall_position"], m["door_position"])].append(row) | |
| quotas = {key: 256 * len(rows) // len(candidates) for key, rows in strata.items()} | |
| order = sorted(strata, key=lambda key: (-(256 * len(strata[key]) % len(candidates)), key)) | |
| for key in order[: 256 - sum(quotas.values())]: | |
| quotas[key] += 1 | |
| chosen = [] | |
| for key in sorted(strata): | |
| ranked = sorted(strata[key], key=lambda row: (hashlib.sha256((SELECTION_VERSION + ":" + row["metadata"]["task_id"]).encode()).hexdigest(), row["metadata"]["task_id"])) | |
| chosen.extend(ranked[: quotas[key]]) | |
| chosen.sort(key=lambda row: row["metadata"]["task_id"]) | |
| groups = {row["metadata"]["split_group_id"] for row in chosen} | |
| train = [row for row in candidates if row["metadata"]["split_group_id"] not in groups] | |
| train.sort(key=lambda row: row["metadata"]["task_id"]) | |
| def assign(rows, split): | |
| return [{**row, "metadata": {**row["metadata"], "split": split}} for row in rows] | |
| audit = { | |
| "selection_version": SELECTION_VERSION, | |
| "length_boundaries": boundaries, | |
| "strata": [{"stratum": list(key), "count": len(strata[key]), "quota": quotas[key]} for key in sorted(strata)], | |
| "selected_task_ids": [row["metadata"]["task_id"] for row in chosen], | |
| "candidate_count": len(candidates), | |
| "train_count": len(train), | |
| "evaluation_count": len(chosen), | |
| "reserved_orientation_variants": len(candidates) - len(train) - len(chosen), | |
| "task_overlap": 0, | |
| "split_group_overlap": 0, | |
| } | |
| return assign(train, "train"), assign(chosen, "evaluation"), audit | |
| def generate(output): | |
| output = Path(output) | |
| folder = output / "fairness" | |
| folder.mkdir(parents=True, exist_ok=True) | |
| frozen = folder / "candidates.jsonl" | |
| env = new_env() | |
| rejected, candidates, seen, solutions = [], [], set(), {} | |
| if frozen.exists(): | |
| candidates = read_rows(frozen) | |
| provenance = json.loads((folder / "provenance.json").read_text()) | |
| else: | |
| journal = output / "generation.journal.jsonl" | |
| completed = read_rows(journal) if journal.exists() else [] | |
| for expected_seed, item in enumerate(completed): | |
| if item["seed"] != expected_seed: | |
| raise ValueError("Generation journal seed sequence mismatch") | |
| if "row" in item: | |
| row = item["row"] | |
| candidates.append(row) | |
| solutions[row["metadata"]["task_id"]] = item["solution"] | |
| seen.add(row["metadata"]["task_id"]) | |
| else: | |
| rejected.append(item) | |
| seen.add(item["task_id"]) | |
| def persist(item): | |
| with journal.open("a") as writer: | |
| writer.write(canonical_json(item) + "\n") | |
| writer.flush() | |
| print(f"resuming at seed {len(completed)}", flush=True) | |
| for seed in range(len(completed), CANDIDATE_SEEDS): | |
| obs, _ = env.reset(seed=seed) | |
| state = snapshot(env) | |
| identity = task_id(state) | |
| if identity in seen: | |
| rejected.append({"seed": seed, "reason": "duplicate_initial_state", "task_id": identity}) | |
| persist(rejected[-1]) | |
| continue | |
| seen.add(identity) | |
| solution = shortest_solution(env, state) | |
| if solution is None: | |
| rejected.append({"seed": seed, "reason": "unreachable_within_64", "task_id": identity}) | |
| persist(rejected[-1]) | |
| continue | |
| restore(env, state) | |
| assert snapshot(env) == state | |
| image = env.observation(env.unwrapped.gen_obs())["image"] | |
| assert (image == obs["image"]).all() | |
| for action in solution: | |
| _, reward, terminated, truncated, _ = env.step(action) | |
| assert terminated and reward > 0 and len(solution) <= 64 | |
| door_pos = next((x, y) for x in range(8) for y in range(8) if state["grid"][x][y][0] == 4) | |
| row = { | |
| "initial_state": state, | |
| "metadata": { | |
| "protocol": PROTOCOL, | |
| "task_id": identity, | |
| "split_group_id": split_group_id(state), | |
| "seed": seed, | |
| "shortest_length": len(solution), | |
| "wall_position": door_pos[0], | |
| "door_position": door_pos[1], | |
| "image_sha256": hashlib.sha256(image.tobytes()).hexdigest(), | |
| }, | |
| } | |
| candidates.append(row) | |
| solutions[identity] = list(solution) | |
| persist({"seed": seed, "row": row, "solution": list(solution)}) | |
| if seed % 128 == 0: | |
| print(f"generated {seed + 1}/{CANDIDATE_SEEDS}; eligible={len(candidates)}", flush=True) | |
| write_rows(frozen, candidates) | |
| write_json(folder / "reference-solutions.audit-only.json", solutions) | |
| provenance = { | |
| "protocol": PROTOCOL, | |
| "state_schema": STATE_SCHEMA, | |
| "prompt_version": "minigrid-vlm-v1", | |
| "env_id": ENV_ID, | |
| "minigrid": MINIGRID_VERSION, | |
| "gymnasium": GYMNASIUM_VERSION, | |
| "seed_sequence": {"start": 0, "stop_exclusive": CANDIDATE_SEEDS, "stride": 1}, | |
| "generation_count": CANDIDATE_SEEDS, | |
| "deduplicated_eligible_count": len(candidates), | |
| "rejected": rejected, | |
| "horizon": 64, | |
| "tile_size": 56, | |
| "highlight": False, | |
| "numpy": "1.26.4", | |
| "generator_script_version": "minigrid-freeze-v1", | |
| "model_calls": 0, | |
| } | |
| write_json(folder / "provenance.json", provenance) | |
| env.close() | |
| train, evaluation, audit = select(candidates) | |
| write_rows(folder / "train.jsonl", train) | |
| write_rows(folder / "evaluation.jsonl", evaluation) | |
| audit.update({"candidate_sha256": sha(frozen), "train_sha256": sha(folder / "train.jsonl"), "evaluation_sha256": sha(folder / "evaluation.jsonl")}) | |
| write_json(folder / "evaluation-256.selection.json", audit) | |
| write_json(folder / "checksums.json", {p.name: sha(p) for p in sorted(folder.iterdir()) if p.name != "checksums.json"}) | |
| print(json.dumps({k: v for k, v in audit.items() if k not in {"strata", "selected_task_ids"}}, indent=2)) | |
| return audit | |
| def audit_download(output, *, bfs=False): | |
| folder = Path(output) / "fairness" | |
| checksums = json.loads((folder / "checksums.json").read_text()) | |
| for name, expected in checksums.items(): | |
| if sha(folder / name) != expected: | |
| raise ValueError(f"Checksum mismatch: {name}") | |
| candidates = read_rows(folder / "candidates.jsonl") | |
| train, evaluation, selection = select(candidates) | |
| for split, expected in (("train", train), ("evaluation", evaluation)): | |
| encoded = "".join(canonical_json(row) + "\n" for row in expected).encode() | |
| if (folder / f"{split}.jsonl").read_bytes() != encoded: | |
| raise ValueError("Selection rerun differs byte-for-byte") | |
| env = new_env() | |
| counts = {} | |
| from agent_system.environments.env_package.minigrid import MiniGridEpisode | |
| from agent_system.environments.minigrid_protocol import ACTIONS | |
| episode = MiniGridEpisode() | |
| native_names = {value: name for name, value in ACTIONS.items()} | |
| solutions = json.loads((folder / "reference-solutions.audit-only.json").read_text()) | |
| for split, rows in (("train", train), ("evaluation", evaluation)): | |
| ids = set() | |
| for row in rows: | |
| validate_task(row, split=split) | |
| state = row["initial_state"] | |
| restore(env, state) | |
| assert snapshot(env) == state | |
| image = env.observation(env.unwrapped.gen_obs())["image"] | |
| assert image.shape == (448, 448, 3) | |
| assert hashlib.sha256(image.tobytes()).hexdigest() == row["metadata"]["image_sha256"] | |
| episode.reset(row) | |
| solution = solutions[row["metadata"]["task_id"]] | |
| for native_action in solution: | |
| _, reward, done, info = episode.step(f"<think></think><action>{native_names[native_action]}</action>") | |
| assert done and info["goal_success"] and reward > 0 | |
| assert len(solution) == row["metadata"]["shortest_length"] | |
| if bfs: | |
| solution = shortest_solution(env, state) | |
| assert len(solution) == row["metadata"]["shortest_length"] | |
| ids.add(row["metadata"]["task_id"]) | |
| assert len(ids) == len(rows) | |
| counts[split] = len(rows) | |
| assert counts["evaluation"] == 256 | |
| assert not ({r["metadata"]["split_group_id"] for r in train} & {r["metadata"]["split_group_id"] for r in evaluation}) | |
| env.close() | |
| episode.close() | |
| print(json.dumps({"verified_counts": counts, "exact_restoration_and_rgb": True, "bfs": bfs, "selection_byte_identical": True})) | |
| if __name__ == "__main__": | |
| parser = argparse.ArgumentParser() | |
| parser.add_argument("--output", required=True) | |
| parser.add_argument("--audit", action="store_true") | |
| parser.add_argument("--bfs", action="store_true") | |
| args = parser.parse_args() | |
| if args.audit: | |
| audit_download(args.output, bfs=args.bfs) | |
| else: | |
| generate(args.output) | |