Create compute_dataset_stats.py

compute_dataset_stats.py

@@ -0,0 +1,106 @@
+"""
+compute_force_stats.py
+Scan the full force dataset and compute per-dimension min / max / mean / std,
+with mean/std computed ONLY over active pixels (union contact region),
+and all-zero frames excluded from the frame count.
+
+Usage:
+  python compute_force_stats.py \
+      --clips  /net/.../vae_index/train_1500_0629.json \
+      --source_root /net/.../grasping \
+      --modality force \
+      --eps 1e-6
+
+Streaming: keeps only per-dim (count, sum, sumsq, min, max) in float64,
+so memory is O(6), not O(dataset). std = sqrt(E[x^2] - E[x]^2).
+"""
+import argparse, json, os, numpy as np
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--clips", required=True)
+    ap.add_argument("--source_root", required=True)
+    ap.add_argument("--modality", default="force")
+    ap.add_argument("--eps", type=float, default=1e-6,
+                    help="a pixel is active if its L2 magnitude across channels > eps")
+    ap.add_argument("--max_frames", type=int, default=None,
+                    help="cap for a quick sample; None = all")
+    args = ap.parse_args()
+
+    key = f"{args.modality}_paths"
+    clips = json.load(open(args.clips))["clips"]
+
+    # dedupe frames: same npy can appear in overlapping clips
+    paths = []
+    seen = set()
+    for c in clips:
+        for rel in c[key]:
+            full = os.path.join(args.source_root, c["episode"], rel)
+            if full not in seen:
+                seen.add(full); paths.append(full)
+    print(f"[scan] {len(paths)} unique {args.modality} frames from {len(clips)} clips")
+
+    C = None
+    cnt = sum_ = sumsq = vmin = vmax = None   # per-dim accumulators (float64)
+    n_total = n_active = n_missing = 0
+
+    for i, p in enumerate(paths):
+        if args.max_frames and i >= args.max_frames:
+            break
+        if not os.path.exists(p):
+            n_missing += 1; continue
+        a = np.load(p).astype(np.float64)     # (C,H,W)
+        if C is None:
+            C = a.shape[0]
+            cnt   = np.zeros(C)
+            sum_  = np.zeros(C)
+            sumsq = np.zeros(C)
+            vmin  = np.full(C, np.inf)
+            vmax  = np.full(C, -np.inf)
+
+        n_total += 1
+        mag = np.sqrt((a ** 2).sum(0))        # (H,W)
+        active = mag > args.eps
+        # min/max over ALL pixels (background zeros never beat real extrema here,
+        # but include them so a channel that is all-zero this frame still reports 0)
+        vmin = np.minimum(vmin, a.reshape(C, -1).min(1))
+        vmax = np.maximum(vmax, a.reshape(C, -1).max(1))
+        if not active.any():
+            continue                          # all-zero frame: excluded from mean/std
+        n_active += 1
+        av = a[:, active]                     # (C, n_active_px) -- union active region
+        cnt   += av.shape[1]
+        sum_  += av.sum(1)
+        sumsq += (av ** 2).sum(1)
+
+        if (i + 1) % 2000 == 0:
+            print(f"  ...{i+1}/{len(paths)}")
+
+    mean = sum_ / np.clip(cnt, 1, None)
+    var  = sumsq / np.clip(cnt, 1, None) - mean ** 2
+    std  = np.sqrt(np.clip(var, 0, None))
+
+    print(f"\n[frames] total={n_total}  active={n_active}  "
+          f"all-zero={n_total-n_active}  missing={n_missing}")
+    print(f"[active px per active frame] mean={cnt.sum()/max(n_active,1):.0f}\n")
+    print("per-dim stats (mean/std over union-active pixels; min/max over all pixels):")
+    for c in range(C):
+        print(f"  dim{c}: min={vmin[c]:+.5f} max={vmax[c]:+.5f} "
+              f"mean={mean[c]:+.5f} std={std[c]:.5f}")
+
+    out = {"modality": args.modality, "eps": args.eps,
+           "n_frames_total": int(n_total), "n_frames_active": int(n_active),
+           "per_dim": {f"dim{c}": {"min": float(vmin[c]), "max": float(vmax[c]),
+                                    "mean": float(mean[c]), "std": float(std[c])}
+                       for c in range(C)},
+           # convenience arrays for normalization code:
+           "mean": mean.tolist(), "std": std.tolist(),
+           "min": vmin.tolist(), "max": vmax.tolist()}
+    outpath = f"{args.modality}_stats_active.json"
+    json.dump(out, open(outpath, "w"), indent=2)
+    print(f"\nsaved -> {outpath}")
+
+
+if __name__ == "__main__":
+    main()