Blame for to_lerobot_v21.py

"""
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/<cat>/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:                      # "<family>: <sentence>"
                    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()