meat000124/mhbench_doorpassage_test

MHBench — DoorPassage (G1 × 2)

60 successful two-operator demonstrations of Isaac-DoorPassage-G1x2-v0: one Unitree G1 opens an articulated door and holds it while the other lifts a 1.6 kg trophy off a plinth, walks it 2.5 m through the doorway, and stands it on a green-topped stand in the far room. One human operator per robot, both in Meta Quest 3 headsets across a federated two-process Isaac Sim link. 44,921 frames at 50 Hz, 15.0 minutes of simulated demonstration.

The trophy is held by the fingers. There is no magnetic grasp constraint in this release (grasp_abstraction = 0) — Robot B's two Dex3 hands hold the trophy by its handles, by contact, for the whole walk.

The difficulty is a dependency in time rather than in force. The two robots never touch the same object: A's job produces a state of the world — an open doorway — that B needs, and B is carrying something breakable through a gap narrower than the pair. An operator who walks before the door is open walks into it, and an operator who lets go of the handle too early closes it on their partner.

Collected in two sessions, and 24 of the 60 episodes are open-loop replays — see The demonstrations.

This release is LeRobot v2.1: parquet rows, H.264 video and meta/. It loads as it stands — point a LeRobot or GR00T dataset path at the repository root. The source HDF5 archive is not published here; it also contains raw operator input, simulator-rate channels and replayable simulator state that do not survive this format.

Splits

split	episodes	frames
train	0 – 49	37,387	50 demonstrations
val	50 – 59	7,534	the 10 recorded last

Declared twice, because two readers ask differently: meta/info.json's splits field is what the LeRobot spec defines, and the configs: block in this card's header is what the Hub viewer and datasets.load_dataset read. Both name the same episode ranges.

The boundary is temporal, not random — val is the tail of the collection, and here that also means it is entirely live rather than replayed. LeRobot splits are index ranges over episode numbering, so a different partition means renumbering episodes rather than editing a field. A loader that ignores splits (GR00T enumerates meta/episodes.jsonl) uses all 60 unless the episode indices are filtered explicitly.

Layout

meta/
  info.json         features, dtypes, per-dimension names, fps, splits, path patterns
  modality.json     which slice of which column each key is
  episodes.jsonl    one line per episode: index, task, length
  tasks.jsonl       the three instructions (see Language)
  mhbench_provenance.json
                    recording, render and export provenance for every episode
data/chunk-000/episode_000000.parquet   ... episode_000059.parquet
videos/chunk-000/observation.images.ego_a/episode_000000.mp4    colour
                 observation.images.ego_b/...
                 observation.images.scene/...
                 observation.depth.ego_a/...                    metres, lossless
                 observation.depth.ego_b/...
configs/operators.yaml    the legend for every meta/* integer code

What a policy reads

NVIDIA's own G1 contract, dimension for dimension. State and action follow the unitree_g1_full_body_with_waist_height_nav_cmd embodiment shipped in Isaac-GR00T (and written by GR00T-WholeBodyControl). The one departure is a robot_a_/robot_b_ prefix on every key, because one row holds two robots and a LeRobot row cannot hold two left_arm keys. This is the same contract as the other MHBench task releases, so a model can be trained across them without a conversion.

State — 43 measured joint angles per robot, in seven groups, URDF order:

key	dims
{robot}_left_leg / _right_leg	6 + 6
{robot}_waist	3
{robot}_left_arm / _right_arm	7 + 7
{robot}_left_hand / _right_hand	7 + 7

Each hand is thumb_0, thumb_1, thumb_2, middle_0, middle_1, index_0, index_1.

Action — 35 per robot: joint targets for the arms, hands and waist, plus the two locomotion commands.

key	dims
{robot}_left_arm / _right_arm	7 + 7	joint targets, relative to the angles measured at the start of the chunk
{robot}_left_hand / _right_hand	7 + 7	joint targets, absolute
{robot}_waist	3	joint targets, absolute
{robot}_base_height_command	1	hip height, metres
{robot}_navigate_command	3	vx, vy, wz

The legs are in the state and not in the action. Locomotion is commanded as a velocity and height, and the balance controller resolves the legs. Leg target columns are still written so a reader can find them, but no default training config consumes them. This is the task where that matters most: both robots walk the whole route.

The following simulator-side measurements are also described in meta/modality.json and excluded from the default policy state:

key	dims
{robot}_{left,right}_wrist_pos / _wrist_abs_quat	3 + 4 each	measured wrist pose, pelvis frame, wxyz (observation.eef_state); the commanded pose is action.eef
{robot}_root	7	pelvis pose, world frame, xyzw
{camera}_camera_pose	7 each	per-row camera pose, world frame, xyzw
{robot}_wrench	12	left force, left torque, right force, right torque at the end of each control step
object	7	trophy pose, world frame, xyzw
grasp_latched	4	contact-derived hold state for A-left, A-right, B-left, B-right

Here grasp_latched = 1 means the fingers have maintained qualifying contact with the trophy; it does not mean that a constraint has attached the hand to the object. Robot A's two channels are identically zero in every episode — A never touches the trophy. What A does with its hand is the door, and the source HDF5 records that separately (handle_latched, door_joint_pos, door_open_state, door_stage); those door channels are archive-only and are not in the parquet export.

Language

Three instructions are provided because the two robots do different jobs, not mirrored halves of one. annotation.human.task_description is the pair's instruction; …_robot_a and …_robot_b are each robot's own. Each column holds a row index into tasks.jsonl, as LeRobot expects, rather than the sentence itself.

Open the door and carry the trophy through the doorway onto the stand in the far room.

A — Walk to the door, pull it open, and hold it open for your partner.

B — Lift the trophy off the plinth by its handles, carry it through the open doorway, and stand it on the green stand.

The demonstrations

Across all 60, with the range and median:

	range	median
frames	618 – 1,037	737 (14.7 s)
trophy travel in world X	2.28 – 2.86 m	2.53 m
trophy travel in world Y	0.08 – 0.81 m	0.41 m
trophy peak height	0.638 – 0.789 m	0.718 m
trophy final height	0.420 – 0.482 m	0.426 m
Robot B left hand holding	0.0 – 82.5 %	69.8 %
Robot B right hand holding	4.3 – 81.6 %	67.7 %
at least one B hand holding	36.4 – 84.4 %	72.0 %
Robot A base displacement	1.88 – 2.96 m	2.55 m
Robot B base displacement	2.72 – 3.06 m	2.87 m
Robot A nonzero navigation command	43.4 – 83.3 %	60.9 %
Robot B nonzero navigation command	36.7 – 65.4 %	54.4 %
door handle turn, peak	0.33 – 0.79 rad	0.72 rad
Robot A hand on the handle	3.2 – 14.7 %	6.4 %

The door opens the same amount every time. The hinge reaches 2.618 rad (150°) in all 60 episodes — it swings to its stop — so the hinge angle is not a signal that distinguishes episodes. The handle turn is: it ranges over a factor of two, because how far a G1 has to rotate the lever before the latch frees depends on where it caught it.

Robot A grips for about six per cent of the episode. Opening a door is a short interaction inside a long walk; most of A's trajectory is approach, pull, and standing clear.

Only the two stands and the trophy are randomized: the pickup plinth by (−0.22 … +0.35) m in X and ±0.26 m in Y, the delivery stand by ±0.03 m in both, and the trophy ±0.05 m on its plinth. Measured over the 60 recorded starts the trophy spans 0.571 m in X and 0.570 m in Y — the widest object randomization in MHBench, because the plinth moves under it. The door, the rooms and the bookcase stay fixed.

Success is a released trophy standing on the far stand. The trophy base must be inside the delivery stand's green top, at that stand's height within 0.06 m, tilted by at most 60°, moving under 0.30 m/s, with the hands released for at least 0.15 s — and Robot B must have crossed x = 1.00 m with the trophy, so carrying it around the doorway would not count. The recorder then requires that predicate for 10 consecutive control steps.

24 of these are replays

Episodes 0 – 23 were not driven by an operator in this environment. They were demonstrated on 2026-08-20 under the magnetic grasp — the constraint the benchmark used to weld an object to a wrist — and re-run open loop under contact physics, keeping the recorded actions and recording what the fingers actually did with them. Only 24 of the 60 originals survived that; carrying a trophy the length of two rooms is the least forgiving thing in MHBench to replay, and 36 of them put it down. Episodes 24 – 59 were then collected live in the physical environment on 2026-08-21 — a larger live share than any other replayed release here.

Both kinds are physical demonstrations — every frame in this file is a frame where fingers were holding the trophy, and the states, wrenches and contact flags are the replay's own, not the recording's. What a replay does not have is a human in the loop at contact: where a real operator would have felt a grip slipping and corrected, the replay simply plays the next recorded action. Each replayed shard names its source in provenance.replayed_from and the 36 live ones have no such block, so the two can be separated exactly.

Images

Five H.264 streams per episode, 240 × 320, one frame per parquet row:

Video key
observation.images.ego_a	Robot A's head-mounted RGB view
observation.images.ego_b	Robot B's head-mounted RGB view
observation.images.scene	fixed third-person RGB view
observation.depth.ego_a	Robot A's depth in metres
observation.depth.ego_b	Robot B's depth in metres

The ego cameras use a 102.0° horizontal lens (fx = fy = 129.565 at 320 px), matching the current MHBench camera contract, and are mounted 25° downward. The scene camera is 82.25° horizontal (fx = fy = 183.250). Per-frame camera poses are included because both ego cameras move with their robots — and in this task they move the most: both robots walk the full route, so the ego stream is the only MHBench view where the room itself changes.

The robots are painted the way Unitree paints them. Earlier MHBench releases rendered the G1 in the Isaac asset's stock material — one grey at metallic = 1.0 and roughness = 0.34 across all ninety-one meshes, which is a mirror, and which is what those datasets show. This release uses the official asset's own split: a light grey shell at roughness = 0.65, with the head, both Dex3 hands, the waist yaw section, the hip covers and the ankles in matte black. The constants are copied from Unitree's published USD, and only the constants — the shading model, the meshes, the joints and every physics parameter are untouched. Evaluation renders through the same code, so a policy trained on these frames is evaluated against robots that look the same.

The rebuild was farmed across GPU classes, and that was measured rather than assumed. MHBench normally renders a dataset and its evaluation on one GPU model, on the grounds that a benchmark should not have the renderer as a free variable. This rebuild ran on the cluster's RTX 4090 and RTX 3090 nodes, so the rule was checked instead of kept: the same episode rendered on the two differs by 0.012 – 0.015 / 255 in mean absolute pixel value with a maximum of ±2 counts, against a 4090-to-4090 floor of 0.000 – 0.002 / 255, and the depth streams come back bit-identical. That is last-bit rounding — well under what the H.264 encode this export applies costs, which is the difference that actually reaches a trainer.

Depth

Depth is an ordinary H.264 MP4 that video readers can open, but it is lossless numeric data: millimetres split across two channels, with zero for no return.

import imageio.v2 as imageio
import numpy as np

frames = np.stack([
    f for f in imageio.get_reader(
        "videos/chunk-000/observation.depth.ego_a/episode_000000.mp4"
    )
])
metres = ((frames[..., 0].astype(np.uint16) << 8) | frames[..., 1]) / 1000.0
metres[metres == 0] = np.nan

In a normal video player it looks like green stripes, and that is expected. R stores the high byte, G the low byte and B is zero; the low byte wraps every 256 mm. Decode the channels before visualization. MHBench also ships scripts/preview_depth_video.py to create a colorized copy for inspection.

meta/info.json records the encoding, units, invalid value and intrinsics for each depth camera. The quantization bound is 0.0005 m. To back-project it, combine those intrinsics with the matching slice of observation.camera_pose:

x = (u - cx) * d / fx          # image right
y = (v - cy) * d / fy          # image down
z = d                          # distance along the optical axis
p_world = R(quat_xyzw) @ np.stack([z, -x, -y]) + pos

The RGB and depth frames were rebuilt from recorded simulator state after the session (scripts/restore_dataset_images.py), path-traced at 16 samples per pixel — the integrator an evaluation renders with. The collection and rebuild both report hidden_heads: [], so neither robot is missing its head in any camera. The source state, camera intrinsics and the commit used to render it are recorded in meta/mhbench_provenance.json.

Known limitations

Only successful demonstrations are published. There are no failed, abandoned or recovery trajectories, and the number of unsuccessful collection attempts is not encoded in this export. This dataset supports imitation of the successful route, not estimation of the task's empirical collection success rate.

Two fifths of the release is a replay, not a session. Episodes 0 – 23 were demonstrated under a magnetic latch and re-run under contact physics; their frames were never seen by an operator, and their recovery behaviour is whatever the recorded action sequence happened to produce rather than what a person would have done about a slipping grip.

Physical grasp is still simulated contact. A hand becomes held after at least two finger links exceed 0.5 N continuously for 0.04 s, and releases after 0.08 s without that contact. That is materially different from the old magnetic constraint, but it remains a PhysX/Dex3 contact model rather than a measurement from a hardware hand.

Robot A's grasp channels never fire, and the door is not in the export. grasp_latched for A-left and A-right is zero in all 44,921 rows, and the door's own joint angles, latch state and stage counter live only in the source HDF5. A policy trained on the published columns sees A's arm moving and the scene changing behind it, but has no explicit door signal.

One operator pair, one building, one trophy. terrain_id = 0, partner_id = 0, operator_id_a = 0, operator_id_b = 1, role_a_leader = 1, and operator_device_b = 3 in every episode. Only the two stands and the trophy's placement vary. Sixty demonstrations are sixty repetitions of one scene, not a distribution over rooms, objects or operator pairs.

The validation split is temporal. It is the final 10 demonstrations from the same session and operator pair, not an independent scene or randomized holdout. Treat it as a check against late-session behavior rather than broad out-of-distribution validation.

RGB is lossy H.264. Training reads decoded yuv420p frames, while an online simulator policy can receive the renderer's raw RGB buffer. Depth does not have that issue because it uses lossless libx264rgb; its H.264 stream probes as planar gbrp and decodes to the rgb24 frames described by meta/info.json. The millimetre packing must still be decoded before use.

The parquet export omits raw Quest input, simulator state and simulator-rate channels retained by the source HDF5. It does include control-rate robot state, actions, wrist measurements, object pose, camera pose and per-hand contact state; consult meta/info.json rather than assuming that an archive-only channel is present.

Loading it

import json
import numpy as np
import pyarrow.parquet as pq

root = "."                                    # this repository
modality = json.load(open(f"{root}/meta/modality.json"))
table = pq.read_table(f"{root}/data/chunk-000/episode_000000.parquet")
column = np.stack(
    table.column("observation.state").to_numpy(zero_copy_only=False)
)

entry = modality["state"]["robot_a_left_arm"]
left_arm = column[:, entry["start"]:entry["end"]]  # (T, 7), joint angles

Every key is a slice of a named column, so read meta/modality.json rather than hardcoding offsets — that is the file the exporter, tests and training configs agree through.

For GR00T, register the embodiment config matching the variant being trained (one policy for the pair, or one per robot) and point it at this directory:

python gr00t/experiment/launch_train.py \
    --embodiment-tag new_embodiment \
    --modality-config-path <MHBench>/configs/gr00t/mhbench_duo.py \
    --dataset-path <this repository>

Use launch_train.py rather than launch_finetune.py: the action chunk is 50 steps (1.0 s at 50 Hz), while the finetune entry point validates chunks against a default of 40.

How it was checked

All 60 parquet files were read and checked against meta/info.json and meta/episodes.jsonl: schemas agree, row counts sum to 44,921, episode indices are contiguous, and the declared split totals are 37,387 train / 7,534 val.

All 300 videos were checked against their episode rows for file presence, resolution, codec, pixel format and frame count (yuv420p for RGB, gbrp for the lossless depth bitstream). The two ego intrinsics read back at 102.0° horizontal and the scene camera at 82.25°, and every shard's render stamp reads PathTracing at 16 samples/pixel — matches evaluation. Every source shard was opened before the rebuild and checked for internal consistency: row counts against num_samples, an initial_state to restore from, one schema across replayed and live episodes, and grasp_abstraction = 0 throughout.