File size: 7,052 Bytes
cc62065 fc9b06b 3bb8031 cc62065 fc9b06b cc62065 3bb8031 cc62065 2b2cfc6 5711283 2b2cfc6 5711283 2b2cfc6 5711283 2b2cfc6 5711283 2b2cfc6 | 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 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 | # 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.01, # 10 mm/s
min_motion_fraction = 0.25,
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.01 # 10 mm/s
moving_R = np.concatenate([[speed_R[0]], speed_R]) >= 0.01
# 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.25 and moving_R[t:t + L].mean() >= 0.25
```
## 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
```
## Visualizing a single .pt or a whole task
Use `examples/play_react_pt.py` to scrub through React data interactively
(same key bindings as `python -m twm.visualize` for H5 archives).
```bash
# Single .pt (mode1_v1 episode or one mode2_v1 segment)
python examples/play_react_pt.py \
processed/mode2_v1/motherboard/2026-05-11/episode_012.segment_00.pt
# Whole task: all 27 episodes are discovered; same-source segments are
# concatenated into one playback timeline. N / P jumps between episodes.
python examples/play_react_pt.py processed/mode2_v1/motherboard
# Headless: write one MP4 per episode into a directory
python examples/play_react_pt.py processed/mode2_v1/motherboard \
--save_video_dir /tmp/react_mp4s
```
Controls:
| Key | Action |
|---|---|
| `space` | pause / resume |
| `left / a`, `right / d` | prev / next frame |
| `1..6` | speed 1x / 2x / 5x / 10x / 25x / 50x |
| `r` | reset GelSight diff reference to current frame |
| **`n` / `p`** | **next / previous episode** |
| `q` | quit |
Panel layout (1280 x 480):
- **Row 1**: cam0 view, tactile_L raw, tactile_L diff, tactile_R raw, tactile_R diff
- **Row 2**: OT pose text (live x/y/z + quaternion), contact-intensity trail plot, controls cheatsheet
- **Status bar at top**: episode index, frame index in the concatenated timeline, segment number, source-H5 frame range
- **Red border for 1 frame** when crossing a segment boundary (visible cue that a bad interval was cut here). Vertical red marks in the trail plot show recent boundaries.
The GelSight diff is computed against `_contact_meta.ref_p01_*` (the quietest frame of the episode), so it reads as the absolute contact on the gel rather than change since the start of the clip.
|