File size: 5,329 Bytes
cc62065 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 | # React — usage examples
Reference code for sampling clean training windows from this dataset. **Use
these examples (or copy their patterns) to avoid sampling on top of known
data-quality issues.**
## What's in here
| File | Purpose |
|---|---|
| [`react_window_dataset.py`](react_window_dataset.py) | A PyTorch `Dataset` that yields short multimodal windows with all four quality filters applied at enumeration time. Drop-in usable. |
| [`demo_react_window.py`](demo_react_window.py) | End-to-end usage example — builds the dataset, prints one sample's structure, renders a static grid of N random windows as a PNG. |
## What the dataloader filters out
The published `.pt` files have already had **OT-uninitialized recording
prefixes** trimmed (those bad spans were before the dataloader ever sees
the data — see [`docs/caveats.md`](../docs/caveats.md)). On top of that,
`ReactWindowDataset` applies four enumeration-time filters:
| # | Filter | What it catches |
|---|---|---|
| 1 | `skip_bad_frames` | Windows overlapping any interval in `bad_frames.json` (`intensity_spikes`, `pose_teleports_{L,R}`, `ot_loss_{L,R}`). These are *broken* data: LED glitches, mocap solver flips, mid-episode OptiTrack track loss. |
| 2 | `respect_active_sensors` | Ignores inactive sensors per `tasks.json:per_date_notes` when checking contact + motion predicates. |
| 3 | `min_contact_fraction` | Drops windows where fewer than `min_contact_fraction` of frames have tactile contact (chosen sensor + metric + threshold). Forces samples to be contact-rich. |
| 4 | **`require_motion`** | **Drops windows where the active sensors are essentially stationary** (operator paused mid-manipulation). The recorded data is healthy, but a near-zero-motion window contains no dynamics to learn. |
Filter (4) is the one most people forget. Without it, you'll get the
occasional "wait, the sensor isn't moving in this clip" sample even
though everything else is clean.
## Minimal recipe
```python
from examples.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,
# (1) (2) — broken data + inactive-sensor handling
skip_bad_frames = True,
respect_active_sensors = True,
# (3) — contact-richness
contact_metric = "mixed",
tactile_threshold = 0.4,
min_contact_fraction = 0.5,
which_sensors = "any",
# (4) — motion content (recommended for dynamics learning)
require_motion = True,
min_motion_mps = 0.03, # 30 mm/s
min_motion_fraction = 0.5,
which_sensors_must_move = "all_active",
)
loader = DataLoader(ds, batch_size=8, shuffle=True, num_workers=2)
```
## Recommended defaults by use case
- **Dynamics / world-model learning**: all four filters on. The recipe above.
- **UMI-style imitation / pose-as-action**: same recipe; filter (4) is
critical here because stationary windows give you constant-action labels.
- **Studying static tactile patterns** (e.g. classification of contact
shapes): turn filter (4) OFF (`require_motion=False`) — you specifically
want windows where the sensor is held still on an object.
## Loading a single `.pt` directly (without this dataloader)
If you're rolling your own sampler, replicate the filter logic by hand:
```python
import json, torch, numpy as np
ep_key = "2026-05-11/episode_017"
ep = torch.load(f"processed/mode1_v1/motherboard/{ep_key}.pt", weights_only=False)
T = ep["view"].shape[0]
bad = json.load(open("bad_frames.json"))["episodes"][ep_key]
# Frame-level mask (True = drop)
mask = np.zeros(T, dtype=bool)
for s, e in (bad["intensity_spikes"]
+ bad["pose_teleports_L"] + bad["pose_teleports_R"]
+ bad["ot_loss_L"] + bad["ot_loss_R"]):
mask[s:e + 1] = True
# Per-frame motion mask (use this in addition to bad_frames)
pose_L = ep["sensor_left_pose"].numpy()
pose_R = ep["sensor_right_pose"].numpy()
speed_L = np.linalg.norm(np.diff(pose_L[:, :3], axis=0), axis=1) * 30 # m/s
speed_R = np.linalg.norm(np.diff(pose_R[:, :3], axis=0), axis=1) * 30
moving_L = np.concatenate([[speed_L[0]], speed_L]) >= 0.03 # 30 mm/s
moving_R = np.concatenate([[speed_R[0]], speed_R]) >= 0.03
# Then when picking a window [t, t+L):
def good(t, L):
if mask[t:t + L].any():
return False
return moving_L[t:t + L].mean() >= 0.5 and moving_R[t:t + L].mean() >= 0.5
```
## Coordinates note
All frame indices in `bad_frames.json` and in the `.pt` files are in
**trimmed** coordinates — the OT-uninitialized prefixes were cut from
the published `.pt` files. The trim offset per file is recorded as
`_contact_meta.trim_offset` inside the `.pt`. You don't need to apply
it yourself: this loader and the metadata are already aligned.
If you also need to read the original H5 archive (held in
`MultimodalData/twm/data/<task>/<date>/`), remember to **add the trim
offset back** before indexing into the H5 — the H5 still has the
pre-trim timeline.
```python
trim_offset = ep["_contact_meta"]["trim_offset"]
h5_index = pt_index + trim_offset # only needed when reading raw H5
```
|