"""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"{native_names[native_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)