Co-Trans/G1_Collaborate_Transport_v3

G1 Collaborative Transport (v3)

Two Unitree G1 humanoids carry a payload together in MuJoCo: they pick it up, carry it 4-8 m to a goal while turning it, and put it down. Each episode is driven by a centralized privileged expert (it plans the payload's path and gives each robot an action every 0.16 s) and executed by a pretrained whole-body controller on each robot (ScaleBFM M, post-trained by a teammate for wrist tracking under hand loads: scalebfm_ee_posttrain). Per robot it records what that robot would sense (egocentric RGB-D, proprioception, the 6-axis wrench at each hand and the robot's combined wrench) and the action it executed; plus the payload's privileged state and a text instruction. Made with the WAM_CT code (scripts/scalebfm_wbc/collect.py --wbc scalebfm_ee_posttrain; how to run it: the repo README, "Collecting the dataset").

Changes from v2: the whole-body controller is scalebfm_ee_posttrain (v2: the released ScaleBFM M): the same network, inputs (pelvis and wrist pose targets) and gains, with its actor and task embedder post-trained with PPO for wrist tracking while the hands carry 1-6 kg. Everything else (expert, actions, scene, fields) is as in v2. On the same 110 new seeds (10 per payload) both controllers succeeded every time; the post-trained one carried the payload more level (mean tilt while carrying 2.8 -> 1.9 deg), it sank less in the hands (0.69 -> 0.47 cm) and its palms followed their targets 0.4 cm closer, while its pelvis followed 0.3 cm less closely.

Changes from v1 (in v2): depth images; robot_wrench; action is now the relative action each robot executed (v1's 18-D twist command was recorded but not executed: ScaleBFM followed the plan); action_target; the start pedestal is violet and the goal pedestal green (v1: both green); desk003 left out.

Only successful episodes are included: no robot fell, and the payload rests level on its goal support covering at least 80 % of the goal's footprint. 220 of 221 runs succeeded; the other covered 76 %.

Contents

220 episodes, 20 per payload, 156 min of motion in total, 29-55 s each. Every episode has its own random seed; the same seed and payload reproduce it exactly.

payload	carried as	from -> to	end error cm (median)	on the goal % (median)	sink in the hands cm
box	box: 0.6 x 0.3 x 0.2 m, 1 kg, with ribs	pedestal -> pedestal	1.7-5.2 (3.2)	82-94 (88)	0.2-2.0
table	table: 0.8 x 0.5 m top on 0.76 m legs, 2.5 kg	floor -> floor	1.2-5.0 (3.0)	92-97 (94)	0.1-0.4
desk001	CORE4D desk, as the table, 2.5 kg	floor -> floor	0.5-5.2 (2.7)	92-99 (95)	0.3-0.6
box004	CORE4D box, as the box (ribs added), 1 kg	pedestal -> pedestal	1.2-5.3 (3.6)	83-96 (88)	0.2-2.1
box006	CORE4D box, as the box (ribs added), 1 kg	pedestal -> pedestal	1.2-4.7 (2.3)	87-97 (94)	0.3-1.7
box021	CORE4D box, as the box (ribs added), 1 kg	pedestal -> pedestal	0.1-5.1 (2.7)	85-99 (92)	0.3-2.0
box023	CORE4D box, as the box (ribs added), 1 kg	pedestal -> pedestal	1.7-5.2 (2.8)	81-93 (90)	0.2-1.9
box005	CORE4D lidded bin, held by the lid's rim, 1 kg	pedestal -> pedestal	1.0-7.9 (3.0)	84-97 (93)	0.0-1.4
box026	CORE4D lidded bin, held by the lid's rim, 1 kg	pedestal -> pedestal	0.5-5.2 (3.7)	87-98 (91)	0.2-3.7
bucket003	CORE4D wheelie bin, held by the lid, 1 kg	pedestal -> pedestal	1.1-5.0 (3.0)	86-96 (91)	0.2-2.0
bucket007	CORE4D round bucket, held by the lid's rim, 1 kg	pedestal -> pedestal	0.8-6.2 (2.3)	86-96 (93)	0.3-2.0

The CORE4D objects (meshes from the CORE4D dataset) are carried like our box (palms inward, on its sides) or our table (palms up, under its top). desk003 is left out: its centre of mass, 4.2 cm off its axis, rolls it in the hands (about 60 % of its runs succeed).

Files

<payload>/<payload>_s<seed>.npz              the recording (below)
<payload>/<payload>_s<seed>_r1.mp4           robot 1's head camera, RGB, 640 x 352, 6.25 fps
<payload>/<payload>_s<seed>_r1_depth.mkv     robot 1's head camera, depth, the same frames (below)
<payload>/<payload>_s<seed>_r2.mp4           robot 2's head camera, RGB
<payload>/<payload>_s<seed>_r2_depth.mkv     robot 2's head camera, depth
<payload>/<payload>_s<seed>.mp4              overview from a camera following the payload, 1280 x 960, 25 fps (for viewing)
<payload>/<payload>_s<seed>.log              the episode's printout
summary.json                                 per payload: successes and runs

Timing

• The npz has one row per 50 Hz control step (time = row x 0.02 s): the state, then the action taken from it.
• The expert acts at 6.25 Hz: action and action_target change every 8 rows (expert_step = row // 8).
• Head-camera frame k (RGB and depth) is rendered at row 8k (the state of that row).
• Overview frame j is rendered after row 2j's step.

Frames and conventions

• World: z up. The payload starts at the origin with yaw 0. Its +x end carries a blue marker (the blue end).
• Robot 1 stands at the payload's -x end and robot 2 at its +x end, facing each other.
• A robot's heading frame: at its pelvis, rotated by the pelvis' yaw only: x forward, y left, z up.
• All quaternions are w, x, y, z.
• The payload's origin:
  • our box: its centre;
  • our table: the centre of its top;
  • a CORE4D object: on its support, under its centre.

npz fields

Per row (n rows; the leading 2 is robot 1, robot 2):

field	shape
q, dq, tau	(n, 2, 29)	joint position, velocity, actuator torque, in the order of joint_names
gyro, acc	(n, 2, 3)	pelvis IMU angular velocity and linear acceleration (sensor frame)
wrench	(n, 2, 2, 6)	per hand (left, right): force, torque at the hand mount (on wrist_yaw_link, 4.15 cm out), in its frame, as the sensor reads it (the hand's weight included)
robot_wrench	(n, 2, 6)	the robot's wrench (below)
root_pos, root_quat	(n, 2, 3/4)	pelvis pose, world (privileged)
root_linvel, root_angvel	(n, 2, 3)	pelvis velocities, world (privileged)
palm_pos	(n, 2, 2, 3)	palm points (wrist_yaw_link + 8 cm along the hand), world (privileged)
payload_pos, payload_quat	(n, 3/4)	payload pose, world (privileged)
payload_linvel, payload_angvel	(n, 3)	payload velocities, world (privileged)
action	(n, 2, 18)	the action each robot executed (below)
action_target	(n, 2, 18)	the same action's end target in the world (below)
scalebfm_target	(n, 2, 3, 7)	what ScaleBFM tracked at this row: world pose (xyz, wxyz) of pelvis, left and right wrist_yaw_link

robot_wrench = [F (3), tau (3)]: the force and torque the robot's hands apply to the payload, from both hand sensors: the hand's weight removed (from the joint angles and the hand's mass, 0.255 kg), summed about the midpoint o of the two sensors, in the robot's heading frame:

F   = F_L + F_R
tau = r_L x F_L + r_R x F_R + tau_L + tau_R        r_L, r_R: from o to each sensor

While carrying, F_z is half the payload's weight (4.9 N for 1 kg, 12.3 N for 2.5 kg); with empty hands it stays under 1 N.

action is each robot's relative action, computed by the expert from the robot's measured pelvis at the step and executed (ScaleBFM got its targets only from it, through an on-robot converter that uses the robot's own pelvis pose; replaying the recorded actions reproduces an episode exactly):

[dx, dy, dyaw, h, p_L (3), q_L (4), p_R (3), q_R (4)]

• dx, dy (m), dyaw (rad): the pelvis pose the robot should reach 0.16 s later, in its heading frame now.
• h: the pelvis height then (m).
• p_L, p_R: the palm positions then, in the pelvis heading frame (z above h).
• q_L, q_R: the palm orientations then, in the same frame.

action_target is the same step's end target in the world: [x, y, yaw, h, palm_L position (3), palm_L wxyz (4), palm_R position (3), palm_R wxyz (4)] (yaw unwrapped). It equals the measured pelvis pose composed with action, and lets action chunks be relabelled in any frame offline.

Per episode, the reference (per expert step, K rows):

• ref_t, ref_pos, ref_yaw: the payload's planned pose.
• ref_twist: its planned twist, in its own frame.
• ref_h: the pelvis height.
• ref_palm: the world palm height.
• ref_grip: 0 = open, 1 = gripping.
• ref_stand: the robots' extra distance from their grasp positions.
• ref_phase: an index into phases (arms, walk_in, squat, close, lift, carry, lower, open, step_back, stand, hold).
• ref_leg: the planned leg the payload is on.
• ref_bounds: the phase start times.

Metadata:

• Episode: seed, payload (box / table: the grasp), object (the CORE4D name, or empty for our box and table), wbc (scalebfm_ee_posttrain).
• Task: instruction: the text task, the same for both robots. goal: the payload's goal x, y, yaw, world. legs: the planned path, JSON.
• Scene: pedestals (x, y, yaw, top height of the start and goal pedestal; none for tables), payload_mass, box_rib.
• Robot: joint_names, phases.
• Camera: head_camera (on torso_link: position (0.06, 0, 0.45) m, xyz Euler angles, vertical fovy 90 deg), ego_size (352, 640), depth_max (10 m).
• Outcome: success, fell, overlap (the share of the goal's footprint the payload covers), sink (how far the payload sank in the hands while carrying, m), and the end pose error: end_xy m, end_yaw deg, tilt deg, end_z and z_end (the payload's end height and its support's).

Example instruction: "Carry the box 4.4 m backward and 7.7 m to the right, turning it 167 degrees to the left, and put it on the other pedestal with its blue end at the pedestal's blue mark." Forward is towards the payload's blue end, in its frame at the start.

Head camera

• Mount: fixed to torso_link, looking 30 deg below horizontal.

• Lens: pinhole. 90 deg vertical and about 122 deg horizontal field of view, wide so that a centred crop gives a narrower real camera.

• Intrinsics at 640 x 352: fx = fy = 176 px, cx = 320, cy = 176.

• Depth: the same camera and frames as the RGB, uint16 mm along the camera axis (not along the ray), 0 = no return (beyond 10 m, or the sky). Noise-free; add a sensor model in training if needed. Stored as a lossless 16-bit FFV1 video; read it with:

  import subprocess, numpy as np, imageio_ffmpeg
  raw = subprocess.run([imageio_ffmpeg.get_ffmpeg_exe(), "-loglevel", "error", "-i", "box_s712578_r1_depth.mkv",
                        "-f", "rawvideo", "-pix_fmt", "gray16le", "-"], capture_output=True).stdout
  depth_mm = np.frombuffer(raw, np.uint16).reshape(-1, 352, 640)   # (frames, H, W)
  

Simulation

• Engine: MuJoCo, physics at 200 Hz (ScaleBFM's PD gains). The post-trained ScaleBFM runs at 50 Hz on its own G1 model (29 DoF, rubber hands).
• Scene: flat floor, no obstacles. For box-like payloads, a pedestal at the start (violet) and at the goal (green, a blue mark on the end where the payload's blue end goes); for tables, a red goal mark on the floor with a blue end.
• Episode phases: the robots
  1. start 0.25 m back from the payload's ends;
  2. walk in;
  3. squat in place and grasp;
  4. stand up lifting it;
  5. carry it;
  6. squat to put it down;
  7. let go, step back and stand up.