Datasets:

yxma
/

React

@@ -37,13 +37,10 @@ configs:
 Dense, contact-rich, synchronized multimodal interaction data collected from **human hands holding handheld GelSight tactile sensors** (no robot arm). Intended for **tactile-visual dynamics / world-model learning**.
 > **133 min · 240 k frames @ 30 Hz · 3× RGB + 2× GelSight + OptiTrack · 2 tasks**
->
-> Rows are written at 30 Hz, but the **tactile stream updates more slowly** — see
-> [Tactile sampling rate](#tactile-sampling-rate-read-this-before-training-on-touch).
 ## Format — LeRobot-style video release
-Each episode ships as **5 MP4 video streams** (640×480, H.264) + a **per-frame parquet** of poses and contact metrics. This matches how LeRobot / DROID / Open X-Embodiment ship manipulation data: tiny on disk (whole dataset ≈ 4.8 GB without depth vs ~1 TB raw), random-access decodable, training-ready.
 ```
 data/<task>/
@@ -71,133 +68,10 @@ data/<task>/
 | `sensor_left_pose`, `sensor_right_pose` | list[7] | OptiTrack world pose of each GelSight (xyz + quat wxyz) |
 | `object_pose` | list[7] | OptiTrack world pose of the manipulated object (NaN where the object body was not tracked — e.g. all pushT) |
 | `tactile_{L,R}_{intensity,area,mixed}` | float32 | contact metrics (computed at full 640×480) |
-| `tactile_{left,right}_is_new` | bool | **True when that row is a fresh tactile reading** (not a repeat of the previous row) |
 | `source_h5_frame` | int | index into the original recording |
 **Decoded frames are RGB** (standard decoder convention) for all five RGB streams.
-### estimated contact force (`motherboard` + `pushT`, 36 episodes)
-There is **no force/torque sensor on this rig** — the demonstrator's hand holds
-the sensor, so demonstrated pose equals achieved pose and the usual
-"position error × stiffness" force channel does not exist. These columns are
-**estimated from the GelSight images alone** by photometric reconstruction
-(difference image → per-sensor RGB lookup table → Poisson integration → depth),
-then mapped to newtons by a calibration fitted on sphere presses of known load.
-| Column | Type | Meaning |
-|---|---|---|
-| `force_{left,right}_normal_n` | float32 | estimated normal force [N], ≥ 0, exactly `0.0` on no-contact rows |
-| `force_{left,right}_penetration_mm` | float32 | `F / k` — how far a stiffness-`k` environment would be pushed in |
-| `force_{left,right}_target_pose` | list[7] | that sensor's pose displaced `F/k` along the contact normal (quaternion carried through unchanged) |
-```python
-import numpy as np, pyarrow.parquet as pq
-t = pq.read_table("data/motherboard/meta/2026-05-10/episode_000.parquet")
-f   = t["force_left_normal_n"].to_numpy()                  # (T,)   newtons
-obs = np.array(t["sensor_left_pose"].to_pylist())          # (T, 7) xyz + quat
-tgt = np.array(t["force_left_target_pose"].to_pylist())    # (T, 7) the action
-```
-#### What "force-informed action" means, and how to train on it
-A policy trained to output `sensor_*_pose` learns **where to go**. It cannot
-learn **how hard to press**, because in this data the two are the same signal:
-a human hand reached a pose, and whatever force resulted was never recorded as
-a separate command. Regressing that pose and replaying it on a compliant robot
-reproduces the trajectory and not the interaction — the same motion against a
-stiffer or differently-placed object produces a different force, and nothing
-in the demonstration says which force was intended.
-`force_*_target_pose` is that missing command, written in the units a robot
-already accepts:
-```
-target = observed + (F / k) · n̂        n̂ = press direction of that sensor,
-                                            R(q_row) @ gel_axis_in_rigid
-```
-It is the pose a **stiffness-`k` impedance controller** would have to be
-commanded in order to generate the estimated force `F` against a surface at the
-observed pose. Train the policy to output `target_pose`, deploy it as the
-setpoint of an impedance/admittance controller with the same `k`, and the
-controller produces both the reach and the press. This is the standard trick
-behind position-based force control; the only new part is that `F` came from
-the tactile images rather than from a load cell.
-```python
-action      = tgt                      # what the policy predicts
-observation = obs                      # where the sensor actually was
-# free space: byte-identical, so this is a strict addition to the old target
-assert np.array_equal(action[f == 0], observation[f == 0])
-```
-That identity is not a claim — it is checked element-wise over all **294,653**
-free-space rows of the release, maximum deviation `0.0`, quaternions included.
-Nothing changes where nothing is touched, so a model trained on `target_pose`
-degenerates to the pose-only model in free space and differs only in contact.
-#### Choosing `k` — it is your controller's number, not ours
-`k = 2.0 N/mm` is a **declared assumption**, recorded in the parquet field
-metadata (`twm.stiffness_n_per_mm`) and in each `<episode>.force.json`, so a
-target pose is never uninterpretable. It is not a measured property of your
-environment — but it is chosen so the shipped column is at least *physically
-possible*:
-| | penetration at the shipped `k = 2.0` | inside the 4.25 mm gel? |
-|---|---|---|
-| p95 over all rows | 3.65 mm | yes |
-| p95 over **contact** rows | 3.93 mm | yes |
-| maximum | 7.870 N → 3.935 mm | yes |
-**0.00%** of rows exceed the gel thickness. This matters because a target
-displaced further past the surface than the gel can be compressed asks for a
-pose that cannot be reached by pressing. Earlier releases shipped `k = 1 N/mm`,
-where 14.98% of rows were in that state.
-The binding constraint is `k ≥ 1.86 N/mm` — the hardest press (7.870 N) inside
-a 4.25 mm gel. Anything softer puts some rows outside it.
-If your controller is stiffer, recompute rather than rescale, since the
-direction matters:
-```python
-K = 4.0                                              # your controller's stiffness
-n_hat  = (tgt[:, :3] - obs[:, :3])                   # F/k · n̂ at the shipped k
-n_hat /= np.linalg.norm(n_hat, axis=1, keepdims=True) + 1e-12
-my_target = obs.copy()
-my_target[:, :3] = obs[:, :3] + (f / K)[:, None] * n_hat
-```
-#### Read this before using the numbers
-- **Accuracy is rank-order within a group, not a certified absolute scale.**
-  Held out by press position the estimator scores ρ = 0.781 / MAE 1.07 N on its
-  own calibration objects — but that holdout is only 158 presses and a paired
-  bootstrap cannot separate it from the previous reconstruction (95% CI on the
-  difference [-0.081, +0.120]). The evidence that it is the better estimator is
-  external: on five public force-labelled datasets the same pipeline reaches
-  ρ 0.648–0.996 over 604–2,000 scored presses each. It is reliable for *how hard, relative to
-  other frames*; it is not a load cell. Do not report absolute newtons from
-  this dataset as ground truth.
-- **Forces saturate at 7.870 N.** The calibration's isotonic stage clips at the
-  hardest press it was fitted on, so 2.22% of samples sit exactly at that value.
-  Treat the maximum as a floor, not a measurement, and consider masking rows at
-  the ceiling out of a regression loss.
-- **Duplicate tactile rows repeat the previous estimate.** The GelSight stream
-  is slower than 30 Hz; rows with `tactile_{side}_is_new == False` carry the
-  previous frame's force unchanged (forward fill, asserted exact). Filter on
-  `is_new` if you need independent samples — and note that a force *derivative*
-  computed without that filter is zero on ~72% of rows by construction.
-- **Row alignment is verified, not assumed.** Every one of the **72/72**
-  sensor-sides was checked row-for-row against the release parquet it was
-  exported from.
-- **The direction `n̂` comes from calibration, not from the image.** It is the
-  sensor's gel axis rotated by the row's own quaternion. Two sensor-sides of 72
-  lack a usable gel-to-rigid transform and carry force with no displacement;
-  they are identified in `data/force_export_manifest.json`.
 ### depth (optional, `data/<task>/depth/`)
 Per-camera depth is shipped as **lossless FFV1 16-bit video** (`gray16le`):
 ```
@@ -226,16 +100,16 @@ Camera extrinsics are used only for the projection overlay; **stored poses are O
 ## Downloading — depth is optional
-The dataset splits into a **lightweight core** (RGB + tactile + poses, ~4.8 GB) and an **optional depth tree** (`data/<task>/depth/`, ~33 GB lossless). Depth lives in its own subtree so you can skip it entirely.
 ```python
 from huggingface_hub import snapshot_download
-# Core only — RGB + tactile + parquet, NO depth (~4.8 GB)
 snapshot_download("yxma/React", repo_type="dataset",
                   ignore_patterns=["*/depth/*"])
-# Everything including depth (~39 GB)
 snapshot_download("yxma/React", repo_type="dataset")
 # One task only
@@ -260,9 +134,9 @@ sample = ds[0]
 ```
 `mode="segment"` iterates clean spans (no bad frames by construction); `mode="window"` slides over whole episodes and skips `bad_frames.json` intervals. Backend: PyAV (install `decord` for faster random access).
-## ✅ Tactile latency corrected (was ~15 frames)
-Recordings **up to and including 2026-06-18** HAD a GelSight-vs-camera capture
 lag of **≈15 frames (~0.5 s)**: the tactile stream at index `i` was physically
 captured ~15 frames *before* the camera/pose at the same index. Cause: a
 recording-side `cv2.VideoCapture` V4L2 buffer that was never flushed
@@ -270,7 +144,7 @@ recording-side `cv2.VideoCapture` V4L2 buffer that was never flushed
 on 2026-06-27; **future recordings will not have this lag**.
 The streams are stored frame-aligned by tick index, so this lag is baked in but
-**now corrected in the published data** (tactile shifted +15f, rebuilt from raw H5). No loader flag needed. The loader still accepts `tactile_latency=` for raw data:
 ```python
 ds = ReactVideoDataset("data/motherboard", tactile_latency=15)  # pairs view[i] with tactile[i+15]
@@ -281,181 +155,13 @@ columns; poses/views/depth are unchanged. Set `tactile_latency=0` for the raw
 (uncompensated) data. The exact per-session value should be re-measured with
 `camera_stream/measure_gelsight_latency.py`.
-## Tactile sampling rate (read this before training on touch)
-Parquet rows and all five videos are written at 30 Hz, but the GelSight stream
-does **not** carry 30 Hz of information. Measured across the whole release:
-| | value |
-|---|---|
-| tactile rows | 480 080 (2 sensors × 240 k frames) |
-| genuinely distinct tactile frames | **135 297** |
-| duplicated rows | **71.8 %** |
-| effective tactile rate | **~8.5 fps** |
-| longest frozen stretch | 30 frames (1.0 s) |
-Two causes, one fixed:
-1. **Sensor ceiling** — the GelSight Mini streams 3280×2464 MJPG at 18.75 fps.
-   Some duplication against a 30 Hz row clock is unavoidable (~40 %).
-2. **Recording-side decode backlog** *(all currently published data)* — the rig
-   decoded each full 8 MP frame on the capture thread (~71 ms), so tactile
-   effectively ran at ~8 fps and every frame was reused ~3.6×. Fixed on the rig
-   on 2026-06-27 (reduced-scale decode + per-sensor capture timestamps);
-   recordings from that date on reach the 18.75 fps ceiling.
-**Use the flags.** Every row carries `tactile_left_is_new` /
-`tactile_right_is_new`:
-```python
-df = pq.read_table("episode_000.parquet").to_pandas()
-fresh = df[df.tactile_left_is_new]     # 8.5 fps of real readings
-```
-Training tactile dynamics on all rows teaches the model that touch mostly does
-not change; it does, we just sampled it slowly. Visual and pose streams are
-unaffected — those are genuinely 30 Hz.
-The flags were recovered from the shipped contact metrics (a repeated frame
-gives a bit-identical metric triple) and checked frame-by-frame against the
-source recordings: **0 mismatches over 899 frames on each of 7 audited
-episodes**, spanning both tasks. The same check independently recovers the
-+15-frame latency correction baked into the release.
-## How to use this dataset
-Three recipes, in the order most people need them. Every one is executed
-against the published files by `scripts/test_readme_recipes.py`, so the code
-below is code that runs, not code that reads well.
-### 1. Sample training clips — start from `segments.json`, not from episodes
-An episode is a raw recording and contains flagged frames. A **segment** is a
-contiguous span that is already clean. Sampling clips from episodes means
-re-deriving the quality filter yourself and getting it slightly different.
-```python
-import json, numpy as np, pyarrow.parquet as pq
-segs = json.load(open("data/pushT/segments.json"))["segments"]
-s = segs[0]                                     # {'source_episode', 'frame_range', ...}
-date, ep = s["source_episode"].split("/")
-a, b = s["frame_range"]                         # inclusive, in VIDEO frame coords
-t = pq.read_table(f"data/pushT/meta/{date}/{ep}.parquet").slice(a, b - a + 1)
-```
-`frame_range` indexes the published MP4s and the parquet with the same origin,
-so frame `i` of `view_middle.mp4` is row `i` of the parquet. No offset, no
-lookup table.
-### 2. Train on touch — respect the tactile rate
-Rows are written at 30 Hz; the GelSight stream is slower. A row with
-`tactile_{side}_is_new == False` repeats the previous tactile frame, its
-contact scalars, and its force estimate, unchanged.
-```python
-new = t["tactile_left_is_new"].to_numpy()
-# independent tactile samples only
-idx = np.flatnonzero(new)
-# a finite difference over ALL rows is 0 wherever is_new is False, by construction
-```
-Roughly 72% of rows are repeats. Ignoring this does not corrupt a model that
-consumes frames independently, but it silently zeroes any temporal derivative
-of a tactile channel and inflates any "how often does touch change" statistic.
-### 3. Train an action that includes *how hard*
-This is the part that distinguishes React from a pose-only demonstration set,
-so it gets its own section: **[estimated contact
-force](#estimated-contact-force-motherboard--pusht-36-episodes)**. In short:
-```python
-observation = np.array(t["sensor_left_pose"].to_pylist())        # where it was
-action      = np.array(t["force_left_target_pose"].to_pylist())  # where to push to
-```
-`action` equals `observation` exactly in free space and leads it by `F/k` along
-the press direction during contact. Train on `action`, deploy through an
-impedance controller of stiffness `k`, and the policy commands both the reach
-and the press. Read that section before choosing `k` — the shipped `k = 1 N/mm`
-is a declared assumption and a soft one.
-### What this dataset is not
-- **No robot.** A human hand holds each sensor. There are no joint angles, no
-  gripper state, and no action in the robot-command sense other than the
-  force-informed target pose described above.
-- **No force sensor.** Every newton in these files is estimated from tactile
-  images. It is calibrated and validated, and it is still an estimate — see the
-  limits in the force section before reporting absolute values.
-- **Not a benchmark.** There is no train/val/test split and no success label.
-  It is interaction data for dynamics and representation learning.
 ## Data quality
-Per-task `bad_frames.json` marks intervals that should not be trained on, and
-`segments.json` is their complement — contiguous clean spans, already excluding
-every flag below. **Use `segments.json` and you never have to think about
-this table.**
-| flag | motherboard | pushT |
-|---|---|---|
-| `cam_corruption` | 0 | 0 |
-| `intensity_spikes` | 56 | 10 |
-| `ot_loss_L` | 1,443 | 106 |
-| `ot_loss_R` | 236 | 191 |
-| `pose_teleports_L` | 24 | 0 |
-| `pose_teleports_R` | 16 | 0 |
-| `tactile_corruption` | 102 | 10 |
-| **flagged (union)** | **1,797 / 194,445 (0.92%)** | **307 / 45,595 (0.67%)** |
-| **clean segments** | 81 spans, 192,626 frames (107.0 min) | 17 spans, 45,288 frames (25.2 min) |
-| **dropped, clean but < 16 frames** | 22 | 0 |
-The three rows above reconcile exactly: flagged + clean + dropped = total, for
-both tasks. Per-flag counts do **not** sum to the flagged total, because one
-frame can trip two detectors; the union is what `summary` reports and what the
-segments complement.
-`ot_loss_*` is OptiTrack track loss (a run of bit-identical poses, i.e. frozen
-action), `pose_teleports_*` an implausible jump in translation *and* rotation
-in one frame, `intensity_spikes` a GelSight reading above anything contact
-produces. `tactile_corruption` and `cam_corruption` are **video** defects —
-torn frames the sidecar scalars cannot see. They are found by looking for
-off-illumination magenta laid out in scanlines: a GelSight is lit by three
-coloured LEDs, magenta is outside that gamut, and a corrupt row is written
-edge to edge while an object pressed into the gel is not. Every flagged
-interval in this release was also inspected by eye.
-**Runt episodes.** Two motherboard recordings are far too short to be complete
-demonstrations and are best filtered out: `2026-05-19/episode_003` (4.0 s) and
-`2026-05-19/episode_004` (7.0 s). Median episode length is 213 s; these two are
-together 0.8 % of the release. They are shipped rather than deleted so episode
-numbering stays stable.
-**A missing pushT episode.** `pushT/2026-06-18/episode_004` was recorded but is
-not published. Its recorder died without closing the file, which loses HDF5's
-metadata cache: 79 GB of intact pixels behind a root object header that was
-never written. All eight image streams were recovered (15,447 frames,
-byte-verified), but only 2 of 16 timestamp chunks survived and no usable
-OptiTrack poses. Without timestamps there is no cross-modal alignment, and
-reconstructing them by interpolation misplaces frames by 15–1431 — so it is
-video, not an episode, and is deliberately absent rather than published
-half-aligned. Episode numbering is unaffected: pushT publishes 000–003.
 ## Notes
-- **Depth is published**, under `data/<task>/depth/<date>/<episode>/depth_*.mkv`
-  (16-bit millimetres, FFV1-in-Matroska, lossless). It is 34.3 GB
-  of the 39.0 GB repo, so the download recipes above let you skip
-  it — everything else is 4.8 GB.
-- The previous single-task `.pt` release (`episodes/`, `segments/`) is
-  superseded by this video format.
-- Preview clips under `data/<task>/previews/` are 30 s renders at 2x with the
-  three camera views, the OptiTrack skeleton, both GelSight streams and the
-  projected sensor position. They are for looking, not for training, and frames
-  excluded by `bad_frames.json` are outlined and named in red.
 ## License
 [CC-BY-4.0](https://creativecommons.org/licenses/by/4.0/).

 Dense, contact-rich, synchronized multimodal interaction data collected from **human hands holding handheld GelSight tactile sensors** (no robot arm). Intended for **tactile-visual dynamics / world-model learning**.
 > **133 min · 240 k frames @ 30 Hz · 3× RGB + 2× GelSight + OptiTrack · 2 tasks**
 ## Format — LeRobot-style video release
+Each episode ships as **5 MP4 video streams** (640×480, H.264) + a **per-frame parquet** of poses and contact metrics. This matches how LeRobot / DROID / Open X-Embodiment ship manipulation data: tiny on disk (whole dataset ≈ 4.3 GB vs ~1 TB raw), random-access decodable, training-ready.
 ```
 data/<task>/
 | `sensor_left_pose`, `sensor_right_pose` | list[7] | OptiTrack world pose of each GelSight (xyz + quat wxyz) |
 | `object_pose` | list[7] | OptiTrack world pose of the manipulated object (NaN where the object body was not tracked — e.g. all pushT) |
 | `tactile_{L,R}_{intensity,area,mixed}` | float32 | contact metrics (computed at full 640×480) |
 | `source_h5_frame` | int | index into the original recording |
 **Decoded frames are RGB** (standard decoder convention) for all five RGB streams.
 ### depth (optional, `data/<task>/depth/`)
 Per-camera depth is shipped as **lossless FFV1 16-bit video** (`gray16le`):
 ```
 ## Downloading — depth is optional
+The dataset splits into a **lightweight core** (RGB + tactile + poses, ~4.4 GB) and an **optional depth tree** (`data/<task>/depth/`, ~33 GB lossless). Depth lives in its own subtree so you can skip it entirely.
 ```python
 from huggingface_hub import snapshot_download
+# Core only — RGB + tactile + parquet, NO depth (~4.4 GB)
 snapshot_download("yxma/React", repo_type="dataset",
                   ignore_patterns=["*/depth/*"])
+# Everything including depth (~37 GB)
 snapshot_download("yxma/React", repo_type="dataset")
 # One task only
 ```
 `mode="segment"` iterates clean spans (no bad frames by construction); `mode="window"` slides over whole episodes and skips `bad_frames.json` intervals. Backend: PyAV (install `decord` for faster random access).
+## ⚠️ Known issue: tactile acquisition latency (~15 frames)
+Recordings **up to and including 2026-06-18** have a GelSight-vs-camera capture
 lag of **≈15 frames (~0.5 s)**: the tactile stream at index `i` was physically
 captured ~15 frames *before* the camera/pose at the same index. Cause: a
 recording-side `cv2.VideoCapture` V4L2 buffer that was never flushed
 on 2026-06-27; **future recordings will not have this lag**.
 The streams are stored frame-aligned by tick index, so this lag is baked in but
+**correctable**. The reference loader compensates at load time:
 ```python
 ds = ReactVideoDataset("data/motherboard", tactile_latency=15)  # pairs view[i] with tactile[i+15]
 (uncompensated) data. The exact per-session value should be re-measured with
 `camera_stream/measure_gelsight_latency.py`.
 ## Data quality
+Per-task `bad_frames.json` flags `intensity_spikes`, `pose_teleports_{L,R}`, `ot_loss_{L,R}` (OptiTrack track loss). Overall flagged: motherboard 0.90 %, pushT 0.67 %. `segments.json` already excludes them.
 ## Notes
+- **Depth** is available in the source recordings and will be added under `data/<task>/depth/` in a later upload.
+- One pushT source recording (`episode_004`) was corrupt and excluded.
+- The previous single-task `.pt` release (`episodes/`, `segments/`) is superseded by this video format.
 ## License
 [CC-BY-4.0](https://creativecommons.org/licenses/by/4.0/).