espejelomar/go2-air-controlbench-v1

Go2 Air ControlBench v1 Public Preview

Go2 Air ControlBench is a compact command-to-outcome benchmark for a stock Unitree Go2 Air. It asks a narrow question that matters for robot planners and world-model scorers:

If we command the robot to move, what actually happens, and which candidate command should a planner have selected?

The release is deliberately small and claim-bounded. It is not an imitation-learning corpus and not mocap-grade ground truth. It is a public-safe benchmark preview with derived tables, baseline models, figures, DecisionTrace examples, and compact Parquet previews.

Companion dataset: need camera frames for visual world-model training? See worldforge-go2-dimos-replay-world-pairs, which provides robot-POV image pairs (images, no commands). ControlBench provides the measured command-to-outcome side (commands, no images). Together they cover both halves of the WorldForge score workflow.

Why This Exists

Large robot datasets such as Open X-Embodiment / RT-X and DROID focus heavily on demonstration-scale robot learning, especially manipulation. LeRobotDataset v3 standardizes robot trajectory storage with Parquet, MP4 shards, and metadata (docs, blog). This dataset is different: it is a controlled command-selection benchmark for a commodity quadruped.

The benchmark shape is:

candidate command -> predicted outcome -> selected command -> measured outcome -> regret

That is the bridge to DecisionTrace and WorldForge: not just “what did the robot do,” but “why was this action selected over alternatives, and was that choice correct under measured outcomes?”

What Is Included

Stable public-preview tables:

• tables/all_trials_normalized.csv: original 116 normalized trial-level rows.
• tables/command_group_stats.csv: grouped native-odom outcomes for the original preview.
• tables/baseline_model_report.json: naive, affine, and deadband-affine baselines.
• tables/release04_trial_aruco_join.csv: bounded ArUco reference join for Release04.
• tables/release04_aruco_metrics.json: external-reference quality metrics.

Release05 expansion:

• tables/release05_second_surface_trials.csv: 115 second-surface derived trial rows.
• tables/release05_second_surface_trials_normalized.csv: normalized Release05 table.
• tables/release05_second_surface_group_stats.csv: Release05 grouped outcomes.
• tables/release05_baseline_model_report.json: Release05-only baselines.
• tables/all_trials_plus_release05_normalized.csv: combined 231-trial table.
• tables/combined_baseline_model_report.json: combined baseline report.
• tables/inverse_command_benchmark.csv: target-motion command-selection benchmark rows.
• tables/inverse_command_benchmark_summary.json: regret, hit-rate, and rank-correlation summary.

Evidence and demos:

• decision_traces/: DecisionTrace v1 examples (including positive measured regret), the JSON Schema, and a dependency-free reference validator/builder (decision_trace.py).
• decision_traces/decision_trace.v1.schema.json: JSON Schema (Draft 2020-12) for the DecisionTrace v1 format.
• figures/: SVG figures for the dataset card and report.
• lerobot_v3_native_rate/: a genuine, loadable LeRobot v3.0 dataset (native-rate yaw stream, 36 episodes / 900 frames). Loads directly with LeRobotDataset.
• lerobot_v3_native_rate_full/: the full multi-release loadable LeRobot v3.0 dataset (release03 + release04 + release05, 231 episodes / 10,562 frames). Loads directly with LeRobotDataset.
• lerobot_v3_preview/: compact Parquet previews plus metadata for the Hugging Face viewer and load_dataset(...).
• metadata/croissant_metadata.json: Croissant-style metadata draft.
• scripts/: validation and baseline scripts.
• paper/: short paper and Release05 addendum.

Raw overhead MP4 video, unredacted raw robot logs, IP addresses, serial numbers, and private-room captures are intentionally excluded from this public package.

Figures

Key Metrics

Original public preview:

• Total trials: 116
• Motion trials: 106
• Forward/backward trials: 50
• Yaw trials: 56
• Native-rate yaw preview: 1,118 ROBOTODOM rows at about 18.7 Hz
• Release04 ArUco pre+post coverage: 35/59 trials

Release05 expansion:

• Clean second-surface trials: 115
• Native ROBOTODOM messages in clean local runs: 5,160
• Native ULIDAR_ARRAY messages in clean local runs: 2,121
• Saved local LiDAR sidecars: 510
• Public Release05 rows are derived tables only; raw logs stay local/private until a separate raw-data release passes review.

Combined preview:

• Combined normalized trials: 231
• Translation command trials: 108
• Yaw command trials: 106

Baseline Results

Original public-preview RMSE:

Task	Naive	Affine	Deadband-affine
Signed planar translation	0.0444 m	0.0313 m	0.0296 m
Yaw	0.141 rad	0.0166 rad	0.00995 rad

Release05-only RMSE:

Task	Naive	Affine	Deadband-affine
Signed planar translation	0.0612 m	0.0316 m	0.0225 m
Yaw	0.122 rad	0.0191 rad	0.00926 rad

Combined public-preview + Release05 RMSE:

Task	Naive	Affine	Deadband-affine
Signed planar translation	0.0540 m	0.0399 m	0.0349 m
Yaw	0.132 rad	0.0179 rad	0.0102 rad

The central finding is stable: a deadband-aware baseline is required before making learned-planning or world-model claims.

Inverse-Command Benchmark

The inverse-command benchmark asks:

Given a target displacement or yaw, which command should a planner select from the observed candidate set?

Each baseline predicts the outcome for every candidate command, selects the command closest to the target, and is scored against the empirically measured best command. This is an in-sample candidate-selection diagnostic, not a held-out learned-policy result.

Release05 mean measured regret:

Task	Naive	Affine	Deadband-affine
Translation	0.0243 m	0.00712 m	0.00607 m
Yaw	0.0153 rad	0.00231 rad	0.00143 rad

Combined preview + Release05 mean measured regret:

Task	Naive	Affine	Deadband-affine
Translation	0.0159 m	0.00776 m	0.00638 m
Yaw	0.0116 rad	0.00509 rad	0.00513 rad

Files:

• tables/inverse_command_benchmark.csv: per-target selected command, measured-best command, regret, and Spearman rank correlation.
• tables/inverse_command_benchmark_summary.csv: summary by dataset, task, and model.
• decision_traces/decision_trace_inverse_command_combined_positive_regret.json: DecisionTrace example generated from the inverse-command benchmark.
• scripts/scripts_inverse_command_benchmark.py: reproducible benchmark builder.

Held-Out Evaluation Protocol

The baseline and inverse-command results above are in-sample diagnostics. To report a comparable result without collecting new robot time, use the built-in split between the original preview and the Release05 second-surface expansion as a held-out generalization check:

1. Fit / calibrate on the original 116-trial preview (tables/all_trials_normalized.csv).
2. Evaluate on the 115 Release05 second-surface trials (tables/release05_second_surface_trials_normalized.csv), captured on a different surface and unseen at fit time.
3. Report translation RMSE, yaw RMSE, and mean measured regret on the held-out Release05 trials.

Because the two splits were captured on different surfaces, this turns the in-sample diagnostic into a surface-transfer test, so results from different models are directly comparable. The combined 231-trial table remains available for calibration baselines.

Load It

import pandas as pd

trials = pd.read_csv("tables/all_trials_normalized.csv")
release05 = pd.read_csv("tables/release05_second_surface_trials_normalized.csv")
combined = pd.read_csv("tables/all_trials_plus_release05_normalized.csv")

From the Hub:

from datasets import load_dataset

trial_level = load_dataset(
    "espejelomar/go2-air-controlbench-v1",
    "trial_level_preview",
    split="train",
)

release05 = load_dataset(
    "espejelomar/go2-air-controlbench-v1",
    "release05_trial_level_preview",
    split="train",
)

combined = load_dataset(
    "espejelomar/go2-air-controlbench-v1",
    "combined_trial_table",
    split="train",
)

inverse = load_dataset(
    "espejelomar/go2-air-controlbench-v1",
    "inverse_command_benchmark",
    split="train",
)

Native-rate LeRobot v3 dataset

lerobot_v3_native_rate/ is a genuine, loadable LeRobot v3.0 dataset built from the release04_yaw_deadband_fast native odometry stream: 36 trial episodes, 900 frames at the native ROBOTODOM rate (~18.7 Hz, stored at fps=19). Each frame carries the commanded action (cmd_x, cmd_y, cmd_z, cmd_duration_s), the measured observation.state (odom_x, odom_y, odom_z, odom_yaw), and obs_time_s (the real relative timestamp before LeRobot regularizes it). It loads directly with LeRobot tooling:

from huggingface_hub import snapshot_download
from lerobot.datasets.lerobot_dataset import LeRobotDataset

root = snapshot_download(
    "espejelomar/go2-air-controlbench-v1",
    repo_type="dataset",
    allow_patterns="lerobot_v3_native_rate/*",
)
ds = LeRobotDataset(
    "espejelomar/go2-air-controlbench-v1",
    root=f"{root}/lerobot_v3_native_rate",
)
ds.num_episodes  # 36
ds.num_frames    # 900
ds[0]["action"], ds[0]["observation.state"], ds[0]["task"]

Full multi-release native-rate LeRobot v3 dataset

lerobot_v3_native_rate_full/ is the full-coverage sibling of the yaw-only export above. It spans every release (release03 + release04 + release05) at the native odometry rate: 231 episodes (one per trial) and 10,562 frames at fps=19. Each frame carries the commanded action (cmd_x, cmd_y, cmd_z, cmd_duration_s), the measured observation.state (odom_x, odom_y, odom_z, odom_yaw), and obs_time_s. Every episode's task is its trial label, so the 231 trials are individually addressable. Frames are derived from the released per-trial telemetry (numeric odometry + commands), not raw logs.

from huggingface_hub import snapshot_download
from lerobot.datasets.lerobot_dataset import LeRobotDataset

root = snapshot_download(
    "espejelomar/go2-air-controlbench-v1",
    repo_type="dataset",
    allow_patterns="lerobot_v3_native_rate_full/*",
)
ds = LeRobotDataset(
    "espejelomar/go2-air-controlbench-v1",
    root=f"{root}/lerobot_v3_native_rate_full",
)
ds.num_episodes  # 231
ds.num_frames    # 10562
ds[0]["action"], ds[0]["observation.state"], ds[0]["task"]

The Parquet files under lerobot_v3_preview/ remain a compact, viewer-friendly slice of the trial-level and native-rate tables for the Hugging Face dataset viewer and load_dataset(...); the two loadable LeRobot datasets above are the canonical native-rate exports (lerobot_v3_native_rate/ for the yaw slice, lerobot_v3_native_rate_full/ for all releases). Neither LeRobot folder is a Hugging Face Dataset Viewer config: load them with LeRobotDataset (or snapshot_download(..., allow_patterns="lerobot_v3_native_rate_full/*")), while the five load_dataset configs listed above are what the viewer exposes.

DecisionTrace v1

DecisionTrace is a portable, provider-neutral record of a single embodied decision: what was observed, the goal, the candidate actions considered, how they were scored, which one was selected, the predicted outcome, the measured outcome, and the reproducibility metadata needed to trust the record. It is meant to be the on-disk artifact of a bounded decision loop (for example WorldForge), so a run can be audited after the fact: why was this action selected over the alternatives, and was that choice correct under measured outcomes?

All example traces in decision_traces/ use schema_version: decision_trace.v1 (the earlier decision_trace.v1-draft value is still accepted for backward compatibility).

Required fields:

• schema_version, trace_id
• observation, goal (with a non-empty type)
• candidate_actions (each with a unique candidate_id and a typed action)
• scores (each with candidate_id + score_kind)
• selected_action (a candidate_id that must exist in candidate_actions)
• predicted_outcome
• measured_or_analytic_outcome (with a non-empty outcome_kind)
• reproducibility

Optional fields: counterfactuals, regret, claim_boundaries.

Schema and reference implementation

• decision_traces/decision_trace.v1.schema.json — JSON Schema (Draft 2020-12).
• decision_traces/decision_trace.py — dependency-free reference implementation: builder helpers (candidate, score, build_trace) plus validate(), which runs structural and cross-field semantic checks (unique candidate ids, selected_action/scores reference real candidates, finite numbers). It uses jsonschema for full schema validation when installed and falls back to a built-in structural check otherwise.

Validate every shipped trace:

python decision_traces/decision_trace.py validate

Build a valid trace in code:

from decision_traces.decision_trace import build_trace, candidate, score

trace = build_trace(
    trace_id="my-run-0001",
    observation={"source": "my_capture", "robot_type": "unitree_go2_air"},
    goal={"type": "target_signed_planar_motion", "target_m": 0.2},
    candidate_actions=[
        candidate("forward_025", "unitree.sport.Move",
                  {"x": 0.25, "y": 0.0, "z": 0.0, "duration_s": 0.6}),
    ],
    scores=[score("forward_025", "deadband_affine_baseline", -0.037)],
    selected_action="forward_025",
    predicted_outcome={"signed_planar_m": 0.163},
    measured_or_analytic_outcome={"outcome_kind": "real_measured_native_odom",
                                  "signed_planar_m": 0.192},
    reproducibility={"hardware_executed": True, "learned_model_used": False},
)  # raises ValueError if the trace is invalid

The strongest trace for demos is decision_traces/decision_trace_candidate_forward_target_025_positive_regret.json: the deadband-affine baseline selects a command that is not the measured-best command, yielding positive measured regret. The richest one is decision_traces/decision_trace_inverse_command_combined_positive_regret.json, generated by scripts/scripts_inverse_command_benchmark.py from the combined 231-trial table (14 candidates, full counterfactuals, positive regret).

Claim Boundary

Use:

A compact command-to-outcome benchmark preview for a stock Go2 Air, with native odometry outcomes, LiDAR metadata summaries, bounded ArUco reference tables, baseline models, second-surface derived results, and DecisionTrace examples.

Do not claim:

• mocap-grade ground truth,
• first external-GT quadruped dataset,
• world-model state of the art,
• raw multi-release sensor logs (the native-rate LeRobot exports are derived from per-trial odometry/command telemetry, not raw LiDAR/camera logs, which remain local pending review),
• mocap-grade odometry (the native-rate exports use onboard Go2 odometry, not external ground truth),
• generalization across all surfaces.

Release05 is native Go2 odometry/LiDAR only. The ArUco reference belongs to the earlier Release04 subset and remains bounded: most usable rows use a 3-marker affine fallback, marker-center measurements are approximate, and robot-marker height/parallax is not corrected in this preview.

Data Dictionary

tables/all_trials_normalized.csv, tables/release05_second_surface_trials_normalized.csv, and tables/all_trials_plus_release05_normalized.csv share the normalized columns:

Column	Unit / Type	Meaning
release	string	Capture/release group.
trial_index	integer	Trial index within the source run.
suite	string	Sub-suite label.
name	string	Human-readable command group name.
rep	integer/string	Repetition index.
cmd_x	m/s	Commanded forward/backward velocity.
cmd_y	m/s	Commanded lateral velocity.
cmd_z	rad/s	Commanded yaw velocity.
duration_s	s	Command duration.
cmd_integral_x_m	m	Naive cmd_x * duration_s.
cmd_integral_y_m	m	Naive cmd_y * duration_s.
cmd_integral_yaw_rad	rad	Naive cmd_z * duration_s.
odom_dx_m, odom_dy_m	m	Native odometry displacement components.
odom_planar_m	m	Native odometry planar displacement magnitude.
odom_dyaw_rad, odom_dyaw_deg	rad, deg	Native odometry yaw delta.
pre_x, pre_y, pre_yaw	m, m, rad	Native odometry before command.
post_x, post_y, post_yaw	m, m, rad	Native odometry after command.
hardware_executed	boolean	Whether a motion command was sent to hardware.
outcome_kind	string	Outcome source label.

Validate

uv run --with pyarrow python scripts/scripts_validate_public_preview.py --root .

License

• Data: CC-BY-4.0.
• Scripts: Apache-2.0.

See LICENSE.md for license text and scope notes. Public releases should still receive human privacy review before upload.