Add dataset documentation, indexes, and conversion example

.gitattributes

@@ -58,3 +58,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+meta/episodes.jsonl filter=lfs diff=lfs merge=lfs -text

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ZJUNLP
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,3 +1,47 @@
 ---
 license: mit
+language:
+- en
+tags:
+- robotics
+- simulation
+- hdf5
+- labvla
+pretty_name: LabEmbodied-Data Beta
 ---
+
+# LabEmbodied-Data Beta
+
+LabEmbodied-Data Beta is a subset of **LabEmbodied-Data**, introduced in [LabVLA](https://arxiv.org/abs/2606.13578). It provides successful laboratory robot demonstrations with multi-view video, language instructions, robot states, actions, and structured annotations.
+
+## Dataset layout
+
+```text
+<robot>/<family>/<case>/   Episode files and task metadata
+meta/                    Dataset information and episode indexes
+docs/                    Data format reference
+examples/                Optional LeRobot conversion example
+```
+
+Each episode is stored in an H5 file. Use `meta/episodes.jsonl` to locate episodes and their associated metadata. File paths in the index are relative to the dataset root.
+
+## Quick start
+
+Read H5 files directly with `h5py`; see the [data format reference](docs/data_format.md) for field definitions and Python usage. Camera videos are embedded in the H5 files.
+
+## Optional LeRobot export
+
+The example exports states, actions, language, and RGB videos to LeRobot v3.0 using LeRobot 0.4.4. Run from the dataset root in a Python 3.10+ environment:
+
+```bash
+pip install -r examples/requirements.txt
+python examples/convert_to_lerobot.py \
+  --source . --out ../labembodied-ur5e-lerobot \
+  --repo-id local/labembodied-ur5e --robot ur5e --max-episodes 2
+```
+
+Omit `--max-episodes` to export all episodes for the selected robot. Joint values and column order are preserved. Videos are decoded and re-encoded; other annotations remain in the H5 files. The output includes `meta/source_episodes.jsonl` to map LeRobot indices to the original episode IDs. Nothing is uploaded.
+
+## License
+
+[MIT](LICENSE).

docs/data_format.md

@@ -0,0 +1,64 @@
+# Data format
+
+## Episode files and indexes
+
+Episodes are grouped by robot, task family, and task configuration:
+
+```text
+<robot>/<family>/<case>/
+  dataset/
+    episode_XXXX.h5
+    meta/episode.jsonl
+    meta/randomization_episodes.jsonl
+  resolved_config.yaml
+  results/
+```
+
+- `meta/episodes.jsonl` lists episodes, unique `episode_id` values, H5 paths, instructions, and associated files.
+- `meta/cases.jsonl` lists task configurations and their metadata files.
+- `meta/info.json` contains dataset information and current statistics.
+
+Index paths are relative to the dataset root. Episode numbers are local to each task configuration and may be non-consecutive. Use the global index to enumerate files.
+
+For associated annotations, match `hdf5_path` or `meta.episode_index` in randomization records and `h5_episode_index` in result records. Task configurations are available as `resolved_config.yaml`.
+
+## H5 fields
+
+Read array shapes, column names, camera names, and frame rate from each file. Below, `T` is the frame count, `D` the selected joint-state dimension, `J` the full joint-state dimension, `K` the object count, `C` the camera count, and `S` the subgoal count.
+
+| Field | Description |
+|---|---|
+| `agent_pose` | `(T, D)` joint states; columns are described by `agent_pose_names` and the associated index arrays. |
+| `actions` | `(T, D)` joint-position targets. |
+| `joint_positions` | `(T, J)` joint states, with columns described by `joint_position_names`. |
+| `ee_pose`, `ee_pose_valid` | End-effector poses and validity flags; see `ee_pose_names` and `ee_frame`. |
+| `camera_*_rgb` | One-dimensional `uint8` arrays containing H.264 MP4 video bytes. |
+| `language_instruction`, `subtask_instructions` | Episode and subtask instructions. |
+| `step_index` | `(T,)` workflow-stage indices; `-1` marks transition frames. |
+| `object_positions`, `object_orientations`, `object_names` | Object poses and names. Quaternion order is given by the `quaternion_order` attribute. |
+| `bboxes_2d`, `bbox_visibility`, `bbox_camera_names` | `(T, K, C, 4)` image-space boxes, visibility flags, and camera-axis names. |
+| `subgoals/frame_idx`, `subgoals/camera_names`, `subgoals/images_png` | Zero-based frame indices, camera names, and an `(S, C)` grid of PNG byte arrays. |
+
+`actions[t]` contains the next recorded joint state; the final target is the measured state at episode end. Read the column names and gripper indices when interpreting joint values.
+
+Video bytes must be decoded before accessing images. OpenCV returns BGR images; convert them to RGB before use. Use the H5 `fps` and `frame_count` attributes for timing and length.
+
+## Read an episode
+
+```python
+import json
+from pathlib import Path
+
+import h5py
+
+root = Path(".")
+with (root / "meta/episodes.jsonl").open() as index:
+    item = json.loads(next(index))
+
+with h5py.File(root / item["hdf5_path"], "r") as episode:
+    states = episode["agent_pose"][()]
+    actions = episode["actions"][()]
+    instruction = episode["language_instruction"].asstr()[()]
+```
+
+For an optional LeRobot export with video decoding, see [convert_to_lerobot.py](../examples/convert_to_lerobot.py) and the command in the [README](../README.md).

examples/convert_to_lerobot.py

@@ -0,0 +1,164 @@
+"""Export LabEmbodied-Data H5 episodes to a local LeRobot v3.0 dataset.
+
+Requires LeRobot 0.4.4. Exports joint states, joint-position targets, language,
+and RGB videos. Additional annotations remain available in the source H5 files.
+"""
+
+import argparse
+from contextlib import ExitStack, contextmanager
+from copy import deepcopy
+import json
+from pathlib import Path
+import tempfile
+
+import cv2
+import h5py
+import numpy as np
+
+
+def select_episodes(source, robot, limit):
+    selected = []
+    with (source / "meta/episodes.jsonl").open(encoding="utf-8") as index:
+        for line in index:
+            item = json.loads(line)
+            if item["robot_type"] == robot and item["success"]:
+                selected.append(item)
+                if limit is not None and len(selected) == limit:
+                    break
+    if not selected:
+        raise ValueError(f"No successful episodes found for robot {robot!r}")
+    return selected
+
+
+def episode_layout(episode, robot):
+    """Read and validate the state, action, video, and timing contract."""
+    if episode.attrs["robot_type"] != robot or not episode.attrs["episode_success"]:
+        raise ValueError(f"Unexpected robot or unsuccessful episode: {episode.filename}")
+    count = int(episode.attrs["frame_count"])
+    fps = float(episode.attrs["fps"])
+    if count <= 0 or fps <= 0 or not fps.is_integer():
+        raise ValueError("Expected a nonempty episode with an integer frame rate")
+    states, actions = episode["agent_pose"], episode["actions"]
+    if states.ndim != 2 or states.shape != actions.shape or states.shape[0] != count:
+        raise ValueError("States and joint-position targets must have matching (T, D) shapes")
+    names = episode["agent_pose_names"].asstr()[()].tolist()
+    if len(names) != states.shape[1]:
+        raise ValueError("Joint names do not match the state dimension")
+    features = {
+        "observation.state": {"dtype": "float32", "shape": states.shape[1:], "names": names},
+        "action": {"dtype": "float32", "shape": actions.shape[1:], "names": names},
+    }
+    cameras = sorted(key for key in episode if key.startswith("camera_") and key.endswith("_rgb"))
+    if not cameras:
+        raise ValueError("No camera videos found")
+    for camera in cameras:
+        video = episode[camera]
+        shape = tuple(int(value) for value in video.attrs["image_shape"])
+        if len(shape) != 3:
+            raise ValueError(f"Expected a three-dimensional image shape: {camera}")
+        layout = video.attrs["image_layout"]
+        if layout == "HWC":
+            shape = (shape[2], shape[0], shape[1])
+        elif layout != "CHW":
+            raise ValueError(f"Unsupported image layout: {layout}")
+        if (
+            shape[0] != 3
+            or int(video.attrs["frame_count"]) != count
+            or float(video.attrs["fps"]) != fps
+        ):
+            raise ValueError(f"Video layout or timing mismatch: {camera}")
+        features[f"observation.images.{camera}"] = {
+            "dtype": "video", "shape": shape, "names": ["channels", "height", "width"],
+        }
+    return int(fps), features, cameras
+
+
+@contextmanager
+def open_video(video, path):
+    path.write_bytes(video[()].tobytes())
+    capture = cv2.VideoCapture(str(path))
+    try:
+        if not capture.isOpened():
+            raise ValueError(f"Cannot open video: {video.name}")
+        yield capture
+    finally:
+        capture.release()
+
+
+def export(source, output, repo_id, robot, limit):
+    # Import lazily so --help does not require the full LeRobot installation.
+    from lerobot.datasets.lerobot_dataset import LeRobotDataset
+
+    items = select_episodes(source, robot, limit)
+    with h5py.File(source / items[0]["hdf5_path"], "r") as episode:
+        fps, features, cameras = episode_layout(episode, robot)
+    dataset = LeRobotDataset.create(
+        repo_id=repo_id, root=output, fps=fps, features=deepcopy(features),
+        robot_type=robot, use_videos=True, video_backend="pyav",
+        vcodec="h264", image_writer_threads=4, encoder_threads=2,
+    )
+    try:
+        # LeRobot assigns consecutive episode indices; retain the source IDs here.
+        with (output / "meta/source_episodes.jsonl").open("w", encoding="utf-8") as mapping:
+            for episode_index, item in enumerate(items):
+                print(f"[{episode_index + 1}/{len(items)}] {item['episode_id']}", flush=True)
+                with h5py.File(source / item["hdf5_path"], "r") as episode:
+                    if episode_layout(episode, robot) != (fps, features, cameras):
+                        raise ValueError("Export each robot, frame rate, and feature layout separately")
+                    states = np.asarray(episode["agent_pose"], dtype=np.float32)
+                    actions = np.asarray(episode["actions"], dtype=np.float32)
+                    task = episode["language_instruction"].asstr()[()]
+                    with tempfile.TemporaryDirectory(prefix="labembodied-") as directory, ExitStack() as stack:
+                        videos = {
+                            camera: stack.enter_context(open_video(episode[camera], Path(directory) / f"{camera}.mp4"))
+                            for camera in cameras
+                        }
+                        for frame_index in range(len(states)):
+                            frame = {
+                                "observation.state": states[frame_index],
+                                "action": actions[frame_index],
+                                "task": task,
+                            }
+                            for camera, capture in videos.items():
+                                ok, bgr = capture.read()
+                                key = f"observation.images.{camera}"
+                                c, h, w = features[key]["shape"]
+                                if not ok or bgr.shape != (h, w, c):
+                                    raise ValueError(f"Missing or invalid frame {frame_index} in {camera}")
+                                frame[key] = cv2.cvtColor(bgr, cv2.COLOR_BGR2RGB)
+                            dataset.add_frame(frame)
+                        for camera, capture in videos.items():
+                            if capture.read()[0]:
+                                raise ValueError(f"Extra video frames in {camera}")
+                    dataset.save_episode(parallel_encoding=False)
+                mapping.write(json.dumps({
+                    "episode_index": episode_index,
+                    "source_episode_id": item["episode_id"],
+                    "source_hdf5_path": item["hdf5_path"],
+                }) + "\n")
+                mapping.flush()
+    finally:
+        try:
+            dataset.finalize()
+        finally:
+            dataset.stop_image_writer()
+    print(f"Saved {len(items)} episodes to {output}")
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--source", type=Path, default=Path("."), help="Raw dataset root (default: current directory)")
+    parser.add_argument("--out", type=Path, required=True, help="New output directory; must not already exist")
+    parser.add_argument("--repo-id", required=True, help="LeRobot dataset ID, e.g. local/labembodied-ur5e")
+    parser.add_argument("--robot", required=True, help="Robot type in the episode index, e.g. ur5e")
+    parser.add_argument("--max-episodes", type=int, help="Limit the export for a small trial; omit to export all selected episodes")
+    args = parser.parse_args()
+    if args.out.exists():
+        parser.error("Output directory already exists; choose a new --out path")
+    if args.max_episodes is not None and args.max_episodes <= 0:
+        parser.error("--max-episodes must be positive")
+    export(args.source, args.out, args.repo_id, args.robot, args.max_episodes)
+
+
+if __name__ == "__main__":
+    main()

examples/requirements.txt

@@ -0,0 +1,2 @@
+lerobot==0.4.4
+h5py>=3.10

meta/episodes.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:00736b30561f50b50652b0c94eec1b120d4c000fe6a0de167c48c7ec56936f11
+size 46690581

meta/info.json

@@ -0,0 +1,45 @@
+{
+  "name": "LabEmbodied-Data Beta",
+  "format": "robogenesis-raw-h5",
+  "format_version": "1.0",
+  "license": "MIT",
+  "robot_type": "ur5e",
+  "episodes": 56314,
+  "task_configurations": 629,
+  "frames": 69539976,
+  "h5_bytes": 366367235420,
+  "fps": 20.0,
+  "camera_names": [
+    "camera_1_rgb",
+    "camera_2_rgb",
+    "camera_3_rgb"
+  ],
+  "camera_resolution_hw": [
+    512,
+    512
+  ],
+  "families": {
+    "fastfix_v3": {
+      "cases": 257,
+      "episodes": 24783,
+      "frames": 23941857,
+      "h5_bytes": 130018270388
+    },
+    "lab3_v1": {
+      "cases": 372,
+      "episodes": 31531,
+      "frames": 45598119,
+      "h5_bytes": 236348965032
+    }
+  },
+  "indices": {
+    "episodes": "meta/episodes.jsonl",
+    "cases": "meta/cases.jsonl"
+  },
+  "native_lerobot": false,
+  "repository_name": "LabEmbodied-Data-Beta",
+  "release_stage": "beta",
+  "data_root": "ur5e",
+  "paper": "https://arxiv.org/abs/2606.13578",
+  "description": "A subset of LabEmbodied-Data introduced in LabVLA."
+}