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