docs/probe_testset_README.md

React probe set — controlled actions for measuring ACTION FOLLOWING

This is one of two evaluation sets, and they answer different questions.

	question	data
held-out split	can the model predict what actually happened?	real frames, real actions, real futures — ReactVideoDataset(..., split="test")
probe set (this)	does the model follow the action it is given?	commanded actions nobody performed; ground truth is geometric

The held-out split scores prediction against recorded frames. It cannot isolate action-following, because the action in a recording is whatever the human happened to do. These probes command motions that were never performed, one axis at a time, so a failure names a direction.

72 commanded action sequences over 6 start frames, for scoring a tactile world model's rollouts against ground truth that is geometric, not photometric.

Format react-probe-testset/1.0. Task: motherboard.

---

Why this exists

A world model rolled out from a real episode can be scored against the frames that were actually recorded. That measures interpolation of behaviour the model has seen. It does not tell you whether the model has learned how a commanded motion moves the sensor — because the action in a recording is whatever the human happened to do.

These probes are axis-aligned, controlled actions: six pure translations along ±x, ±y, ±z and six pure rotations about the same axes, from each start frame. Nobody performed them, so there is no ground-truth future image.

What is ground truth is where the sensor would be if the action were executed exactly — a pose sequence, and its projection into each camera. A rollout is judged by comparing the sensor it draws against that projection. Axis-aligned on purpose: when a probe fails you can say which direction failed. A random direction gives you a number and no handle.

Yellow: commanded ground truth. Red: a deliberately wrong rollout, offset 25 mm in world x — it reads 18–19 px, three times the ~6 px noise floor. Dimmed: the hand that must stay still. overlays/ holds one such still for every probe.

What a probe is

Probes	72 — 12 per start frame (6 translations, 6 rotations)
Start frames	6, each 4 consecutive context frames × 5 streams (3 cameras + 2 tactile)
Translation amplitude	0.113 – 0.391 m
Rotation amplitude	18.6 – 88.7°
Horizon	1.50 – 4.27 s at 30 Hz
Speed	dataset percentile p33 – p77
Moving hand	36 left / 36 right; one hand moves, the other holds
Closest approach between gels	0.131 m (rule: ≥ 0.12 m)

One hand moves per probe. The other holds its pose for the whole horizon, so a rollout must keep it still — a model that drifts both hands is visibly wrong even when the moving one is right.

Rotations pivot on the gel, not on the OptiTrack marker cluster. The marker cluster sits 65.7 mm from the gel, so rotating about it would swing the contact point through an arc of up to 53 mm and a "pure rotation" would translate across the screen.

Layout

manifest.json                      format, conventions, error budget, residuals
calibration/                       T_mocap_to_cam_{left,middle,right}.json
                                   T_gel_to_rigid_{left,right}.json
probes/runN/
  meta.json                        episode, context rows, moving/held hand
  context/ctx{0..3}_view_{left,middle,right}.jpg    what a model conditions on
  context/ctx{0..3}_tactile_{left,right}.jpg
  {trans,rot}{±x,±y,±z}.npz        one probe
overlays/runN_<probe>.jpg          ground truth drawn on the last context frame
overlay_example.jpg                the figure above

Each .npz holds:

key	shape	meaning
poses	(T+1, 7)	commanded ground-truth pose of the moving sensor
held_pose	(7,)	the stationary hand, constant over the horizon
context_poses_moving / _held	(4, 7)	poses at the context frames
gel_pos_m	(T+1, 3)	the gel centre — what the action is measured at
delta_gel_pos_m	(T, 3)	the action: per-step translation, world axes, at the gel
delta_gel_rotvec_rad	(T, 3)	the action: per-step rotation, world axes
action_scalar	(T,)	the same action as one number: signed step along action_axis
action_axis / action_sign	scalar	0/1/2 for x/y/z, and ±1
delta_rigid_pos_m / delta_rigid_rotvec_rad	(T, 3)	the marker cluster's motion instead
gt_px_{left,middle,right}	(T+1, 2)	ground-truth gel-centre pixels
context_{tactile,force}_*	(4,)	the numeric channels at the context rows — intensity, area, is_new, force, penetration

Poses are [x, y, z, qx, qy, qz, qw], position in metres, quaternion in xyzw order (scipy.spatial.transform.Rotation.from_quat), in the OptiTrack world frame with 2026-05-10 as reference.

One action, one direction — and where you have to measure it

Every probe moves along exactly one axis: a translation probe has zero rotation, a rotation probe has zero translation, and the off-axis components are zero to machine precision. All of that is true at the gel, and false at the marker cluster.

The pose 7-vec is the OptiTrack marker cluster's, and rotations pivot on the gel 65.7 mm away — so in rigid-body coordinates a "pure rotation" carries up to 91 mm of translation. A model fed delta_rigid_* for rot+x reads "translate 91 mm and rotate 79°" for something labelled a pure rotation. Hence delta_gel_* is the primary action; delta_rigid_* ships alongside for a model that predicts the marker-cluster pose, under a name that cannot be confused.

Rotation deltas are world-frame, i.e. pre-multiplied: dq = q[i+1] · q[i]⁻¹, integrate as q[i+1] = dq · q[i]. The probes rotate about world axes, so the world-frame increment lies exactly along the named axis; the body-frame increment q[i]⁻¹ · q[i+1] is the same rotation seen from the moving hand and sits 7.1e-3 rad off it.

Both deltas integrate back to their own trajectory exactly — the rigid one to poses, the gel one to gel_pos_m — asserted to 1e-9 m and 1e-6 deg.

Usage

import json, numpy as np, cv2
from react_toolbox.calibration import load_calibration
from react_toolbox.probe_eval import overlay_gt, rollout_error

root = "react_probe_testset"
cal  = load_calibration(root)              # the calibration IN the package
run  = json.load(open(f"{root}/probes/run0/meta.json"))
d    = np.load(f"{root}/probes/run0/trans+x.npz")

gel  = cal[f"gel_{run['moving_side']}"]
cam  = cal["cams"]["middle"]

# --- the model input: 4 context frames, and the action
ctx    = [cv2.imread(f"{root}/probes/run0/context/ctx{i}_view_middle.jpg")[:, :, ::-1]
          for i in range(4)]
tac_l  = [cv2.imread(f"{root}/probes/run0/context/ctx{i}_tactile_left.jpg")[:, :, ::-1]
          for i in range(4)]      # and tactile_right
action = np.concatenate([d["delta_gel_pos_m"],
                         d["delta_gel_rotvec_rad"]], axis=1)   # (T, 6), at the gel
# or, since each probe is one-directional, the same thing as one number:
#   d["action_scalar"], along axis "xyz"[int(d["action_axis"])]

pred = my_world_model.rollout(ctx, action)      # -> (T+1, 7) poses

# --- score it
err = rollout_error(pred, d["poses"], gel, cam)
print(err["pos_mm_final"], err["rot_deg_final"], err["px_final"])

# --- and look at it
vis = overlay_gt(ctx[-1], d["poses"], gel, cam,
                 held_pose7=d["held_pose"], held_gel_mm=cal[f"gel_{run['held_side']}"])
vis = overlay_gt(vis, pred, gel, cam, color=(255, 90, 90))   # your rollout, in red

The overlay

overlay_gt draws, on a context frame:

• the held hand, dimmed, with a stem back to its marker cluster
• the start and end sensor frames as perspective triads — a dot cannot show a rotation probe, where the gel centre does not move at all
• the commanded path as a polyline, start a white dot, end a ring

Triads go down first and the path markers on top; the other order puts the start triad's centre dot exactly over the start marker and hides it.

All projection goes through calibration.project_gel_to_pixel, the same function the dataset previews and the release fingerprint use, so an overlay you draw cannot disagree with the stored gt_px_*.

What "correct" means — the overlay's error bar

Projected ground truth is not exact:

source	at 800 mm depth
camera reprojection rmse (left / middle / right: 4.7 / 5.3 / 7.5 mm)	3.6 / 4.0 / 5.7 px
gel centre in the rigid frame (≤ ~5 mm)	≈ 3.8 px

Agreement within about 6 px is at the noise floor and should be read as correct. rollout_error reports millimetres and pixels because they differ by depth, and neither substitutes for the other.

How the probes were generated

1. Sample a start frame. A run of 4 consecutive rows with both sensors tracked, from a session whose world frame is pinned (below). Start frames and actions are sampled independently: a frame is accepted or rejected against the actions, never adjusted to fit them — nudging a trajectory to keep it on screen would make two probes named +x mean different things.

2. Generate 12 actions from the moving hand's start pose: six translations along the signed world axes, six rotations about them. Rotations pre-multiply in the world frame ("turn the hand this way in the room"), which is what a viewer can judge from a camera image.

3. Pace them against the dataset. Speed is drawn uniformly in percentile of the measured per-step distribution (p45–p85, capped by the horizon), not uniformly in mm/step — the distribution spans a decade between p25 and p90, so a uniform draw in value would put most probes in a tail the data barely occupies. Every probe records the percentile it actually lands on.

   The 1.5 s horizon caps speed at amplitude / 45, which bites at small amplitudes: 0.1 m over 45 steps is p44, 18° is p32. Those probes are the slowest in the set and cannot be faster without breaking the horizon.

4. Reject, never adjust. A probe is discarded, and the start frame with it, if the two gel centres come within 0.12 m — hands do not pass through each other, and a probe that says they do tests whether the model will hallucinate rather than whether it can predict. The projected path must also stay 40 px clear of the image border: in frame is not enough, because a rollout that overshoots a path ending 15 px from the edge leaves the image and cannot be scored at all.

Start frames are HELD OUT

Start frames are drawn only from the held-out intervals of splits.json. Without that the context images would be training frames: the action is novel either way, but the model would already have seen the picture it starts from, and nothing would say so.

meta.json records context_rows — release-parquet row indices, not raw HDF5 frames and not seconds. Row r is camera frame trim + r, where trim = source_h5_frame[0]; source_h5_frames in the same file gives the mapping explicitly so you never have to apply it yourself. The four rows are consecutive, one camera frame apart.

Context is five streams, not three. The first export shipped only the camera views, which made the package unusable for the one thing it exists to test. Each start frame now ships view_{left,middle,right} and tactile_{left,right}, plus the numeric channels at those exact rows.

The images come from the published videos/ tree, not the unpublished raw HDF5, so the package can be rebuilt from what the dataset ships. Video frame r is parquet row r for every stream — measured against the raw capture at 1.88 mean pixel difference where two adjacent raw frames differ by 4.89. The tactile videos are already row-aligned: cross-correlating a contact measure from the video against the parquet's tactile_left_intensity peaks at lag 0 with r = 0.980, falling off symmetrically. The +15-frame acquisition lag was applied at encode time, so nothing is re-applied here.

The release holds out intervals from inside episodes, not whole episodes. There are 32 motherboard episodes; spending them on episode-level held-out data buys independence a short-horizon world model does not need — what it must generalise over is dynamics within a scene, not scenes. Measured, with a 64-frame training window: test 12.1%, guard 9.4%, train 78.5%, over 147 intervals plus 2 wholly-held-out episodes.

The guard is the part that leaks if you get it wrong. A training window starting shortly before a held-out interval still contains its frames, so starts in [a-(S-1), b] must be rejected, not just [a, b]. splits.json records guard_frames = max_train_window - 1, and the loader refuses a longer window rather than leaking — a leak here leaves no trace in any metric until the numbers are suspiciously good. Without the guard, 1827 windows leak in the first six episodes alone.

Sessions

All three sessions are eligible; which ones a given draw contains is chance. Run build_probe_testset.py with a different --seed and the mix changes.

2026-05-19 had its OptiTrack world redefined mid-collection. The release applies the translation-only correction (230, 0, 175) mm, and the residual yaw about the table normal is unmeasured — attempts scatter ±2.3°, about 16 px at the workspace. It is included with that stated in manifest.json under world_residual and session_note, rather than dropped: a bounded, declared error is not a reason to discard a fifth of the sessions. An earlier build did drop it, and an earlier version of the web page went on saying so after the decision was reversed — the pages now generate that sentence from the manifest.

Reproducing

python scripts/build_splits.py                     # writes splits.json
python scripts/build_probe_testset.py --runs 6 --seed 0
python scripts/test_splits.py
python scripts/test_probe_testset.py

test_splits.py enumerates every admissible training window and asserts none touches a held-out frame, and that removing the guard does leak — a guard nobody can show to be load-bearing is decoration.

test_probe_testset.py asserts the package is self-contained, that the stored ground-truth pixels recompute from the calibration inside the package, that the deltas integrate back to the poses, that the ground truth keeps its scoring margin, and that the scorer reads zero on the ground truth and exactly 10 mm on an injected 10 mm error.