"""React: short-horizon contact-rich window dataset (PyTorch). Yields short multimodal windows sampled from the React recordings, with all known data-quality issues filtered out at window-enumeration time. Intended for tactile-visual dynamics / world-model / UMI-style imitation learning. What each filter catches ------------------------ 1. `skip_bad_frames` → windows overlapping any flagged interval in `bad_frames.json` are dropped. Covers: - `intensity_spikes` — single-frame GelSight LED glitches - `pose_teleports_{L,R}` — translation-velocity > 5 m/s solver flips - `ot_loss_{L,R}` — mid-episode OptiTrack track loss (pose held stale for ≥ 0.25 s while the cross-modal motion check shows the sensor was actually moving) 2. `respect_active_sensors` → per-date metadata in `tasks.json` tells us which GelSight rigid bodies were actually in use that day; the predicate below ignores inactive sensors when deciding "is this window useful?". 3. `min_contact_fraction` → windows where fewer than this fraction of frames have tactile contact (per the configured metric + threshold + `which_sensors`) are dropped. Forces samples to be contact-rich. 4. `require_motion` → windows where the sensor is sitting essentially still (operator paused mid-manipulation) are dropped. Specifically: an active sensor "passes" if at least `min_motion_fraction` of its frames have per-frame translation speed ≥ `min_motion_mps`. The `which_sensors_must_move` parameter says whether every active sensor must pass, or just one. This catches the failure mode that bad_frames.json *can't* — windows where OT is healthy and pose is changing every frame, but the change is sub-millimeter per frame so there's nothing to learn dynamics from. Coordinates note ---------------- All frame indices in `bad_frames.json` and the .pt files are in TRIMMED coordinates: the OT-uninitialized prefixes at the start of three episodes have been cut from the published .pt files (see `_contact_meta.trim_offset` inside each .pt). You don't need to do anything special — this loader and the metadata are already aligned. Usage ----- ```python from react_window_dataset import ReactWindowDataset from torch.utils.data import DataLoader ds = ReactWindowDataset( data_root = "processed/mode1_v1/motherboard", bad_frames_path = "bad_frames.json", tasks_json_path = "tasks.json", window_length = 16, stride = 1, window_step = 8, # contact filter contact_metric = "mixed", tactile_threshold = 0.4, min_contact_fraction = 0.5, which_sensors = "both", # quality filters (recommended on) skip_bad_frames = True, respect_active_sensors = True, # motion filter (recommended on for dynamics learning) require_motion = True, min_motion_mps = 0.01, # 10 mm/s — below typical slow manipulation min_motion_fraction = 0.25, which_sensors_must_move = "all_active", ) loader = DataLoader(ds, batch_size=8, shuffle=True, num_workers=2) ``` Each sample is a dict of `(T, ...)` tensors plus per-window metadata (`episode`, `episode_key`, `frame_start`, `frame_end`, `active_sensors`). """ from __future__ import annotations import json from pathlib import Path from typing import Iterable import numpy as np import torch from torch.utils.data import Dataset CONTACT_METRICS = ("intensity", "area", "mixed") def _per_frame_speed_mps(pose7: np.ndarray, fps: float = 30.0) -> np.ndarray: """Per-frame translation speed in m/s. Output shape == input frame count; pad the first frame's speed with the second frame's (forward difference).""" if pose7.shape[0] < 2: return np.zeros(pose7.shape[0], dtype=np.float64) d = np.linalg.norm(np.diff(pose7[:, :3], axis=0), axis=1) * fps out = np.empty(pose7.shape[0], dtype=np.float64) out[0] = d[0] out[1:] = d return out class ReactWindowDataset(Dataset): """Per-window dataset over the React recordings. See the module docstring for what each filter catches. Parameters ---------- data_root : path Directory containing `//episode_*.pt` files (searched recursively). bad_frames_path : optional path Path to `bad_frames.json`. If None, no quality filter is applied. tasks_json_path : optional path Path to `tasks.json`. Used for the `respect_active_sensors` mode. window_length : int Frames per sample (default 16). stride : int Frame stride *within* a window. `stride=1` → consecutive source frames; `stride=2` → every other source frame; etc. Span of a window in source-frame indices = `(window_length - 1) * stride + 1`. window_step : int, default `window_length // 2` Step between window start indices within an episode. Controls overlap between adjacent windows. contact_metric : {"intensity", "area", "mixed"} Which per-frame tactile metric to threshold on. tactile_threshold : float Minimum value of the chosen metric to count a frame as in-contact. min_contact_fraction : float in [0, 1] Window must have ≥ this fraction of in-contact frames. which_sensors : {"any", "both", "left", "right"} How left + right sensors combine when checking the contact predicate. (Inactive sensors per `tasks.json` are always excluded.) skip_bad_frames : bool, default True Drop windows whose source-frame span overlaps any interval in `intensity_spikes / pose_teleports_{L,R} / ot_loss_{L,R}`. respect_active_sensors : bool, default True If True (and `tasks.json` has per-date `active_sensors`), inactive sensors are ignored by both the contact filter and the motion filter, and the returned sample carries an `active_sensors` field so downstream code can mask out the inactive modalities. require_motion : bool, default False Toggle the motion filter (off for back-compat; recommended on for dynamics learning). min_motion_mps : float, default 0.03 Per-frame translation speed (in m/s) above which a frame counts as "moving" for a given sensor. min_motion_fraction : float in [0, 1], default 0.25 An active sensor passes the motion filter if ≥ this fraction of the window's frames have speed ≥ `min_motion_mps`. which_sensors_must_move : {"any", "all_active"}, default "all_active" Whether every active sensor must pass the motion filter (strict; rejects the "left held still while right moves" pattern), or just one. "all_active" is what you typically want for dynamics learning. tasks, dates : optional iterables of str Restrict to specific task names / date strings. fps : float, default 30 Frame rate used to convert pose deltas to m/s. """ def __init__( self, data_root: str | Path, bad_frames_path: str | Path | None = None, tasks_json_path: str | Path | None = None, *, window_length: int = 16, stride: int = 1, window_step: int | None = None, contact_metric: str = "mixed", tactile_threshold: float = 0.4, min_contact_fraction: float = 0.5, which_sensors: str = "both", # bimanual default; pass "any" to allow single-hand contact tasks: Iterable[str] | None = None, dates: Iterable[str] | None = None, skip_bad_frames: bool = True, respect_active_sensors: bool = True, require_motion: bool = False, min_motion_mps: float = 0.01, min_motion_fraction: float = 0.25, which_sensors_must_move: str = "all_active", fps: float = 30.0, ): if contact_metric not in CONTACT_METRICS: raise ValueError(f"contact_metric must be one of {CONTACT_METRICS}") if which_sensors not in ("any", "both", "left", "right"): raise ValueError("which_sensors must be 'any' | 'both' | 'left' | 'right'") if which_sensors_must_move not in ("any", "all_active"): raise ValueError("which_sensors_must_move must be 'any' | 'all_active'") if window_length < 1 or stride < 1: raise ValueError("window_length and stride must be ≥ 1") self.data_root = Path(data_root) self.window_length = int(window_length) self.stride = int(stride) self.window_step = int(window_step) if window_step is not None else max(1, window_length // 2) self.contact_metric = contact_metric self.tactile_threshold = float(tactile_threshold) self.min_contact_fraction = float(min_contact_fraction) self.which_sensors = which_sensors self.respect_active_sensors = bool(respect_active_sensors) self.skip_bad_frames = bool(skip_bad_frames) self.require_motion = bool(require_motion) self.min_motion_mps = float(min_motion_mps) self.min_motion_fraction = float(min_motion_fraction) self.which_sensors_must_move = which_sensors_must_move self.fps = float(fps) self.bad = {} if bad_frames_path is not None and Path(bad_frames_path).is_file(): self.bad = json.loads(Path(bad_frames_path).read_text()).get("episodes", {}) elif skip_bad_frames and bad_frames_path is not None: print(f"[ReactWindowDataset] WARNING: bad_frames_path={bad_frames_path} not found; not filtering.") self.per_date = {} if tasks_json_path is not None and Path(tasks_json_path).is_file(): tj = json.loads(Path(tasks_json_path).read_text()) for tk, td in tj.get("tasks", {}).items(): for d, info in td.get("per_date_notes", {}).items(): self.per_date[d] = info # ── Episode discovery ──────────────────────────────────────────── pt_files = sorted(self.data_root.rglob("episode_*.pt")) if not pt_files: raise RuntimeError(f"No episode_*.pt under {self.data_root}") tasks = set(tasks) if tasks is not None else None dates = set(dates) if dates is not None else None self.episodes: list[dict] = [] self.episode_paths: list[Path] = [] self.episode_keys: list[str] = [] self.episode_active: list[list[str]] = [] self.windows: list[tuple[int, int]] = [] span = (self.window_length - 1) * self.stride + 1 # Counters for reporting how many windows each filter rejects n_total_candidates = 0 n_drop_bad = 0 n_drop_contact = 0 n_drop_motion = 0 for pt in pt_files: rel = pt.relative_to(self.data_root) if len(rel.parts) == 3: task, date, _ = rel.parts; key = f"{date}/{pt.stem}" elif len(rel.parts) == 2: task, date = None, rel.parts[0]; key = f"{date}/{pt.stem}" else: task, date, key = None, None, pt.stem if tasks is not None and task not in tasks: continue if dates is not None and date not in dates: continue d = torch.load(pt, weights_only=False, map_location="cpu") active = ["left", "right"] if self.respect_active_sensors and date in self.per_date: active = list(self.per_date[date].get("active_sensors", active)) mL = d[f"tactile_left_{self.contact_metric}"].numpy() mR = d[f"tactile_right_{self.contact_metric}"].numpy() T = mL.shape[0] # Contact predicate (respecting active sensors) cL = mL > self.tactile_threshold cR = mR > self.tactile_threshold if "left" not in active: cL[:] = False if "right" not in active: cR[:] = False req = self.which_sensors if req == "any": contact_frame = cL | cR elif req == "both": contact_frame = cL & cR elif req == "left": contact_frame = cL else: contact_frame = cR # Bad-frame mask (intensity, pose_teleport, ot_loss) bad_mask = np.zeros(T, dtype=bool) if self.skip_bad_frames and key in self.bad: bf = self.bad[key] for s, e in (bf.get("intensity_spikes", []) + bf.get("pose_teleports_L", []) + bf.get("pose_teleports_R", []) + bf.get("ot_loss_L", []) + bf.get("ot_loss_R", [])): bad_mask[s:e + 1] = True # Per-frame motion predicate per sensor if self.require_motion: pose_L = d["sensor_left_pose"].numpy() pose_R = d["sensor_right_pose"].numpy() speed_L = _per_frame_speed_mps(pose_L, self.fps) speed_R = _per_frame_speed_mps(pose_R, self.fps) moving_L = speed_L >= self.min_motion_mps moving_R = speed_R >= self.min_motion_mps else: moving_L = moving_R = None ep_idx = len(self.episodes) self.episodes.append(d) self.episode_paths.append(pt) self.episode_keys.append(key) self.episode_active.append(active) kept = 0 for t_start in range(0, T - span + 1, self.window_step): n_total_candidates += 1 t_end = t_start + span - 1 frame_idx = np.arange(t_start, t_start + span, self.stride) if bad_mask[t_start:t_end + 1].any(): n_drop_bad += 1 continue if contact_frame[frame_idx].mean() < self.min_contact_fraction: n_drop_contact += 1 continue if self.require_motion: passed = [] for side, mov in [("left", moving_L), ("right", moving_R)]: if side not in active: continue passed.append(mov[frame_idx].mean() >= self.min_motion_fraction) if self.which_sensors_must_move == "all_active": ok = bool(passed) and all(passed) else: # "any" ok = any(passed) if not ok: n_drop_motion += 1 continue self.windows.append((ep_idx, t_start)) kept += 1 print(f"[ReactWindowDataset] {key}: T={T}, active={active}, kept {kept} windows") # Persist build stats on the instance so callers can inspect / log them self.stats = { "n_episodes": len(self.episodes), "n_candidates": n_total_candidates, "n_dropped_bad_frames": n_drop_bad, "n_dropped_contact": n_drop_contact, "n_dropped_motion": n_drop_motion, "n_contact_rich_windows": len(self.windows), "window_length": self.window_length, "stride": self.stride, "window_step": self.window_step, "min_contact_fraction": self.min_contact_fraction, "tactile_threshold": self.tactile_threshold, "contact_metric": self.contact_metric, "which_sensors": self.which_sensors, "skip_bad_frames": self.skip_bad_frames, "require_motion": self.require_motion, "min_motion_mps": self.min_motion_mps, "min_motion_fraction": self.min_motion_fraction, "which_sensors_must_move": self.which_sensors_must_move, } # Headline summary — emphasises the contact-rich count, which is the # number you'd quote in a paper or a model training log. pct = 100.0 * len(self.windows) / max(1, n_total_candidates) print() print(f"[ReactWindowDataset] =================================") print(f"[ReactWindowDataset] Contact-rich windows sampled: {len(self.windows):,}") print(f"[ReactWindowDataset] ({pct:.1f}% of {n_total_candidates:,} sliding-window candidates)") print(f"[ReactWindowDataset] =================================") print(f"[ReactWindowDataset] Window spec: length={self.window_length}, stride={self.stride}, " f"step={self.window_step} (≈{self.window_length / 30:.2f}s @ 30 fps)") print(f"[ReactWindowDataset] Rejected by filter:") print(f"[ReactWindowDataset] bad_frames (intensity_spikes, pose_teleports, ot_loss): {n_drop_bad:,}") print(f"[ReactWindowDataset] contact (< {self.min_contact_fraction:.0%} of frames in tactile contact): {n_drop_contact:,}") print(f"[ReactWindowDataset] motion ({'enabled' if self.require_motion else 'disabled'}): {n_drop_motion:,}") def __len__(self) -> int: return len(self.windows) def __getitem__(self, idx: int) -> dict: ep_idx, t_start = self.windows[idx] ep = self.episodes[ep_idx] frame_idx = torch.arange(t_start, t_start + self.window_length * self.stride, self.stride) sample = { "view": ep["view"][frame_idx], "tactile_left": ep["tactile_left"][frame_idx], "tactile_right": ep["tactile_right"][frame_idx], "sensor_left_pose": ep["sensor_left_pose"][frame_idx], "sensor_right_pose": ep["sensor_right_pose"][frame_idx], "timestamps": ep["timestamps"][frame_idx], "tactile_left_intensity": ep["tactile_left_intensity"][frame_idx], "tactile_right_intensity": ep["tactile_right_intensity"][frame_idx], "tactile_left_mixed": ep["tactile_left_mixed"][frame_idx], "tactile_right_mixed": ep["tactile_right_mixed"][frame_idx], } sample["episode"] = str(self.episode_paths[ep_idx]) sample["episode_key"] = self.episode_keys[ep_idx] sample["frame_start"] = int(t_start) sample["frame_end"] = int(frame_idx[-1].item()) sample["active_sensors"] = list(self.episode_active[ep_idx]) return sample if __name__ == "__main__": import argparse ap = argparse.ArgumentParser() ap.add_argument("--data_root", required=True) ap.add_argument("--bad_frames", default=None) ap.add_argument("--tasks_json", default=None) ap.add_argument("--window_length", type=int, default=16) ap.add_argument("--stride", type=int, default=1) ap.add_argument("--window_step", type=int, default=None) ap.add_argument("--tactile_threshold", type=float, default=0.4) ap.add_argument("--min_contact_fraction", type=float, default=0.5) ap.add_argument("--contact_metric", default="mixed", choices=CONTACT_METRICS) ap.add_argument("--which_sensors", default="any", choices=["any", "both", "left", "right"]) ap.add_argument("--require_motion", action="store_true") ap.add_argument("--min_motion_mps", type=float, default=0.01) ap.add_argument("--min_motion_fraction", type=float, default=0.25) ap.add_argument("--which_sensors_must_move", default="all_active", choices=["any", "all_active"]) args = ap.parse_args() ds = ReactWindowDataset( data_root=args.data_root, bad_frames_path=args.bad_frames, tasks_json_path=args.tasks_json, window_length=args.window_length, stride=args.stride, window_step=args.window_step, contact_metric=args.contact_metric, tactile_threshold=args.tactile_threshold, min_contact_fraction=args.min_contact_fraction, which_sensors=args.which_sensors, require_motion=args.require_motion, min_motion_mps=args.min_motion_mps, min_motion_fraction=args.min_motion_fraction, which_sensors_must_move=args.which_sensors_must_move, ) print(f"\nlen(ds) = {len(ds)}") if len(ds): sample = ds[0] for k, v in sample.items(): if isinstance(v, torch.Tensor): print(f" {k:30s} {tuple(v.shape)} {v.dtype}") else: print(f" {k:30s} {v!r}")