slime_bench_balanced.py

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