"""Action-balanced SlimeBench; see docs/slime-bench-balanced.md.""" import argparse import json import multiprocessing import random import subprocess from collections import Counter from concurrent.futures import ProcessPoolExecutor, as_completed from pathlib import Path import slime_bench as base np = base.np def targets(count, seed): """Randomize remainder recipients and order, with count differences <= 1.""" rng = random.Random(seed) actions = list(range(6)) rng.shuffle(actions) result = actions * (count // 6) + actions[: count % 6] rng.shuffle(result) return result def collect(env, teacher, episode_seed, target): """Uniform matching timestep in a complete rollout, or None if absent.""" env.seed(episode_seed) env.policy.reset() observation = env.reset() rng = random.Random(f"balanced-timestep:{episode_seed}") selected, matches, total = None, 0, 0.0 for step in range(env.t_limit): observation = np.asarray(observation, dtype=np.float32) action = base.action_from_controls(teacher.predict(observation)) if action == target: matches += 1 if rng.randrange(matches) == 0: selected = { "observation": observation.tolist(), "expert_action": action, "episode_seed": episode_seed, "step": step, } observation, reward, done, info = env.step(base.BUTTONS[action]) total += float(reward) if done: if selected is not None: selected.update( episode_return=total, episode_steps=step + 1, matching_timesteps=matches, time_limit=info["ale.lives"] > 0 and info["ale.otherLives"] > 0, ) return selected raise RuntimeError("Rollout did not terminate") def build_row(args, index): letters, order = base.row_permutations(args.seed, args.rows)[index] env, teacher = base.load_runtime(args.source_dir) row = {"row_id": index, "num_train": args.num_train, "num_test": args.num_test} audit = { "row_id": index, "action_to_letter": list(letters), "observation_order": list(order), "stats": {}, } attempt = 0 rejected = Counter() try: for split, count in (("train", args.num_train), ("test", args.num_test)): records = [] for target in targets(count, f"quotas:{args.seed}:{index}:{split}"): while True: # Each row owns a disjoint arithmetic progression, including retries. episode_seed = args.seed + index + args.rows * attempt attempt += 1 if episode_seed >= 2**32: raise ValueError("Exhausted seed space") record = collect(env, teacher, episode_seed, target) if record is not None: records.append(record) break rejected[target] += 1 random.Random(f"examples:{args.seed}:{index}:{split}").shuffle(records) row[split + "_data"] = [ base.conversation(r, letters, order) for r in records ] audit[split] = records audit["stats"][split] = base.split_stats(records, letters) audit.update(attempted_rollouts=attempt, rejected_by_action=dict(rejected)) base.write_json( args.output_dir / "checkpoints" / f"{index:03d}.json", {"row": row, "audit": audit}, ) finally: env.close() return index def export(args): env, teacher = base.load_runtime(args.source_dir) rows, seen, totals, attempted = ( [], set(), {s: Counter() for s in ("train", "test")}, 0, ) returns, duplicates = [], 0 try: for index in range(args.rows): checkpoint = json.loads( (args.output_dir / "checkpoints" / f"{index:03d}.json").read_text() ) row, audit = checkpoint["row"], checkpoint["audit"] letters, order = base.row_permutations(args.seed, args.rows)[index] assert row["row_id"] == audit["row_id"] == index assert audit["action_to_letter"] == list(letters) and audit[ "observation_order" ] == list(order) attempted += audit["attempted_rollouts"] prompts = set() for split, count in (("train", args.num_train), ("test", args.num_test)): records, chats = audit[split], row[split + "_data"] assert row["num_" + split] == len(records) == len(chats) == count counts = Counter(r["expert_action"] for r in records) assert counts == Counter( targets(count, f"quotas:{args.seed}:{index}:{split}") ) assert audit["stats"][split] == base.split_stats(records, letters) totals[split].update(counts) for record, chat in zip(records, chats, strict=True): seed = record["episode_seed"] assert seed not in seen and seed >= args.seed + index assert (seed - args.seed - index) % args.rows == 0 assert (seed - args.seed - index) // args.rows < audit[ "attempted_rollouts" ] seen.add(seed) assert 0 <= record["step"] < record["episode_steps"] <= env.t_limit assert 1 <= record["matching_timesteps"] <= record["episode_steps"] assert chat == base.conversation(record, letters, order) restored = np.empty(12, dtype=np.float32) restored[list(order)] = np.asarray( json.loads(chat[0]["content"]), dtype=np.float32 ) assert np.array_equal( restored, np.asarray(record["observation"], dtype=np.float32) ) assert ( base.action_from_controls(teacher.predict(restored)) == record["expert_action"] ) returns.append(record["episode_return"]) if split == "test" and chat[0]["content"] in prompts: duplicates += 1 if split == "train": prompts.add(chat[0]["content"]) rows.append(row) finally: env.close() if duplicates: raise ValueError(f"Found {duplicates} train/test duplicate prompts") path = args.output_dir / "slime_bench.jsonl" pending = path.with_suffix(".jsonl.partial") with pending.open("w") as f: for row in rows: f.write(json.dumps(row, allow_nan=False) + "\n") pending.replace(path) summary = { "rows": len(rows), "conversations": len(seen), "distinct_rollouts": len(seen), "attempted_rollouts": attempted, "rejected_rollouts": attempted - len(seen), "cross_split_duplicate_prompts": duplicates, "mean_rollout_return": sum(returns) / len(returns), "action_counts": {s: [c[a] for a in range(6)] for s, c in totals.items()}, "jsonl_sha256": base.sha256(path), } base.write_json(args.output_dir / "validation.json", summary) print(json.dumps(summary), flush=True) return rows, summary def upload(args, rows, summary): from datasets import Dataset, Features, Value from huggingface_hub import DatasetCard, HfApi if (args.rows, args.num_train, args.num_test) != base.PRODUCTION: raise ValueError("Only production-size dataset may be uploaded") message = {"role": Value("string"), "content": Value("string")} schema = Features( { "row_id": Value("int64"), "num_train": Value("int64"), "num_test": Value("int64"), "train_data": [[message]], "test_data": [[message]], } ) Dataset.from_list(rows, features=schema).push_to_hub( args.output_dataset, config_name="default", split="train" ) card = DatasetCard.load(args.output_dataset) card.text = ( (base.ROOT / "docs/slime-bench-balanced.md").read_text() + "\n## Validation\n\n```json\n" + json.dumps(summary, indent=2) + "\n```\n" ) card.push_to_hub(args.output_dataset, repo_type="dataset") api = HfApi() for path in (Path(__file__), Path(base.__file__)): api.upload_file( path_or_fileobj=str(path), path_in_repo=path.name, repo_id=args.output_dataset, repo_type="dataset", ) revision = api.dataset_info(args.output_dataset).sha base.write_json( args.output_dir / "upload.json", {"repository": args.output_dataset, "revision": revision}, ) print(f"Uploaded {args.output_dataset} at {revision}", flush=True) def main(): parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--source-dir", type=Path, required=True) parser.add_argument( "--output-dir", type=Path, default=base.ROOT / "local_data/slime_bench_balanced" ) parser.add_argument("--rows", type=int, default=64) parser.add_argument("--num-train", type=int, default=2048) parser.add_argument("--num-test", type=int, default=100) parser.add_argument("--seed", type=int, default=10000000) parser.add_argument("--workers", type=int, default=32) parser.add_argument("--upload", action="store_true") parser.add_argument("--output-dataset", default="aklein4/SlimeBench-balanced") args = parser.parse_args() if ( not 1 <= args.rows <= 720 or min(args.num_train, args.num_test, args.workers) < 1 or args.seed < 0 ): parser.error("Invalid sizes/seed") if args.upload and (args.rows, args.num_train, args.num_test) != base.PRODUCTION: parser.error("Upload requires 64 x (2048 + 100)") from dotenv import load_dotenv load_dotenv(base.ROOT / ".env") args.source_dir = args.source_dir.resolve() args.output_dir = args.output_dir.resolve() assert ( subprocess.check_output( ["git", "-C", str(args.source_dir), "rev-parse", "HEAD"], text=True ).strip() == base.REVISION ) assert base.sha256(args.source_dir / base.WEIGHTS) == base.WEIGHTS_SHA256 subprocess.run( [ "git", "-C", str(args.source_dir), "diff", "--exit-code", "HEAD", "--", "slimevolleygym", base.WEIGHTS, ], check=True, ) config = { k: v for k, v in vars(args).items() if k not in ("workers", "upload", "output_dir", "source_dir", "output_dataset") } config.update( sampling="action quotas per row/split; uniform matching timestep per complete eligible rollout", generator_sha256=base.sha256(Path(__file__)), helper_sha256=base.sha256(Path(base.__file__)), upstream_revision=base.REVISION, weights_sha256=base.WEIGHTS_SHA256, versions={name: base.version(name) for name in ("numpy", "gym", "datasets")}, ) (args.output_dir / "checkpoints").mkdir(parents=True, exist_ok=True) manifest = args.output_dir / "manifest.json" if manifest.exists(): assert ( json.loads(manifest.read_text()) == config ), "Config/source changed; use new directory" else: base.write_json(manifest, config) missing = [ i for i in range(args.rows) if not (args.output_dir / "checkpoints" / f"{i:03d}.json").exists() ] if missing: with ProcessPoolExecutor( max_workers=min(args.workers, len(missing)), mp_context=multiprocessing.get_context("spawn"), ) as pool: futures = [pool.submit(build_row, args, i) for i in missing] for f in as_completed(futures): print(f"Completed row {f.result()+1}/{args.rows}", flush=True) rows, summary = export(args) if args.upload: upload(args, rows, summary) if __name__ == "__main__": main()