meat000124/mhbench_cocarry_test

MHBench — CoCarry (G1 × 2)

50 successful two-operator demonstrations of Isaac-CoCarry-G1x2-v0: two Unitree G1 humanoids carrying a 1.2 m board side-by-side past a goal line, one human operator per robot, both in Meta Quest 3 headsets across a federated two-process Isaac Sim link. 23,651 frames at 50 Hz, 7.9 minutes of simulated demonstration.

The difficulty in this task is not the reach or the grasp — it is the coupling. Two independent pairs of arms hold one rigid body, and each operator's mistakes arrive at the other through the object.

Collected 2026-08-13 (eb5eb9a, dirty tree) across three sessions. Every success was auto-detected rather than kept by hand: mhbench.tasks.cocarry.mdp.carry_success held for the last 10 consecutive steps, which is --num_success_steps firing, not an operator pressing M.

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 HDF5 archive it was exported from is not published here; it holds the sim-rate wrenches, the raw operator input and the replayable simulator states, none of which survive this format.

Layout

meta/
  info.json         features, dtypes, per-dimension names, fps, 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
                    which recording each episode came from, and what was dropped
data/chunk-000/episode_000000.parquet   ... episode_000049.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

meta/stats.json is not shipped: GR00T writes it on the first training run, indexed by the chunk length that run uses.

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), so a policy trained on one robot of this dataset reads and writes exactly what an upstream single-G1 policy does. The one departure is a robot_a_/robot_b_ prefix on every key, because one row here holds two robots and a LeRobot row cannot hold two left_arm keys.

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 a height, and the balance controller resolves the legs — the same division upstream makes. Their target columns are written all the same, so a reader can find them; no config consumes them.

Also described in meta/modality.json and read by no default config, matching what the upstream generator emits plus one addition:

key	dims
{robot}_{left,right}_wrist_pos / _wrist_abs_quat	3 + 4 each	measured wrist pose, pelvis frame, wxyz (observation.eef_state); the commanded one is action.eef
{robot}_root	7	pelvis pose, world frame, xyzw
{camera}_camera_pose	7 each	where that camera was for this row's frame, world, xyzw — what the depth is back-projected with
{robot}_wrench	12	left force, left torque, right force, right torque at the end of each control step — a real G1 has these sensors
object	7	the board's pose, which no robot could measure
grasp_latched	4	the magnetic latch's own state, which has no hardware counterpart

Language

Three instructions, because the roles are not symmetric — one robot side-steps right while the other side-steps left, so a per-robot policy given the pair's sentence would be told to do its partner's half as well. annotation.human.task_description is the pair's; …_robot_a and …_robot_b are each robot's own. Each column holds a row index into tasks.jsonl, as LeRobot expects, not the sentence itself.

The demonstrations

Across all 50, with the range and the median:

	range	median
frames	364 – 651	471
board travel in X	+1.45 – +1.56 m	+1.50 m
max |Y| off the centreline	0.02 – 0.19 m	0.07 m
final board height	0.78 m	0.78 m
both robots holding	73 – 86 % of steps	82 %
load share ratio	0.09 – 0.81	0.38
real-time factor	0.25 – 0.28	0.28

The goal line is X = 1.5 m (±0.15), the corridor ±0.6 m, the stands 0.78 m. No episode left the corridor, every board ended level on both stands, and all four hands latch in every episode. scripts/verify_dataset.py passes the whole directory: the lens is the configured 90°, every ego camera measures 24–25° below its own torso against a 25° mount, and every ego pose travels with its robot.

Numbering does not match the sessions' transcripts. Those call the first collection's demonstrations demo_1…demo_25 and the second's demo_24…demo_49 — the second session restarted its numbering where the directory's highest surviving index left off, so both used demo_24. On disk the shards are a contiguous demo_0…demo_49, with the collided one renamed to match its file name. demo_0 is from an earlier session, recorded as its demo_4. Known limitations explains how the numbering came apart.

Images

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

Video key
observation.images.ego_a	what operator 1's robot saw
observation.images.ego_b	what operator 2's robot saw
observation.images.scene	fixed third-person
observation.depth.ego_a	the same view in metres
observation.depth.ego_b

The ego lens is this benchmark's rather than the hardware's — 90° horizontal, 25° down, so each operator can see the partner they are carrying with (mhbench.g1.cameras).

Depth

Still an ordinary h264 MP4 that any reader opens, but lossless, and its pixels are a number rather than a picture: millimetres, split across two channels, zero where the camera got no return.

import imageio.v2 as imageio, 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          # no return

In a video player it looks like green stripes, and that is the file being correct. B is always zero; R is the high byte, which never passes about 20 in a room this size and so renders nearly black; G is the low byte, which wraps every 256 mm — that is the banding. The stripes are the low-order millimetres, which is exactly what a viewable 8-bit depth video throws away (that one is wrong by metres; this one by 0.5 mm). Decode it and the same frame is a clean depth map. MHBench ships scripts/preview_depth_video.py to write a colourised, human-viewable copy beside it — for eyes only, never for training.

meta/info.json says the same thing per camera (depth.encoding, depth.units_per_metre, depth.invalid_value), so nothing here has to be assumed. Worst-case error is the 0.5 mm rounding — finer than the float16 the simulator recorded, past one metre.

To back-project it, each depth feature also carries its camera's intrinsics (camera.fx/fy/cx/cy, constant across the release), and observation.camera_pose carries where the camera was on every row. The ego cameras walk with their robot, so one fixed extrinsic would be wrong by up to a metre and a half:

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

These pixels were rebuilt from recorded state after the session (scripts/restore_dataset_images.py), and they had to be. Robot A's head is hidden during a session so it does not sit between the operator's eye and their hands (mhbench.teleop.self_occlusion), but USD visibility belongs to the stage rather than to a camera — so the head was hidden from every camera in the recording process, and the session's own ego_b and scene frames show Robot A headless. Only Robot B kept its head, because operator B's headset runs in a second process with its own stage. Rebuilding the frames in a process with no headset puts every head back.

The geometry restores exactly — rerender_demo_views.py --verify measures 0.0 error reading the scene back, and the session's own camera_info is byte-identical to the rebuild's — so this is the same demonstration through the same lens, not the same bytes.

Known limitations

Two takes from the first session were dropped by hand, between the sessions: demo_13 failed, and it was removed along with demo_25, with the then-newest shard renamed into the gap. That is why the sessions' transcripts list demonstrations this directory does not have. Nothing was lost by accident and the 50 here are each intact — but the rename is worth knowing about, because mv moves a shard and not the demo_N group inside it, so the file called cocarry.demo_13.hdf5 arrived carrying a group named demo_24. The next session then numbered its own first export demo_24, and since every tool keys demonstrations by group name rather than by file, one of the two became unreachable: 50 files, 49 loadable. Both are repaired here.

To drop a take, delete the shard and leave the hole. Gaps are safe — the index scan takes one past the highest, readers sort by index, and nothing requires the sequence to be dense. Renaming is what breaks, and it breaks silently. verify_dataset.py now fails a directory whose file names and group names disagree.

The rebuilt frames now match the session's exposure, and earlier releases of this dataset did not. Two separate causes, both found by measuring against the session's own surviving pixels and both fixed:

• The sky. A live XR session does not draw the dome light behind the room and an offline re-render did, putting a white band across 13% of the scene frame where the session recorded black — 1.33× on that camera alone. The dome is declared visible_in_primary_ray=False in the task config now.
• Light transport. What was left was a flat ~1.08× on every camera. Not auto-exposure, which was off in both processes all along, and not a post-process gain. The live XR process and the offline one load different Kit experience files, and their lighting defaults disagree: directLighting.sampledLighting accounts for ~5%, ambientLightIntensity ~1%, and the render mode ~1%. mhbench.runtime.configure_render pins all of them to the values a live session already uses.

Measured on the frames in this release against the session's own: 0.998 / 0.999 / 1.002 for ego_a / ego_b / scene, where the previous release was 1.072 / 1.070 / 1.079. The scene camera's mean error is 1.3/255, down from 10.9. What remains is temporal-accumulation state around edges, which a re-render of a teleported scene cannot reproduce and no setting controls.

The load is rarely shared evenly. derived/load_share_ratio has a median of 0.38 against 0.50 for an even carry and spans 0.09 to 0.81 — in the extreme episodes one robot takes nine tenths of the board. Which robot leads varies, so the collection is not biased to one side, but few episodes are a balanced two-robot lift.

Every session ran at 0.25–0.28× realtime — 12.7 Hz against the 50 Hz control rate. Both operators were teleoperating in slow motion, and whatever that does to human timing is in the demonstrated behaviour. The cause is the XR render and encode share rather than physics (docs/teleop.md §5, docs/measurements.md §"Where env.step goes").

Operator alignment is federated-stale. The two operators' streams sit ~13 ms apart at the median, worst p90 37.1 ms across the collection — one secondary frame, the floor the two-process architecture imposes rather than a defect. Individual episodes contain stalls, where a worst frame of 80–140 ms lines up with a link_rtt peak and the mirror misses frames. The recorded actions array is self-consistent throughout, so this does not mis-pair actions with states; it bounds claims about inter-operator synchrony, nothing else.

Grasp is an abstraction. grasp_abstraction = 1: a magnetic surface latch, not a finger-object contact solve. states/hand_contact/* is therefore identically zero — the latch holds the board at a standoff and the palms never touch it.

Single scene, single operator pair, flat ground. terrain_id = 0, partner_id = 0, one board, one spawn layout. 50 demonstrations meets the collection target (--num_demos 50, README §2), but they are 50 repetitions of one configuration — there is no variation here to generalise across.

Loading it

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

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, its tests and the training configs all agree through.

For GR00T, register the embodiment config that matches the variant you are training (one policy for the pair, or one per robot) and point 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>

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

How it was checked

Every episode was compared against the recording it came from, key by key, through meta/modality.json alone — the way a loader reads it. State, action and wrenches match the source exactly (max|difference| = 0), the hand compression is lossless on every frame, no quaternion changes hemisphere, and each video's frame count equals its parquet's row count.

.venv/bin/python scripts/test_export_lerobot.py     # the export's own gate
.venv/bin/python scripts/verify_dataset.py datasets/cocarry/data