"""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)