exp2/code/build.py

"""Stage 2: materialize one arm as a LeRobot v3.0 dataset (30 fps uniform grid, cam0/cam1 video, state/action deg).
Parallel: this script launches N shard subprocesses of itself, then aggregates.
    python build.py --arm isr_d4 --workers 24            (driver)
    python build.py --arm isr_d4 --shard k/N             (worker, internal)"""
import argparse, json, glob, shutil, subprocess, sys
from pathlib import Path
import numpy as np, pyarrow.parquet as pq, pyarrow.compute as pc
sys.path.insert(0, str(Path(__file__).resolve().parent)); from prep import apply_plan  # noqa
import os
SRC = os.environ.get("ISR_SRC", "/workspace/isr/datasets/so100_bowl_train"); TRAJS = os.environ.get("ISR_TRAJS", "/workspace/isr/trajs"); KEEPS = os.environ.get("ISR_KEEPS", "/workspace/isr/keeps"); DS = "/workspace/isr/datasets"
CAMS = os.environ.get("ISR_CAMS", "observation.images.cam0,observation.images.cam1").split(","); FPS = int(os.environ.get("ISR_FPS", "30")); ROBOT = os.environ.get("ISR_ROBOT", "so100")

def meta():
    ep_tbl = pq.read_table(sorted(glob.glob(f"{SRC}/meta/episodes/**/*.parquet", recursive=True))[0])
    return {ep_tbl["episode_index"][i].as_py(): {c: ep_tbl[c][i].as_py() for c in ep_tbl.column_names} for i in range(ep_tbl.num_rows)}

def load_imgs(r, L):
    from torchcodec.decoders import VideoDecoder
    out = {}
    for cam in CAMS:
        start = round(r[f"videos/{cam}/from_timestamp"] * FPS)
        vp = f"{SRC}/videos/{cam}/chunk-{r[f'videos/{cam}/chunk_index']:03d}/file-{r[f'videos/{cam}/file_index']:03d}.mp4"
        out[cam] = VideoDecoder(vp).get_frames_in_range(start=start, stop=start + L).data.permute(0, 2, 3, 1).numpy()
    return out

def blend(imgs, p):
    lo = int(np.floor(p)); hi = min(lo + 1, len(imgs) - 1); w = p - lo
    return imgs[lo] if w < 0.02 else ((1 - w) * imgs[lo] + w * imgs[hi]).astype(np.uint8)

def worker(arm, shard, root, enc_threads):
    from lerobot.datasets.lerobot_dataset import LeRobotDataset
    from lerobot.configs.video import RGBEncoderConfig
    k, n = map(int, shard.split("/")); M = meta(); index = json.load(open(f"{TRAJS}/index.json")); task = index["task"]
    eps = sorted(int(e[2:]) for e in index["episodes"])[k::n]
    src = LeRobotDataset("local/src", root=SRC, episodes=[eps[0]]).meta
    feats = {kk: v for kk, v in src.features.items() if kk in ["observation.state", "action"] + CAMS}
    shutil.rmtree(root, ignore_errors=True)
    dst = LeRobotDataset.create(f"local/{arm}_shard{k}", fps=FPS, features=feats, root=root, robot_type=ROBOT, use_videos=True,
                                rgb_encoder=RGBEncoderConfig(vcodec="libsvtav1", pix_fmt="yuv420p", crf=30, preset="10"))
    for j, ep in enumerate(eps):
        d = np.load(f"{TRAJS}/ep{ep}.npz"); keep = np.load(f"{KEEPS}/{arm}/ep{ep}.npy"); r = M[ep]; L = int(r["length"])
        imgs = load_imgs(r, L); pos = d["pos"]; S = (np.concatenate([d["positions"], d["gripper"][:, None]], 1) if "state" not in d else d["state"]).astype(np.float32); A = d["actions"]
        for t in keep:
            dst.add_frame({"observation.state": S[t], "action": A[t], **{c: blend(imgs[c], pos[t]) for c in CAMS}, "task": task})
        dst.save_episode()
        if j % 20 == 0: print(f"shard{k} [{j+1}/{len(eps)}] ep{ep} {L}->{len(keep)}", flush=True)
    if hasattr(dst, "finalize"): dst.finalize()
    print(f"shard{k} DONE", flush=True)

def driver(arm, workers, enc_threads):
    from lerobot.datasets.aggregate import aggregate_datasets
    from lerobot.datasets.lerobot_dataset import LeRobotDataset
    roots = [f"{DS}/_shards/{arm}_shard{k}" for k in range(workers)]; procs = []
    for k, rt in enumerate(roots):
        lf = open(f"{DS}/_shards/{arm}_shard{k}.log", "w")
        procs.append(subprocess.Popen([sys.executable, "-u", __file__, "--arm", arm, "--shard", f"{k}/{workers}", "--encoder-threads", str(enc_threads)], stdout=lf, stderr=subprocess.STDOUT))
    rc = [p.wait() for p in procs]; print("shard rc", rc, flush=True)
    if any(rc):
        for k, r in enumerate(rc):
            if r: print(open(f"{DS}/_shards/{arm}_shard{k}.log").read()[-2000:])
        sys.exit(1)
    final = f"{DS}/{arm}"; shutil.rmtree(final, ignore_errors=True)
    aggregate_datasets([f"local/{arm}_shard{k}" for k in range(workers)], f"local/{arm}", roots=[Path(r) for r in roots], aggr_root=Path(final))
    ds = LeRobotDataset(f"local/{arm}", root=final); st = json.load(open(f"{KEEPS}/{arm}/stats.json"))["summary"]
    json.dump({"arm": arm, "episodes": ds.meta.total_episodes, "frames": ds.meta.total_frames, "select": st}, open(f"{final}/build.json", "w"), indent=1)
    print(f"BUILT {arm}: {ds.meta.total_episodes} eps {ds.meta.total_frames} frames (kept {st['mean_kept']:.2f})", flush=True)
    for r in roots: shutil.rmtree(r, ignore_errors=True)

if __name__ == "__main__":
    ap = argparse.ArgumentParser(); ap.add_argument("--arm", required=True); ap.add_argument("--shard", default=""); ap.add_argument("--workers", type=int, default=24); ap.add_argument("--encoder-threads", type=int, default=4)
    a = ap.parse_args(); Path(f"{DS}/_shards").mkdir(parents=True, exist_ok=True)
    if a.shard: worker(a.arm, a.shard, f"{DS}/_shards/{a.arm}_shard{a.shard.split('/')[0]}", a.encoder_threads)
    else: driver(a.arm, a.workers, a.encoder_threads)