chess-sim/code/sim/generate_dataset.py

"""Generate the Phase 2 LeRobot dataset of successful expert episodes.

Each worker process draws a piece set every `episodes_per_piece_set` episodes,
simulates an episode without cameras, and only if it succeeds replays it from the
same seed with rendering into its own LeRobot shard. The shards are then merged
with LeRobot's aggregate_datasets and the result is loaded back as a check.

With --seeds-from, the episode seeds are read from another dataset's
phase2_episodes.jsonl (in its episode order) instead of drawn, so each episode repeats
that dataset's scene; each worker takes a contiguous block, so the merged order matches.
With the dart profile, a perturbed episode that fails is retried with fresh offsets
(--dart-retries), then run unperturbed.

Run:  .venv/bin/python sim/generate_dataset.py --episodes 200 --workers 8
      PHASE2_PROFILE=baseline,dart .venv/bin/python sim/generate_dataset.py \
          --seeds-from hub/chess-sim/datasets/baseline_v1/phase2_episodes.jsonl --workers 12
"""
from __future__ import annotations

import argparse
import json
import multiprocessing as mp
import shutil
import sys
import time
from collections import Counter
from pathlib import Path

HERE = Path(__file__).resolve().parent
ROOT = HERE.parent
sys.path.insert(0, str(HERE))


def worker(k: int, n_target: int, cfg: dict, shard_root: str, repo_id: str, seed: int, queue,
           seeds: list | None = None, dart_retries: int = 2):
    import warnings

    warnings.filterwarnings("ignore")
    import numpy as np

    from episode import EpisodeRunner
    from lerobot_export import Recorder, append_jsonl, create_dataset
    from piece_sets import sample_piece_set

    root = Path(shard_root)
    ds = create_dataset(cfg, repo_id, root)
    rec = Recorder(cfg, ds)
    rng = np.random.default_rng([seed, k])
    per_set = cfg["dataset"]["episodes_per_piece_set"]
    runner, on_set, n_sets = None, per_set, 0
    done, attempts, replay_mismatch = 0, 0, 0
    failures = Counter()
    t0 = time.time()
    dart = cfg["expert"].get("dart_probability", 0.0) > 0
    listed = iter(seeds) if seeds is not None else None
    while done < n_target:
        if on_set >= per_set:
            if runner is not None:
                runner.close()
            pset = sample_piece_set(rng, cfg, f"worker{k}_set{n_sets}")
            runner = EpisodeRunner(cfg, pset, render=True)
            on_set, n_sets = 0, n_sets + 1
        if listed is not None:
            ep_seed = next(listed, None)
            if ep_seed is None:
                break                                  # listed seeds used up (some failed)
        else:
            ep_seed = int(rng.integers(2**62))
        attempts += 1
        # Perturbed tries first (fresh offsets each), then the plain teacher; the first that succeeds is recorded.
        for dart_attempt in (list(range(1 + dart_retries)) + [-1]) if dart else [0]:
            task = runner.setup(np.random.default_rng(ep_seed))
            res = runner.run(task, ep_seed, dart_attempt=dart_attempt)
            if res.success:
                break
            failures[res.reason.split(":")[0].split(" ")[0] or "other"] += 1
        if not res.success:
            continue
        task = runner.setup(np.random.default_rng(ep_seed))
        rec.begin(runner, task, np.random.default_rng(ep_seed ^ 0x5EED))
        res = runner.run(task, ep_seed, recorder=rec, dart_attempt=dart_attempt)
        if not res.success:
            rec.discard()
            replay_mismatch += 1
            continue
        ds.save_episode(parallel_encoding=False)   # workers already run in parallel
        on_set += 1
        append_jsonl(root / "phase2_episodes.jsonl", dict(
            shard=k, shard_episode=done, seed=ep_seed, piece=runner.w.kind[task.target], body=task.target,
            source=task.source, destination=task.dest.square or "bin", move_kind=task.kind, fen=task.fen,
            frames=res.frames, centre_error_mm=res.centre_error_mm, jaw_yaw_deg=res.yaw_deg,
            dart_offset_mm=res.dart_offset_mm, dart_attempt=dart_attempt if dart else None,
            piece_set=runner.piece_set.name, piece_set_dims=runner.piece_set.describe(), **runner.episode_info))
        done += 1
        queue.put((k, done, attempts))
    ds.finalize()
    runner.close()
    summary = dict(worker=k, episodes=done, attempts=attempts, failures=dict(failures),
                   replay_mismatch=replay_mismatch, piece_sets=n_sets, seconds=round(time.time() - t0, 1))
    (root / "phase2_summary.json").write_text(json.dumps(summary, indent=2))
    queue.put((k, "done", summary))


def main():
    from episode import load_config

    cfg = load_config()
    ds = cfg["dataset"]
    ap = argparse.ArgumentParser(description=__doc__)
    ap.add_argument("--episodes", type=int, default=ds["episodes"])
    ap.add_argument("--workers", type=int, default=ds["workers"])
    ap.add_argument("--root", default=ds["root"])
    ap.add_argument("--seed", type=int, default=0)
    ap.add_argument("--overwrite", action="store_true", help="delete an existing dataset at --root first")
    ap.add_argument("--seeds-from", help="phase2_episodes.jsonl whose episode seeds to repeat, in its order")
    ap.add_argument("--dart-retries", type=int, default=2)
    args = ap.parse_args()
    seeds = None
    if args.seeds_from:
        recs = [json.loads(line) for line in Path(args.seeds_from).read_text().splitlines() if line.strip()]
        recs.sort(key=lambda r: r["episode_index"])
        seeds = [int(r["seed"]) for r in recs][:args.episodes]
        args.episodes = len(seeds)

    root = (ROOT / args.root).resolve()
    shards = root.parent / (root.name + "_shards")
    if root.exists() or shards.exists():
        if not args.overwrite:
            sys.exit(f"{root} exists; pass --overwrite to replace it")
        shutil.rmtree(root, ignore_errors=True)
        shutil.rmtree(shards, ignore_errors=True)
    shards.mkdir(parents=True)
    n = args.workers
    quota = [args.episodes // n + (1 if i < args.episodes % n else 0) for i in range(n)]
    starts = [sum(quota[:i]) for i in range(n)]
    ctx = mp.get_context("spawn")
    queue = ctx.Queue()
    procs, repo_ids, roots = [], [], []
    for k in range(n):
        if quota[k] == 0:
            continue
        repo_ids.append(f"{ds['repo_id']}_shard{k:02d}")
        roots.append(shards / f"shard_{k:02d}")
        block = seeds[starts[k]:starts[k] + quota[k]] if seeds is not None else None
        p = ctx.Process(target=worker, args=(k, quota[k], cfg, str(roots[-1]), repo_ids[-1], args.seed, queue,
                                             block, args.dart_retries))
        p.start()
        procs.append(p)
    t0, progress, summaries = time.time(), {}, {}
    while len(summaries) < len(procs):
        k, done, extra = queue.get()
        if done == "done":
            summaries[k] = extra
            continue
        progress[k] = (done, extra)
        total = sum(d for d, _ in progress.values())
        tried = sum(a for _, a in progress.values())
        if total % max(1, args.episodes // 50) == 0 or total == args.episodes:
            rate = total / (time.time() - t0)
            eta = (args.episodes - total) / max(rate, 1e-9)
            print(f"{total}/{args.episodes} episodes, {100 * total / max(tried, 1):.1f}% of attempts succeed, "
                  f"{rate * 3600:.0f}/h, ETA {eta / 60:.0f} min", flush=True)
    for p in procs:
        p.join()

    from lerobot.datasets.aggregate import aggregate_datasets
    from lerobot.datasets.lerobot_dataset import LeRobotDataset

    aggregate_datasets(repo_ids=repo_ids, aggr_repo_id=ds["repo_id"], roots=roots, aggr_root=root)
    # Episode notes in the merged episode order.
    offset, lines = 0, []
    for r in roots:
        recs = [json.loads(line) for line in (r / "phase2_episodes.jsonl").read_text().splitlines()]
        for rec in recs:
            rec["episode_index"] = offset + rec["shard_episode"]
            lines.append(json.dumps(rec))
        offset += len(recs)
    (root / "phase2_episodes.jsonl").write_text("\n".join(lines) + "\n")
    attempts = sum(s["attempts"] for s in summaries.values())
    failures = Counter()
    for s in summaries.values():
        failures.update(s["failures"])
    summary = dict(episodes=offset, attempts=attempts, success_rate=round(offset / attempts, 4),
                   seeds_from=args.seeds_from,
                   failures=dict(failures), replay_mismatch=sum(s["replay_mismatch"] for s in summaries.values()),
                   piece_sets=sum(s["piece_sets"] for s in summaries.values()),
                   minutes=round((time.time() - t0) / 60, 1), workers=n, config=cfg)
    (root / "phase2_summary.json").write_text(json.dumps(summary, indent=2))

    loaded = LeRobotDataset(ds["repo_id"], root=root)
    item = loaded[len(loaded) // 2]
    shapes = {k: tuple(v.shape) for k, v in item.items() if hasattr(v, "shape")}
    print(f"loaded {root}: {loaded.num_episodes} episodes, {loaded.num_frames} frames at {loaded.fps} fps")
    print("sample:", shapes, "task:", item["task"])
    print(json.dumps({k: v for k, v in summary.items() if k != "config"}, indent=2))
    shutil.rmtree(shards)


if __name__ == "__main__":
    main()