B1k_Recovery

Failure-recovery and demonstration data for BEHAVIOR-1K, in LeRobot v3.0 format, organised one subfolder per task.

B1k_Recovery/
├── task1/
│   └── Demo+Recovery/            picking_up_trash — human demos + recoveries from policy failures
│       ├── data/         793 Parquet files (chunk-000 demos, chunk-001 recoveries)
│       ├── videos/       2,391 MP4 files (3 camera keys × 2 chunks)
│       ├── meta/         info.json, stats.json, tasks.parquet, episodes/
│       └── annotations/  official skill annotations of the demos
└── task5/
    └── Demo+Recovery+Success/    setting_mousetraps — human demos + nav + place + success
        ├── data/    5,795 Parquet shards (chunk-000 … chunk-005)
        ├── videos/  17,385 MP4 files (3 camera keys × 6 chunks)
        └── meta/    info.json, tasks.parquet, episodes/, conversion_manifest.jsonl

Further tasks will be added as sibling folders (task10/, …). Each subfolder is a self-contained LeRobot v3 dataset: point your loader at the innermost dataset folder (e.g. task5/Demo+Recovery+Success), not at the repository root.

---

task5 — setting_mousetraps

Training-ready mixed dataset combining official human demonstrations with generated navigation, placement/recovery, and successful-rollout episodes.

Composition

Source family	Episodes	Frames	Hours @ 30 fps
Official 2026 human demonstrations	200	2,039,222	18.882
Generated navigation	1,170	562,590	5.209
Generated success demonstrations	37	327,684	3.034
Generated placement / recovery	4,388	607,744	5.627
Total	5,795	3,537,240	32.752

Roughly 58% of frames are official human demonstration; the remaining 42% is generated navigation, placement/recovery, and success data.

Episode lengths are strongly bimodal: 5,102 of 5,795 episodes are under 500 frames (short recovery clips, ~25% of all frames), while 237 episodes exceed 3,000 frames (long demonstrations, ~67% of all frames). Sampling is per-frame, so a uniformly shuffled batch reflects the frame split, not the episode split.

• LeRobot codebase format: v3.0
• Robot: R1Pro
• Task: setting_mousetraps, stored as local task_index=0
• Observation state: float32[61]
• Action: float32[23]
• Frequency: 30 Hz
• RGB: three 224×224 H.264 (yuv420p) streams
• Size on disk: 7.3 GB across 23,192 files
• Frame-sample count after action-horizon truncation (H=30): 3,363,390

Observation state (61-D, BEHAVIOR 2026 layout)

Slice	Meaning
0:3	base-frame observed base_qvel = [vx, vy, wz]
3:10, 10:17	left arm qpos, qvel
17:20, 20:24	left end-effector position, quaternion
24:26, 26:28	left gripper qpos, qvel
28:35, 35:42	right arm qpos, qvel
42:45, 45:49	right end-effector position, quaternion
49:51, 51:53	right gripper qpos, qvel
53:57, 57:61	trunk qpos, qvel

These are observed simulator states in physical velocity units, not normalized actions.

For generated sources retaining the legacy 256-D proprioception, the builder extracts the documented blocks and rotates the holonomic virtual-joint velocity at legacy indices 253:256 into the robot/base frame using the virtual-joint yaw at index 246:

vx_base =  cos(yaw) * vx_world + sin(yaw) * vy_world
vy_base = -sin(yaw) * vx_world + cos(yaw) * vy_world
wz_base =  wz_world

Official 61-D human states are preserved directly.

Action (23-D R1Pro VLA action)

base[0:3], trunk[3:7], left_arm[7:14], left_gripper[14],
right_arm[15:22], right_gripper[22]

Cameras

• observation.rgb.zed_link_camera_0 (head)
• observation.rgb.left_realsense_link_camera_0
• observation.rgb.right_realsense_link_camera_0

Generated sources contain no depth or robot-to-camera pose, so those fields are omitted rather than fabricated.

Transition fields

Every row carries next.reward, next.terminated, next.truncated, plus the standard LeRobot v3 timestamp, frame, episode, global, and task indices.

---

Usage notes (read before training)

1. Remap task_index — this is the most common way to get this wrong. meta/tasks.parquet maps setting_mousetraps → 0, a dataset-local index. The BEHAVIOR-1K global index for this activity is 5. A pipeline that feeds the stored task_index straight to the model will train it as task 0, and — because stage count is keyed off the task id — will use 5 stages instead of 12, while evaluation conditions on task 5. Remap via the activity name (tasks.parquet ↔ task_data.json), not the stored integer.

2. base_qvel is base-frame. Do not re-rotate it. Verified empirically on this dataset: std = (0.0694, 0.0292, 0.0762), std_x/std_y = 2.37, and |vx| > |vy| in 77.7% of frames. A world-frame dataset would show a ratio near 1.0 and no forward bias. If your evaluator has a frame switch (e.g. B1K_BASE_QVEL_FRAME), leave it unset/base; forcing world feeds a rotated signal to a base-frame-trained policy.

3. Use qvel-corrected normalization statistics. Norm stats whose state[0:3] std is ~10× smaller than their own action[0:3] std were computed on a corrupted qvel channel. Achieved and commanded base velocity must have comparable magnitude; on this data the correct scale is std ≈ (0.109, 0.061, 0.133).

4. Known bias: the base channel has a strong stand-still prior. 81.6% of frames have |state_vx| < 0.005, and of those only ~2.0% command |action_vx| > 0.05. corr(state[0:3], action[0:3]) = 0.88 / 0.79 / 0.68. A policy can score low base-velocity loss by echoing the current velocity rather than learning when to start moving, which at evaluation can present as a robot that turns in place but does not drive. Worth measuring open-loop before concluding a checkpoint is healthy. The generated recovery episodes reduce this leakage — the human-only subset is markedly worse (corr ≈ 0.997, and only 0.05% of stationary frames command motion).

Validation

Validated before publication:

• all 5,795 Parquets and all 3,537,240 state/action rows scanned;
• every state 61-D, every action 23-D, all values finite;
• episode/frame/global indices, timestamps, task mapping, and metadata totals agree;
• all 17,385 videos decoded and checked against episode frame counts;
• exact source-to-output checks passed for human, navigation, success, and placement episodes;
• samples from every source family loaded through LeRobot 0.5.2 with all three RGB tensors.

The conversion manifest is at task5/Demo+Recovery+Success/meta/conversion_manifest.jsonl. The converter is omnigibson/learning/embodiedClaw_recovery/scripts/export/build_lerobot_2026.py in the associated BEHAVIOR-1K challenge codebase.

Models trained on this data

Checkpoints fine-tuned from BEHAVIOR-1K checkpoint_1 on task5 are published at fastwalker1118/b1kcheckpoints (task5ckptmerged15000 … 39999). Each bundles its own assets/ norm stats, so evaluation picks up matching normalization automatically. 30,000 steps at batch 128 is ≈1.14 epochs over this dataset.

Compatibility warning

This is the 2026 format. Do not train a legacy 2025 pipeline expecting a 256-D state, world/canonical-frame base qvel, or observation.images.rgb.* camera keys on this data without an explicit format adapter.

---

task1 — picking_up_trash

task1/Demo+Recovery holds the 200 official human demonstrations of the task beside 788 recoveries that start from states where a Pi0.5 policy went wrong. The two halves are about equal in time.

Composition

Source	Episodes	Frames	Hours @ 30 fps	Share of frames
Official 2026 human demonstrations	200	1,053,550	9.755	53.7%
Recoveries from policy failure states	788	907,537	8.403	46.3%
Total	988	1,961,087	18.158

Episodes 0–199 are the demonstrations in the official order; 200–987 are the recoveries. Demonstrations are long (median 179 s) and recoveries short (median 38 s), so sampling by frame gives the split above, while sampling by episode would give 20% / 80%.

Each recovery starts from one of six situations the policy often reaches and mostly fails in. Prevention clips start before the policy's mistake, correction clips after it, once the scene has settled:

recovery_mode	Situation	Prevention	Correction	Hours
last_can_unseen	Two cans are in the carried trash can and the last can is out of the head camera's view; the policy sets the trash can down and idles	133	169	4.68
can_before_trash	The policy grasps a can before it has ever picked up the trash can	82	194	2.65
can_dropped_outside	A can released next to the carried trash can misses it	27	46	0.51
place_stalled	A can is held next to the carried trash can for 30 s or more without being released	71	41	0.33
can_chatter	The free hand closes again and again over a can it has knocked onto its side	9	6	0.12
trash_chatter	A hand closes again and again on the trash can, usually after tipping it over	5	5	0.11

• LeRobot codebase format: v3.0, in the layout of behavior-1k/2026-challenge-demos
• Robot: R1Pro; frequency: 30 Hz
• Observation state: float32[61], the 2026 layout documented under task5 (base velocity in the robot's frame)
• Action: float32[23]
• RGB: head 720×720 and two wrists 480×480, HEVC yuv420p, a keyframe every 8 frames, no B-frames
• Task: picking_up_trash with the official task_index=1. meta/tasks.parquet is the official 100-task table, so no remapping is needed here (unlike task5)
• Size on disk: 8.4 GB across 3,388 files

task1/Demo+Recovery/
├── data/chunk-000/      5 files: the demonstrations
├── data/chunk-001/      788 files: one per recovery
├── videos/<camera>/chunk-000/   the official demonstration videos, unchanged
├── videos/<camera>/chunk-001/   788 files: one per recovery
├── meta/                info.json, stats.json, tasks.parquet, episodes/
└── annotations/task-0001/       the official skill annotations of the 200 demonstrations

How the recoveries were made

1. Pi0.5 (checkpoint_2) was rolled out on task instances 501–999.
2. An agent studied the rollouts, defined the six situations above as code, and swept every rollout for start frames.
3. The simulator was restored to each start frame, and a scripted planner with access to the simulator state completed the pending subtask from there.
4. A recovery was kept only if the simulator's own checks confirmed it: the can ended inside the trash can, or the trash can ended in the hand, and nothing already inside fell out. 788 of 904 restorable start frames passed, from 239 different rollouts (instances 501–864). 336 of them went on to finish the whole task.

meta/episodes says where each episode comes from:

Column	Meaning
_src	human_demo_2026 or recovery
source	the official episode index of a demonstration, or the run and episode of a recovery
recovery_mode, recovery_kind, planner	the situation, prevention or correction, and the planner that recovered
rollout_episode, rollout_frame	the policy rollout and the frame of it the recovery starts from
task_instance_id	the task instance (1–300 for demonstrations)
stage_origin, stage_span	recoveries only: see the note on stages below

What was converted

Demonstration rows and videos are the official ones; only episode and frame numbers restart at zero, and observation.robot2cam_pose.* and the depth videos are left out because recoveries have neither.

Recoveries were recorded with the 2025 evaluator (OmniGibson 3.8) and brought to the demonstrations' conventions:

• State: the 61 quantities were copied out of the 256-D vector, and base velocity was rotated from the scene's frame into the robot's with the formula in the task5 section.
• Action timing: the 2025 recorder stored action k beside the frame taken after it. Actions were moved up one row, so every row pairs a frame with the action chosen from it, as the demonstrations do. The last row of each recovery repeats its final action.
• Video: the recordings had 250-frame GOPs with B-frames, in which the frames just before a keyframe cannot be reached by a seek. They were re-encoded once with the demonstrations' settings (x265, crf 30, a keyframe every 8 frames, no B-frames).
• Transition fields: next.reward is 0, and next.terminated is true on the last frame only. Demonstrations keep their official values.

Usage notes

1. Stages. A loader that derives the task stage by slicing each episode into equal parts would restart every recovery at stage 0, although recoveries begin mid-task. stage_origin is the frame of the task a recovery's first frame corresponds to (the rollout frame it was restored from), and stage_span the length to divide: the recovery's own end if it finished the task, otherwise 5,268, the mean demonstration length. Demonstrations carry neither.

2. Recoveries are not teleoperation. They come from scripted planners, and their arm postures cover a wider range of joint angles than the demonstrations do.

3. Decoding cost. Videos are at the simulator's full resolution. A loader that reads at 224×224 can transcode them first; no frame depends on one more than 8 frames away.

Validation

Checked before publication:

• all 1,961,087 rows scanned: every state 61-D, every action 23-D, all values finite, task_index 1; episode and frame indices contiguous and consistent with the metadata;
• demonstration videos are the official files byte for byte, with the official timestamps;
• all 2,364 recovery videos read: one frame per row, HEVC yuv420p at 30 fps, a keyframe every 8 frames, no B-frames;
• 40 random recovery frames compared with the recordings: PSNR 41.2 dB on average, 38.3 dB at worst, and wherever the image changes between frames (22 of the 40) the frame matches its own source frame better than either neighbour;
• in both halves, the commanded base velocity correlates best with the state one row later, as in the official demonstrations;
• 309 random frames from both halves loaded through LeRobot 0.5.2 (pyav backend) with all three images.

Built by scripts/mix_dataset.py in the EmbodiedClaw repository.