""" Convert the retargeted YAM HDF5 clips -> a LeRobot v2.1 dataset, using the downloaded EgoDex egocentric videos as the image observation. Each retargeted clip (/workspace/retargeted//clip_file-YYY_epN/retargeted.hdf5) becomes one LeRobot episode: data/chunk-CCC/episode_EEEEEE.parquet videos/chunk-CCC/observation.images.camera/episode_EEEEEE.mp4 (EgoDex clip, hardlinked) Trajectory -> LeRobot columns (matching angkul07/abc-teleop, also v2.1): observation.state[t] = joint_positions[t] (14-D, absolute) action[t] = joint_positions[t+1] (next absolute target; last frame repeated) + timestamp, frame_index, episode_index, index, task_index The 14 dims are [R_j1..6, R_gripper, L_j1..6, L_gripper]; gripper already normalized to [0,1], arm joints in radians — same convention as abc-teleop. Frame alignment: retargeting only ever drops frames, so T <= source frames = video frames. We use T; the EgoDex mp4 (>= T frames, 30 fps, from t=0) lines up. Video is HARDLINKED (same filesystem) — no re-encode, no extra disk. Usage: python to_lerobot_v21.py --out /workspace/retargeted_lerobot [--limit N] [--workers K] """ import os, sys, re, glob, json, argparse, subprocess, shutil, random from pathlib import Path import numpy as np import pyarrow as pa import pyarrow.parquet as pq import h5py import multiprocessing as mp RETGT = os.environ.get("RETGT", "/workspace/retargeted") EGO = os.environ.get("EGO", "/workspace/ego") FPS = 30 CHUNK = 1000 VIDEO_KEY = "observation.images.camera" # EgoDex video properties (from ego meta/info.json) VID_H, VID_W, VID_CODEC, VID_PIXFMT = 1080, 1920, "av1", "yuv420p" DOF = 14 STATE_NAMES = [f"R_joint{i}" for i in range(1,7)] + ["R_gripper"] + \ [f"L_joint{i}" for i in range(1,7)] + ["L_gripper"] OUT = "" # set in main IMG_STATS = None # global image stats dict, set in main TASK_INDEX = {} # task string -> index, set in main # ───────────────────────────────────────────────────────────────────────────── # discovery / mapping # ───────────────────────────────────────────────────────────────────────────── def clip_fileidx(name: str) -> str: return re.search(r"(file-\d+)_ep", name).group(1) def source_video(cat: str, fyy: str) -> str | None: hits = glob.glob(f"{EGO}/{cat}/videos/{VIDEO_KEY}/chunk-*/{fyy}.mp4") return hits[0] if hits else None def discover() -> list[dict]: """All clips, sorted by (category, file index), assigned a global episode index. Returns dicts with hdf5/category/video/task.""" ego_tasks = ego_task_maps() eps = [] for h in sorted(glob.glob(f"{RETGT}/*/clip_*/retargeted.hdf5")): parts = h.split("/") cat, name = parts[3], parts[4] fyy = clip_fileidx(name) eps.append({"hdf5": h, "category": cat, "name": name, "fileidx": int(fyy.split("-")[1]), "video": source_video(cat, fyy), "task": ego_tasks.get((cat, int(fyy.split("-")[1])), "")}) eps.sort(key=lambda e: (e["category"], e["fileidx"])) for i, e in enumerate(eps): e["episode_index"] = i return eps def ego_task_maps() -> dict: """(category, file_index) -> instruction string, from EgoDex meta/episodes. Authoritative and complete (fixes clips whose HDF5 description was empty because the meta had not downloaded yet at retarget time).""" out = {} for cat_dir in sorted(glob.glob(f"{EGO}/*/meta/episodes")): cat = cat_dir.split("/")[3] for mf in sorted(glob.glob(f"{cat_dir}/chunk-*/*.parquet")): try: t = pq.read_table(mf, columns=["tasks", "data/file_index"]).to_pydict() except Exception: continue for tasks, fi in zip(t["tasks"], t["data/file_index"]): s = (list(tasks) or [""])[0] if tasks is not None else "" if ": " in s: # ": " s = s.split(": ", 1)[1] out[(cat, int(fi))] = s return out # ───────────────────────────────────────────────────────────────────────────── # image stats (global, sampled via ffmpeg — no python decoder on this box) # ───────────────────────────────────────────────────────────────────────────── def _decode_frames(mp4: str, n: int = 2, size: int = 224) -> list[np.ndarray]: try: dur = float(subprocess.run( ["ffprobe","-v","error","-show_entries","format=duration", "-of","csv=p=0",mp4], capture_output=True, text=True).stdout.strip()) except ValueError: return [] frames = [] for k in range(n): t = dur * (k + 0.5) / n r = subprocess.run( ["ffmpeg","-v","error","-ss",f"{t:.3f}","-i",mp4,"-frames:v","1", "-vf",f"scale={size}:{size}","-f","rawvideo","-pix_fmt","rgb24","-"], capture_output=True) buf = r.stdout if len(buf) == size*size*3: frames.append(np.frombuffer(buf, np.uint8).reshape(size, size, 3)) return frames def global_image_stats(videos: list[str], n_videos: int = 120) -> dict: random.seed(0) samp = random.sample(videos, min(n_videos, len(videos))) px = [] for v in samp: px.extend(_decode_frames(v)) if not px: # ffmpeg/av1 unavailable — neutral [0,1] placeholder so the dataset is # still valid; recompute later if image normalization matters. z = np.zeros((3,1,1)); return {"min": z.tolist(), "max": (z+1).tolist(), "mean": (z+0.5).tolist(), "std": (z+0.25).tolist(), "_placeholder": True} arr = np.stack(px).astype(np.float32) / 255.0 # (N,H,W,3) in [0,1] def perch(f): return f(arr, axis=(0,1,2)).reshape(3,1,1).tolist() return {"min": perch(np.min), "max": perch(np.max), "mean": perch(np.mean), "std": perch(np.std), "_placeholder": False, "_n_frames": len(px)} # ───────────────────────────────────────────────────────────────────────────── # per-episode conversion # ───────────────────────────────────────────────────────────────────────────── def _stat(a: np.ndarray) -> dict: """LeRobot per-feature stats. a: (L,) or (L,D).""" a = np.asarray(a, np.float64) if a.ndim == 1: a = a[:, None] return {"min": a.min(0).tolist(), "max": a.max(0).tolist(), "mean": a.mean(0).tolist(), "std": a.std(0).tolist(), "count": [a.shape[0]]} def convert_one(e: dict) -> dict | None: try: with h5py.File(e["hdf5"], "r") as f: q = f["joint_positions"][:].astype(np.float32) # (T,14) except Exception as ex: return {"episode_index": e["episode_index"], "error": f"hdf5: {ex}"} if e["video"] is None or not os.path.exists(e["video"]): return {"episode_index": e["episode_index"], "error": "no video"} T = len(q) state = q # (T,14) action = np.vstack([q[1:], q[-1:]]) # next target ts = (np.arange(T) / FPS).astype(np.float32) fidx = np.arange(T, dtype=np.int64) eidx = np.full(T, e["episode_index"], np.int64) tidx = np.full(T, e["task_index"], np.int64) gindex = e["index_offset"] + np.arange(T, dtype=np.int64) ci = e["episode_index"] // CHUNK # data parquet dp = Path(OUT) / f"data/chunk-{ci:03d}/episode_{e['episode_index']:06d}.parquet" dp.parent.mkdir(parents=True, exist_ok=True) lst = pa.list_(pa.float32(), DOF) table = pa.table({ "observation.state": pa.array(state.tolist(), type=lst), "action": pa.array(action.tolist(), type=lst), "timestamp": pa.array(ts, pa.float32()), "frame_index": pa.array(fidx, pa.int64()), "episode_index": pa.array(eidx, pa.int64()), "index": pa.array(gindex, pa.int64()), "task_index": pa.array(tidx, pa.int64()), }) pq.write_table(table, dp) # video: hardlink (same fs) -> canonical path; copy if cross-device vp = Path(OUT) / f"videos/chunk-{ci:03d}/{VIDEO_KEY}/episode_{e['episode_index']:06d}.mp4" vp.parent.mkdir(parents=True, exist_ok=True) if vp.exists() or vp.is_symlink(): vp.unlink() try: os.link(e["video"], vp) except OSError: shutil.copy(e["video"], vp) stats = { VIDEO_KEY: {**{k: IMG_STATS[k] for k in ("min","max","mean","std")}, "count": [T]}, "observation.state": _stat(state), "action": _stat(action), "timestamp": _stat(ts), "frame_index": _stat(fidx), "episode_index": _stat(eidx), "index": _stat(gindex), "task_index": _stat(tidx), } return {"episode_index": e["episode_index"], "length": T, "task": e["task"], "stats": stats} # ───────────────────────────────────────────────────────────────────────────── # meta writers # ───────────────────────────────────────────────────────────────────────────── def feature_block(): v = lambda names, shape, dt="float32": {"dtype": dt, "shape": shape, "names": names} return { VIDEO_KEY: {"dtype": "video", "shape": [VID_H, VID_W, 3], "names": ["height","width","channels"], "info": {"video.height": VID_H, "video.width": VID_W, "video.codec": VID_CODEC, "video.pix_fmt": VID_PIXFMT, "video.is_depth_map": False, "video.fps": FPS, "video.channels": 3, "has_audio": False}}, "observation.state": v(["state"], [DOF]), "action": v(["action"], [DOF]), "timestamp": v(None, [1]), "frame_index": v(None,[1],"int64"), "episode_index": v(None,[1],"int64"), "index": v(None,[1],"int64"), "task_index": v(None,[1],"int64"), } def write_meta(results, total_frames): meta = Path(OUT) / "meta"; meta.mkdir(parents=True, exist_ok=True) n = len(results) n_chunks = (n + CHUNK - 1) // CHUNK info = { "codebase_version": "v2.1", "robot_type": "yam_bimanual", "total_episodes": n, "total_frames": total_frames, "total_tasks": len(TASK_INDEX), "total_videos": n, "total_chunks": n_chunks, "chunks_size": CHUNK, "fps": FPS, "splits": {"train": f"0:{n}"}, "data_path": "data/chunk-{episode_chunk:03d}/episode_{episode_index:06d}.parquet", "video_path": "videos/chunk-{episode_chunk:03d}/{video_key}/episode_{episode_index:06d}.mp4", "features": feature_block(), } (meta/"info.json").write_text(json.dumps(info, indent=4)) with (meta/"episodes.jsonl").open("w") as f: for r in results: f.write(json.dumps({"episode_index": r["episode_index"], "tasks": [r["task"]], "length": r["length"]}) + "\n") with (meta/"tasks.jsonl").open("w") as f: for task, idx in sorted(TASK_INDEX.items(), key=lambda kv: kv[1]): f.write(json.dumps({"task_index": idx, "task": task}) + "\n") with (meta/"episodes_stats.jsonl").open("w") as f: for r in results: f.write(json.dumps({"episode_index": r["episode_index"], "stats": r["stats"]}) + "\n") def main(): global OUT, IMG_STATS, TASK_INDEX ap = argparse.ArgumentParser() ap.add_argument("--out", required=True) ap.add_argument("--limit", type=int, default=0) ap.add_argument("--workers", type=int, default=0) args = ap.parse_args() OUT = args.out Path(OUT).mkdir(parents=True, exist_ok=True) eps = discover() if args.limit: eps = eps[:args.limit] print(f"episodes: {len(eps)}", flush=True) # task strings -> index (single source of truth: EgoDex meta, fallback category) for e in eps: if not e["task"]: e["task"] = f"{e['category'].replace('_',' ')} pick and place" for t in sorted({e["task"] for e in eps}): TASK_INDEX[t] = len(TASK_INDEX) for e in eps: e["task_index"] = TASK_INDEX[e["task"]] print(f"unique tasks: {len(TASK_INDEX)}", flush=True) # global index offsets (cumulative frame counter) — need per-episode T first lengths = [] for e in eps: with h5py.File(e["hdf5"], "r") as f: lengths.append(int(f.attrs["n_frames"])) off = np.concatenate([[0], np.cumsum(lengths)[:-1]]) for e, o in zip(eps, off): e["index_offset"] = int(o) print("computing global image stats (ffmpeg sample)...", flush=True) IMG_STATS = global_image_stats([e["video"] for e in eps if e["video"]]) print(f" image stats placeholder={IMG_STATS.get('_placeholder')} " f"mean={np.array(IMG_STATS['mean']).ravel().round(3).tolist()}", flush=True) n = args.workers or min(len(eps), os.cpu_count() or 1) print(f"converting with {n} workers...", flush=True) with mp.Pool(n) as pool: results = pool.map(convert_one, eps, chunksize=8) ok = [r for r in results if r and "stats" in r] err = [r for r in results if r and "error" in r] ok.sort(key=lambda r: r["episode_index"]) total_frames = sum(r["length"] for r in ok) write_meta(ok, total_frames) print(f"\nDONE: {len(ok)} episodes, {total_frames} frames, {len(err)} errors") for e in err[:10]: print(" ERR", e["episode_index"], e["error"]) print(f"dataset -> {OUT}") if __name__ == "__main__": main()