nota-gmbh/vga_nota_dataset

LIBERO-3D — GT depth + camera for openvla/modified_libero_rlds

Metric depth and camera pose (K, E) for every training episode of openvla/modified_libero_rlds (LIBERO, 4 suites, no_noops). The depth and camera are rendered from the LIBERO MuJoCo simulator and aligned frame-for-frame to the RLDS episodes. Self-contained: the RGB the policy sees is bundled in too — those frames are not re-rendered here; they are copied verbatim from the source dataset openvla/modified_libero_rlds. So every modality — RGB, depth, camera pose, proprioception, action, and language — sits in one file, keyed by RLDS episode.

Files

file	size	what
libero_3d_no_noops_aligned.hdf5	~19 GB	the dataset (RGB + depth + K + E + state + action), keyed by RLDS episode
lang_cache/libero_instructions.npy	0.24 MB	(40, 1536) float32 instruction embeddings
lang_cache/libero_instructions.instructions.json	2 KB	the 40 instruction strings, same row order as the .npy
verify_alignment.ipynb	1.9 MB	the checks below, runnable

Fields (inside the hdf5)

<suite> is spatial | object | goal | long. <i> is the RLDS episode index in default tfds read order, so episode_<i> lines up 1:1 with modified_libero_rlds. L = number of frames in the episode. Camera axis: [0] = agentview (static front cam), [1] = eye-in-hand (wrist cam).

path	shape	dtype	what each value is
<suite>/intrinsics	(2, 3, 3)	float32	camera matrix K = [[fx,0,cx],[0,fy,cy],[0,0,1]], one per camera. agentview fx=fy=270.39, cx=cy=111; wrist fx=fy=145.96. Same for every episode in the suite.
<suite>/episode_<i>/image	(L, 2)	vlen uint8	RGB as JPEG-encoded bytes, [agentview, wrist], 256×256. Not rendered here — copied byte-for-byte from the source dataset openvla/modified_libero_rlds (observation.image / observation.wrist_image). Decode one: cv2.imdecode(np.frombuffer(img[t, v], np.uint8), cv2.IMREAD_COLOR).
<suite>/episode_<i>/depth	(L, 2, 224, 224)	float16	depth in meters (z-depth): distance from the camera along its optical axis, per pixel.
<suite>/episode_<i>/extrinsics	(L, 2, 4, 4)	float32	camera→world 4×4 pose, per frame (OpenCV, +Z into the scene). agentview is fixed; wrist moves with the arm.
<suite>/episode_<i>/state	(L, 8)	float32	robot proprioception: end-effector position (3) + orientation (3) + gripper (2).
<suite>/episode_<i>/action	(L, 7)	float32	control command: Δposition (3) + Δrotation (3) + gripper (1). Equal to the RLDS action — this is the key used to align the two.

Per-episode attrs (where this episode came from):

attr	type	value
language_instruction	str	the task text, e.g. "pick up the orange juice and place it in the basket"
source_demo	str	the source demo, "<task>/demo_<k>"
mode	str	contig (a contiguous frame window) or subseq (non-contiguous frames)
orig_demo_len	int	frames in the original demo, before no-op trimming
length	int	L, frames in this episode (= the RLDS episode length)
offset_k	int	contig only — leading frames dropped; source frames are orig[k : k+L]
source_indices	int32 (L,)	subseq only — the exact original-demo frame indices used

Counts

suite	episodes	frames
spatial	432	52,970
object	454	66,984
goal	428	52,042
long (libero_10)	379	101,469
total	1,693	273,465

Conventions

• Unproject a pixel (u, v) with its depth z: world = E @ (z · K⁻¹ · [u, v, 1]).
• Orientation: depth/K/E are stored in the RLDS-RGB frame, so depth[y, x] matches modified_libero_rlds image[y, x] with no flip or rotate. (Verified: reprojection error 0.)
• Resolution: depth/K/E are 224×224; the bundled image RGB is 256×256, so resize RGB to 224 to combine with depth.

Usage

Everything is in the one file now — read episode_<i> directly; no need to open the RLDS alongside it. episode_<i> still matches modified_libero_rlds episode i (same suite, default tfds order) if you want to cross-check.

import h5py, numpy as np, cv2

suite = "object"
gt = h5py.File("libero_3d_no_noops_aligned.hdf5", "r")
K = gt[suite]["intrinsics"][:]                  # (2,3,3) camera matrices [agentview, wrist]

ep    = gt[suite]["episode_0"]
instr = ep.attrs["language_instruction"]        # str, e.g. "pick up the ... and place it ..." (an attr, not a dataset)
img   = ep["image"]                             # (L,2) JPEG bytes  [agentview, wrist]
depth = ep["depth"][:]                          # (L,2,224,224) meters
E     = ep["extrinsics"][:]                     # (L,2,4,4) camera->world per frame
state = ep["state"][:]                          # (L,8)
action = ep["action"][:]                        # (L,7)

# decode an RGB frame (agentview, t=0)
rgb0 = cv2.imdecode(np.frombuffer(img[0, 0], np.uint8), cv2.IMREAD_COLOR)  # (256,256,3) BGR

How it was built

• Depth (MuJoCo GT). Replay each LIBERO demo in the simulator: set_state per frame, then get_real_depth_map for metric depth and read K/E straight from the sim. Exact, not estimated.
• Alignment. modified_libero_rlds is a no-op-trimmed replay with no simulator state, so its joint_state drifts (~0.08 rad) and can't be matched on. The recorded action is bit-exact, so each RLDS episode is matched to its demo and frames by action sequence — contig (1609 episodes) or subseq (84). All 1693 episodes map; depth is then gathered by frame index.
• Checks (verify_alignment.ipynb): action bit-exact on 1691/1693 (2 have ~1e-3 float noise on the correct frames, which does not move the depth index); subseq alignments have 0 forks (0 m depth ambiguity); dropped frames are no-ops (|action| ≈ 0).

Language cache

Precomputed instruction embeddings so training never loads the 1.5B text encoder. libero_instructions.npy is (40, 1536) float32 (one row per instruction); libero_instructions.instructions.json lists the 40 instructions in the same row order. Encoder: gte-Qwen2-1.5B-instruct, last-valid-token pooling.

Source

Rendered with LIBERO + robosuite/MuJoCo; aligned to openvla/modified_libero_rlds.