Sit on the chair

humanoidbench-sit-simplehumanoidbenchUnitree H1 humanoid with two Shadow handsManipulationmedium

Reference solution, 787 of 1,000 steps.

Instruction

You are the policy of a Unitree H1 humanoid robot (about 1.8 m tall, 5-joint legs, 4-joint arms) with a Shadow dexterous hand on each arm, simulated in MuJoCo by HumanoidBench (the h1hand robot). The robot is free-standing: it must keep its balance and it can fall. A walking controller keeps it balanced for you: it is Unitree's pretrained H1 locomotion policy, which drives the legs from a velocity command and steps in place when the command is zero. World frame in metres, +z up, the floor at z = 0; heading_deg is the robot's facing direction (0 = +x, counter-clockwise positive). The robot starts at the origin facing +x. Simulated time advances only when you act; the scene is paused while you think.

Task

Sit down on the chair behind you and stay seated, upright and still. The chair (scene.chair: its position is the centre of its footprint on the floor) has a 0.42 x 0.42 m seat 0.475 m high and a backrest on its -x side; its seat centre is 0.25 m behind the robot's start position. HumanoidBench's sit reward is the product of: small control, not moving, upright (torso within about 18 degrees of vertical), a seated posture (head 0.35-0.45 m above the torso's IMU, which holds whenever the torso is upright) and 0.5 x sitting (pelvis 0.68-0.72 m above the floor) + 0.5 x on the chair (pelvis x within 0.19 m of the chair's x, and pelvis y at the chair's y: the term falls to 0.1 at 0.1 m sideways).

Success: HumanoidBench scores every 20 ms step with the task's reward (at most about 1 per step for this task; the terms are in progress.reward_terms) and counts the task as solved when the episode return reaches its success bar of 750. The episode ends as solved the moment progress.return reaches 750; calling robo done earlier scores 0. If the robot falls (HumanoidBench's termination: pelvis below 0.5 m), the episode can no longer succeed.

Controls. robo act FORWARD LEFT TURN LDX LDY LDZ RDX RDY RDZ [--repeat N] applies one 20 ms control step N times (N <= 50). FORWARD in [-1, 1] m/s and LEFT in [-0.5, 0.5] m/s are the walking velocity in the robot's heading frame, TURN in [-1, 1] rad/s the turn rate (+ = counter-clockwise). The robot reaches a new velocity within about half a second; at FORWARD 1 it walks at about 0.9 m/s, and the walking policy treats sideways-plus-forward speeds below about 0.2 m/s as zero. An all-zero FORWARD LEFT TURN holds the robot's current spot and heading: it keeps stepping in place and walks back when it drifts more than about 4 cm. LDX LDY LDZ and RDX RDY RDZ in [-1, 1] move the goal point of the left and right hand by 2 cm per step in the heading frame (x forward, y left, z up, origin on the floor under the pelvis); inverse kinematics on the 4 arm joints makes the hand follow its goal, so the hands move with the body when it walks. Zero holds the goal. The arms are about 0.64 m long from the shoulder (at about 1.48 m height, 0.2 m to each side of the pelvis), so a hand reaches about 0.55 m ahead of the pelvis at 1 m height; the fingers and wrists hold their start pose. Skills (robo info lists their arguments): walk_to X Y [HEADING_DEG] [TOL] walks to a floor point (it does not avoid obstacles), walk FORWARD LEFT TURN STEPS holds a velocity command, turn_to HEADING_DEG, stand STEPS holds the spot, reach left|right X Y Z [TOL] moves a hand to a world point and keeps it there while the body sways, hands_home, and sit_down (one-way: stops the walking controller and sits down where the robot stands, the pelvis ending about 0.2 m further back).

Observation. robo observe reports robot (pelvis position, heading_deg, head_height, torso_upright (1 = upright), com_velocity (world x, y) and com_velocity_body (forward, left), the current velocity command, and per hand pos (world), pos_body and goal_body (heading frame) and anchored_at (the world point a reach holds), fallen), scene (the task's objects and goals) and progress: HumanoidBench's return so far, last_reward and its reward_terms, steps of episode_steps, the success_bar for return-based tasks and solved. Camera images: robo observe --image (HumanoidBench's view for the task, following the robot).

The step budget is 1000 steps (20 s of simulated time), HumanoidBench's episode length for this task.

How the robot is controlled and scored

You are controlling a simulated robot. Read the task below, then solve it by running the robo command in your shell (start with robo info and robo observe). Keep going until the task is done, then call robo done once. Do not stop to ask questions; there is no human to answer.

How to control the robot

You are the robot's policy. You act only through the robo command in your shell. There is no other way to move the robot, and you cannot read or change the simulator, the scoring, or other files to succeed; the episode server judges the final physical state itself.

robo info                          # the robot, its sensors, action groups, skills and step budget
robo observe                       # robot and scene state as numbers
robo observe --image [--camera C]  # also saves a camera image and prints its path (open it to look)
robo act V1 V2 ... [--repeat N]    # one low-level action (the action groups under Controls), applied N times (N <= 50)
robo skill NAME ARG ...            # run a skill listed by `robo info`; it runs until it finishes and reports the result
robo done "short summary"          # end the episode and ask for scoring
robo give-up "reason"              # end the episode without claiming success

Positions are in metres in the world frame (+z up); angles are in degrees unless a field says otherwise.
The episode has a fixed step budget (see robo info); every simulated control step counts, including the steps a skill runs.
Skills are ordinary controllers: they can fail, stop early or be blocked by the scene. Read what they report and re-observe.
The episode ends as solved the moment the task's success rule holds (see Success); robo done before that scores 0.
Call robo done exactly once when finished.

Run this task

bench eval run \
  -d carlosferrazza/humanoid-bench@0.1 \
  --registry https://robouse.ai/hub/registry.json \
  --agent oracle \
  --include humanoidbench-sit-simple

Embodiment

Unitree H1 humanoid with two Shadow hands

Humanoid, hand · HumanoidBench (MuJoCo 3.1.6)

Action · 9 numbers per step

FORWARDFORWARD1LEFTLEFT1TURNTURN1LDXLDX1LDYLDY1LDZLDZ1RDXRDX1RDYRDY1RDZRDZ1

base.velocity (base_twist, m/s, m/s, rad/s): velocity command for the H1 walking controller (heading frame; TURN + = counter-clockwise); zero = step in place | left.hand_delta (ee_delta_pos, x 2 cm per step): moves the left hand's goal point (heading frame: x forward, y left, z up); zero holds it | right.hand_delta (ee_delta_pos, x 2 cm per step): moves the right hand's goal point (heading frame); zero holds it. One step = 20 ms.

Skills

walk-to X Y [HEADING-DEG=999.0] [TOL=0.1]: walk to the floor point (X, Y) (world frame): turn toward it in place, walk, slow down near it and turn to HEADING-DEG; stops when there, when blocked (under 3 cm of progress in 60 steps) or if the robot falls, and reports which. It does not avoid obstacles (at most 600 steps per call)walk FORWARD [LEFT=0.0] [TURN=0.0] [STEPS=50]: hold one velocity command (heading frame) for STEPS steps; the same as `robo act FORWARD LEFT TURN 0 0 0 0 0 0` repeated (at most 1000 steps per call)turn-to HEADING-DEG [TOL=5.0]: turn in place to a world heading (0 = +x, counter-clockwise positive) (at most 300 steps per call)stand [STEPS=50]: zero velocity command (step in place, balanced) for STEPS steps (at most 1000 steps per call)reach SIDE=left|right X Y Z [TOL=0.03]: move one hand in a straight line to the world point (X, Y, Z) while the robot steps in place; stops when there, when blocked or at the edge of the arm's reach, and reports which. Afterwards the hand keeps holding that world point (compensating the body's sway) until the next command for that hand (at most 150 steps per call)hands-home: both hands back to their start positions (relative to the body) (at most 150 steps per call)sit-down: sit down where the robot stands: the walking controller stops, the feet come together and the hips and knees bend to about 90 degrees in 0.6 s, lowering the pelvis about 0.3 m and moving it about 0.2 m backwards (onto a seat behind the robot, if there is one; otherwise the robot falls). One-way: afterwards FORWARD, LEFT and TURN have no effect. The skill returns after 60 steps (at most 60 steps per call)

Observation

State: positions of the robot and objects

robotscenetime_sprogress

Camera

cam_default

Budget and scoring

1,000 stepsends when first reached

In datasets

carlosferrazza/humanoid-bench

Pinned to robohub commit bcd0d002b9df. The verifier and the reference solution are not published.

No trials yet.