Hugging Face's logo

Datasets:
rooty2020
/
LIBERO-VP

Tasks:
Robotics
Languages:
English
Size:
1K<n<10K
ArXiv:
Tags:
robotics
robot-manipulation
3d-point-tracking
point-trajectories
multi-view
world-model
License:
Dataset card Files
xet
 Community
The Dataset Viewer has been disabled on this dataset.

LIBERO-VP

Dataset Description

LIBERO-VP is a modified version of the LIBERO benchmark datasets, created as part of the Video-Point Model (VPM) project (paper · project page · code).

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

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).

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).
  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,

pi,tw=Rℓ,tw piℓ+tℓ,tw.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 

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 

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:

Citation

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

@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.06940},
  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) license, the license of the original LIBERO datasets.
Downloads last month
41
Total file size:
13.8 GB

Papers for rooty2020/LIBERO-VP