| """ |
| build_clip_index.py |
| |
| Build the clip index + global normalization statistics for Contact/Force VAE |
| finetuning. |
| |
| Per episode: |
| 1. Read metadata.json, compute frame-to-frame action delta (trans mm + rot rad). |
| 2. Trim only the static head/tail: |
| moving = (trans > trans_thresh) | (rot > rot_thresh) |
| first = first moving frame, last = last moving frame -> valid range |
| (zeros in the MIDDLE are kept; we only cut the two ends.) |
| 3. Inside the valid range, take CLIPS_PER_EPISODE start positions spaced |
| evenly (not dense sliding) so clips overlap little and cover the whole |
| motion (approach -> contact -> release). |
| 4. Each clip = 17 frames at frame_stride: positions s, s+stride, ..., s+16*stride. |
| |
| Outputs: |
| - clips.json : list of clips, each with episode path + 17 frame_idx + |
| 17 contact/force npy paths. |
| - statistics.json : global normalization constants. |
| contact: per-finger scale on sqrt-transformed values (p99) |
| force: per-channel mean/std over nonzero pixels |
| |
| Usage: |
| python build_clip_index.py --source_root /path/to/root --out_dir ./vae_index |
| python build_clip_index.py --source_root /path/to/root --out_dir ./vae_index \ |
| --clips_per_episode 15 --frame_stride 3 --trans_thresh 1.0 --rot_thresh 0.01 |
| """ |
|
|
| import argparse |
| import json |
| import os |
| import glob |
| import random |
| import numpy as np |
| from pathlib import Path |
| from tqdm import tqdm |
|
|
| from collections import defaultdict |
|
|
| FLAG_NAME = "double_checked.flag" |
|
|
|
|
| |
| def load_metadata(episode_dir, camera="camera2"): |
| with open(os.path.join(episode_dir, "metadata.json")) as f: |
| meta = json.load(f) |
| cam = [m for m in meta if m.get("camera") == camera] |
| if cam: |
| meta = cam |
| meta = sorted(meta, key=lambda m: m.get("frame_idx", 0)) |
| return meta |
|
|
|
|
| def get_pose(entry): |
| s = entry["eef_state"] |
| t = np.array([s["x"], s["y"], s["z"]], dtype=np.float64) |
| r = np.array([s["r1"], s["r2"], s["r3"]], dtype=np.float64) |
| return t, r |
|
|
|
|
| def rpy_delta(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): |
| """Return (first_pos, last_pos) positions in the meta list that bound the |
| moving segment. Only trims the two ends; middle zeros are kept.""" |
| n = len(meta) |
| trans_d = np.zeros(n) |
| rot_d = np.zeros(n) |
| 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(r0, r1) |
| moving = (trans_d > trans_thresh) | (rot_d > 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 sample_clip_starts( |
| first_pos, |
| last_pos, |
| frame_stride, |
| n_frames, |
| clips_per_episode, |
| ): |
| """ |
| Greedily choose clip starts that maximize the number of previously unseen |
| sampled frame positions. |
| |
| Example with stride=3: |
| start 12 -> 12,15,18,... |
| start 16 -> 16,19,22,... |
| These overlap temporally but do not reuse the exact same frames. |
| """ |
| span = (n_frames - 1) * frame_stride |
| max_start = last_pos - span |
|
|
| if max_start < first_pos: |
| return [] |
|
|
| candidates = list(range(first_pos, max_start + 1)) |
| k = min(clips_per_episode, len(candidates)) |
|
|
| selected = [] |
| used_frames = set() |
|
|
| while candidates and len(selected) < k: |
| best_start = None |
| best_gain = -1 |
| best_spacing = -1 |
|
|
| for s in candidates: |
| clip_frames = { |
| s + i * frame_stride |
| for i in range(n_frames) |
| } |
|
|
| |
| gain = len(clip_frames - used_frames) |
|
|
| |
| if selected: |
| spacing = min(abs(s - old_s) for old_s in selected) |
| else: |
| spacing = float("inf") |
|
|
| if ( |
| gain > best_gain |
| or (gain == best_gain and spacing > best_spacing) |
| ): |
| best_start = s |
| best_gain = gain |
| best_spacing = spacing |
|
|
| selected.append(best_start) |
| used_frames.update( |
| best_start + i * frame_stride |
| for i in range(n_frames) |
| ) |
| candidates.remove(best_start) |
|
|
| return sorted(selected) |
|
|
|
|
| def build_clips_for_episode(episode_dir, source_root, meta, valid_range, |
| frame_stride, n_frames, clips_per_episode, |
| contact_dir="modalities/contact", |
| force_dir="modalities/force"): |
| first_pos, last_pos = valid_range |
| starts = sample_clip_starts(first_pos, last_pos, frame_stride, n_frames, |
| clips_per_episode) |
|
|
| """ |
| new print |
| """ |
| sampled_positions = set() |
|
|
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| for s in starts: |
| sampled_positions.update( |
| s + i * frame_stride |
| for i in range(n_frames) |
| ) |
| |
| total_entries = len(starts) * n_frames |
| unique_frames = len(sampled_positions) |
| valid_length = last_pos - first_pos + 1 |
| |
| unique_ratio = unique_frames / max(total_entries, 1) |
| coverage_ratio = unique_frames / max(valid_length, 1) |
| |
| print( |
| f"clips={len(starts)}, " |
| f"entries={total_entries}, " |
| f"unique={unique_frames}, " |
| f"unique_ratio={unique_ratio:.1%}, " |
| f"valid_length={valid_length}, " |
| f"coverage={coverage_ratio:.1%}" |
| ) |
| |
| rel_ep = os.path.relpath(episode_dir, source_root) |
| clips = [] |
| for s in starts: |
| positions = [s + i * frame_stride for i in range(n_frames)] |
| frame_idxs = [meta[p]["frame_idx"] for p in positions] |
| contact_paths = [os.path.join(contact_dir, f"{fi:06d}.npy") for fi in frame_idxs] |
| force_paths = [os.path.join(force_dir, f"{fi:06d}.npy") for fi in frame_idxs] |
| |
| ok = all(os.path.exists(os.path.join(episode_dir, p)) for p in contact_paths) |
| if not ok: |
| continue |
| clips.append({ |
| "episode": rel_ep, |
| "frame_indices": frame_idxs, |
| "contact_paths": contact_paths, |
| "force_paths": force_paths, |
| }) |
| return clips |
|
|
|
|
| |
| def accumulate_stats(clips, source_root, n_sample_frames, seed=0): |
| """Sample frames across clips and compute global normalization stats. |
| contact: per-finger (2) p99 of sqrt(nonzero values) |
| force: per-channel (6) mean/std over nonzero pixels""" |
| rng = random.Random(seed) |
| |
| frame_entries = [] |
| for c in clips: |
| ep = c["episode"] |
| for cp, fp in zip(c["contact_paths"], c["force_paths"]): |
| frame_entries.append((ep, cp, fp)) |
| rng.shuffle(frame_entries) |
| if n_sample_frames > 0: |
| frame_entries = frame_entries[:n_sample_frames] |
|
|
| |
| contact_vals = [[], []] |
| |
| f_sum = np.zeros(6); f_sqsum = np.zeros(6); f_cnt = np.zeros(6) |
|
|
| for ep, cp, fp in frame_entries: |
| c = np.load(os.path.join(source_root, ep, cp)) |
| for ch in range(2): |
| nz = c[ch][c[ch] != 0] |
| if nz.size: |
| contact_vals[ch].append(np.sqrt(nz)) |
| f = np.load(os.path.join(source_root, ep, fp)) |
| for ch in range(6): |
| nz = f[ch][f[ch] != 0] |
| if nz.size: |
| f_sum[ch] += nz.sum() |
| f_sqsum[ch] += (nz ** 2).sum() |
| f_cnt[ch] += nz.size |
|
|
| contact_p99 = [] |
| contact_max = [] |
| for ch in range(2): |
| if contact_vals[ch]: |
| allv = np.concatenate(contact_vals[ch]) |
| contact_p99.append(float(np.percentile(allv, 99))) |
| contact_max.append(float(allv.max())) |
| else: |
| contact_p99.append(1.0); contact_max.append(1.0) |
|
|
| f_cnt_safe = np.maximum(f_cnt, 1) |
| f_mean = f_sum / f_cnt_safe |
| f_std = np.sqrt(np.maximum(f_sqsum / f_cnt_safe - f_mean ** 2, 1e-12)) |
|
|
| return { |
| "n_frames_used": len(frame_entries), |
| "contact": { |
| "transform": "sqrt", |
| "scale_p99": contact_p99, |
| "max_sqrt": contact_max, |
| }, |
| "force": { |
| "transform": "per_channel_std", |
| "mean": f_mean.tolist(), |
| "std": f_std.tolist(), |
| }, |
| } |
|
|
|
|
| |
| def is_episode(p): |
| return ( |
| (p / "metadata.json").exists() |
| and (p / "masks.json").exists() |
| and (p / "modalities" / "contact").exists() |
| and (p / "modalities" / "force").exists() |
| and (p / FLAG_NAME).exists() |
| ) |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--source_root", required=True) |
| ap.add_argument("--out_dir", default="./vae_index") |
| ap.add_argument("--camera", default="camera2") |
| ap.add_argument("--frame_stride", type=int, default=3) |
| ap.add_argument("--n_frames", type=int, default=17) |
| ap.add_argument("--clips_per_episode", type=int, default=15) |
| ap.add_argument("--trans_thresh", type=float, default=1.0) |
| ap.add_argument("--rot_thresh", type=float, default=0.01) |
| ap.add_argument("--n_sample_frames", type=int, default=3000, |
| help="frames to sample for statistics (0 = use all)") |
| ap.add_argument("--with_stats", action="store_true", |
| help="also compute statistics.json (slow, reads npy)") |
| ap.add_argument("--stats_full", action="store_true", |
| help="use all frames for statistics instead of sampling") |
| ap.add_argument("--seed", type=int, default=0) |
| args = ap.parse_args() |
|
|
| source_root = Path(args.source_root) |
| out_dir = Path(args.out_dir) |
| out_dir.mkdir(parents=True, exist_ok=True) |
|
|
| candidates = [source_root] + [p for p in source_root.rglob("*") if p.is_dir()] |
| episode_dirs = sorted([p for p in candidates if is_episode(p)]) |
| print(f"Found {len(episode_dirs)} episodes under {source_root}") |
|
|
| all_clips = [] |
| n_skipped = 0 |
| for ep in tqdm(episode_dirs, desc="Building clips", unit="episode"): |
| meta = load_metadata(str(ep), args.camera) |
| if len(meta) < args.n_frames: |
| n_skipped += 1; continue |
| vr = compute_valid_range(meta, args.trans_thresh, args.rot_thresh) |
| if vr is None: |
| n_skipped += 1; continue |
| clips = build_clips_for_episode( |
| str(ep), str(source_root), meta, vr, |
| args.frame_stride, args.n_frames, args.clips_per_episode) |
| all_clips.extend(clips) |
|
|
| print(f"Built {len(all_clips)} clips ({n_skipped} episodes skipped)") |
| denom = max(len(episode_dirs) - n_skipped, 1) |
| print(f" avg clips/episode = {len(all_clips)/denom:.1f}") |
|
|
| config = { |
| "frame_stride": args.frame_stride, |
| "n_frames": args.n_frames, |
| "clips_per_episode": args.clips_per_episode, |
| "trans_thresh": args.trans_thresh, |
| "rot_thresh": args.rot_thresh, |
| "camera": args.camera, |
| "n_episodes": len(episode_dirs) - n_skipped, |
| "n_clips": len(all_clips), |
| } |
|
|
| |
| with open(out_dir / "clips.json", "w") as f: |
| json.dump({"config": config, "clips": all_clips}, f) |
| print(f"\nWrote: {out_dir/'clips.json'} ({len(all_clips)} clips)") |
|
|
| |
| |
| if args.with_stats: |
| print("\nComputing global statistics (reads npy, slower)...") |
| stats = accumulate_stats( |
| all_clips, str(source_root), |
| n_sample_frames=0 if args.stats_full else args.n_sample_frames, |
| seed=args.seed) |
| stats["config"] = config |
| with open(out_dir / "statistics.json", "w") as f: |
| json.dump(stats, f, indent=2) |
| print(f"Wrote: {out_dir/'statistics.json'}") |
| print(json.dumps(stats, indent=2)[:800]) |
| else: |
| print("\n[stats skipped] pass --with_stats to compute statistics.json,") |
| print("or compute global normalization constants yourself and drop in a") |
| print("statistics.json matching the schema in accumulate_stats().") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
