Create compute_physical_stats.py

compute_physical_stats.py

@@ -0,0 +1,123 @@
+#!/usr/bin/env python3
+"""
+compute_dataset_stats.py
+Dataset-wide normalization stats for the contact / force modalities. Run AFTER
+generate_modalities.py (needs modalities/{contact,force}/*.npy).
+
+Replaces the old compute_force_stats.py + compute_dataset_stats() pair.
+
+  contact -> contact_ch_max        (per finger, 2)     nonneg magnitude field:
+                                                        normalize by max only.
+  force   -> force_ch_active_std   (per channel, 6)    signed, heavy-tailed,
+                                                        ~98% zero background:
+                                                        std over NONZERO pixels
+                                                        only (all-pixel std is
+                                                        diluted toward 0 and
+                                                        blows up real contacts).
+
+Output: <root>/dataset_norm_params.json   (or --out)
+
+Usage:
+  python compute_dataset_stats.py --root ./grasping
+  python compute_dataset_stats.py --root ./grasping --out ./grasping/dataset_norm_params.json
+"""
+import argparse
+import json
+from pathlib import Path
+
+import numpy as np
+from tqdm import tqdm
+
+
+FORCE_CH = ["L_fx", "L_fy", "L_fz", "R_fx", "R_fy", "R_fz"]
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--root", required=True)
+    ap.add_argument("--out", default=None,
+                    help="output json (default: <root>/dataset_norm_params.json)")
+    args = ap.parse_args()
+
+    root = Path(args.root)
+    episodes = [p for p in root.rglob("*")
+                if p.is_dir() and (p / "modalities" / "force").exists()]
+    print(f"Found {len(episodes)} episodes with modalities")
+
+    # contact: per-finger max only (values are >= 0)
+    contact_ch_max = np.zeros(2)
+
+    # force: per-channel accumulators over NONZERO pixels only
+    f_sum = np.zeros(6); f_sq = np.zeros(6); f_cnt = np.zeros(6)
+    f_absmax = np.zeros(6)
+    f_min = np.full(6, np.inf); f_max = np.full(6, -np.inf)
+
+    n_frames = 0
+    n_bad = 0
+    for ep in tqdm(episodes, desc="episodes"):
+        cdir = ep / "modalities" / "contact"
+        fdir = ep / "modalities" / "force"
+        for ff in sorted(fdir.glob("*.npy")):
+            f = np.load(ff).astype(np.float64)          # (6,H,W)
+            if f.ndim != 3 or f.shape[0] != 6:
+                n_bad += 1
+                continue
+            flat = f.reshape(6, -1)
+            for ch in range(6):
+                v = flat[ch][flat[ch] != 0]             # nonzero only
+                if v.size:
+                    f_sum[ch] += v.sum()
+                    f_sq[ch] += (v ** 2).sum()
+                    f_cnt[ch] += v.size
+                    f_absmax[ch] = max(f_absmax[ch], float(np.abs(v).max()))
+                    f_min[ch] = min(f_min[ch], float(v.min()))
+                    f_max[ch] = max(f_max[ch], float(v.max()))
+
+            cf = cdir / ff.name
+            if cf.exists():
+                c = np.load(cf).astype(np.float64)      # (2,H,W)
+                if c.ndim == 3 and c.shape[0] == 2:
+                    contact_ch_max = np.maximum(
+                        contact_ch_max, c.reshape(2, -1).max(1))
+            n_frames += 1
+
+    if n_frames == 0:
+        raise RuntimeError("no modality frames found under --root")
+
+    f_cnt_safe = np.maximum(f_cnt, 1)
+    f_active_mean = f_sum / f_cnt_safe
+    f_active_std = np.sqrt(np.maximum(f_sq / f_cnt_safe - f_active_mean ** 2, 1e-12))
+    f_min[~np.isfinite(f_min)] = 0.0
+    f_max[~np.isfinite(f_max)] = 0.0
+
+    stats = {
+        "num_episodes": len(episodes),
+        "num_frames": int(n_frames),
+        # contact (2): normalize by per-finger max
+        "contact_ch_max": contact_ch_max.tolist(),
+        # force (6): normalize by per-channel nonzero std
+        "force_ch_active_mean": f_active_mean.tolist(),
+        "force_ch_active_std": f_active_std.tolist(),
+        "force_ch_abs_max": f_absmax.tolist(),
+        "force_ch_min": f_min.tolist(),
+        "force_ch_max": f_max.tolist(),
+    }
+
+    # heavy-tail check: if abs_max >> std, clip after normalizing
+    print(f"\nframes: {n_frames}  (bad-shape skipped: {n_bad})")
+    print(f"contact_ch_max: {contact_ch_max.tolist()}")
+    print(f"{'ch':6s} {'active_std':>11s} {'abs_max':>9s} {'max/std':>8s}")
+    print("-" * 40)
+    for i in range(6):
+        ratio = f_absmax[i] / (f_active_std[i] + 1e-12)
+        print(f"{FORCE_CH[i]:6s} {f_active_std[i]:11.5f} {f_absmax[i]:9.4f} {ratio:8.1f}")
+    print("(max/std > ~20 -> clip after normalization, e.g. force_clip=6)")
+
+    out = args.out or str(root / "dataset_norm_params.json")
+    with open(out, "w") as fp:
+        json.dump(stats, fp, indent=2)
+    print(f"\nwrote {out}")
+
+
+if __name__ == "__main__":
+    main()