SO-101 SmolVLA data: ISR-standardized teleop + retargeted ego, both LeRobot v3.0

README.md

@@ -0,0 +1,119 @@
+---
+license: apache-2.0
+task_categories:
+- robotics
+tags:
+- LeRobot
+- so101
+- smolvla
+- teleoperation
+- egocentric
+- retargeting
+- ISR
+size_categories:
+- 10K<n<100K
+---
+
+# so101-smolvla-data — two SO-101 halves in LeRobot v3.0, ready for SmolVLA
+
+```
+std_mm_teleop_v30.tar    95 MB   100 eps    9,500 frames   1 task    ISR-standardized real teleop
+ego_v30.tar             319 MB   324 eps   36,442 frames  89 tasks   retargeted egocentric video
+std_results/                     the standardization run that produced the first half
+```
+
+Both tars unpack to a complete **LeRobot v3.0** tree (`meta/ data/ videos/`) that loads with
+`LeRobotDataset(repo_id, root=...)`. Same 6-DOF SO-101 layout, same camera keys, same units.
+
+## The two halves
+
+| Field | `std_mm_teleop_v30` | `ego_v30` |
+|---|---|---|
+| Format | LeRobot **v3.0** | LeRobot **v3.0** ✓ |
+| Robot | `so_follower` | `so101_follower` (same arm, different string) |
+| Rate | **10 fps** (30 Hz ÷ 3.05 ISR compression) | **30 fps** |
+| Episodes | **100** | **324** |
+| Frames | **9,500** (from 28,948) | **36,442** |
+| Tasks | **1** — "pick up blue cube and put into orange box" | **89** |
+| Duration | 15.8 min nominal (real span 16.1 min) | 20.2 min |
+| Episode length | mean 95, range 78–117 | mean 112.5, range 30–354 |
+| Camera keys | `observation.images.front` / `.wrist` | same ✓ |
+| Video | 640×480, h264, yuv420p | 640×480, h264, yuv420p ✓ |
+| Image source | **real** cameras (openbooth SO-101 rig), ISR-selected subset, re-encoded | **synthesized** — 2 crops from 1 ego camera |
+| state / action | `float32[6]` | `float32[6]` ✓ |
+| State layout | `[pan, lift, elbow, wrist_flex, wrist_roll, gripper]`, **degrees** | same ✓ |
+| Action convention | teleop **command**, leads state by ~4 raw frames (0.13 s, residual 0.90°); 2 steps / 2.08° after ISR | absolute **next-frame target** — exact, max abs diff **0.0** on all 324 eps |
+| Gripper encoding | deg, **larger = open** (checked against the wrist video: 1.40° = jaws touching, 59.78° = wide), range 1.4–59.8 | deg, **larger = open**, range −10.0–84.3 — same polarity ✓ |
+| Gripper occupancy | rests **closed** — mean 0.294 of span, 52.6 % of frames in the bottom quarter, 4.1 % in the top | rests **mid** — mean 0.328, 33.5 % bottom quarter, 0.7 % top |
+
+Every row is measured off the files (`std_results/stats_compare.py`, ffprobe on the mp4s, the
+parquet columns); raw numbers in `std_results/comparison_stats.json`.
+
+### What to watch when co-training
+
+1. **10 vs 30 fps.** ISR frames are non-uniform in real time, so no single fps is literally true;
+   10 is the measured effective rate and keeps episode durations within ~2 % of the real ones.
+   A shared action horizon in *seconds* therefore covers 3× more steps on the ego half.
+2. **Action convention.** On ego, `action[t] == state[t+1]` exactly — no controller dynamics to
+   learn. The teleop half carries a genuine ~0.13 s tracking lag, and ISR does not remove it.
+3. **Gripper span** differs (1.4–59.8° vs −10.0–84.3°) at identical polarity, so per-dataset
+   normalization differs; binarizing at each dataset's own closed→open midpoint is the safe fix.
+4. **1 vs 89 tasks**, real vs synthesized imagery.
+
+## Provenance
+
+| half | source | processing |
+|---|---|---|
+| `std_mm_teleop_v30` | `makermods/2nd_100ep_blue_cube_orange_box` (LeRobot v3.0, real SO-101 teleop) | ISR standardization (`teleop_std_poc`) → kept frames rewritten as a v3.0 dataset |
+| `ego_v30` | `angkul07/ego-data` (EgoDex), retargeted through DT-pipeline stage 6 run F | LeRobot v2.1 → v3.0 (metadata + ffmpeg concat, **stream copy** — pixels untouched) |
+
+## `std_results/` — the standardization run
+
+ISR (*Information-Standardized Trajectory Resampling*, Yang et al., IROS 2026,
+[arXiv:2606.22907](https://arxiv.org/abs/2606.22907)) keeps one frame per fixed amount of
+**information** (distance moved + accumulated acceleration) instead of one frame per fixed amount
+of time, so operator pauses collapse and contact-rich moments stay dense. Demonstration consistency
+is then scored with ActionVariance (Eq. 9 of
+[arXiv:2306.02437](https://arxiv.org/abs/2306.02437)) and episodes are bucketed.
+
+```
+out/report.json         final artifact: per-episode bucket + ISR stats + thresholds
+out/scores_raw.json     ActionVariance before ISR
+out/scores_isr.json     ActionVariance after ISR
+out/eps_sensitivity.json  cluster-radius stability check
+out/isr/                per-episode kept indices + resampled arrays + 3x uniform baseline
+out/plots/              compression / spacing / variance + 12 per-episode figures
+RUN_NOTES.md            knobs, calibration, results, caveats
+calibrate.py, eps_sens.py, build_std_dataset.py, stats_compare.py
+```
+
+**Results.** 28,948 → 9,500 frames (32.8 %). The kept ratio varies **25.1–44.1 %** per episode
+against a flat 33.4 % for the 3× time-uniform baseline — that content-adaptivity is ISR's claim,
+and it reproduces here. Buckets (P50/P90 on ISR scores): **50 train / 40 review / 10 quarantine**.
+
+Two caveats that belong next to those numbers:
+
+- **ActionVariance rose raw→ISR** (89.8 → 94.3, up in 76/100 episodes), the opposite of the
+  BridgeData POC. Expected rather than broken: dropping pause frames removes the *lowest*-variance
+  samples. Read the ISR column alone, as a within-dataset ranking.
+- **Buckets are ε-sensitive.** All 100 episodes are one task, so states overlap heavily; per-episode
+  rank correlation against ε=0.5 falls to 0.51 (ε=0.3), 0.41 (0.2), 0.19 (0.1). Treat the 10
+  quarantined episodes as a shortlist to eyeball, not a verdict.
+
+Knobs were recalibrated for degree units (the defaults assume metres): `d_target=12`,
+`λ_acc=0.002`, `gripper-threshold=2.0°`. See `RUN_NOTES.md`.
+
+The ActionVariance scorer is a from-the-paper implementation (the paper ships no code) and
+joint-space ISR is an extension beyond the paper, which operates on end-effector positions.
+
+## Use
+
+```bash
+huggingface-cli download angkul07/so101-smolvla-data --repo-type dataset --local-dir .
+tar -xf std_mm_teleop_v30.tar && tar -xf ego_v30.tar
+```
+
+```python
+from lerobot.datasets.lerobot_dataset import LeRobotDataset
+ds = LeRobotDataset("angkul07/so101-smolvla-data", root="std_mm_teleop_v30")
+```

ego_v30.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8b3946a5ef64e225feadce8f6dddd22a0967e6c8a6a9ce2c9ae6e8c96698fc1c
+size 334131200

std_mm_teleop_v30.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4f6390493354d38acb2f640c5eaea957c784ba509a0494fc92618c58641b5137
+size 98867200

std_results/RUN_NOTES.md

@@ -0,0 +1,98 @@
+# std_mm_teleop — teleop standardization run on `mm_teleop`
+
+Pipeline: `/workspace/teleop_std_poc` (ISR resample → ActionVariance score → bucket → plots).
+Source: `/workspace/mm_teleop` — LeRobot **v3.0**, `so_follower` (SO-101), 100 episodes,
+28 948 frames @ 30 fps, 1 task, 6-D state/action in **degrees** (5 arm joints + gripper).
+
+Run date: 2026-08-18. Env: `/workspace/.venv-tsp` (py3.10, numpy 2.2.6, pyarrow 25.0.1, mpl 3.10.9).
+
+## Command
+
+```bash
+cd /workspace/teleop_std_poc
+TSP_ROOT=/workspace/std_mm_teleop /workspace/.venv-tsp/bin/python run_all.py \
+    --local /workspace/mm_teleop --all-episodes \
+    --d-target 12 --lambda-acc 0.002 --gripper-threshold 2.0 --baseline 3 \
+    --eps 0.5 --max-episode-figs 12
+```
+
+## Pipeline changes this run needed (all backward compatible)
+
+| Change | Why |
+|---|---|
+| `TSP_ROOT` env var in all 5 stages | outputs land here instead of inside the repo |
+| `fetch_trajs.py --local <dir>` / `--all` | the POC only read the HF Hub; this dataset is on disk |
+| SO-101 6-D layout in `split_state` | 6-D state was falling through to `unknown[6]` → gripper force-keep disabled |
+| v3 parquet cache in `_episode_table_v3` | it re-read the 28 948-row concatenated file once per episode (100×) |
+| `isr_resample.py --gripper-threshold` | 0.05 is a *normalized* gripper default; this gripper is in degrees |
+| `viz.py --max-episode-figs`, wide-figure scaling | 100 bars/figures were unreadable |
+
+## Knob calibration (defaults assume metres — this data is degrees)
+
+Measured over all 100 episodes: per-frame joint step 2.03° mean / 1.50° median;
+accel magnitude 267 °/s² mean; gripper span 41.6° per episode.
+
+- `--lambda-acc 0.002` → the acceleration term carries **21 %** of per-frame info
+  (paper's 0.01-in-metres is likewise a minority-but-material share). 0.01 here would be 57 % — acc-dominated.
+- `--gripper-threshold 2.0` ≈ 5 % of the 41.6° gripper span — the same intent as the 0.05 normalized default.
+  Flags 12.5 % of frame pairs as gripper events (0.5 → 21 %, i.e. jitter).
+- `--d-target 12` → 32.8 % of frames kept, deliberately matched to the 3× uniform baseline (33.7 %)
+  so ISR-vs-uniform is like-for-like. Sweep is in `calibration_sweep.txt`.
+
+## Results
+
+**Compression** — 28 948 → 9 500 frames (32.8 %). Kept ratio varies **25.1 %–44.1 %** per episode
+(std 0.040); the 3× baseline is flat at 33.4 % (std 0.001). That content-adaptivity is the ISR claim,
+and it reproduces here. 42 frames/episode on average are gripper-forced.
+
+**Scoring** — dataset ActionVariance **raw 89.8 → ISR 94.3 (+5.0 %)**; it *rose* in 76/100 episodes
+(mean +5.4 %). This is the opposite of the BridgeData POC (−22 %) and is expected rather than a bug:
+removing pause frames removes the *lowest*-variance samples (a held pose has near-identical actions),
+so the mean over what remains goes up. The raw→ISR delta is therefore **not** a "pacing noise removed"
+readout on this dataset — read the ISR column alone, as a relative ranking.
+
+**Buckets** (percentile mode, P50/P90 on ISR scores): **50 train / 40 review / 10 quarantine**.
+Quarantined: `ep7, ep11, ep15, ep42, ep61, ep71, ep83, ep86, ep87, ep92`.
+Score spread 71.0 → 115.1 (p50 95.0, p90 106.1); every episode was scoreable (100 % clustered coverage).
+
+## Caveats
+
+1. **Bucket assignment is ε-sensitive on this dataset** (`out/eps_sensitivity.json`). All 100 episodes
+   are the same task, so states overlap heavily. Per-episode rank correlation against ε=0.5:
+   ε=0.3 → 0.51, ε=0.2 → 0.41, ε=0.1 → 0.19; mean cluster size 90 → 22 → 8.5 → 3.5 points.
+   The train/quarantine split would reshuffle materially at a tighter radius — treat the current
+   10 quarantines as a shortlist to eyeball, not a verdict, until ε is pinned by a labeled reference.
+2. Scores are in **degrees²** and only comparable within this dataset (the scorer is test-grade —
+   implemented from paper Eq. 9, no official code exists).
+3. Joint-space ISR is the POC's extension beyond the paper (paper operates on EE positions).
+4. Only 5 arm joints drive the resampling; the gripper channel drives force-keeping only.
+
+## Outputs
+
+```
+trajs/               100 × ep{N}.npz (positions/gripper/actions/timestamps) + index.json
+out/isr/             100 × ep{N}.npz (ISR-kept) + ep{N}_baseline3x.npz + stats.json
+out/scores_raw.json  ActionVariance before ISR
+out/scores_isr.json  ActionVariance after ISR
+out/report.json      final artifact — buckets, thresholds, per-episode ISR stats
+out/eps_sensitivity.json   ε-radius stability check
+out/plots/           compression.png, spacing.png, variance.png, ep{0..11}_isr.png
+run.log              full stdout
+```
+
+Nothing was written back into `mm_teleop`; it is untouched.
+
+---
+
+## v3.0 dataset build (2026-08-18, after the POC run)
+
+`build_std_dataset.py` materializes the ISR-kept frames as a real LeRobot **v3.0** dataset at
+`lerobot_v30/` (223 MB): parquet rows AND the matching video frames, decoded from `mm_teleop`
+and re-encoded h264. 100 eps / 9,500 frames / 1 task, loads via `LeRobotDataset`.
+
+Frames are renumbered onto a uniform grid at **10 fps** — the measured effective rate
+(30 fps ÷ 3.05x compression) — because ISR spacing is non-uniform in real time and LeRobot
+enforces `timestamp ≈ frame_index / fps`. Episode durations stay within ~2% of the real ones.
+`--fps 30` rebuilds at the source rate instead.
+
+Env: `/workspace/.venv-lerobot` (lerobot 0.4.4). Comparison against ego: `COMPARISON_ego_vs_std_mm_teleop.md`.

std_results/build_std_dataset.py

@@ -0,0 +1,149 @@
+#!/usr/bin/env python3
+"""Materialize the ISR-standardized teleop set as a native LeRobot v3.0 dataset.
+
+`teleop_std_poc` only emits npz + report artifacts; SmolVLA needs a real dataset. This takes
+    source frames : /workspace/mm_teleop            (LeRobot v3.0, SO-101, 30 fps)
+    kept indices  : /workspace/std_mm_teleop/out/isr/ep{N}.npz  ["keep"]
+and writes the kept frames — parquet rows AND the matching video frames — as a new v3.0 tree.
+
+TIME: ISR frames are non-uniform in real time, so the original timestamps cannot be carried over
+(LeRobot enforces timestamp ≈ frame_index / fps within tolerance_s). Frames are renumbered onto a
+uniform grid at the dataset's EFFECTIVE rate (30 fps / mean compression ≈ 10 fps), which keeps
+episode durations within a few percent of the real ones. Pass --fps 30 to renumber at the source
+rate instead (episodes then play ~3x fast).
+
+Videos are decoded sequentially per camera file (episodes are contiguous and ordered inside them),
+so each source frame is touched exactly once.
+"""
+import argparse
+import json
+import os
+import time
+from pathlib import Path
+
+os.environ.setdefault("HF_HUB_OFFLINE", "1")
+os.environ.setdefault("HF_DATASETS_OFFLINE", "1")
+
+import av
+import numpy as np
+import pyarrow.parquet as pq
+
+from lerobot.datasets.lerobot_dataset import LeRobotDataset
+
+SRC = Path("/workspace/mm_teleop")
+ISR = Path("/workspace/std_mm_teleop/out/isr")
+OUT = Path("/workspace/std_mm_teleop/lerobot_v30")
+
+
+class CamReader:
+    """Sequential decoder over one camera's concatenated v3.0 video files."""
+
+    def __init__(self, root: Path, cam: str):
+        self.dir = root / "videos" / cam / "chunk-000"
+        self.file_index = None
+        self.container = None
+        self.iter = None
+
+    def _open(self, file_index: int):
+        if self.container is not None:
+            self.container.close()
+        path = self.dir / f"file-{file_index:03d}.mp4"
+        self.container = av.open(str(path))
+        self.iter = self.container.decode(video=0)
+        self.file_index = file_index
+
+    def take(self, file_index: int, count: int, keep_local: set[int]) -> dict[int, np.ndarray]:
+        """Consume `count` frames of that file, returning only the ones in keep_local."""
+        if file_index != self.file_index:
+            self._open(file_index)
+        out = {}
+        for i in range(count):
+            frame = next(self.iter)
+            if i in keep_local:
+                out[i] = frame.to_ndarray(format="rgb24")
+        return out
+
+    def close(self):
+        if self.container is not None:
+            self.container.close()
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--fps", type=int, default=0, help="0 = effective rate (source fps / compression)")
+    ap.add_argument("--repo-id", default="angkul07/std_mm_teleop")
+    ap.add_argument("--out", default=str(OUT))
+    ap.add_argument("--limit", type=int, default=0, help="debug: only N episodes")
+    a = ap.parse_args()
+
+    out_root = Path(a.out)
+    if out_root.exists():
+        raise SystemExit(f"{out_root} exists — remove it first")
+
+    info = json.loads((SRC / "meta" / "info.json").read_text())
+    src_fps = int(info["fps"])
+    features = {k: dict(v, shape=tuple(v["shape"]))   # info.json stores lists; validation wants tuples
+                for k, v in info["features"].items()
+                if k in ("action", "observation.state") or k.startswith("observation.images")}
+    cams = [k for k in features if k.startswith("observation.images")]
+
+    ep_meta = pq.read_table(SRC / "meta" / "episodes" / "chunk-000" / "file-000.parquet").to_pydict()
+    n_eps = len(ep_meta["episode_index"])
+    data = pq.read_table(SRC / "data" / "chunk-000" / "file-000.parquet")
+    state_all = np.array(data["observation.state"].to_pylist(), dtype=np.float32)
+    action_all = np.array(data["action"].to_pylist(), dtype=np.float32)
+    task_by_index = dict(zip(*pq.read_table(SRC / "meta" / "tasks.parquet").to_pydict().values()))
+    task_index_all = np.array(data["task_index"].to_pylist())
+
+    keeps = {}
+    for ep in range(n_eps):
+        keeps[ep] = np.load(ISR / f"ep{ep}.npz")["keep"].astype(int)
+    kept_total = sum(len(v) for v in keeps.values())
+    src_total = int(info["total_frames"])
+    compression = src_total / kept_total
+    fps = a.fps or max(1, round(src_fps / compression))
+    print(f"{src_total} -> {kept_total} frames ({100*kept_total/src_total:.1f}%), "
+          f"compression {compression:.2f}x -> writing at {fps} fps "
+          f"({'effective rate' if not a.fps else 'forced'})")
+
+    ds = LeRobotDataset.create(
+        repo_id=a.repo_id, fps=fps, features=features, root=out_root,
+        robot_type=info.get("robot_type"), use_videos=True,
+        image_writer_processes=0, image_writer_threads=4, vcodec="h264",
+    )
+
+    readers = {c: CamReader(SRC, c) for c in cams}
+    t0 = time.time()
+    todo = n_eps if not a.limit else min(a.limit, n_eps)
+    for ep in range(todo):
+        lo, hi = ep_meta["dataset_from_index"][ep], ep_meta["dataset_to_index"][ep]
+        length = hi - lo
+        keep = keeps[ep]
+        keep_set = set(keep.tolist())
+        frames = {}
+        for cam in cams:
+            fi = ep_meta[f"videos/{cam}/file_index"][ep]
+            frames[cam] = readers[cam].take(fi, length, keep_set)
+            if len(frames[cam]) != len(keep):
+                raise SystemExit(f"ep{ep} {cam}: got {len(frames[cam])} frames, expected {len(keep)}")
+        task = task_by_index[int(task_index_all[lo])]
+        for j in keep:
+            ds.add_frame({
+                "observation.state": state_all[lo + j],
+                "action": action_all[lo + j],
+                **{c: frames[c][int(j)] for c in cams},
+                "task": task,
+            })
+        ds.save_episode()
+        if ep % 10 == 0 or ep == todo - 1:
+            el = time.time() - t0
+            print(f"  ep{ep:>3}: {length} -> {len(keep)} frames | {el:.0f}s elapsed, "
+                  f"eta {el/(ep+1)*(todo-ep-1):.0f}s", flush=True)
+
+    for r in readers.values():
+        r.close()
+    print(f"done in {time.time()-t0:.0f}s -> {out_root}")
+
+
+if __name__ == "__main__":
+    main()

std_results/build_v30.log.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bcc356159e6c0c7a67dc4de1459cc5782414cc4577bfd7f40a60d3bfc1e6e611
+size 25508

std_results/calibrate.py

@@ -0,0 +1,51 @@
+"""Calibrate ISR knobs for degree-unit SO-101 joint data (defaults assume metres)."""
+import sys, json
+from pathlib import Path
+import numpy as np
+
+sys.path.insert(0, "/workspace/teleop_std_poc")
+from isr_resample import _acceleration_magnitudes, isr_resample, _gripper_forced
+
+T = Path("/workspace/std_mm_teleop/trajs")
+files = sorted(T.glob("ep*.npz"), key=lambda p: int(p.stem[2:]))
+
+step_all, acc_all, grip_d, spans = [], [], [], []
+for f in files:
+    d = np.load(f)
+    pos, ts, g = d["positions"], d["timestamps"], d["gripper"]
+    step_all.append(np.linalg.norm(np.diff(pos, axis=0), axis=1))
+    acc_all.append(_acceleration_magnitudes(pos, ts))
+    grip_d.append(np.abs(np.diff(g)))
+    spans.append(g.max() - g.min())
+step = np.concatenate(step_all); acc = np.concatenate(acc_all); gd = np.concatenate(grip_d)
+print(f"per-frame joint step (deg): mean {step.mean():.3f} median {np.median(step):.3f} p90 {np.percentile(step,90):.3f}")
+print(f"accel magnitude (deg/s^2): mean {acc.mean():.1f} median {np.median(acc):.1f}")
+print(f"gripper |delta| per frame: median {np.median(gd):.3f} p90 {np.percentile(gd,90):.3f} max {gd.max():.2f}")
+print(f"gripper span per episode : mean {np.mean(spans):.1f}")
+
+# lambda_acc so the acceleration term carries a comparable weight to distance, as in the paper
+# (paper: metres + lambda_acc 0.01 -> acc term is a minority but non-trivial share of the info)
+for la in [0.0, 0.001, 0.002, 0.005, 0.01]:
+    share = la * acc.mean() / (step.mean() + la * acc.mean())
+    print(f"  lambda_acc={la:<6} -> acc share of per-frame info {100*share:.0f}%")
+
+# gripper threshold: pick the knee between "real open/close" and per-frame jitter
+for th in [0.5, 1.0, 2.0, 3.0]:
+    frac = float((gd > th).mean())
+    print(f"  grip_threshold={th:<4} -> {100*frac:.1f}% of frame pairs flagged as gripper events")
+
+# d_target sweep on a 12-episode probe (keep ratio + gripper-forced share)
+probe = files[:12]
+la, gt = 0.002, 2.0
+print("\nd_target sweep (12-episode probe, lambda_acc=%.3f, grip_th=%.1f):" % (la, gt))
+for dt in [2, 4, 6, 8, 12, 16, 24]:
+    ratios, forced_share = [], []
+    for f in probe:
+        d = np.load(f)
+        pos, ts, g = d["positions"], d["timestamps"], d["gripper"]
+        keep = isr_resample(pos, ts, g, dt, 1.0, la, gt)
+        forced = _gripper_forced(g, len(pos), threshold=gt)
+        ratios.append(len(keep) / len(pos))
+        forced_share.append(len(forced) / max(len(keep), 1))
+    print(f"  d_target={dt:<4} kept {100*np.mean(ratios):5.1f}% (min {100*min(ratios):.0f} max {100*max(ratios):.0f}) "
+          f"| gripper-forced share of kept {100*np.mean(forced_share):.0f}%")

std_results/calibration_sweep.txt

@@ -0,0 +1,22 @@
+per-frame joint step (deg): mean 2.028 median 1.497 p90 4.997
+accel magnitude (deg/s^2): mean 267.4 median 237.4
+gripper |delta| per frame: median 0.000 p90 2.478 max 3.75
+gripper span per episode : mean 41.6
+  lambda_acc=0.0    -> acc share of per-frame info 0%
+  lambda_acc=0.001  -> acc share of per-frame info 12%
+  lambda_acc=0.002  -> acc share of per-frame info 21%
+  lambda_acc=0.005  -> acc share of per-frame info 40%
+  lambda_acc=0.01   -> acc share of per-frame info 57%
+  grip_threshold=0.5  -> 21.3% of frame pairs flagged as gripper events
+  grip_threshold=1.0  -> 18.0% of frame pairs flagged as gripper events
+  grip_threshold=2.0  -> 12.5% of frame pairs flagged as gripper events
+  grip_threshold=3.0  -> 7.3% of frame pairs flagged as gripper events
+
+d_target sweep (12-episode probe, lambda_acc=0.002, grip_th=2.0):
+  d_target=2    kept  69.7% (min 65 max 74) | gripper-forced share of kept 21%
+  d_target=4    kept  60.5% (min 53 max 65) | gripper-forced share of kept 24%
+  d_target=6    kept  51.5% (min 41 max 58) | gripper-forced share of kept 29%
+  d_target=8    kept  42.9% (min 34 max 49) | gripper-forced share of kept 34%
+  d_target=12   kept  33.3% (min 26 max 42) | gripper-forced share of kept 44%
+  d_target=16   kept  28.8% (min 22 max 38) | gripper-forced share of kept 51%
+  d_target=24   kept  23.9% (min 18 max 34) | gripper-forced share of kept 61%

std_results/comparison_stats.json

@@ -0,0 +1,224 @@
+[
+  {
+    "name": "std_mm_teleop",
+    "root": "/workspace/std_mm_teleop/lerobot_v30",
+    "format": "LeRobot v3.0",
+    "robot_type": "so_follower",
+    "fps": 10,
+    "episodes": 100,
+    "frames": 9500,
+    "tasks": 1,
+    "task_examples": [
+      "pick up blue cube and put into orange box"
+    ],
+    "duration_s": 950.0,
+    "duration_hms": "15.8 min",
+    "episode_len": {
+      "mean": 95.0,
+      "min": 78,
+      "max": 117,
+      "median": 94
+    },
+    "camera_keys": [
+      "observation.images.wrist",
+      "observation.images.front"
+    ],
+    "video": {
+      "observation.images.wrist": {
+        "codec": "h264",
+        "size": "640x480",
+        "pix_fmt": "yuv420p",
+        "fps": "10/1",
+        "n_files": 1
+      },
+      "observation.images.front": {
+        "codec": "h264",
+        "size": "640x480",
+        "pix_fmt": "yuv420p",
+        "fps": "10/1",
+        "n_files": 1
+      }
+    },
+    "state_dtype": "float32[6]",
+    "action_dtype": "float32[6]",
+    "state_layout": [
+      "shoulder_pan.pos",
+      "shoulder_lift.pos",
+      "elbow_flex.pos",
+      "wrist_flex.pos",
+      "wrist_roll.pos",
+      "gripper.pos"
+    ],
+    "state_range_deg": [
+      [
+        -14.3,
+        62.6
+      ],
+      [
+        -105.8,
+        70.7
+      ],
+      [
+        -78.3,
+        97.1
+      ],
+      [
+        28.7,
+        97.2
+      ],
+      [
+        -72.2,
+        115.5
+      ],
+      [
+        1.4,
+        59.8
+      ]
+    ],
+    "action_convention": {
+      "mae_vs_state_at_lag": {
+        "0": 4.0875,
+        "1": 2.4818,
+        "2": 2.0846,
+        "3": 3.0765,
+        "4": 4.45,
+        "5": 6.1464,
+        "6": 7.921
+      },
+      "best_lag_frames": 2,
+      "best_lag_mae_deg": 2.0846
+    },
+    "gripper": {
+      "state_range": [
+        1.398,
+        59.784
+      ],
+      "action_range": [
+        0.0,
+        60.714
+      ],
+      "looks_normalized_01": false,
+      "mean": 18.569,
+      "mean_normalized": 0.294,
+      "p05_p50_p95": [
+        1.461,
+        13.85,
+        44.473
+      ],
+      "pct_below_25pct_of_span": 52.6,
+      "pct_above_75pct_of_span": 4.1
+    }
+  },
+  {
+    "name": "ego_v21",
+    "root": "/workspace/final_dataset/final_data/ego_v21",
+    "format": "LeRobot v3.0",
+    "robot_type": "so101_follower",
+    "fps": 30,
+    "episodes": 324,
+    "frames": 36442,
+    "tasks": 89,
+    "task_examples": [
+      "pick up a AirPods case from the table and place it on the chessboard.",
+      "pick up a black silk hairtie from the table and place it in the clear jar.",
+      "pick up a black stapler from the table and place it in the box lid."
+    ],
+    "duration_s": 1214.7,
+    "duration_hms": "20.2 min",
+    "episode_len": {
+      "mean": 112.5,
+      "min": 30,
+      "max": 354,
+      "median": 96
+    },
+    "camera_keys": [
+      "observation.images.front",
+      "observation.images.wrist"
+    ],
+    "video": {
+      "observation.images.front": {
+        "codec": "h264",
+        "size": "640x480",
+        "pix_fmt": "yuv420p",
+        "fps": "30/1",
+        "n_files": 1
+      },
+      "observation.images.wrist": {
+        "codec": "h264",
+        "size": "640x480",
+        "pix_fmt": "yuv420p",
+        "fps": "30/1",
+        "n_files": 1
+      }
+    },
+    "state_dtype": "float32[6]",
+    "action_dtype": "float32[6]",
+    "state_layout": [
+      "shoulder_pan.pos",
+      "shoulder_lift.pos",
+      "elbow_flex.pos",
+      "wrist_flex.pos",
+      "wrist_roll.pos",
+      "gripper.pos"
+    ],
+    "state_range_deg": [
+      [
+        -110.0,
+        110.0
+      ],
+      [
+        -100.0,
+        100.0
+      ],
+      [
+        -96.8,
+        96.8
+      ],
+      [
+        -95.0,
+        95.0
+      ],
+      [
+        -157.2,
+        162.8
+      ],
+      [
+        -10.0,
+        84.3
+      ]
+    ],
+    "action_convention": {
+      "mae_vs_state_at_lag": {
+        "0": 1.9507,
+        "1": 0.0,
+        "2": 1.9761,
+        "3": 3.8321,
+        "4": 5.6246,
+        "5": 7.3562,
+        "6": 9.0061
+      },
+      "best_lag_frames": 1,
+      "best_lag_mae_deg": 0.0
+    },
+    "gripper": {
+      "state_range": [
+        -10.0,
+        84.298
+      ],
+      "action_range": [
+        -8.594,
+        84.298
+      ],
+      "looks_normalized_01": false,
+      "mean": 20.944,
+      "mean_normalized": 0.328,
+      "p05_p50_p95": [
+        1.1,
+        18.343,
+        49.112
+      ],
+      "pct_below_25pct_of_span": 33.5,
+      "pct_above_75pct_of_span": 0.7
+    }
+  }
+]

std_results/eps_sens.py

@@ -0,0 +1,43 @@
+"""ε sensitivity: is the per-episode ranking stable, or an artifact of over-wide state clusters?"""
+import sys, json
+from pathlib import Path
+import numpy as np
+
+sys.path.insert(0, "/workspace/teleop_std_poc")
+import os
+os.environ.setdefault("TSP_ROOT", "/workspace/std_mm_teleop")
+from action_variance import load, score
+
+eps_list = [0.5, 0.3, 0.2, 0.1]
+episodes = load("isr")
+S = np.concatenate([p for _, p, _ in episodes])
+mu, sd = S.mean(0), S.std(0) + 1e-9
+Z = (S - mu) / sd
+res = {}
+rank0 = None
+out = {}
+for e in eps_list:
+    per, ds, _ = score(episodes, e, 2)
+    names = list(per)
+    vals = np.array([per[n]["score"] if per[n]["score"] is not None else np.nan for n in names])
+    cov = np.mean([per[n]["scored_points"] / per[n]["total_points"] for n in names])
+    # mean cluster size, sampled (full N^2 already done inside score, recompute cheaply on a sample)
+    idx = np.random.default_rng(0).choice(len(Z), size=min(2000, len(Z)), replace=False)
+    sizes = [(np.linalg.norm(Z - Z[i], axis=1) <= e).sum() for i in idx]
+    r = np.argsort(np.argsort(np.nan_to_num(vals, nan=-1)))
+    if rank0 is None:
+        rank0 = r
+        corr = 1.0
+    else:
+        corr = float(np.corrcoef(rank0, r)[0, 1])
+    out[str(e)] = {"dataset_av": None if ds is None else round(ds, 4),
+                   "coverage": round(100 * cov, 1),
+                   "mean_cluster_size": round(float(np.mean(sizes)), 1),
+                   "median_cluster_size": int(np.median(sizes)),
+                   "cluster_pct_of_dataset": round(100 * float(np.mean(sizes)) / len(Z), 2),
+                   "rank_corr_vs_eps0.5": round(corr, 3)}
+    print(e, out[str(e)])
+Path("/workspace/std_mm_teleop/out/eps_sensitivity.json").write_text(json.dumps(
+    {"note": "per-episode ActionVariance ranking vs cluster radius on ISR-resampled data",
+     "n_points": int(len(Z)), "eps": out}, indent=2))
+print("wrote out/eps_sensitivity.json")

std_results/out/eps_sensitivity.json

@@ -0,0 +1,38 @@
+{
+  "note": "per-episode ActionVariance ranking vs cluster radius on ISR-resampled data",
+  "n_points": 9500,
+  "eps": {
+    "0.5": {
+      "dataset_av": 94.3317,
+      "coverage": 99.6,
+      "mean_cluster_size": 90.5,
+      "median_cluster_size": 34,
+      "cluster_pct_of_dataset": 0.95,
+      "rank_corr_vs_eps0.5": 1.0
+    },
+    "0.3": {
+      "dataset_av": 32.7051,
+      "coverage": 92.4,
+      "mean_cluster_size": 22.1,
+      "median_cluster_size": 11,
+      "cluster_pct_of_dataset": 0.23,
+      "rank_corr_vs_eps0.5": 0.51
+    },
+    "0.2": {
+      "dataset_av": 11.1128,
+      "coverage": 74.0,
+      "mean_cluster_size": 8.5,
+      "median_cluster_size": 5,
+      "cluster_pct_of_dataset": 0.09,
+      "rank_corr_vs_eps0.5": 0.41
+    },
+    "0.1": {
+      "dataset_av": 2.0393,
+      "coverage": 42.3,
+      "mean_cluster_size": 3.5,
+      "median_cluster_size": 1,
+      "cluster_pct_of_dataset": 0.04,
+      "rank_corr_vs_eps0.5": 0.186
+    }
+  }
+}

std_results/out/isr/ep0.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:985b67a2ce220606a9e653a896b59fdc2a57b07fecf117d74a82e218fbdffbf0
+size 11892

std_results/out/isr/ep0_baseline3x.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:36f8b60d3a2df4547b707ef891ca7be607c27cbaa276259b8d04cc7b3d606cd4
+size 10474

std_results/out/isr/ep1.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c46ef8ae2811b763b1448d8faa49363adb991570c4e2b41bbb0aa6b828ae4922
+size 13012

std_results/out/isr/ep10.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9b747a59d43f26557313b3c913162b108537c083697a05ea4e3c31e9b148dc3f
+size 11204

std_results/out/isr/ep10_baseline3x.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3e9f5a0271b47ccdab8b720a73e6817c80e459c5843fe55a93da653118136cb6
+size 9434

std_results/out/isr/ep11.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ec2b14f66547bc2631c51282e474e4f0e6909c2bc1c213876dfd952e74aa6142
+size 13900

std_results/out/isr/ep11_baseline3x.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:88ad0bacbb046414ba96ccdfc949725a911e7a8694ce1006ad0c8e66440c289d
+size 9850

std_results/out/isr/ep12.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:035d209f965c95151b7eba7456d6050495ff2f9d51e9ce26406fee5dde2748f1
+size 10428

std_results/out/isr/ep12_baseline3x.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9b7732ffc8edb4b9ad2bdac87dd514624b67921549928b126d23ca38cc332303
+size 11618

std_results/out/isr/ep13.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:901aac020baf83a6a1aad7ba708fd22ec1bca77e9f0896186564e98e5c1a9098
+size 11708

std_results/out/isr/ep13_baseline3x.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3ff292435eb8ea4daf5074050f942141ff4ad11dd606b3d4f2c9afce61535229
+size 10890

std_results/out/isr/ep14.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:169de8654175ce48f7015fb0f8a2559a12d102dbb388846544b1a8d165aaf3fc
+size 12396

std_results/out/isr/ep14_baseline3x.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6d68a24718b36111636517c3209b8904f4539626735da7fc1c7cfa77dde9f3f7
+size 10578

std_results/out/isr/ep15.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7dbe44609551f66b178a649fede6290084ddea47215a61204ba5b4c7251d7c1c
+size 11948

std_results/out/isr/ep15_baseline3x.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:89ebded65b49f5f1b81d21c8370869af984dc96798f70c844e0ec90953d27553
+size 10058

std_results/out/isr/ep16.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1664a043dcd8b57805528a7047dc120f0956f69f3fbbec9be2223797e2c92e3b
+size 12356

std_results/out/isr/ep16_baseline3x.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6763f63dfedf77819721ca9d0113812e6540cdd91495e7adce6fc21b9da9d663
+size 9954

std_results/out/isr/ep17.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e6f2096948a3b46a7e802793d782cf434eb4710d34032e7cb8ac46f6f3fd4f39
+size 11740

std_results/out/isr/ep17_baseline3x.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7ca1475df5eccf002945dce6bedfd6004fa8625ede8be8c89f3880f9550c9740
+size 11618

std_results/out/isr/ep18.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bf5de414cbf1f58f8a92cf0b0b57fc8d197771a4cd4f64ea81e668fe1fe166a2
+size 11812

std_results/out/isr/ep18_baseline3x.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c4fec41fee45ac170abbad2cda14c39cc0679ba03a9de15ba14cfbd8289182fb
+size 12138

std_results/out/isr/ep19.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4eaaed4f00ef975bba3e65b65348042d58f90b94e2add2844655659c3327beef
+size 12116

std_results/out/isr/ep19_baseline3x.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:468fedc8588646b89f1d9cbfc4891cdb17a045530f847dcbb0bdfab665a1602e
+size 12034

std_results/out/isr/ep1_baseline3x.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:57f614de6f14ae058e995263ccd87d8878b94e28f235587a58fd507168b6bfc6
+size 10786

std_results/out/isr/ep2.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:132a9fb38a2d123947821770ca4e6d7dc23fb39fab5254e7b6378156176e809e
+size 13236

std_results/out/isr/ep20.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:495a5b06dd3b741196096e67de84496fe777281fd8b3304636b38953f182f2ce
+size 11460

std_results/out/isr/ep20_baseline3x.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f3fbb4703da668d03ee3a8830214067240b8cff450603096020c07ca01d88b2a
+size 11410

std_results/out/isr/ep21.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2a88c387c87c00e07baaffd460c2b3abd95b659d12e2eaea73c041c2c872f8fa
+size 12500

std_results/out/isr/ep21_baseline3x.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:50267cef61387e4ba41035ba79079ee16469e550634349b97ca4572ef06585c8
+size 10890

std_results/out/isr/ep22.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:06d9121af94aa8ba6860a0a2209335c04e81b22c60e71254970fdcffd7dbaf32
+size 12476

std_results/out/isr/ep22_baseline3x.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:680b29fb1157c0716d683e86c51fa341a2ed32ed73b0bea278972d74e5278714
+size 9954

std_results/out/isr/ep23.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c2c353d5ad4e8d2a686a7f0ed4864c459d7211e6c77d94afc5a4061384ed7694
+size 13164

std_results/out/isr/ep23_baseline3x.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:92e583eb910c6939e3759e2174d548368554d6aa009832c287b17e7e0270ddc4
+size 10786

std_results/out/isr/ep24.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7a8efde2763569981b15501719ce8e04c86c943fb9aadc15aac45ca0c78519d1
+size 12236

std_results/out/isr/ep24_baseline3x.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:27d3b75bb608f6698707b727c3fe90d155ee6c92e30ae2fe1f3e82fbf7274b6a
+size 9850

std_results/out/isr/ep25.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b64a738b2beb136f31c3a2a1608a9dd1406c14ba446b5237582b277d701444d5
+size 12972

std_results/out/isr/ep25_baseline3x.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:00b3f760a31619dd4f8d6b3d46210f8349ea22244c0b3083c9e472f9cb079479
+size 10370

std_results/out/isr/ep26.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:94bc70762da5b1602f3bed5606160b429927275649c52214c1e612ebf85899cd
+size 13764

std_results/out/isr/ep26_baseline3x.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e465a129ac69756b6f0f5b78836c3ccafaa7a6b4d6665bd141100278ad2db41a
+size 9330