podolinsky/gr00t-N1.7-libero-x-features

GR00T-N1.7 LIBERO-X backbone features — 90-task fine-tune (LEVEL1-3)

Aligned rollouts of a LIBERO-X fine-tune of GR00T-N1.7 (rohansiva/gr00t-libero-x-90task) on the LIBERO-X simulator, over the exact 90 tasks that checkpoint was fine-tuned on (30 tasks × 3 difficulty levels, LEVEL1–LEVEL3). Train and eval task sets are identical by design, so this is an in-distribution dataset for the checkpoint.

90 tasks × 20 rollouts = 1,800 episodes (600 per level). Every GR00T inference, executed action, and video frame in an episode is joinable by array row.

This is the LIBERO-X counterpart of podolinsky/gr00t-n1.7-libero-10-features — same layer-16 backbone feature schema, same alignment contract — but on a fine-tuned checkpoint and a harder, distribution-shifted benchmark. The two differ in a few protocol details (no settle steps, native LIBERO-X image / gripper convention, max_steps = 1200) — see Provenance and Alignment contract below.

Benchmarks & model

• LIBERO — Liu et al., Benchmarking Knowledge Transfer for Lifelong Robot Learning, arXiv:2306.03310
• LIBERO-X — Wang et al., LIBERO-X: Robustness Litmus for Vision-Language-Action Models, RSS 2026, arXiv:2602.06556. Dataset: meituan/LIBERO-X. LIBERO-X extends LIBERO with new objects / textures, new goal predicates (ExactIn, UprightOn, SideOn), reworded instructions, and 5 progressively harder distribution-shift levels.
• GR00T N1 — NVIDIA, An Open Foundation Model for Generalist Humanoid Robots, arXiv:2503.14734. Base checkpoint: nvidia/GR00T-N1.7-LIBERO (libero_10); VLM backbone nvidia/Cosmos-Reason2-2B. Fine-tune: rohansiva/gr00t-libero-x-90task — 20 epochs on the meituan/LIBERO-X dataset (625 demos, 208,964 frames), the VLM backbone frozen, projector I/O + VL self-attention + the diffusion action head trained.

Tasks

The checkpoint card gives its 90 fine-tune tasks only as natural-language descriptions. They were resolved to LIBERO-X BDDL files by matching each against the parsed BDDL language field (all 90 matched exactly). The task lists are in scripts/libero-x/finetune_tasks/ of the collecting repo; 40 distinct scenes (KITCHEN_SCENE*, STUDY_SCENE*, LIVING_ROOM_SCENE*) across the 90.

Success rates

replan_steps = 25 requested but GR00T's action horizon is 16, so 16 actions executed per inference (open-loop). max_steps = 1200, seed 7, single RTX 4090. Success = the LIBERO-X BDDL goal predicate; a failed episode runs to the 1200-step cap.

level	success rate	episodes	notes
LEVEL1	61.0% (366/600)	600	mildest shift
LEVEL2	42.5% (255/600)	600
LEVEL3	8.8% (53/600)	600	compound / multi-predicate tasks
all	37.4% (674/1800)	1800

These match this checkpoint's zero-shot eval-harness numbers (scripts/libero-x/run_eval.py) within a point per level. All 1,126 failures ran to the 1200-step cap; the 674 successes finished early (1–~1000 steps). LEVEL3 is low because its tasks are genuinely hard (e.g. "place the largest bowl in the left side of the drainer and the medium bowl in the right side"), even for a checkpoint trained on them.

summary.json has the machine-readable per-level / per-task breakdown.

Which GR00T features

GR00T-N1.7 runs a prefix forward pass through its Cosmos-Reason2-2B backbone (Qwen3-VL: a SigLIP-style vision encoder + a Qwen3-2B language model) over the image and language tokens; those hidden states condition the flow-matching action head. Here the layer-16 residual stream (config.select_layer = 16, of the backbone's 28 LM layers — a mid-stack representation) is captured once per policy inference (every 16 control steps), raw and per-token (no pooling), as float16, then split by token type:

key	shape	tokens
base_image	(64, 2048)	agentview RGB, 256×256 → 16×16 patches → 2×2 spatial merge → 8×8
wrist_image	(64, 2048)	eye-in-hand RGB, same
language	(200, 2048)	instruction tokens (after the last <|vision_end|>, before <|im_end|>), zero-padded to 200
language_mask	(200,) bool	real vs padding for language
language_len	() int32	real instruction token count (4–22 here; constant within an episode)
state_features	(1536,)	the action head's embedded proprioceptive vector

2048 is the Qwen3-2B hidden width. These are the frozen-backbone representation before the action head's LayerNorm + VL self-attention — the input to any perception / failure probe. Because the fine-tune froze the backbone, base_image / wrist_image / language for this dataset are the same function of the observation as in podolinsky/gr00t-n1.7-libero-10-features; state_features and the action chunks come from the fine-tuned action head.

Layout

<LEVEL>/<NN>_<task_stem>/ep<NNN>/
    rollout.json    metadata + per-policy / per-control clock records
    rollout.npz     the arrays below
    rollout.mp4     agentview video, 20 fps, one frame per control step
    wrist.mp4       eye-in-hand video, same timing
manifest.csv        one row per episode
summary.json        per-level / per-task success rate + failure-category counts

<LEVEL> is LEVEL1 / LEVEL2 / LEVEL3; <NN> is the 0-indexed position of the task in that level's fine-tune list. ep000–ep019 — episodes ep010– ep019 reuse the 10 released initial states (ep000–ep009) with a different env.seed, so their trajectories still differ (the diffusion action head and env seed are both stochastic).

Modalities & size

video	rollout.mp4 (agentview) + wrist.mp4 (eye-in-hand) — H.264, 256×256, yuv420p, 20 fps, one frame per control step (1–1200 frames/episode; no settle steps). Vertical-flipped to a human-upright view (LIBERO-X native convention). 3,600 clips, ~0.7 GiB.
arrays (.npz)	per-inference backbone features + action chunks + per-control-step clocks — see below. 1,800 files, avg 24 MiB (7–35 MiB), ≈42 GiB total, dominated by the fp16 feature tensors.
tabular (.csv)	manifest.csv — one row per episode (level, task_index, task, prompt, success, n_policy, n_control, sim_failure_category, failing_predicate, has_features, dir, …).
metadata (.json)	rollout.json per episode (≈77 MiB total); summary.json.

1,800 episodes, ≈44 GiB total. 101,525 policy inferences, 1,619,555 control steps in aggregate.

rollout.npz

Same schema as podolinsky/gr00t-n1.7-libero-10-features (one loader reads both).

Features (present on every episode; has_features scalar is True): base_image, wrist_image, language, language_mask, language_len, state_features — each stacked over the n_policy inferences.

Actions: predicted_action_chunks (n_policy, 16, 7) — the raw GR00T output (delta-EEF x,y,z,roll,pitch,yaw,gripper); predicted_chunk_len (all 16); executed_actions (n_control, 7) — the action actually sent to the simulator.

Clocks, per control step (n_control,): control_step, sim_step, policy_step (which inference produced this step), chunk_index (position within that predicted chunk, 0..15), video_frame_id (== control_step).

Scalars: success, replan_steps (25), n_policy, n_control, img_tokens (64), hidden (2048), control_hz (20), has_features.

Alignment contract

policy_step ids are sequential; each policy_step maps to a contiguous block of control steps; chunk_index runs 0,1,… within a block; video frame t is control step t.

sim_step == control_step for every row — this dataset uses LIBERO-X's --load-mode init protocol (env.regenerate_obs_from_state, no num_steps_wait settle steps), unlike the libero-10 dataset where sim_step carries a +10 settle offset.

The executed action is the decoded chunk row:

executed_actions[t] == decode(predicted_action_chunks[policy_step[t], chunk_index[t]])

where decode applies the native LIBERO-X gripper convention — g → sign(g) on dim 6, dims 0–5 (pose delta) unchanged. So executed_actions[:, :6] equals the raw chunk rows exactly; only the gripper column differs (its sign). (The libero-10 dataset uses NVIDIA's g → 2g−1 → sign → − instead — that fine-tune was trained on the raw meituan/LIBERO-X demos.)

Every episode passed this check plus a reload gate at collection time (0 alignment-gate failures, 0 errors across 1,800 episodes).

Provenance

Collected with scripts/libero-x/collect.py in the 12-Visual-Occlusion-Reasoning project against a local GR00T policy server (openpi-style msgpack websocket wrapping gr00t.policy.Gr00tPolicy, embodiment LIBERO_PANDA, --with-features). Observations follow the native LIBERO-X convention: vertical-flipped 256px agentview + wrist images, 8-dim [eef_pos, axis-angle, gripper_qpos] state. replan_steps = 25 (16 executed), num_steps_wait = 10 (budget only — no settle steps executed), seed 7, env_resolution = 256 (the GR00T processor resizes internally), num_inference_timesteps = 4 (flow-matching), max_steps = 1200, horizon = max_steps + num_steps_wait + 1.