README: document the estimated contact-force columns (force_*_normal_n / penetration_mm / target_pose), the 1 N/mm stiffness assumption, and the limits — the data shipped without a word about it

README.md

@@ -43,7 +43,7 @@ Dense, contact-rich, synchronized multimodal interaction data collected from **h
 
 ## 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.
+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>/
@@ -92,54 +92,107 @@ then mapped to newtons by a calibration fitted on sphere presses of known load.
 | `force_{left,right}_target_pose` | list[7] | that sensor's pose displaced `F/k` along the contact normal (quaternion carried through unchanged) |
 
 ```python
-import pyarrow.parquet as pq
+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()          # N, per frame
-tgt = np.array(t["force_left_target_pose"].to_pylist())   # (T, 7)
+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
 ```
 
-**`target_pose` is the force-informed action.** Training on the observed pose
-teaches "go here"; training on the target teaches "go here *and push this
-hard*", which an impedance controller reproduces at deployment. In free space
-the two are byte-identical (`F = 0 → target == observed`, verified
-element-wise on 301,727 rows), so nothing changes where nothing is touched.
+#### 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 **301,727**
+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 = 1.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 deliberately soft, and at that
+value the implied penetrations are larger than the gel is thick:
+
+| | penetration at `k = 1` | inside the 4.25 mm gel? |
+|---|---|---|
+| p95 over all rows | 5.78 mm | no |
+| p95 over **contact** rows | 6.86 mm | no |
+| maximum | 7.285 N → 7.285 mm | no |
+
+**8.84%** of all rows exceed the gel thickness at `k = 1`. To keep penetration
+physically plausible you need a stiffer environment model:
+
+* `k ≥ 1.37 N/mm` — p95 over all rows inside the gel. *This is the weakest of
+  the three and the least useful:* 62.8% of rows are free space, so a
+  percentile over all rows is mostly a percentile of zeros.
+* `k ≥ 1.62 N/mm` — p95 over **contact** rows inside the gel. Use this one.
+* `k ≥ 1.72 N/mm` — even the hardest press inside the gel.
+
+Recompute rather than rescale the shipped column, since the direction matters:
+
+```python
+K = 1.62                                             # your controller's stiffness
+n_hat  = (tgt[:, :3] - obs[:, :3])                   # F/k · n̂ at the shipped k=1
+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
 
-- **`k = 1.0 N/mm` is a declared assumption, not a measurement.** It is written
-  into the parquet field metadata (`twm.stiffness_n_per_mm`) and the
-  `<episode>.force.json` sidecar so a target pose is never uninterpretable.
-  To use a different stiffness, recompute from `force_*_normal_n` directly —
-  `penetration = F / k`, `target = observed + (F/k)·n̂`.
-- **1 N/mm is on the soft side.** p95 penetration is 5.78 mm and 8.84% of rows
-  exceed the 4.25 mm gel thickness. `k ≈ 1.4` keeps p95 inside the gel,
-  `k ≈ 1.7` the maximum.
-- **Forces saturate at 7.285 N** — the calibration's isotonic stage clips at
-  the hardest press it was fitted on, so 0.90% of samples sit exactly at that
-  value. Treat the maximum as a floor, not a measurement.
 - **Accuracy is rank-order within a group, not a certified absolute scale.**
-  Held out by press position the estimator scores ρ = 0.739 / MAE 1.23 N on
-  its own calibration objects. On five public force-labelled datasets the same
+  Held out by press position the estimator scores ρ = 0.739 / MAE 1.23 N on its
+  own calibration objects. On five public force-labelled datasets the same
   pipeline reaches ρ 0.775–0.986. It is reliable for *how hard, relative to
-  other frames*; it is not a load cell.
+  other frames*; it is not a load cell. Do not report absolute newtons from
+  this dataset as ground truth.
+- **Forces saturate at 7.285 N.** The calibration's isotonic stage clips at the
+  hardest press it was fitted on, so 0.90% 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.
-- **Contact must be visible.** A contact clipped by the sensor border is
-  systematically under-measured.
-
-Provenance travels with the data: `data/force_export_manifest.json` and
-`data/force_export_verify.json` record which calibration produced these
-newtons and every check it passed (row alignment 72/72, free-space identity,
-round-trip `k·‖target−observed‖ = F` closing to 5.6e-14 N).
-
-Method, validation against five public datasets, and the failure cases:
-**https://huggingface.co/spaces/yxma/react-force-recovery**
-
-The preview clips under `data/motherboard/previews/` show the force directly —
-a semi-transparent disc on each camera view, centred on that sensor's projected
-position, whose **area** is linear in newtons (legend in frame).
+  `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`):
@@ -169,16 +222,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.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.
+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.4 GB)
+# Core only — RGB + tactile + parquet, NO depth (~4.8 GB)
 snapshot_download("yxma/React", repo_type="dataset",
                   ignore_patterns=["*/depth/*"])
 
-# Everything including depth (~37 GB)
+# Everything including depth (~39 GB)
 snapshot_download("yxma/React", repo_type="dataset")
 
 # One task only
@@ -265,15 +318,140 @@ 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` 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.
 
-**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.
+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 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.
+- **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/).