Hugging Face's logo

Datasets:
yxma
/
React

Tasks:
Robotics
Modalities:
Image
Tabular
Text
Formats:
parquet
Size:
100K - 1M
Tags:
robotics
tactile
manipulation
multimodal
gelsight
realsense
Libraries:
Datasets
Dask
Polars
License:
Dataset card Data Studio Files
xet
 Community
1
React / README.md
yxma's picture
yxma
dataset card: add rope and validation to configs
561e38c verified
preview code
|
Raw
History Blame Contribute Delete
12 kB
metadata 
license: cc-by-4.0
task_categories:
  - robotics
tags:
  - robotics
  - tactile
  - manipulation
  - multimodal
  - gelsight
  - realsense
  - motion-capture
  - world-model
  - human-collected
  - lerobot
pretty_name: React (Tactile-Visual Manipulation)
size_categories:
  - 100K<n<1M
configs:
  - config_name: motherboard
    data_files:
      - split: train
        path: data/motherboard/meta/**/*.parquet
  - config_name: pushT
    data_files:
      - split: train
        path: data/pushT/meta/**/*.parquet
  - config_name: rope
    data_files:
      - split: train
        path: data/rope/meta/**/*.parquet
  - config_name: validation
    data_files:
      - split: train
        path: data/validation/meta/**/*.parquet
  - config_name: all
    default: true
    data_files:
      - split: train
        path: data/**/meta/**/*.parquet

React — Multi-Task Tactile-Visual Manipulation

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.

173 min · 312 k frames @ 30 Hz · 3× RGB + 2× GelSight + 2× wrist + OptiTrack · 3 tasks

dataset statistics

Per-task scale, contact-force distribution, bimanual contact occupancy, and tactile validity for the wrist-camera era. Panel B shows the ECDF of unsaturated contact force; the steps are real — the force calibration ends in an isotonic (piecewise-constant) stage, so its output is quantised. See Known limits.

What is published

Episodes are cut into clean segments before release: every span a defect detector flagged is removed, and each remaining span of at least 30 s is published as its own episode. So the flagged frames are the gaps between published episodes, and you do not need to consult bad_frames.json before training on data/<task>/.

Task Source recordings Published segments Duration Median contact force
motherboard 12 25 93.9 min 2.94 N
pushT 10 31 32.5 min 4.29 N
rope 10 27 47.1 min 1.38 N
(total) 32 83 173.5 min

data/validation/ holds a separate 5-segment / 7.1 min set from an earlier session (2026-09-09) that carries different wrist cameras and a different calibration epoch. It is not a random held-out split — training on data/<task> and evaluating there measures domain shift. See its own README.

earlier session

Known limits

Read these before using the force channel or the tactile stream.

Force saturates at 7.87 N. The calibration was fitted on presses up to 8 N, and its final stage is an isotonic regression, which cannot extrapolate — anything above the fitted range is clipped to 7.87 N. Affected fraction of contact frames:

  • motherboard — 8.3 %
  • pushT — 8.4 %
  • rope — 0.6 %

Treat those frames as right-censored, not as measurements. The force labels also carry roughly 1 N of held-out error, so do not compare models at 0.1 N resolution.

Tactile frames repeat. The GelSight Mini tops out near 17.8 Hz while rows are written at 29.8 Hz, so only about 56–58 % of rows are a fresh sensor reading. tactile_{left,right}_is_new marks which. Train tactile dynamics on the flagged rows, not on all of them.

duration_s is n_frames / 30, the nominal write tick. The RealSense streams actually run at 29.80 Hz.

Format — LeRobot-style video release

Each episode ships as 7 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 (data/ ≈ 21 GB vs ~1.9 TB raw), random-access decodable, training-ready.

data/<task>/
├── calibration/                     # OptiTrack→camera extrinsics for this task
│   ├── T_mocap_to_cam_{left,middle,right}.json
│   ├── T_gel_to_rigid_{left,right}.json
│   └── calibration.json             # epoch, applies-to dates, RMSE, chain
├── videos/<date>/episode_NNN/
│   ├── view_left.mp4  view_middle.mp4  view_right.mp4    # 640×480 RGB
│   ├── tactile_left.mp4  tactile_right.mp4               # 640×480 GelSight
│   └── wrist_left.mp4  wrist_right.mp4                   # 640×480 wrist cams
├── meta/<date>/episode_NNN.parquet  # one row per frame (see below)
├── episodes.jsonl                   # one row per episode
├── segments.json                    # clean-segment index (no bad frames)
├── bad_frames.json                  # quality intervals per episode
└── previews/<date>/episode_NNN.mp4  # 1280×480 viewer-layout preview

parquet columns (per frame, aligned to video frame i)

Column Type Meaning
frame_idx / frame_index int 0…T-1, matches MP4 frame index
episode / episode_index str / int source episode key and its 0-based index within the task
task / task_index str / int task name and index (0=motherboard, 1=pushT, 2=rope)
force_{L,R}_normal_n float32 estimated normal contact force (N) — censored at 7.87 N, see Known limits
force_{L,R}_penetration_mm float32 gel penetration depth (mm)
force_{L,R}_source_frame int the raw tactile frame this force was computed from
tactile_{L,R}_is_new bool True when the row is a fresh sensor reading, not a repeat
timestamp float64 camera clock (s)
sensor_left_pose, sensor_right_pose list[7] OptiTrack world pose of each GelSight (xyz metres + quat xyzw, scalar-LAST — scipy...Rotation.from_quat takes it as-is)
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):

data/<task>/depth/<date>/episode_NNN/depth_{left,middle,right}.mkv
  • uint16, millimeters; 0 = no return / invalid.
  • Frame i aligns to the RGB video frame i and parquet row i.
  • Decode with PyAV (frame.to_ndarray() → (480, 640) uint16). cv2 cannot read 16-bit video.
  • Load via ReactVideoDataset(..., load_depth=True).

Tasks and calibration

Task Dates Source recordings Published segments Duration Calibration epoch
motherboard 2026-09-11, 2026-09-12 12 25 93.9 min 2026-09-09
pushT 2026-09-10, 2026-09-11 10 31 32.5 min 2026-09-09
rope 2026-09-11 10 27 47.1 min 2026-09-09
validation 2026-09-09 5 9 25.2 min 2026-09-09

All currently published sessions share the 2026-09-09 extrinsics. Camera extrinsics are used only for the projection overlay; stored poses are OptiTrack world-frame and independent of calibration. Poses are Z-up.

data/validation/ mixes two tasks and two sessions of the same date, and its episode numbers are not the recorder's — the recorder reuses numbers within a date, so every row there carries source_recording. Read its README before using it.

See tasks.json for the machine-readable registry.

Downloading — depth is optional

The dataset splits into a lightweight core (RGB + tactile + wrist + poses, ~21 GB) and an optional depth tree (data/validation/depth/, ~6 GB lossless; only the 2026-09-09 session has depth). Depth lives in its own subtree so you can skip it entirely.

from huggingface_hub import snapshot_download

# Core only — RGB + tactile + wrist + parquet, NO depth (~21 GB)
snapshot_download("yxma/React", repo_type="dataset",
                  ignore_patterns=["*/depth/*"])

# Everything including depth (~27 GB)
snapshot_download("yxma/React", repo_type="dataset")

# One task only
snapshot_download("yxma/React", repo_type="dataset",
                  allow_patterns=["data/motherboard/*"], ignore_patterns=["*/depth/*"])

Or use the helper: python examples/download.py --no-depth (see examples/download.py).

The ReactVideoDataset loader never touches depth unless you pass load_depth=True, so depth-free training requires no depth download.

Loading 

from examples.react_video_dataset import ReactVideoDataset

ds = ReactVideoDataset("data/motherboard", window_length=16, mode="segment")
sample = ds[0]
# sample["view_middle"]:       (16, 480, 640, 3) uint8 RGB
# sample["tactile_left"]:      (16, 480, 640, 3) uint8 RGB
# sample["sensor_left_pose"]:  (16, 7) float32

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).

World frame — Z-up as published, Y-up on request

Every pose in this release is Z-up: sensor_{left,right}_pose, object_pose, force_{left,right}_target_pose, and the T_mocap_to_cam extrinsics in each calibration/. Each subset says so itself, in episodes.jsonl ("up_axis": "z") and in every calibration file, so nothing has to infer it from a directory name.

OptiTrack records Y-up. The release is rotated once, by R_x(-90): (x, y, z) -> (x, -z, y). If you want the raw convention, ask the loader:

ds = ReactVideoDataset("data/motherboard", up_axis="y")   # default is "z"
cal = ds.calibration()          # comes back in the SAME convention

Take the calibration from the dataset, not from disk. This is a rotation of the world frame, so poses and T_mocap_to_cam have to move together — one without the other leaves every projection up to 165 px from the sensor and raises nothing. react_toolbox.frames is the same conversion if you need it directly: convert_poses(poses7, to_zup=), as_up_axis(cal, want).

The invariant worth knowing: rotating both changes no picture. Measured on data/validation over 450 (frame, camera, sensor) combinations, the projected GelSight centre moves 0.000000 px between the two conventions. Newtons, timestamps and every video frame are identical either way.

Tactile acquisition latency — does NOT affect any published episode

Recordings up to and including 2026-06-18 had a GelSight-vs-camera capture lag of ≈15 frames (~0.5 s), caused by a recording-side cv2.VideoCapture V4L2 buffer that was never flushed. It was fixed in the rig on 2026-06-27.

Every episode currently published was recorded on 2026-09-09 or later, and each one carries per-sensor GelSight timestamps, so the tactile stream is resampled onto the camera clock during the build. Verified across all 80 published force records: tactile_timestamped is True for every one, and tactile_align.gel_lag_frames returns 0.

Do not apply a 15-frame shift. Doing so would introduce the half-second misalignment this note used to warn about. The correction is relevant only if you obtain one of the withdrawn 2026-05/06 releases.

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.