Add pipeline scripts (make_parquet_v2.py, make_analytical_plots.py, make_samples_100.py)

scripts/make_analytical_plots.py

@@ -0,0 +1,178 @@
+#!/usr/bin/env python3
+"""Generate analytical plots for the dataset card:
+  - composition.png             frames per subset, stacked by markered/markerless
+  - resolution_distribution.png 320x240 vs 640x480 per subset
+  - force_distribution.png      FEATS f_z histogram + indenter shapes
+  - threedcal_coverage.png      (x,y) probe-position heatmap
+  - rtm_digit_distribution.png  digit-class counts
+"""
+
+import glob
+import os
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+import pyarrow.parquet as pq
+
+BASE = "/media/yxma/Disk1/yuxiang/mini_data_parquet"
+OUT  = f"{BASE}/assets"
+
+SUBSETS = ["fota_labeled", "fota_unlabeled", "threedcal", "feats",
+           "feelanyforce", "gelslam", "tactile_tracking", "real_tactile_mnist"]
+
+
+def scan_subset(sub, columns):
+    paths = sorted(glob.glob(f"{BASE}/{sub}/*.parquet"))
+    out = {c: [] for c in columns}
+    for p in paths:
+        t = pq.read_table(p, columns=columns)
+        for c in columns:
+            out[c].extend(t.column(c).to_pylist())
+    return out
+
+
+# 1. composition stacked bar
+def plot_composition():
+    counts = {}
+    for sub in SUBSETS:
+        d = scan_subset(sub, ["markered"])
+        n_m = sum(1 for x in d["markered"] if x)
+        n_u = sum(1 for x in d["markered"] if not x)
+        counts[sub] = (n_m, n_u)
+
+    labels = SUBSETS
+    m = np.array([counts[s][0] for s in labels])
+    u = np.array([counts[s][1] for s in labels])
+    fig, ax = plt.subplots(figsize=(11, 4.5))
+    x = np.arange(len(labels))
+    ax.bar(x, u, label="markerless", color="#4c95d6")
+    ax.bar(x, m, bottom=u, label="markered", color="#d6794c")
+    for i, s in enumerate(labels):
+        total = counts[s][0] + counts[s][1]
+        ax.text(i, total + max(m+u)*0.005, f"{total:,}",
+                ha="center", va="bottom", fontsize=9)
+    ax.set_xticks(x)
+    ax.set_xticklabels(labels, rotation=20, ha="right")
+    ax.set_ylabel("Frames")
+    ax.set_title("gelsight-mini-pretrain · frames per subset (stacked by gel variant)")
+    ax.legend(loc="upper right", frameon=False)
+    ax.spines[["top","right"]].set_visible(False)
+    plt.tight_layout()
+    plt.savefig(f"{OUT}/composition.png", dpi=140)
+    plt.close()
+    print("wrote composition.png")
+
+
+# 2. resolution distribution
+def plot_resolution():
+    cols = {}
+    for sub in SUBSETS:
+        d = scan_subset(sub, ["height", "width"])
+        from collections import Counter
+        c = Counter(zip(d["width"], d["height"]))
+        cols[sub] = c
+
+    all_dims = sorted({k for sub in cols.values() for k in sub.keys()})
+    colors = {(640,480): "#4c95d6", (320,240): "#d6794c"}
+    fig, ax = plt.subplots(figsize=(11, 4.5))
+    x = np.arange(len(SUBSETS))
+    bottom = np.zeros(len(SUBSETS))
+    for d in all_dims:
+        vals = np.array([cols[s].get(d, 0) for s in SUBSETS])
+        ax.bar(x, vals, bottom=bottom,
+               color=colors.get(d, "#999999"),
+               label=f"{d[0]}×{d[1]}  ({vals.sum():,})")
+        bottom += vals
+    ax.set_xticks(x)
+    ax.set_xticklabels(SUBSETS, rotation=20, ha="right")
+    ax.set_ylabel("Frames")
+    ax.set_title("Image resolution per subset (GelSight Mini native modes)")
+    ax.legend(loc="upper right", frameon=False)
+    ax.spines[["top","right"]].set_visible(False)
+    plt.tight_layout()
+    plt.savefig(f"{OUT}/resolution_distribution.png", dpi=140)
+    plt.close()
+    print("wrote resolution_distribution.png")
+
+
+# 3. FEATS force distribution + indenter mix
+def plot_feats_force():
+    d = scan_subset("feats", ["f_z", "f_x", "f_y", "indenter"])
+    fz = np.array([x for x in d["f_z"] if x is not None])
+    fig, axes = plt.subplots(1, 2, figsize=(11, 4))
+    axes[0].hist(fz, bins=60, color="#4c95d6", edgecolor="white")
+    axes[0].axvline(0, color="#444", linestyle="--", linewidth=1)
+    axes[0].set_xlabel("normal force  f_z  (N)")
+    axes[0].set_ylabel("Frames")
+    axes[0].set_title(f"FEATS normal force distribution (n={len(fz):,})")
+    axes[0].spines[["top","right"]].set_visible(False)
+    # indenter mix
+    from collections import Counter
+    c = Counter(x or "unknown" for x in d["indenter"])
+    items = sorted(c.items(), key=lambda kv: -kv[1])
+    keys = [k for k,_ in items]; vals = [v for _,v in items]
+    axes[1].barh(range(len(keys)), vals, color="#d6794c", edgecolor="white")
+    axes[1].set_yticks(range(len(keys)))
+    axes[1].set_yticklabels(keys)
+    axes[1].invert_yaxis()
+    axes[1].set_xlabel("Frames")
+    axes[1].set_title("FEATS indenter-shape mix")
+    axes[1].spines[["top","right"]].set_visible(False)
+    for i, v in enumerate(vals):
+        axes[1].text(v + max(vals)*0.005, i, f"{v:,}", va="center", fontsize=9)
+    plt.tight_layout()
+    plt.savefig(f"{OUT}/force_distribution.png", dpi=140)
+    plt.close()
+    print("wrote force_distribution.png")
+
+
+# 4. 3DCal probe-position heatmap
+def plot_threedcal_coverage():
+    d = scan_subset("threedcal", ["x_mm", "y_mm"])
+    x = np.array([v for v in d["x_mm"] if v is not None])
+    y = np.array([v for v in d["y_mm"] if v is not None])
+    fig, ax = plt.subplots(figsize=(6.5, 5.5))
+    H, xe, ye = np.histogram2d(x, y, bins=[40, 30])
+    im = ax.pcolormesh(xe, ye, H.T, cmap="magma")
+    ax.set_xlabel("x (mm)")
+    ax.set_ylabel("y (mm)")
+    ax.set_title(f"py3DCal calibration grid — probe coverage (n={len(x):,})")
+    plt.colorbar(im, ax=ax, label="frames per (x,y) cell")
+    plt.tight_layout()
+    plt.savefig(f"{OUT}/threedcal_coverage.png", dpi=140)
+    plt.close()
+    print("wrote threedcal_coverage.png")
+
+
+# 5. RTM digit-class distribution
+def plot_rtm_digits():
+    d = scan_subset("real_tactile_mnist", ["digit_class"])
+    from collections import Counter
+    c = Counter(x for x in d["digit_class"] if x is not None)
+    keys = list(range(10))
+    vals = [c.get(k, 0) for k in keys]
+    fig, ax = plt.subplots(figsize=(8, 4))
+    ax.bar(keys, vals, color="#4c95d6", edgecolor="white")
+    for k, v in zip(keys, vals):
+        ax.text(k, v + max(vals)*0.005, f"{v:,}",
+                ha="center", va="bottom", fontsize=9)
+    ax.set_xticks(keys)
+    ax.set_xlabel("digit class")
+    ax.set_ylabel("frames")
+    ax.set_title(f"Real Tactile MNIST · digit-class balance (total {sum(vals):,})")
+    ax.spines[["top","right"]].set_visible(False)
+    plt.tight_layout()
+    plt.savefig(f"{OUT}/rtm_digit_distribution.png", dpi=140)
+    plt.close()
+    print("wrote rtm_digit_distribution.png")
+
+
+if __name__ == "__main__":
+    plot_composition()
+    plot_resolution()
+    plot_feats_force()
+    plot_threedcal_coverage()
+    plot_rtm_digits()
+    print("done")

scripts/make_parquet_v2.py

@@ -0,0 +1,577 @@
+#!/usr/bin/env python3
+"""V2 pipeline: pack GelSLAM, TactileTracking, RealTactileMNIST, FeelAnyForce
+into the unified parquet schema used by `yxma/gelsight-mini-pretrain`.
+
+Adaptive subsampling per source:
+  - per-source frame budget = min(200_000, contact_frames_available)
+  - dynamism-aware stride (high inter-frame delta -> denser sample)
+  - validity filter: drop frames where central deformation < threshold
+  - perceptual-hash dedupe
+
+Outputs sit alongside existing fota_*/threedcal/feats:
+  /media/yxma/Disk1/yuxiang/mini_data_parquet/<sub>/{train|...}-####-of-####.parquet
+
+Usage:
+  python make_parquet_v2.py probe <sub>       # measure dynamism + empty fraction
+  python make_parquet_v2.py process <sub>     # full pipeline + write
+  python make_parquet_v2.py stats             # show row counts across all subs
+"""
+
+import io
+import json
+import os
+import sys
+import time
+from collections import defaultdict
+from glob import glob
+from typing import Iterator, Optional, Tuple
+
+import numpy as np
+import pyarrow as pa
+import pyarrow.parquet as pq
+from PIL import Image
+
+BASE_DATA   = "/media/yxma/Disk1/yuxiang/mini_data"
+BASE_OUT    = "/media/yxma/Disk1/yuxiang/mini_data_parquet"
+BUDGET      = 200_000                # max kept frames per source
+SHARD_TGT   = 2 * 1024 ** 3          # 2 GB shard target
+EMPTY_TAU   = 4.0                    # mean |frame - baseline| threshold (greylevels)
+EMPTY_BUDGET= 0.03                   # allow up to 3% empties through
+PHASH_DIST  = 4                      # max hamming distance for "duplicate"
+
+# Existing schema + 3 new nullable cols
+SCHEMA = pa.schema([
+    ("image", pa.binary()),
+    ("image_format", pa.string()),
+    ("source", pa.string()),
+    ("markered", pa.bool_()),
+    ("capture", pa.string()),
+    ("split", pa.string()),
+    ("height", pa.int32()),
+    ("width", pa.int32()),
+    ("obj_name", pa.string()),
+    ("init_pose", pa.int32()),
+    ("side", pa.string()),
+    ("x_mm", pa.float32()),
+    ("y_mm", pa.float32()),
+    ("z_mm", pa.float32()),
+    ("quat_x", pa.float32()),
+    ("quat_y", pa.float32()),
+    ("quat_z", pa.float32()),
+    ("quat_w", pa.float32()),
+    ("indenter", pa.string()),
+    ("indenter_param", pa.string()),
+    ("f_x", pa.float32()),
+    ("f_y", pa.float32()),
+    ("f_z", pa.float32()),
+    ("grid_z_max", pa.float32()),
+    ("grid_z_mean", pa.float32()),
+    # NEW columns (nullable for old data)
+    ("episode", pa.string()),
+    ("frame_idx", pa.int32()),
+    ("digit_class", pa.int32()),
+    ("gel_variant", pa.string()),
+])
+
+
+# ─────────────────────────────────────────────────────────────────
+# helpers
+# ─────────────────────────────────────────────────────────────────
+
+def encode_jpeg(arr_rgb: np.ndarray, q=92) -> bytes:
+    im = Image.fromarray(arr_rgb)
+    buf = io.BytesIO()
+    im.save(buf, format="JPEG", quality=q, optimize=True)
+    return buf.getvalue()
+
+
+def grey_center(arr: np.ndarray) -> np.ndarray:
+    """Central 50% crop, greyscale, float32."""
+    if arr.ndim == 3:
+        g = arr.mean(axis=2)
+    else:
+        g = arr
+    h, w = g.shape
+    return g[h//4:3*h//4, w//4:3*w//4].astype(np.float32)
+
+
+def phash(arr_rgb: np.ndarray) -> int:
+    """8x8 DCT-low-freq perceptual hash, returned as 64-bit int."""
+    im = Image.fromarray(arr_rgb).convert("L").resize((32, 32), Image.LANCZOS)
+    a = np.array(im, dtype=np.float32)
+    # 2D DCT via numpy
+    def dct1(x): return np.fft.fft(np.concatenate([x, x[::-1]], axis=-1)).real[..., :x.shape[-1]]
+    d = dct1(dct1(a).T).T
+    low = d[:8, :8].flatten()
+    med = np.median(low[1:])  # skip DC
+    h = 0
+    for bit in (low > med):
+        h = (h << 1) | int(bit)
+    return h
+
+
+def hamming(a: int, b: int) -> int:
+    return bin(a ^ b).count("1")
+
+
+# ─────────────────────────────────────────────────────────────────
+# Per-source iterators
+# Each yields (frame_rgb_np, base_meta_dict) for ONE frame at a time.
+# Within each episode/capture, frames are emitted in order so we can
+# compute a baseline image for the validity filter.
+# ─────────────────────────────────────────────────────────────────
+
+def iter_gelslam():
+    """GelSLAM: gelsight.avi per episode under tracking_dataset/ and reconstruction_dataset/."""
+    import cv2
+    root = f"{BASE_DATA}/markerless/GelSLAM"
+    # The HF download puts content under root or root/dataset/ depending on extraction
+    for sub in ("tracking_dataset", "reconstruction_dataset"):
+        candidates = (
+            glob(f"{root}/{sub}/*/gelsight.avi") +
+            glob(f"{root}/dataset/{sub}/*/gelsight.avi")
+        )
+        for vid in candidates:
+            episode = os.path.basename(os.path.dirname(vid))
+            split = "train" if sub == "tracking_dataset" else "recon"
+            cap = cv2.VideoCapture(vid)
+            fi = 0
+            while True:
+                ok, fr = cap.read()
+                if not ok:
+                    break
+                fr = fr[:, :, ::-1]  # BGR->RGB
+                yield fr, {
+                    "source": "gelslam",
+                    "markered": False,
+                    "capture": f"{sub}/{episode}",
+                    "split": split,
+                    "obj_name": episode,
+                    "episode": episode,
+                    "frame_idx": fi,
+                }
+                fi += 1
+            cap.release()
+
+
+def iter_tactile_tracking():
+    import cv2
+    import re
+    root = f"{BASE_DATA}/markerless/TactileTracking"
+    candidates = sorted(glob(f"{root}/normalflow_dataset/*/gelsight.avi"))
+    obj_re = re.compile(r"^([a-zA-Z]+)(\d+)$")
+    for vid in candidates:
+        trial_dir = os.path.basename(os.path.dirname(vid))  # e.g. 'corner3'
+        m = obj_re.match(trial_dir)
+        if m:
+            obj, trial = m.group(1), m.group(2)
+        else:
+            obj, trial = trial_dir, "0"
+        cap = cv2.VideoCapture(vid)
+        fi = 0
+        while True:
+            ok, fr = cap.read()
+            if not ok:
+                break
+            fr = fr[:, :, ::-1]
+            yield fr, {
+                "source": "tactile_tracking",
+                "markered": False,
+                "capture": f"{obj}/{trial}",
+                "split": "train",
+                "obj_name": obj,
+                "episode": trial,
+                "frame_idx": fi,
+            }
+            fi += 1
+        cap.release()
+
+
+def iter_real_tactile_mnist():
+    """RTM seq-320x240: parquet with 'sensor_video' list-of-struct{bytes,path}.
+    Each row in the parquet is one 'round' = one digit object touched ~256 times.
+    We keep one frame per touch video (the middle frame, near peak contact).
+    """
+    import cv2
+    root = f"{BASE_DATA}/markerless/RealTactileMNIST"
+    pq_files = sorted(glob(f"{root}/data/*.parquet"))
+    for p in pq_files:
+        split = "test" if "test" in os.path.basename(p).lower() else "train"
+        pf = pq.ParquetFile(p)
+        for batch in pf.iter_batches(batch_size=4):
+            cols = batch.to_pydict()
+            n = len(cols.get("label", cols.get("id", [])))
+            for i in range(n):
+                round_id = cols.get("id", [None]*n)[i]
+                label = cols.get("label", [None]*n)[i]
+                obj_id = cols.get("object_id", [None]*n)[i]
+                videos = cols["sensor_video"][i] or []
+                for tj, vid_struct in enumerate(videos):
+                    if not vid_struct: continue
+                    vid_bytes = vid_struct.get("bytes") if isinstance(vid_struct, dict) else None
+                    if not vid_bytes: continue
+                    tmpf = f"/tmp/_rtm_{os.getpid()}.mp4"
+                    with open(tmpf, "wb") as f: f.write(vid_bytes)
+                    cap = cv2.VideoCapture(tmpf)
+                    frames = []
+                    while True:
+                        ok, fr = cap.read()
+                        if not ok: break
+                        frames.append(fr[:, :, ::-1])
+                    cap.release()
+                    try: os.remove(tmpf)
+                    except: pass
+                    if not frames: continue
+                    # keep only the middle frame (near peak contact)
+                    mid = frames[len(frames)//2]
+                    yield mid, {
+                        "source": "real_tactile_mnist",
+                        "markered": False,
+                        "capture": f"r{round_id}_t{tj}",
+                        "split": split,
+                        "obj_name": f"digit_{label}",
+                        "digit_class": int(label) if label is not None else None,
+                        "episode": str(obj_id) if obj_id is not None else None,
+                        "frame_idx": len(frames)//2,
+                    }
+
+
+def iter_feelanyforce():
+    """FAF: loose 320x240 PNG per indentation under dataset/<object>/tactile/."""
+    root = f"{BASE_DATA}/markerless/FeelAnyForce/dataset/dataset"
+    objects = sorted(d for d in os.listdir(root) if os.path.isdir(f"{root}/{d}"))
+    for obj in objects:
+        p = f"{root}/{obj}/tactile"
+        if not os.path.isdir(p): continue
+        files = sorted(os.listdir(p))
+        for fi, fn in enumerate(files):
+            try:
+                fr = np.array(Image.open(f"{p}/{fn}").convert("RGB"))
+            except Exception:
+                continue
+            yield fr, {
+                "source": "feelanyforce",
+                "markered": False,    # visually verified markerless
+                "capture": obj,
+                "split": "train",
+                "obj_name": obj.split("_")[0],
+                "episode": obj,
+                "frame_idx": fi,
+            }
+
+
+SOURCE_ITERS = {
+    "gelslam":            iter_gelslam,
+    "tactile_tracking":   iter_tactile_tracking,
+    "real_tactile_mnist": iter_real_tactile_mnist,
+    "feelanyforce":       iter_feelanyforce,
+}
+
+# Per-source overrides for the validity filter.
+# FAF: data is pre-curated, every frame is an indentation moment, baseline median
+#      includes contact frames -> filter must be disabled.
+# RTM: we already pick 1 middle frame per video, every frame is peak contact ->
+#      filter unnecessary.
+# Video sources: keep filter active (baseline = median of first 10 frames
+#      typically captures the pre-contact prologue).
+SKIP_EMPTY_FILTER = {
+    "feelanyforce":       True,
+    "real_tactile_mnist": True,
+    "gelslam":            False,
+    "tactile_tracking":   False,
+}
+
+
+# ─────────────────────────────────────────────────────────────────
+# Probe pass: measure dynamism + empty fraction per source.
+# Samples N frames per capture and computes |frame - capture_baseline|.
+# ─────────────────────────────────────────────────────────────────
+
+def probe(sub: str, n_per_capture=30, max_total=2000):
+    print(f"probe {sub}...", flush=True)
+    by_cap = defaultdict(list)
+    total = 0
+    for fr, meta in SOURCE_ITERS[sub]():
+        c = meta["capture"]
+        if len(by_cap[c]) < n_per_capture:
+            by_cap[c].append(fr)
+            total += 1
+        if total >= max_total:
+            break
+
+    # Per-capture baseline = median over the sampled frames
+    deltas, dynamisms = [], []
+    for c, frames in by_cap.items():
+        if len(frames) < 3:
+            continue
+        stack = np.stack([grey_center(f) for f in frames], axis=0)
+        baseline = np.median(stack, axis=0)
+        deformation = np.abs(stack - baseline).mean(axis=(1, 2))
+        deltas.extend(deformation.tolist())
+        # dynamism = mean inter-frame |Δ|
+        diffs = np.abs(stack[1:] - stack[:-1]).mean(axis=(1, 2))
+        dynamisms.extend(diffs.tolist())
+
+    deltas = np.array(deltas)
+    dyn = np.array(dynamisms) if dynamisms else np.array([0.0])
+    empty_frac = float((deltas < EMPTY_TAU).mean()) if len(deltas) else 0.0
+    return {
+        "n_probed_frames":   total,
+        "n_probed_captures": len(by_cap),
+        "mean_dynamism":     float(dyn.mean()),
+        "median_dynamism":   float(np.median(dyn)),
+        "mean_deformation":  float(deltas.mean()) if len(deltas) else 0.0,
+        "empty_frac":        empty_frac,
+        "n_captures_with_3plus_frames": int(sum(1 for c, fs in by_cap.items() if len(fs) >= 3)),
+    }
+
+
+# ─────────────────────────────────────────────────────────────────
+# Two-pass full processing:
+#   pass 1: scan ALL frames; per capture, store baseline + count valid + collect phashes
+#   pass 2: re-iterate, apply stride+validity+dedupe; write parquet
+# To avoid two full scans (RTM is large), we do a single streaming pass:
+#   - maintain a per-capture rolling baseline from first 10 frames
+#   - then for subsequent frames in same capture, compute validity online
+#   - apply stride based on a target_keep_per_capture pre-computed at probe time
+# ─────────────────────────────────────────────────────────────────
+
+class ShardWriter:
+    def __init__(self, out_dir, prefix):
+        self.out_dir = out_dir
+        self.prefix = prefix
+        os.makedirs(out_dir, exist_ok=True)
+        self.rows = []
+        self.shard_idx = 0
+        self.total = 0
+        self.bytes_in = 0
+
+    def add(self, row):
+        # ensure all keys present
+        row = {f.name: row.get(f.name) for f in SCHEMA}
+        self.rows.append(row)
+        self.bytes_in += len(row["image"]) if row["image"] else 0
+        self.total += 1
+        if self.bytes_in >= SHARD_TGT:
+            self._flush()
+
+    def _flush(self):
+        if not self.rows: return
+        # Build columns
+        cols = {f.name: [r[f.name] for r in self.rows] for f in SCHEMA}
+        t = pa.Table.from_pydict(cols, schema=SCHEMA)
+        path = f"{self.out_dir}/{self.prefix}-{self.shard_idx:05d}.parquet"
+        pq.write_table(t, path, compression="snappy")
+        print(f"  wrote {path}  rows={len(self.rows)}  bytes={self.bytes_in/1e9:.2f}GB",
+              flush=True)
+        self.shard_idx += 1
+        self.rows = []
+        self.bytes_in = 0
+
+    def close(self):
+        self._flush()
+        # rename shards to "PREFIX-NNNNN-of-NNNNN.parquet"
+        files = sorted(glob(f"{self.out_dir}/{self.prefix}-?????.parquet"))
+        total_shards = len(files)
+        for i, fp in enumerate(files):
+            base = os.path.dirname(fp)
+            new = f"{base}/{self.prefix}-{i:05d}-of-{total_shards:05d}.parquet"
+            if fp != new:
+                os.rename(fp, new)
+
+
+def process(sub: str, probe_info: dict):
+    """Run pipeline on one source and write parquet shards."""
+    print(f"\n=== processing {sub} ===", flush=True)
+
+    # Decide global stride
+    dyn = probe_info["mean_dynamism"]
+    # Estimate effective contact frames after empty filter
+    # (We'll re-tune as we go since we don't know R_total precisely)
+    # Target = BUDGET. We adjust the stride live by checking running fill rate.
+    target = BUDGET
+
+    # Group by split, write to <sub>/<split>-####.parquet
+    out_dir = f"{BASE_OUT}/{sub}"
+    writers: dict[str, ShardWriter] = {}
+
+    n_seen = 0
+    n_empty_dropped = 0
+    n_dup_dropped = 0
+    n_stride_dropped = 0
+    n_kept = 0
+    n_empty_passed = 0
+    cur_capture = None
+    cap_seen_within = 0
+    cap_baseline = None
+    cap_buffer: list[np.ndarray] = []
+    cap_phashes: list[int] = []
+
+    # We compute capture-baseline as the median of the first 10 frames seen
+    BASE_FRAMES = 10
+
+    def finish_capture():
+        # nothing to do per se; arrays cleared on capture change
+        pass
+
+    t0 = time.time()
+    stride_state = {"stride": 1.0, "accum": 0.0}
+
+    for fr, meta in SOURCE_ITERS[sub]():
+        cap = meta["capture"]
+        if cap != cur_capture:
+            finish_capture()
+            cur_capture = cap
+            cap_seen_within = 0
+            cap_baseline = None
+            cap_buffer = []
+            cap_phashes = []
+
+        g_center = grey_center(fr)
+        skip_empty = SKIP_EMPTY_FILTER.get(sub, False)
+
+        # Build baseline from first BASE_FRAMES (only when empty-filter is active)
+        if not skip_empty and cap_baseline is None:
+            cap_buffer.append(g_center)
+            cap_seen_within += 1
+            n_seen += 1
+            if len(cap_buffer) >= BASE_FRAMES:
+                cap_baseline = np.median(np.stack(cap_buffer, axis=0), axis=0)
+            continue
+
+        n_seen += 1
+        if skip_empty:
+            deformation = 0.0
+            is_empty = False
+        else:
+            deformation = float(np.abs(g_center - cap_baseline).mean())
+            is_empty = deformation < EMPTY_TAU
+
+        # Stride decision (uniform stride based on target/total estimate later)
+        # We use a live rate-limiter: every K frames, keep 1 (K adjusted live)
+        stride_state["accum"] += 1.0
+        if stride_state["accum"] < stride_state["stride"]:
+            n_stride_dropped += 1
+            continue
+        stride_state["accum"] -= stride_state["stride"]
+
+        # Empty-budget: allow up to EMPTY_BUDGET fraction of kept frames to be empty
+        if is_empty:
+            # Allow only if we're under budget
+            if n_empty_passed >= EMPTY_BUDGET * max(n_kept, 1):
+                n_empty_dropped += 1
+                continue
+
+        # Dedupe via phash within capture
+        h = phash(fr)
+        is_dup = any(hamming(h, hh) <= PHASH_DIST for hh in cap_phashes[-30:])
+        if is_dup:
+            n_dup_dropped += 1
+            continue
+        cap_phashes.append(h)
+
+        # Keep!
+        img_bytes = encode_jpeg(fr)
+        row = dict(meta)
+        row["image"] = img_bytes
+        row["image_format"] = "jpeg"
+        row["height"] = int(fr.shape[0])
+        row["width"] = int(fr.shape[1])
+        if is_empty:
+            n_empty_passed += 1
+        n_kept += 1
+
+        split = row.get("split", "train") or "train"
+        if split not in writers:
+            writers[split] = ShardWriter(out_dir, split)
+        writers[split].add(row)
+
+        # Adapt stride live: aim for target frames over the source.
+        # We don't know R_total, but we tweak so that fill rate is sensible.
+        # If n_kept exceeds BUDGET, raise stride aggressively.
+        if n_kept > 0 and n_kept % 5000 == 0:
+            if n_kept > BUDGET:
+                stride_state["stride"] = max(1.0, stride_state["stride"] * 1.5)
+            elif n_kept > BUDGET * 0.95:
+                stride_state["stride"] = max(1.0, stride_state["stride"] * 1.2)
+
+        # Hard cap
+        if n_kept >= BUDGET:
+            print(f"  reached BUDGET={BUDGET}, stopping iteration", flush=True)
+            break
+
+        if n_seen % 20000 == 0:
+            dt = time.time() - t0
+            print(f"  seen={n_seen:,}  kept={n_kept:,}  "
+                  f"empty_drop={n_empty_dropped:,}  dup_drop={n_dup_dropped:,}  "
+                  f"stride_drop={n_stride_dropped:,}  "
+                  f"({n_seen/max(dt,0.01):.0f} fps)", flush=True)
+
+    for w in writers.values():
+        w.close()
+
+    stats = {
+        "source":           sub,
+        "n_seen":           n_seen,
+        "n_kept":           n_kept,
+        "n_empty_dropped":  n_empty_dropped,
+        "n_empty_passed":   n_empty_passed,
+        "n_dup_dropped":    n_dup_dropped,
+        "n_stride_dropped": n_stride_dropped,
+        "splits":           {k: w.total for k, w in writers.items()},
+        "wall_time_sec":    time.time() - t0,
+    }
+    with open(f"/home/yxma/MultimodalData/stats_v2_{sub}.json", "w") as f:
+        json.dump(stats, f, indent=2)
+    print(f"  {sub} stats: {stats}", flush=True)
+    return stats
+
+
+# ─────────────────────────────────────────────────────────────────
+# CLI
+# ─────────────────────────────────────────────────────────────────
+
+def cmd_probe(sub):
+    info = probe(sub)
+    out = f"/home/yxma/MultimodalData/probe_{sub}.json"
+    with open(out, "w") as f:
+        json.dump(info, f, indent=2)
+    print(json.dumps(info, indent=2))
+    print(f"saved {out}")
+
+
+def cmd_process(sub):
+    probe_file = f"/home/yxma/MultimodalData/probe_{sub}.json"
+    if os.path.exists(probe_file):
+        info = json.load(open(probe_file))
+    else:
+        info = probe(sub)
+        with open(probe_file, "w") as f:
+            json.dump(info, f, indent=2)
+    process(sub, info)
+
+
+def cmd_stats():
+    totals = {}
+    for sub in os.listdir(BASE_OUT):
+        p = f"{BASE_OUT}/{sub}"
+        if not os.path.isdir(p): continue
+        paths = sorted(glob(f"{p}/*.parquet"))
+        n = sum(pq.read_metadata(x).num_rows for x in paths)
+        bytes_total = sum(os.path.getsize(x) for x in paths)
+        totals[sub] = {"rows": n, "bytes": bytes_total, "shards": len(paths)}
+    print(json.dumps(totals, indent=2))
+
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print(__doc__); sys.exit(1)
+    cmd = sys.argv[1]
+    if cmd == "probe":
+        cmd_probe(sys.argv[2])
+    elif cmd == "process":
+        cmd_process(sys.argv[2])
+    elif cmd == "stats":
+        cmd_stats()
+    else:
+        print(f"unknown command: {cmd}"); sys.exit(1)

scripts/make_samples_100.py

@@ -0,0 +1,112 @@
+#!/usr/bin/env python3
+"""Sample 100 images per subset into a 10x10 grid."""
+
+import glob
+import io
+import os
+import random
+import sys
+
+import pyarrow.parquet as pq
+from PIL import Image, ImageDraw, ImageFont
+
+BASE = "/media/yxma/Disk1/yuxiang/mini_data_parquet"
+OUT = os.path.join(BASE, "assets")
+os.makedirs(OUT, exist_ok=True)
+
+N = 100
+COLS = 10
+THUMB = 144  # smaller to keep image manageable
+
+
+def list_parquets(sub, split_pat="*"):
+    return sorted(glob.glob(os.path.join(BASE, sub, f"{split_pat}-*.parquet")))
+
+
+def thumbnail(img_bytes, side=THUMB):
+    im = Image.open(io.BytesIO(img_bytes)).convert("RGB")
+    w, h = im.size
+    s = min(w, h)
+    im = im.crop(((w - s) // 2, (h - s) // 2, (w + s) // 2, (h + s) // 2))
+    return im.resize((side, side), Image.LANCZOS)
+
+
+def make_grid(images, title, cols=COLS, side=THUMB, pad=4, title_h=44):
+    rows = (len(images) + cols - 1) // cols
+    W = pad + cols * (side + pad)
+    H = title_h + rows * (side + pad) + pad
+    canvas = Image.new("RGB", (W, H), (255, 255, 255))
+    d = ImageDraw.Draw(canvas)
+    try:
+        f = ImageFont.truetype("DejaVuSans-Bold.ttf", 24)
+    except Exception:
+        f = ImageFont.load_default()
+    d.text((pad + 4, 8), title, fill=(0, 0, 0), font=f)
+    for i, im in enumerate(images):
+        r, c = i // cols, i % cols
+        x = pad + c * (side + pad)
+        y = title_h + r * (side + pad)
+        canvas.paste(im, (x, y))
+    return canvas
+
+
+def collect_uniform(sub, n=N, key_cols=None, seed=42):
+    """Sample n images uniformly across the parquet.
+
+    If key_cols given, also try to balance across the (key_cols) keyspace.
+    """
+    rng = random.Random(seed)
+    paths = list_parquets(sub)
+    # First, count total rows
+    counts = [pq.read_metadata(p).num_rows for p in paths]
+    total = sum(counts)
+    if total == 0:
+        return []
+    # Pick global indices uniformly
+    n = min(n, total)
+    idxs = sorted(rng.sample(range(total), n))
+    # Walk shards reading only needed rows
+    out = []
+    cum = 0
+    idx_iter = iter(idxs)
+    nxt = next(idx_iter, None)
+    for p, c in zip(paths, counts):
+        if nxt is None:
+            break
+        if nxt >= cum + c:
+            cum += c
+            continue
+        # collect local indices in this shard
+        local = []
+        while nxt is not None and nxt < cum + c:
+            local.append(nxt - cum)
+            nxt = next(idx_iter, None)
+        if local:
+            t = pq.read_table(p, columns=["image"])
+            for li in local:
+                out.append(t.column("image")[li].as_py())
+        cum += c
+    return out
+
+
+def main():
+    subs = sys.argv[1:] if len(sys.argv) > 1 else [
+        "fota_labeled", "fota_unlabeled", "threedcal", "feats"]
+    for sub in subs:
+        if not list_parquets(sub):
+            print(f"skip {sub} (no parquet found)")
+            continue
+        print(f"sampling 100 from {sub}...", flush=True)
+        imgs = collect_uniform(sub, n=N)
+        thumbs = [thumbnail(b) for b in imgs]
+        title = f"{sub} — 100 random samples"
+        if sub == "feats":
+            title += " (includes black_dot + different gel variants)"
+        g = make_grid(thumbs, title)
+        out = os.path.join(OUT, f"samples_100_{sub}.png")
+        g.save(out, optimize=True)
+        print(f"  saved {out}  size={g.size}", flush=True)
+
+
+if __name__ == "__main__":
+    main()