Update build_longvideo_test.py

build_longvideo_test.py

@@ -1,46 +1,42 @@
 """
-build_longvideo_test.py
-Build a long-horizon test index for autoregressive rollout evaluation.
+make_longvideo_test.py
+Build a long-horizon rollout test json, schema-identical to data_test_0730.json.
 
-Takes the existing test json (data_test_0730.json), picks N cases from it, and
-re-extends each one from 16 future frames to n_chunks*16 (default 80) by walking
-forward through the episode's metadata.json with the SAME action_stride.
+Picks N random episodes from one task directory, takes ONE case per episode
+starting at the beginning of its moving segment, and extends it to
+n_chunks * 16 future frames at action_stride.
 
-Everything -- action_delta math, pose extraction, path naming -- is copied from
-build_pipeline_data.py so the output is schema-identical to data.json, just with
-a longer n_future. ACWMDataset should load it unchanged.
+samples[i] has exactly the 5 keys the dataset expects:
+    episode, obs_frame_idx, observation_frame, frames, actions
+`frames` and `actions` are n_chunks*16 long instead of 16. `actions` are RAW
+deltas (mm / rad / absolute gripper) -- ACWMDataset normalizes them with
+statistics.json, same as before.
 
 Chunk k of the rollout uses:
-  obs           = future frame [16k - 1]      (k=0 -> the original obs frame)
-  action_delta  = action_delta[16k : 16k+16]
-so chunk k's observation is exactly the last frame chunk k-1 generated.
+    obs    = frames[16k - 1]        (k=0 -> observation_frame)
+    action = actions[16k : 16k+16]
 
-Cases that cannot reach n_chunks are truncated to the largest whole number of
-chunks; selection prefers full-length cases.
+Per-case chunk metadata goes in top-level "rollout_info" (parallel to samples),
+so `samples` stays byte-compatible with what the dataset already reads.
 
 Usage:
-  python build_longvideo_test.py \
-    --source_root /net/.../physical_wm/grasping \
-    --test_json   /n/netscratch/.../data_test_0730.json \
-    --out         /n/netscratch/.../data_test_0823_longvideo.json \
-    --n_cases 16 --n_chunks 5 --action_stride 3
+  python make_longvideo_test.py \
+    --task_dir /n/lab_storage/ydu_lab/sycen/data/physical_wm/grasping/grasping_videos/grasping_gello_flip_the_switch_box_open_to_the_left_100 \
+    --source_root /n/lab_storage/ydu_lab/sycen/data/physical_wm/grasping \
+    --out /n/netscratch/ydu_lab/Lab/sycen/data/data_test_0823_longvideo.json \
+    --n_episodes 15 --n_chunks 5
 """
 
 import argparse
 import json
 import os
 import random
-from collections import defaultdict
-from pathlib import Path
 
 import numpy as np
 from scipy.spatial.transform import Rotation as R
-from tqdm import tqdm
 
 
-# --------------------------------------------------------------------------- #
-# verbatim from build_pipeline_data.py -- do not "improve" these
-# --------------------------------------------------------------------------- #
+# --- copied verbatim from build_pipeline_data.py ---------------------------- #
 def load_metadata(episode_dir, camera="camera2"):
     with open(os.path.join(episode_dir, "metadata.json")) as f:
         meta = json.load(f)
@@ -59,127 +55,54 @@ def get_pose(entry):
 
 
 def action_delta(entry_from, entry_to):
+    """[dx,dy,dz, drx,dry,drz, gripper_abs]; rot = SO(3) relative, euler xyz."""
     t0, r0, _ = get_pose(entry_from)
     t1, r1, g1 = get_pose(entry_to)
     dt = t1 - t0
-    R0 = R.from_euler("xyz", r0)
-    R1 = R.from_euler("xyz", r1)
-    drot = (R0.inv() * R1).as_euler("xyz")
+    drot = (R.from_euler("xyz", r0).inv() * R.from_euler("xyz", r1)).as_euler("xyz")
     return np.array([dt[0], dt[1], dt[2], drot[0], drot[1], drot[2], g1],
                     dtype=np.float64)
 
 
-def rpy_delta_norm(r0, r1):
-    d = r1 - r0
-    d = (d + np.pi) % (2 * np.pi) - np.pi
-    return float(np.linalg.norm(d))
-
-
-def compute_valid_range(meta, trans_thresh, rot_thresh):
+def compute_valid_range(meta, trans_thresh=1.0, rot_thresh=0.01):
     n = len(meta)
     if n < 2:
         return None
-    trans_d = np.zeros(n)
-    rot_d = np.zeros(n)
+    moving = np.zeros(n, dtype=bool)
     for i in range(1, n):
         t0, r0, _ = get_pose(meta[i - 1])
         t1, r1, _ = get_pose(meta[i])
-        trans_d[i] = float(np.linalg.norm(t1 - t0))
-        rot_d[i] = rpy_delta_norm(r0, r1)
-    moving = (trans_d > trans_thresh) | (rot_d > rot_thresh)
+        dr = (r1 - r0 + np.pi) % (2 * np.pi) - np.pi
+        moving[i] = (np.linalg.norm(t1 - t0) > trans_thresh
+                     or np.linalg.norm(dr) > rot_thresh)
     if not moving.any():
         return None
-    first = int(np.argmax(moving))
-    last = n - 1 - int(np.argmax(moving[::-1]))
-    return first, last
-
-
-def contact_nonblack(path):
-    return bool(np.any(np.load(path) != 0))
-
-
-# --------------------------------------------------------------------------- #
-def reachable_chunks(meta, obs_pos, last_pos, action_stride, chunk_len, n_chunks):
-    """How many whole 16-frame chunks fit starting at obs_pos."""
-    for k in range(n_chunks, 0, -1):
-        if obs_pos + k * chunk_len * action_stride <= last_pos:
-            return k
-    return 0
-
-
-def build_long_clip(ep_dir, source_root, meta, obs_pos, n_future,
-                    action_stride, chunk_len):
-    """Schema-identical to build_pipeline_data.py's clip, with n_future frames."""
-    future_pos = [obs_pos + (i + 1) * action_stride for i in range(n_future)]
-
-    obs_entry = meta[obs_pos]
-    obs_frame_idx = obs_entry["frame_idx"]
-    future_frame_idxs = [meta[p]["frame_idx"] for p in future_pos]
-
-    obs_image_path = obs_entry.get(
-        "image_path", f"images/frame_{obs_frame_idx:06d}.png")
-    future_image_paths = [
-        meta[p].get("image_path", f"images/frame_{meta[p]['frame_idx']:06d}.png")
-        for p in future_pos
-    ]
-    contact_paths = [os.path.join("modalities/contact", f"{fi:06d}.npy")
-                     for fi in future_frame_idxs]
-    force_paths = [os.path.join("modalities/force", f"{fi:06d}.npy")
-                   for fi in future_frame_idxs]
-
-    for p in contact_paths + force_paths:
-        if not os.path.exists(os.path.join(ep_dir, p)):
-            return None, f"missing {p}"
-
-    # action[i] = pos[s+i*stride] -> pos[s+(i+1)*stride]
-    action = np.stack([
-        action_delta(meta[obs_pos + i * action_stride],
-                     meta[obs_pos + (i + 1) * action_stride])
-        for i in range(n_future)
-    ])
-
-    n_nonblack = sum(contact_nonblack(os.path.join(ep_dir, cp))
-                     for cp in contact_paths)
-
-    t, r, g = get_pose(obs_entry)
-
-    # per-chunk contact activity: tells you which chunks actually have contact,
-    # so a flat force curve in chunk 0 is not mistaken for model collapse
-    n_chunks = n_future // chunk_len
-    chunk_active = []
-    for k in range(n_chunks):
-        sub = contact_paths[k * chunk_len:(k + 1) * chunk_len]
-        chunk_active.append(
-            sum(contact_nonblack(os.path.join(ep_dir, cp)) for cp in sub) / chunk_len)
-
-    clip = {
-        "episode": os.path.relpath(ep_dir, source_root),
-        "obs_frame_idx": obs_frame_idx,
-        "future_frame_idxs": future_frame_idxs,
-        "obs_image_path": obs_image_path,
-        "future_image_paths": future_image_paths,
-        "contact_paths": contact_paths,
-        "force_paths": force_paths,
-        "obs_pose": [t[0], t[1], t[2], r[0], r[1], r[2], g],
-        "action_delta": action.tolist(),
-        "activate_frac": n_nonblack / n_future,
-        "n_contact_frames": n_nonblack,
-        # rollout bookkeeping
-        "n_chunks": n_chunks,
-        "chunk_len": chunk_len,
-        "chunk_activate_frac": chunk_active,
-    }
-    return clip, None
+    return int(np.argmax(moving)), n - 1 - int(np.argmax(moving[::-1]))
+# ---------------------------------------------------------------------------- #
+
+
+def rel_image(episode_rel, entry):
+    """Full relative path with episode prefix, matching the test json."""
+    p = entry.get("image_path", f"images/frame_{entry['frame_idx']:06d}.png")
+    return os.path.join(episode_rel, p)
+
+
+def contact_active(ep_dir, frame_idx):
+    p = os.path.join(ep_dir, "modalities", "contact", f"{frame_idx:06d}.npy")
+    if not os.path.exists(p):
+        return None
+    return bool(np.any(np.load(p) != 0))
 
 
-# --------------------------------------------------------------------------- #
 def main():
     ap = argparse.ArgumentParser()
-    ap.add_argument("--source_root", required=True)
-    ap.add_argument("--test_json", required=True,
-                    help="existing short test json; supplies episode + obs_frame_idx")
+    ap.add_argument("--task_dir", required=True,
+                    help="directory containing the episode folders (0000, 0001, ...)")
+    ap.add_argument("--source_root", required=True,
+                    help="root that `episode` is relative to; must match the "
+                         "--source_root you pass to inference")
     ap.add_argument("--out", required=True)
-    ap.add_argument("--n_cases", type=int, default=16)
+    ap.add_argument("--n_episodes", type=int, default=15)
     ap.add_argument("--n_chunks", type=int, default=5)
     ap.add_argument("--chunk_len", type=int, default=16)
     ap.add_argument("--action_stride", type=int, default=3)
@@ -187,148 +110,134 @@ def main():
     ap.add_argument("--trans_thresh", type=float, default=1.0)
     ap.add_argument("--rot_thresh", type=float, default=0.01)
     ap.add_argument("--seed", type=int, default=0)
-    ap.add_argument("--one_per_episode", action="store_true", default=True,
-                    help="at most one rollout per episode (default on) so the "
-                         "cases are not near-duplicates of each other")
-    ap.add_argument("--allow_repeat_episode", dest="one_per_episode",
-                    action="store_false")
-    ap.add_argument("--use_full_range", action="store_true",
-                    help="allow rolling past the moving segment into the static "
-                         "tail; default stops at the valid range's last frame")
+    ap.add_argument("--start_offset", type=int, default=0,
+                    help="frames to skip past the start of the moving segment; "
+                         "raise it if the early chunks have no contact")
     args = ap.parse_args()
 
     rng = random.Random(args.seed)
-    source_root = str(Path(args.source_root))
-
-    with open(args.test_json) as f:
-        test = json.load(f)
-    src_clips = test["clips"] if isinstance(test, dict) else test
-    print(f"loaded {len(src_clips)} clips from {args.test_json}")
-
-    # unique (episode, obs_frame_idx) start points, grouped by episode
-    by_ep = defaultdict(set)
-    for c in src_clips:
-        by_ep[c["episode"]].add(c["obs_frame_idx"])
-    print(f"{len(by_ep)} distinct episodes")
-
-    n_future = args.n_chunks * args.chunk_len
-    span = n_future * args.action_stride
-    print(f"target: {n_future} future frames, span={span} raw frames "
-          f"(stride={args.action_stride})")
-
-    # ---- evaluate every candidate start point ----
-    candidates = []       # (n_reachable, episode, obs_pos, meta, ep_dir)
-    meta_cache = {}
-    for ep, obs_idxs in tqdm(sorted(by_ep.items()), desc="scanning episodes"):
-        ep_dir = os.path.join(source_root, ep)
-        if ep not in meta_cache:
-            try:
-                meta_cache[ep] = load_metadata(ep_dir, args.camera)
-            except Exception as e:
-                print(f"  [skip] {ep}: {e}")
-                meta_cache[ep] = None
-        meta = meta_cache[ep]
-        if not meta:
-            continue
+    task_dir = os.path.abspath(args.task_dir)
+    source_root = os.path.abspath(args.source_root)
+
+    ep_names = sorted(
+        d for d in os.listdir(task_dir)
+        if os.path.isdir(os.path.join(task_dir, d))
+        and os.path.exists(os.path.join(task_dir, d, "metadata.json"))
+    )
+    print(f"{len(ep_names)} episodes in {os.path.basename(task_dir)}")
+    rng.shuffle(ep_names)
+
+    samples, info = [], []
+    n_short = n_missing = 0
+
+    for name in ep_names:
+        if len(samples) >= args.n_episodes:
+            break
+        ep_dir = os.path.join(task_dir, name)
+        episode_rel = os.path.relpath(ep_dir, source_root)
 
+        meta = load_metadata(ep_dir, args.camera)
         vr = compute_valid_range(meta, args.trans_thresh, args.rot_thresh)
         if vr is None:
+            n_short += 1
             continue
         first, last = vr
-        if args.use_full_range:
-            last = len(meta) - 1
-
-        fi2pos = {m["frame_idx"]: i for i, m in enumerate(meta)}
-        for fi in sorted(obs_idxs):
-            pos = fi2pos.get(fi)
-            if pos is None:
-                continue
-            k = reachable_chunks(meta, pos, last, args.action_stride,
-                                 args.chunk_len, args.n_chunks)
-            if k > 0:
-                candidates.append((k, ep, pos, fi))
-
-    if not candidates:
-        raise RuntimeError("no start point can reach even one chunk")
-
-    hist = defaultdict(int)
-    for k, *_ in candidates:
-        hist[k] += 1
-    print("\nreachable-chunk histogram over all candidate starts:")
-    for k in sorted(hist, reverse=True):
-        print(f"  {k} chunks: {hist[k]}")
-
-    # ---- select: prefer full-length, then shorter; one per episode ----
-    rng.shuffle(candidates)
-    candidates.sort(key=lambda x: -x[0])          # stable: full-length first
-
-    selected, used_eps = [], set()
-    for k, ep, pos, fi in candidates:
-        if len(selected) >= args.n_cases:
-            break
-        if args.one_per_episode and ep in used_eps:
+        s = min(first + args.start_offset, last)
+
+        # largest whole number of chunks that fits
+        k = 0
+        for cand in range(args.n_chunks, 0, -1):
+            if s + cand * args.chunk_len * args.action_stride <= last:
+                k = cand
+                break
+        if k == 0:
+            n_short += 1
             continue
-        selected.append((k, ep, pos, fi))
-        used_eps.add(ep)
-
-    if len(selected) < args.n_cases and args.one_per_episode:
-        print(f"\nonly {len(selected)} cases with one-per-episode; "
-              f"filling the rest by allowing repeats")
-        for k, ep, pos, fi in candidates:
-            if len(selected) >= args.n_cases:
+
+        n_future = k * args.chunk_len
+        fut_pos = [s + (i + 1) * args.action_stride for i in range(n_future)]
+
+        # every frame's png and modality npy must exist
+        ok = True
+        for p in fut_pos:
+            fi = meta[p]["frame_idx"]
+            if not os.path.exists(os.path.join(source_root,
+                                               rel_image(episode_rel, meta[p]))):
+                ok = False
                 break
-            if (k, ep, pos, fi) in selected:
-                continue
-            selected.append((k, ep, pos, fi))
-
-    print(f"\nselected {len(selected)} cases:")
-    for k, ep, pos, fi in selected:
-        print(f"  {k} chunks  frame={fi:6d}  {ep}")
-
-    # ---- build ----
-    out_clips = []
-    for k, ep, pos, fi in tqdm(selected, desc="building"):
-        meta = meta_cache[ep]
-        clip, err = build_long_clip(
-            os.path.join(source_root, ep), source_root, meta, pos,
-            k * args.chunk_len, args.action_stride, args.chunk_len)
-        if clip is None:
-            print(f"  [drop] {ep} frame {fi}: {err}")
+            for mod in ("contact", "force"):
+                if not os.path.exists(os.path.join(
+                        ep_dir, "modalities", mod, f"{fi:06d}.npy")):
+                    ok = False
+                    break
+            if not ok:
+                break
+        if not ok:
+            n_missing += 1
             continue
-        out_clips.append(clip)
-
-    config = dict(test.get("config", {})) if isinstance(test, dict) else {}
-    config.update({
-        "camera": args.camera,
-        "action_stride": args.action_stride,
-        "n_future": n_future,
-        "chunk_len": args.chunk_len,
-        "n_chunks": args.n_chunks,
-        "trans_thresh": args.trans_thresh,
-        "rot_thresh": args.rot_thresh,
-        "action_dim_names": ["dx", "dy", "dz", "drx", "dry", "drz", "gripper_abs"],
-        "obs_pose_names": ["x", "y", "z", "r1", "r2", "r3", "gripper"],
-        "note": ("long-horizon rollout index. n_future is VARIABLE per clip "
-                 "(n_chunks*chunk_len); read clip['n_chunks']. chunk k uses "
-                 "obs = future frame [16k-1] and action_delta[16k:16k+16]."),
-        "source_test_json": args.test_json,
-        "seed": args.seed,
-    })
 
+        actions = np.stack([
+            action_delta(meta[s + i * args.action_stride],
+                         meta[s + (i + 1) * args.action_stride])
+            for i in range(n_future)
+        ])
+
+        samples.append({
+            "episode": episode_rel,
+            "obs_frame_idx": meta[s]["frame_idx"],
+            "observation_frame": rel_image(episode_rel, meta[s]),
+            "frames": [rel_image(episode_rel, meta[p]) for p in fut_pos],
+            "actions": actions.tolist(),
+        })
+
+        # contact activity per chunk -- a flat force curve in a chunk with
+        # activate=0.00 is correct behaviour, not model collapse
+        act = []
+        for c in range(k):
+            sub = fut_pos[c * args.chunk_len:(c + 1) * args.chunk_len]
+            vals = [contact_active(ep_dir, meta[p]["frame_idx"]) for p in sub]
+            act.append(sum(bool(v) for v in vals) / len(vals))
+        info.append({
+            "episode": episode_rel,
+            "obs_frame_idx": meta[s]["frame_idx"],
+            "n_chunks": k,
+            "chunk_len": args.chunk_len,
+            "n_frames_total": len(meta),
+            "valid_range": [first, last],
+            "chunk_activate_frac": act,
+        })
+
+    out = {
+        "source": task_dir,
+        "config": {
+            "action_stride": args.action_stride,
+            "chunk_len": args.chunk_len,
+            "n_chunks_requested": args.n_chunks,
+            "camera": args.camera,
+            "source_root": source_root,
+            "seed": args.seed,
+            "note": ("long-horizon rollout index. `frames`/`actions` are "
+                     "n_chunks*16 long. chunk k: obs = frames[16k-1] "
+                     "(k=0 -> observation_frame), action = actions[16k:16k+16]. "
+                     "actions are RAW deltas; normalize with statistics.json."),
+        },
+        "n_samples": len(samples),
+        "samples": samples,
+        "rollout_info": info,
+    }
     with open(args.out, "w") as f:
-        json.dump({"config": config, "n_clips": len(out_clips),
-                   "clips": out_clips}, f)
-
-    dist = defaultdict(int)
-    for c in out_clips:
-        dist[c["n_chunks"]] += 1
-    print(f"\nwrote {args.out}  ({len(out_clips)} clips)")
-    print("  chunk-count distribution: " +
-          ", ".join(f"{k}x{v}" for k, v in sorted(dist.items(), reverse=True)))
-    print("  per-case contact activity by chunk:")
-    for c in out_clips:
-        s = " ".join(f"{v:.2f}" for v in c["chunk_activate_frac"])
-        print(f"    {c['episode'][-40:]:40s} frame={c['obs_frame_idx']:6d}  [{s}]")
+        json.dump(out, f)
+
+    print(f"\nwrote {args.out}  ({len(samples)} cases)")
+    if n_short:
+        print(f"  {n_short} episodes too short / never moving")
+    if n_missing:
+        print(f"  {n_missing} episodes dropped for missing png/npy")
+    print(f"\n{'episode':>6s}  {'obs':>5s}  {'len':>4s}  ch  contact fraction per chunk")
+    for it in info:
+        s = " ".join(f"{v:.2f}" for v in it["chunk_activate_frac"])
+        print(f"{it['episode'].split('/')[-1]:>6s}  {it['obs_frame_idx']:5d}  "
+              f"{it['n_frames_total']:4d}  {it['n_chunks']}   [{s}]")
 
 
 if __name__ == "__main__":