README.md

---
license: cc-by-4.0
task_categories:
  - robotics
language:
  - en
tags:
  - robotics
  - robot-manipulation
  - 3d-point-tracking
  - point-trajectories
  - multi-view
  - world-model
  - simulation
  - libero
pretty_name: LIBERO-VP
viewer: false
size_categories:
  - 1K<n<10K
---

# LIBERO-VP

## Dataset Description

LIBERO-VP is a modified version of the [LIBERO benchmark datasets](https://libero-project.github.io/), created as
part of the **Video-Point Model (VPM)** project ([paper](https://arxiv.org/abs/2610.06940) ·
[project page](https://rootyjeon.github.io/video-point-model/) · [code](https://github.com/vpm-project/VPM)).

All 6,500 human demonstrations of the five LIBERO suites are replayed in simulation and re-rendered from three
calibrated cameras. Every frame comes with **persistent, metric 3D point trajectories** of the robot arm, the gripper
and the task-relevant objects, read directly from the simulator state, so they are exact and consistent across time
and across views.

- 🎥 3 synchronized views per episode: two exocentric cameras and the wrist camera (256×256, 20 fps)
- 📍 1,024 persistent 3D surface points per frame (512 arm + 256 gripper + 256 task objects), metric, in the camera frame
- 🦴 12 robot keypoints (base, links 1–7, hand, end-effector, fingers)
- 📷 intrinsics and extrinsics of every camera (per frame for the wrist camera)
- 📝 the LIBERO language instruction of every episode

<video src="https://huggingface.co/datasets/rooty2020/LIBERO-VP/resolve/main/assets/demo.mp4" poster="https://huggingface.co/datasets/rooty2020/LIBERO-VP/resolve/main/assets/example.png" autoplay loop muted playsinline controls width="100%"></video>
<p align="center"><em>Two LIBERO-10 episodes. 128 arm and gripper points and 40 points per target object (white rim) are projected onto agentview, frontview and the wrist camera; dot size and brightness follow camera depth, and trails show the last 10 frames (not drawn for the moving wrist camera).</em></p>

### Key Modifications

Compared to the original LIBERO datasets:

1. **Higher-resolution, multi-view video**: the episodes are re-rendered at 256×256 (vs. 128×128 in the original),
   upright, from three cameras: LIBERO's `agentview`, an additional exocentric `frontview` camera that the original data
   does not record, and the `robot0_eye_in_hand` wrist camera.
2. **Ground-truth 3D point trajectories** of the arm, the gripper and the objects the task acts on (see
   [3D Point Trajectory Curation](#3d-point-trajectory-curation)).
3. **Robot keypoints**: 3D positions of 12 robot bodies per frame (`joints.npz`).
4. **Camera calibration**: pinhole intrinsics and world-to-camera extrinsics of every view, stored per frame for the
   moving wrist camera.
5. **Deterministic state replay**: every demonstration is replayed from its recorded simulator states in the MuJoCo
   model stored with the demonstration, so the videos and the trajectories describe exactly the recorded motion.

LIBERO episodes are short single tasks, so they are kept whole (no subtask split).

### 3D Point Trajectory Curation

The goal is metric, temporally consistent 3D trajectories of the action-relevant geometry over the whole episode
(Appendix B.2 of the paper).

**3D point extraction.** We start from the visual meshes of every robot link and of the manipulated objects. Surface
points are drawn on each mesh by area-weighted triangle sampling, **once**, in the mesh-local frame, with a fixed
random seed; the same points are reused for the whole episode. A fixed point budget goes to each action-relevant
component: **512 points on the Franka Panda arm** (links 0–7), **256 points on the Panda gripper**, and **256 points on
the target objects**. Within a component made of several meshes the budget is split roughly in proportion to mesh
surface area. A point $p^{\ell}_i$ sampled on body $\ell$ is placed in the world at time $t$ by the body pose,

$$p^{w}_{i,t} = R^{w}_{\ell,t}\, p^{\ell}_i + t^{w}_{\ell,t}.$$

Because $p^{\ell}_i$ is fixed, point $i$ is the same physical surface location in every frame, and the trajectories
carry no resampling noise. In simulation the poses $(R^{w}_{\ell,t}, t^{w}_{\ell,t})$ need no estimation: we replay the
recorded simulator state and query the per-frame pose of every mesh geom, object and camera directly
(`geom_xpos` / `geom_xmat` in MuJoCo).

**Target objects.** The objects come from the goal of the task (its BDDL goal predicates): the objects that are moved
and the fixture parts that are operated (e.g. the stove for *"turn on the stove"*); receptacles are excluded. When a
task has several targets, the 256 object points are split equally between them and concatenated in goal order
(`meta.json → object.targets` gives the split).

**Camera-frame trajectories and projection.** World trajectories are moved into each camera with its world-to-camera
extrinsics, $p^{c}_{i,t} = R^{c\leftarrow w}_t\, p^{w}_{i,t} + t^{c\leftarrow w}_t$. Point identities are unchanged by
this transformation, so the data gives explicit correspondences across time and across viewpoints.

**Filtering.** The calibration filter that the paper applies to real-robot data (projected CAD mask vs. SAM 2 mask)
is not needed here: cameras, robot and objects all come from the same simulator state.

**Output representation.** Each sample holds synchronized multi-view RGB, the persistent 3D surface-point
trajectories of the arm, gripper and target objects, and all camera metadata needed to reproduce the image-space
projections. Each point index refers to the same physical surface location across time and across camera views.

## Dataset Structure

```
LIBERO-VP/
├── README.md
├── assets/                  # demo.mp4 and its poster example.png
├── manifest.json            # every episode -> shard, suite, task, instruction, length; shard sizes and SHA-256
├── data/
│   ├── libero_10.tar        # 500 episodes
│   ├── libero_90.tar        # 4,500 episodes
│   ├── libero_goal.tar      # 500 episodes
│   ├── libero_object.tar    # 500 episodes
│   └── libero_spatial.tar   # 500 episodes
└── tools/
    ├── visualize_sample.py  # re-projects all 3D points onto the videos (calibration check)
    └── render_demo.py       # renders demo videos like the one above
```

Each shard holds one directory per episode, named `<suite prefix>_<task>_ep<NNNNNN>` (e.g.
`L10_KITCHEN_SCENE3_turn_on_the_stove_and_put_the_moka_pot_on_it_ep000000`):

```
<episode>/
├── view1.mp4      # agentview, 256x256, 20 fps
├── view2.mp4      # frontview, 256x256, 20 fps
├── ego.mp4        # wrist camera (robot0_eye_in_hand), 256x256, 20 fps
├── robot.npz      # points: (T, 512, 3) float32
├── gripper.npz    # points: (T, 256, 3) float32
├── object.npz     # points: (T, 256, 3) float32
├── joints.npz     # points: (T, 12, 3) float32 + names, parent, is_hand
└── meta.json
```

`T` is the episode length (`meta.json → n_frames`), and frame `t` of the three videos and of all point arrays is the
same instant.

## Data Format

### Point tracks

| file | key | shape | dtype | content |
|:--|:--|:--|:--|:--|
| `robot.npz` | `points` | `(T, 512, 3)` | float32 | Franka Panda arm surface points (links 0–7, no gripper) |
| `gripper.npz` | `points` | `(T, 256, 3)` | float32 | Panda gripper surface points, fingers included |
| `object.npz` | `points` | `(T, 256, 3)` | float32 | surface points of the task's target object(s) |
| `joints.npz` | `points` | `(T, 12, 3)` | float32 | positions of `robot0_base`, `robot0_link1..7`, `robot0_right_hand`, `gripper0_eef`, `gripper0_leftfinger`, `gripper0_rightfinger` |
| | `names`, `parent`, `is_hand` | `(12,)` | str, int64, bool | body names, kinematic parent index (−1 for the root), gripper flag |

All points are in meters, in the **`view1` camera frame** (OpenCV convention: +x right, +y down, +z forward). The
point order is fixed, so `points[:, i]` is one trajectory.

### `meta.json`

| field | content |
|:--|:--|
| `id`, `sample_id` | episode directory name |
| `task`, `task_category`, `episode` | LIBERO task (scene + instruction), suite (`libero_10`, `libero_90`, `libero_goal`, `libero_object`, `libero_spatial`), demo index |
| `lang`, `language_instructions`, `language_source` | LIBERO language instruction (from the task's BDDL file) |
| `robot_type` | `Panda` |
| `fps`, `n_frames`, `n_video_frames` | 20, episode length `T`, frames per video |
| `extrinsics_convention` | `"cam_from_world"` |
| `views.<view>.camera` | MuJoCo camera name |
| `views.<view>.intrinsics` | `fx, fy, cx, cy`, `width, height` (pinhole from the camera field of view, no distortion) |
| `views.<view>.T_cam_world` | world-to-camera matrix, `p_cam = T_cam_world @ [p_world; 1]`: 4×4 for the fixed `view1`/`view2`, `(T, 4, 4)` for the wrist camera `ego` |
| `object` | target objects: `goal_targets`, `goal_preds` (BDDL goal predicates), `targets` (body and number of points of each target, in `object.npz` order) |
| `points` | description and shape of each point file |
| `camera_moves` | `false` (the exocentric cameras are fixed) |
| `provenance` | source demonstration file and key in the LIBERO datasets, BDDL file, LIBERO commit, robosuite version, method |

### Projecting the points into a view

```python
import json, numpy as np

d = "L10_KITCHEN_SCENE3_turn_on_the_stove_and_put_the_moka_pot_on_it_ep000000"
meta = json.load(open(f"{d}/meta.json"))
pts = np.concatenate([np.load(f"{d}/{f}.npz")["points"] for f in ("robot", "gripper", "object")], axis=1)  # (T, 1024, 3)

def view_T(v, t):
    T = np.asarray(meta["views"][v]["T_cam_world"])
    return T if T.ndim == 2 else T[t]                          # the wrist camera has one matrix per frame

t, v = 0, "ego"
T = view_T(v, t) @ np.linalg.inv(view_T("view1", t))           # view1 camera -> camera v
intr = meta["views"][v]["intrinsics"]
p = pts[t] @ T[:3, :3].T + T[:3, 3]
uv = np.stack([intr["fx"] * p[:, 0] / p[:, 2] + intr["cx"],
               intr["fy"] * p[:, 1] / p[:, 2] + intr["cy"]], 1)  # pixels, valid where p[:, 2] > 0
```

`tools/visualize_sample.py <episode_dir> --out vis.mp4` renders all views with the projected points.

## Statistics

| | |
|:--|:--|
| Episodes | 6,500 (130 tasks × 50 demonstrations) |
| Frames | 1,007,618 per view (14.0 h at 20 fps) |
| Episode length | 58–517 frames (median 142 ≈ 7.1 s, mean 155) |
| Views | 3 (agentview, frontview, wrist), 256×256, 20 fps |
| 3D points per frame | 1,024 (512 arm + 256 gripper + 256 objects) + 12 keypoints |
| Unique instructions | 112 |
| Robot | Franka Panda (simulated, robosuite / MuJoCo) |
| Size | 13.8 GB in 5 tar shards |

| suite | tasks | episodes | frames per episode (median, range) |
|:--|--:|--:|:--|
| `libero_10` | 10 | 500 | 263 (150–517) |
| `libero_90` | 90 | 4,500 | 141 (58–373) |
| `libero_goal` | 10 | 500 | 110 (75–347) |
| `libero_object` | 10 | 500 | 148 (114–254) |
| `libero_spatial` | 10 | 500 | 124 (75–197) |

## Usage

```bash
hf download rooty2020/LIBERO-VP --repo-type dataset --local-dir LIBERO-VP
cd LIBERO-VP && mkdir -p extracted && for t in data/*.tar; do tar -xf "$t" -C extracted; done
python tools/visualize_sample.py "extracted/L10_KITCHEN_SCENE3_turn_on_the_stove_and_put_the_moka_pot_on_it_ep000000" --out vis.mp4
python tools/render_demo.py extracted/<episode> --out demo.mp4   # needs av, matplotlib
```

`manifest.json` lists every episode with its shard, suite, task, instruction and length, plus the size and SHA-256 of
every shard.

## Original LIBERO Dataset

LIBERO-VP is derived from the LIBERO benchmark for lifelong robot learning:
- **Paper**: [LIBERO: Benchmarking Knowledge Transfer for Lifelong Robot Learning](https://arxiv.org/abs/2306.03310)
- **Website**: https://libero-project.github.io/
- **Repository**: https://github.com/Lifelong-Robot-Learning/LIBERO
- **License**: datasets CC BY 4.0, code MIT

## Citation

If you use this dataset, please cite both the original LIBERO paper and the VPM paper.

```bibtex
@article{vpm2026,
  title   = {Learning the 4D World through Point Trajectory Forecasting},
  author  = {Jeon, Byungwoo and Hong, Sunghwan and Kim, Dohyeon and Lee, Jonghoon and Park, Jungwoo and Lee, Inhee and
             Baek, Doosan and Kim, Jinil and Lim, Taehyun and Joo, Hanbyul and Pollefeys, Marc and Xie, Saining and
             Shin, Jinwoo},
  journal = {arXiv preprint arXiv:2610.xxxxx},
  year    = {2026}
}

@article{liu2023libero,
  title   = {LIBERO: Benchmarking Knowledge Transfer for Lifelong Robot Learning},
  author  = {Liu, Bo and Zhu, Yifeng and Gao, Chongkai and Feng, Yihao and Liu, Qiang and Zhu, Yuke and Stone, Peter},
  journal = {arXiv preprint arXiv:2306.03310},
  year    = {2023}
}
```

## License

LIBERO-VP is released under the [Creative Commons Attribution 4.0 International (CC BY 4.0)](https://creativecommons.org/licenses/by/4.0/)
license, the license of the original LIBERO datasets.