README.md

---
pretty_name: GR00T-N1.7 LIBERO-10 backbone features + K=10 action samples (normal + occluded)
task_categories:
  - robotics
modalities:
  - video
  - tabular
size_categories:
  - n<1K
tags:
  - robotics
  - vision-language-action
  - libero
  - gr00t
  - representation-probing
  - occlusion-robustness
  - failure-detection
---

# 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`](https://huggingface.co/datasets/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](#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](https://arxiv.org/abs/2306.03310)
- LIBERO-Occ — Li et al., [arXiv:2606.10862](https://arxiv.org/abs/2606.10862)
- GR00T N1 — NVIDIA, [arXiv:2503.14734](https://arxiv.org/abs/2503.14734).
  Checkpoint [`nvidia/GR00T-N1.7-LIBERO`](https://huggingface.co/nvidia/GR00T-N1.7-LIBERO)
  (`libero_10`), VLM backbone [`nvidia/Cosmos-Reason2-2B`](https://huggingface.co/nvidia/Cosmos-Reason2-2B).
- STAC — Agia et al., *Unpacking Failure Modes of Generative Policies: Runtime
  Monitoring of Consistency and Progress*, [arXiv:2410.04640](https://arxiv.org/abs/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.md) /
[`gemini_prompts.json`](gemini_prompts.json), identical to
[`podolinsky/pi0.5-libero-10-features-v3`](https://huggingface.co/datasets/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`](https://github.com/dtl184/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 and onset-time overview](failure_overview.png)

| 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`](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`.