podolinsky/groot-libero-10-features-v3

GR00T-N1.7 LIBERO-10 — backbone features + K=10 action samples

Aligned rollouts of the stock NVIDIA GR00T-N1.7-LIBERO (libero_10 checkpoint) policy on LIBERO libero_10, in two matched scene variants (normal and the LIBERO-Occ occluded suite), with K = 10 action chunks sampled at every policy inference. Sample 0 is the chunk the robot executes; the other 9 are drawn from the same observation and never executed. This is what sampling-based failure detectors such as STAC need, alongside the per-token backbone features used by representation probes (e.g. SAFE).

10 tasks × 2 variants × 25 initial states = 500 episodes, all with features and all 10 samples.

This is a separate run of the same 500 initial states (seed 7) as podolinsky/gr00t-n1.7-libero-10-features, which has one chunk per inference plus Gemini labels. GR00T's flow-matching head is stochastic, so outcomes differ between the two runs: 412 of 500 episodes have the same success label. The Gemini labels here (see Labels) come from that new run, with a newer prompt and a finer failure taxonomy than v1.

Benchmarks & model

• LIBERO — Liu et al., arXiv:2306.03310
• LIBERO-Occ — Li et al., arXiv:2606.10862
• GR00T N1 — NVIDIA, arXiv:2503.14734. Checkpoint nvidia/GR00T-N1.7-LIBERO (libero_10), VLM backbone nvidia/Cosmos-Reason2-2B.
• STAC — Agia et al., Unpacking Failure Modes of Generative Policies: Runtime Monitoring of Consistency and Progress, arXiv:2410.04640

Success rates

replan_steps = 8 (GR00T predicts a 16-step chunk, 8 are executed per inference), max_steps = 520, seed 7. Success = the LIBERO BDDL goal predicate; every failure is unsatisfied_goal and runs to the 520-step cap.

#	LIBERO-10 task	normal	occluded	Δ
0	KITCHEN_SCENE3 turn on the stove and put the moka pot on it	100%	44%	−56
1	KITCHEN_SCENE4 put the black bowl in the bottom drawer of the cabinet and close it	88%	36%	−52
2	KITCHEN_SCENE6 put the yellow and white mug in the microwave and close it	68%	20%	−48
3	KITCHEN_SCENE8 put both moka pots on the stove	60%	0%	−60
4	LIVING_ROOM_SCENE1 put both the alphabet soup and the cream cheese box in the basket	100%	80%	−20
5	LIVING_ROOM_SCENE2 put both the alphabet soup and the tomato sauce in the basket	92%	88%	−4
6	LIVING_ROOM_SCENE2 put both the cream cheese box and the butter in the basket	100%	32%	−68
7	LIVING_ROOM_SCENE5 put the white mug on the left plate and put the yellow and white mug on the right plate	80%	40%	−40
8	LIVING_ROOM_SCENE6 put the white mug on the plate and put the chocolate pudding to the right of the plate	92%	28%	−64
9	STUDY_SCENE1 pick up the book and place it in the back compartment of the caddy	100%	76%	−24
	all 10 (250 paired episodes)	88.0% (220/250)	44.4% (111/250)	−43.6

115 of the 139 occluded failures are occlusion-only (the matched normal episode from the same initial state succeeds).

Layout

<scene_variant>/<NN>_<task_stem>/ep<NNN>/
    rollout.json    metadata + per-policy 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
    labels.json     Gemini video description + failure localization (see Labels)
    labels.npz      the same phrases / failure fields as aligned arrays
    example.md      human-readable render of labels.json
manifest.csv                  one row per episode
EXAMPLES.md                   all per-episode example.md cards in one file
failure_overview.png          failure-mode share + onset time (see Failure statistics)
FAILURE_ACTION_SUMMARIES.md   one row per failure: reason / recovery / prevention summaries
gemini_prompts.md             verbatim Gemini prompt templates (+ gemini_prompts.json)

<NN> is the 1-indexed task id; <scene_variant> is normal or occluded. 500 episodes, ≈9.3 GiB (npz 9.2 GiB, 7.8–29.1 MiB each; videos 0.1 GiB); 21,934 policy inferences, 174,358 control steps.

rollout.npz

Action samples (the addition over the v1 dataset):

key	shape
sampled_action_chunks	(n_policy, 10, 16, 7) float32	all K = 10 raw chunks per inference, same observation
predicted_action_chunks	(n_policy, 16, 7) float32	the executed chunk, == sampled_action_chunks[:, 0]
num_action_samples	()	10
executed_sample_index	()	0

Chunks are the raw GR00T output (delta-EEF x,y,z,roll,pitch,yaw,gripper). The first replan_steps = 8 rows of sample 0 are executed.

Features, captured from the inference that produced sample 0 — the layer-16 residual stream of the Cosmos-Reason2-2B backbone (select_layer = 16 of 28), raw per-token, float16, stacked over the n_policy inferences:

key	shape	tokens
base_image	(n_policy, 64, 2048)	agentview, 8×8 after 2×2 merge
wrist_image	(n_policy, 64, 2048)	eye-in-hand, same
language	(n_policy, 200, 2048)	instruction tokens, zero-padded to 200
language_mask	(n_policy, 200) bool	real vs padding
language_len	(n_policy,) int32	real instruction token count
state_features	(n_policy, 1536)	the action head's embedded proprioceptive vector

Executed actions and clocks, per control step (n_control,): executed_actions (n_control, 7), control_step, sim_step (includes the num_steps_wait = 10 settle steps, not in the video), policy_step, chunk_index, video_frame_id (== control_step).

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

Alignment contract

Identical to the v1 dataset: policy_step ids are sequential, each maps to a contiguous block of control steps, chunk_index runs 0,1,… within a block, video frame t is control step t, and

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

where decode applies GR00T's gripper convention (g → 2g−1 → sign → −) to dim 6 only. Every episode passed this check, and the check that predicted_action_chunks == sampled_action_chunks[:, 0], at collection time.

manifest.csv

One row per episode: scene_variant, suite, task_id, task, prompt, episode, rollout_id, success, n_policy, n_control, control_hz, replan_steps, sim_failure_category, failing_predicate, labeled_captions, labeled_failure, labeler_model, vlm_failure_onset_frame, dir. The four label columns come from the label pass (vlm_failure_onset_frame is blank for successes).

Labels

Each episode carries a Gemini gemini-3.5-flash (Batch API) description of its video and, for failures, a localized failure onset. Produced offline from rollout.mp4 + rollout.json only (no sim, no policy server). The exact prompt templates are in gemini_prompts.md / gemini_prompts.json, identical to podolinsky/pi0.5-libero-10-features-v3, and are also embedded verbatim in every labels.json under labeler.prompts. 499 of 500 episodes are labeled: the keyword pass returned no phrases for one success (occluded/08_LIVING_ROOM_SCENE5_…/ep003), so it has no label files. All 169 failures are labeled.

Two passes on one shared video session:

1. Failure localizer (fork of Dan Lawson's liberox-evals) — a coarse pass on the full video gives the failure mode (10-way taxonomy below), onset type (obvious_mistake / operator_intervention / timeout), onset time, and long + short reason / recovery / prevention strings; a second pass on a slowed ±window clip (1 clip-second = 1 rollout frame) refines the onset to a single frame (165 of 169 failures refined). Only runs on episodes the simulator scored as failures; {} for successes.
2. 3-second keyword phrases — a second turn on the same session captions every consecutive 3 s window (2–6 word phrases), given the failure summary as context but told not to copy it in. 3–9 windows per episode.

Taxonomy (10 modes): wrong_object, wrong_target, press_failure, open_close_failure, grasp_failure, object_displacement, placement_or_insertion_failure, stuck_or_no_progress, timeout_or_insufficient_progress, other. Definitions are in gemini_prompts.md §1. v1 used a different 8-way set (a single wrong_object_or_target, an unstable_or_dangerous_behavior mode, no press / open-close modes), so mode counts are not directly comparable across versions (v1 was also labeled with a different model, gemini-3.7-flash).

labels.json per episode: rollout_id / scene_variant / task_id / task_file / instruction / success; labeler (backend, model, refine, labeled_at, pipeline, prompts); semantic_timeline (list of {segment_index, t_start_sec, t_end_sec, control_step_start/end, policy_step_start/end, phrase, description}); vlm_failure (mode, onset type / seconds / timestamp / frame / step, coarse vs refined onset and window, confidence, justification, reason / recovery / prevention long + summary, token usage, vlm_raw_response; {} on success); failure_annotation (the onset mapped onto the collection clocks: failure_control_step, failure_sim_step, failure_policy_step, failure_chunk_index, first_post_failure_policy_step, failure_type, correction_action).

labels.npz is the array-aligned copy: sem_t_start, sem_t_end, sem_control_start, sem_control_end, sem_phrase, fail_onset_frame, fail_onset_seconds, fail_mode, fail_reason, fail_reason_summary, fail_recovery, fail_recovery_summary, fail_prevention, fail_prevention_summary.

Failure statistics

failure mode	n	% of failures	onset mean ± std (s)
stuck / no progress	51	30.2%	8.6 ± 3.7
object displacement	30	17.8%	11.8 ± 6.7
placement / insertion	27	16.0%	12.9 ± 7.0
grasp failure	22	13.0%	8.6 ± 4.3
open / close failure	16	9.5%	13.9 ± 3.1
wrong target	15	8.9%	4.9 ± 4.4
wrong object	3	1.8%	5.3 ± 3.1
press failure	3	1.8%	10.7 ± 4.8
timeout / insuff. progress	2	1.2%	25.9 ± 0.0
other	0	0.0%	–

169 failures, all confidence: high. Onset type: obvious_mistake 118, operator_intervention 49, timeout 2. Overall onset 10.2 ± 6.0 s (median 8.7 s, range 0.6–26.0 s). other never occurs (0 episodes). Per-failure reason / recovery / prevention summaries are in FAILURE_ACTION_SUMMARIES.md.

Provenance

Collected with scripts/baselines/stac/collect_groot.py --with-features in the 12-Visual-Occlusion-Reasoning project, against a local GR00T policy server (scripts/groot-libero-10/server/serve_groot_ws.py, GROOT_WITH_FEATURES=1, embodiment LIBERO_PANDA). At each inference the server is queried K = 10 times on the same observation. Observations follow NVIDIA's LIBERO convention (180°-rotated 256 px agentview + wrist images, 8-dim state); num_steps_wait = 10, seed 7, num_inference_timesteps = 4 (flow matching). Labels: the scripts/semantic_failure/ batch labeler (episode_batch.py, Gemini Batch API); statistics: scripts/semantic_failure/build_failure_stats.py.