Episodes Preview Franka Panda Visualizer
1.42k episodes · 20 fps

HiddenPhys expert demonstrations

Paper · Project page · Code

Expert demonstrations for the seven tasks of HiddenPhys, the MuJoCo benchmark released with ForceHarness: Turning Force into Action and Physics for Frozen Frontier Models. Each HiddenPhys task hides one physical variable that decides success (a mass, a centre of mass, a table height, a hole position, an unlock angle, whether a door is locked or only stiff) that position alone does not reveal. The demonstrations were recorded from the benchmark's expert force controller and used to train the learned baselines of the paper (Diffusion Policy, π0.5 and ForceVLA, each with and without force input).

Code, task definitions and the recorder: the ForceHarness repository (forceharness/hiddenphys/tasks.py, forceharness/backends/mujoco/recorder.py, scripts/hiddenphys/record_demos*.py, scripts/hiddenphys/replay_demos.py).

Content

Task Released episodes Attempted Frames (control steps) Raw size
weight_sort 210 210 144,312 0.82 GB
com_sort 208 210 140,607 0.81 GB
wipe_hard 207 210 68,960 0.43 GB
stack_gentle 206 210 121,311 0.75 GB
peg_in_hole_hard 185 240 122,194 0.88 GB
door_latch 197 210 111,329 1.11 GB
lock_or_stiff 210 210 18,154 0.18 GB
total 1423 1500 726,867 4.99 GB
Task Hidden variable What force must do
weight_sort cube mass, 0.15 or 0.60 kg weigh the held cube, place it in the heavy or light zone
com_sort bar's centre of mass, centred or 4 cm off measure the held moment, place it in the balanced or offset zone
wipe_hard table height, up to about 6 cm low press 5 to 15 N on 12 dirt spots
stack_gentle lower cube's top, known to ±1 cm feel contact and place gently
peg_in_hole_hard hole position, 15 mm error per axis search by touch until the peg drops, then insert
door_latch unlock angle, 15 to 35° press the lever to release the latch, then pull
lock_or_stiff locked, or stiff and freed at 6 to 11 N pull below the 15 N damage threshold; stop if locked

Simulator: robosuite 1.5.1 on MuJoCo 3.2.7, Franka Panda with the OSC_POSE controller at 20 Hz, two cameras (agentview, robot0_eye_in_hand) at 128×128. Only successful episodes are released; episode seeds start at 20000 and never overlap the benchmark's development (9000-9019) or test (9100-9149) seeds.

Two forms in one repository

raw/: the recorded episodes (exact replay)

raw/<task>/episode_<seed>.npz, one file per episode, plus raw/<task>/index.jsonl (seed, length, hidden variable, verdict) and raw/attempts.json. Observations have one more frame than actions: frame i is what the controller saw before action i.

Key Shape Meaning
action (T, 7) float64 normalised OSC delta actually sent to the environment, in [-1, 1]: position × output_max_pos metres, rotation × output_max_rot rad, gripper (-1 open … +1 closed); wipe_hard has no fingers, so its 7th entry is NaN
kp (T, 6) float64 OSC stiffness during the step (the primitives soften the arm near contact)
weld (T,) bool whether the held object was welded to the hand (pegs start held)
via_step (T,) bool whether the step went through the harness step (task hooks such as latches and damage ran)
prim (T,) int16 index into meta.prim_names: the primitive running at that step (analysis only)
t (T+1,) simulation time, s
eef_pos, eef_quat (T+1, 3), (T+1, 4) end-effector position (m) and quaternion [x, y, z, w], world frame
gripper_qpos, joint_pos (T+1, 2), (T+1, 7) finger and joint positions; gripper_qpos is empty in wipe_hard, whose wiping tool has no fingers (the loader reads it as zeros)
force_raw, torque_raw (T+1, 3) wrist sensor reading in the sensor frame, noise-free and not tared
R_ft (T+1, 9) sensor-to-world rotation (row-major)
b0_force, b0_torque, bias_ep_force, bias_ep_torque (3,) the zero taken at reset and the per-episode residual bias
img_<cam>_jpeg, img_<cam>_off bytes, offsets JPEG frames (quality 90, BGR channel order, upside down as robosuite renders them); frame i is jpeg[off[i]:off[i+1]]
meta_json bytes JSON: task, seed, hidden-variable ground truth (truth; label / theta_u in the two mechanism tasks), verdict, noise settings, cameras, the noisy scene the controller was given (scene0), primitive names, and the episode configuration replay needs (episode_cfg; start_after_pregrasp and prims_args for lock_or_stiff)

The force the harness uses is F = force_sign · R (f_raw + bias_ep + n − b0) with n ~ N(0, σ) drawn per step (σ = meta.force_noise_std, torques 0.1 σ). Recording the noise-free reading keeps the episode's random stream untouched and lets a training pipeline add noise with the same model; forceharness/data/demos.py (wrench_obs) does exactly that. Replaying action, kp and weld from the episode's seed reproduces the trajectory (scripts/hiddenphys/replay_demos.py; the end-effector end point matches to 0.00 mm in our checks).

from forceharness.data.demos import load_demo, decode_frame
d = load_demo("raw/weight_sort/episode_20000.npz")
img = decode_frame(d, "agentview", 0)          # upright RGB uint8
print(d["meta"]["truth"], d["action"].shape, d["force_raw"].shape)

Root: LeRobot v2.1 (training)

The same episodes as one multi-task LeRobot v2.1 dataset (meta/, data/), as used to train the π0.5 and ForceVLA baselines:

Feature Shape Meaning
image, wrist_image 128×128×3 agentview and wrist camera, upright RGB
state (26,) end-effector position 3 + orientation 6D 6 + fingers 2, then the noisy object poses the controller was given (5 numbers per object: position, sin/cos yaw), zero-padded to 15
wrench (6,) wrist force and torque in the world frame, tared at the start, with the harness noise model applied
actions (13,) the 7 OSC action entries (6 for wipe_hard, padded with 0) followed by the 6 stiffness values
task text a short instruction per task
# any lerobot release that reads codebase version v2.1, e.g. the one pinned by openpi
from lerobot.common.datasets.lerobot_dataset import LeRobotDataset
ds = LeRobotDataset("Jack97/ForceHarness-Data")

How the data was recorded

The expert is a hand-written state machine per task that calls the same self-terminating force primitives the model uses in ForceHarness and reads the force they report (five tasks through forceharness/baselines/expert.py, the two mechanism tasks through scripts/hiddenphys/door_latch_expert.py and lock_or_stiff_expert.py). Its constants were chosen with knowledge of the task design (for example, the weight threshold is the midpoint of the two masses), so it is an upper reference, not a task-agnostic method. On lock_or_stiff, recording starts after the scripted pre-grasp of the handle (the environment performs it for every method) and uses the soft arm (stiffness 150). Episode budgets follow the benchmark protocol (40 turns, 80 tool calls, 300 s).

Intended use and limitations

  • Training and evaluating learned policies on HiddenPhys, studying force as an input, and replaying expert behaviour.
  • Simulation only. The expert's behaviour is narrow; policies trained on it inherit its strategy.
  • Information differs from the harness setting: learned policies see camera images (the wrist camera can see the true hole position), whereas the harness receives object poses as noisy text.
  • Learned policies have no safety stop of their own; report peak force and damage (handle force above 15 N in the mechanism tasks) together with success, as the benchmark does.

License and citation

MIT. The simulated scenes are built from robosuite (MIT) assets. If you use this dataset, please cite the paper:

@article{sun2026forceharness,
  title   = {ForceHarness: Turning Force into Action and Physics for Frozen Frontier Models},
  author  = {Sun, Ke and Ma, Kevin Yuchen and Zhang, Yike and Chen, Yanzhe and Shou, Mike Zheng},
  journal = {arXiv preprint arXiv:2611.21099},
  year    = {2026}
}
Downloads last month
-

Paper for Jack97/ForceHarness-Data