HDF5 vs RLDS vs LeRobot: Roboterdatenformat verglichen
Vollständiger Vergleich von Roboter-Datenformat <unk> HDF5, RLDS, LeRobot. Wann jedes zu verwenden, wie man zwischen ihnen konvertiert und wie RCSV Ihre Daten liefert.
[← Führer]
Der endgültige Leitfaden für Robotikingenieure, die zwischen den drei dominierenden Roboter-Datenformatformaten ACT, Octo, LeRobot und Open X-Embodiment verstehen, produzieren und konvertieren müssen.
Warum das Datensatzformat wichtig ist
Das Format, das Sie am ersten Tag wählen, bestimmt drei Dinge, die Ihr Projekt für Monate beeinflussen werden:
1. Kompatibilität des Bildungsrahmens
Jedes wichtige Trainingsrahmen erwartet Daten in einem bestimmten Format. ACT und Diffusion Policy lesen HDF5 natively. Octo und die Open X-Embodiment Datenmix-Skripte erwarten RLDS/TFRecord. Die LeRobot-Training-Bibliothek liest LeRobot Parquet. Wenn Ihre Daten im falschen Format sind, schreiben Sie Konversions-Scripts, bevor Sie
2. Speicher- und Zugriffseffizienz
Ein 500-Episoden-Datensatz mit 3 Kameras bei 30 Fps nimmt 25-50 GB in RAW HDF5, 15-30 GB in komprimiertem HDF5, 3-8 GB in LeRobot (MP4-Video) oder 20-40 GB in RLDS/TFRecord ein. Der Speicherunterschied spielt bei Cloud-Hosting-Kosten, Download-Zeiten und Trainingsdaten-Lade-Geschwindigkeit eine Rolle. Die Speichereffizienz ist jedoch im Gegensatz zur Datenvertragbarkeit schlecht: Die MP4-Kompression von LeRobot ist verlustreich, während HDF5 und RLDS genaue Pixelwerte erhalten.
3. Gemeinschaft und Teilung
Wenn Sie Ihren Datensatz öffentlich teilen möchten, bietet Ihnen das LeRobot-Format mit eingebauter Webvisualisierung einen One-Command-Upload auf Hugging Face Hub. RLDS bietet Ihnen Kompatibilität mit dem Open X-Embodiment-Ökosystem (50+ Datensätze, 22 Robotertypen). HDF5 bietet Ihnen maximale Flexibilität, aber keine standardisierte Sharing-Plattform.
Unsere Empfehlung: Nutzen Sie HDF5 als Ihr Informations- und Speicherformat. Umwandeln Sie auf LeRobot zum Teilen und auf RLDS zum Kreuz-Einbildungs-Training. Dies gibt Ihnen das Beste aus allen drei Ökosystemen ohne die Nachteile eines einzigen Format-Lock-in.
HDF5: Goldstandard für die Datenspeicherung von Robotern
HDF5 (Hierarchical Data Format 5) speichert Daten in einer Dateisystem-ähnlichen Hierarchie von Gruppen (Verzeichnisse) und Datensätzen (Aren). Es wurde ursprünglich für wissenschaftliche Rechenarbeit entwickelt und ist dank seiner Flexibilität, reifem Werkzeug und effizienten Zufallszugangs zum de facto Standard für Roboterdemonstrationsdaten geworden.
Episodensstruktur
Das Standard-Layout von ACT/ALOHA HDF5 speichert jede Episode als Top-Level-Gruppe mit Beobachtungen, Aktionen und Metadaten-Attributen:
/episode_0/
observations/
images/
cam_high # uint8 [T x 480 x 640 x 3] overhead camera
cam_wrist_left # uint8 [T x 480 x 640 x 3] left wrist camera
cam_wrist_right # uint8 [T x 480 x 640 x 3] right wrist camera
qpos # float32 [T x 14] joint positions (7 per arm)
qvel # float32 [T x 14] joint velocities
action # float32 [T x 14] leader arm positions (supervision signal)
attrs:
task = "pick_cube_bimanual"
operator_id = "op_03"
success = True
num_timesteps = 450
timestamp = "2026-04-10T14:32:00Z"
Lesen von HDF5 mit Python
Das Lesen von Episoden mit h5py ist einfach. Hier ist ein vollständiges Beispiel, das die Beobachtungen und Aktionen einer Episode aufladen:
import h5py
import numpy as np
# Open a single episode file
with h5py.File("episode_0.hdf5", "r") as f:
# Read joint positions and actions
qpos = f["/observations/qpos"][:] # shape: [T, 14]
action = f["/action"][:] # shape: [T, 14]
# Read a specific camera frame (random access)
frame_100 = f["/observations/images/cam_high"][100] # shape: [480, 640, 3]
# Read all frames for a camera
all_frames = f["/observations/images/cam_high"][:] # shape: [T, 480, 640, 3]
# Read metadata
task = f.attrs.get("task", "unknown")
success = f.attrs.get("success", False)
print(f"Task: {task}, Success: {success}")
print(f"Episode length: {qpos.shape[0]} timesteps")
print(f"Joint positions range: [{qpos.min():.3f}, {qpos.max():.3f}]")
HDF5 Beste Praxis
- ** Chunking:** Stets schneiden Sie Datensätze entlang der Zeitsachse. Verwenden Sie chunk_size=1 für zufälligen Zugriff (Debugging, Visualisierung) oder chunk_size=32 für die sequentielle Leseffizienz (Training).
- ** Kompression:** LZF für Bilddaten (3-5x schneller als GZIP bei ähnlichen Verhältnissen für Kamerabläufe). GZIP-Level 4 für gemeinsame Bahnen (höheres Verhältnis, Geschwindigkeit nicht kritisch).
- Metadatenattribute: Speichern Sie Episoden-Metadaten als HDF5-Gruppenattribute:
T10 , T11 , T12 , T13 . Fügen Sie ein T14 -Attribut in die Dateirot ein, um Änderungen des Formats zu verfolgen. - Eine Datei pro Episode vs. eine Datei pro Datensatz: Für Datensätze unter 1.000 Episoden ist eine HDF5-Datei pro Episode für parallele Verarbeitung und teilweise Wiedererhebung einfacher. Für größere Datensätze sollten 50-100 Episoden pro Datei verpackt werden, um die Overhead des Dateisystems zu reduzieren.
HDF5 Vor- und Nachteile
Pros
- Erwachsene Bibliotheksunterstützung (h5py, HDFView, Julia, C++)
- Effizienter zufälliger Zugang zu jedem Rahmen
- Flexibles Schema
freie Angabe von benutzerdefinierten Sensortypen - Verlustfreie Speicherung bewahrt genaue Pixelwerte
- Native zu ACT, ALOHA und Diffusion
- Menschlich überprüfbar mit HDFView GUI
Kons
- Keine integrierte Versionsverfolgung oder Herkunftsverfolgung
- Nicht cloud-streamable (Muss vollständige Datei herunterladen)
- Große Dateigrößen ohne Video-Kompression
- Schema-Inkonsistenzen zwischen den Laboren
- Keine standardisierte Plattform zum Teilen
- Gleichzeitige Schriften erfordern sorgfältiges Sperren
RLDS: Der offene X-Einheit-Standard
RLDS (Reinforcement Learning Datasets) ist das Format, das von dem Open X-Embodiment Datensatz verwendet wird
RLDS-Schema
Jeder RLDS-Datensatz wird durch einen TensorFlow DatensatzBuilder definiert, der das Featureschema spezifiziert. Episoden werden als Schrittenfolge dargestellt, in denen jeder Schritt Folgendes enthält:
# Standard RLDS step structure
step = {
"observation": {
"image": tf.uint8, # shape: [H, W, C]
"state": tf.float32, # shape: [D] (joint positions + gripper)
"wrist_image": tf.uint8, # shape: [H, W, C] (optional)
},
"action": tf.float32, # shape: [D]
"reward": tf.float32, # scalar
"discount": tf.float32, # scalar (typically 1.0)
"is_terminal": tf.bool, # True on terminal state
"is_first": tf.bool, # True on first step
"is_last": tf.bool, # True on last step
"language_instruction": tf.string, # natural language task description
}
Lade von RLDS-Daten
import tensorflow_datasets as tfds
# Load an Open X-Embodiment dataset
dataset = tfds.load("berkeley_autolab_ur5", split="train")
# Iterate over episodes
for episode in dataset.take(5):
steps = episode["steps"]
for step in steps:
image = step["observation"]["image"].numpy() # [H, W, 3]
state = step["observation"]["state"].numpy() # [D]
action = step["action"].numpy() # [D]
instruction = step["language_instruction"].numpy().decode()
print(f"Instruction: {instruction}")
print(f"State shape: {state.shape}, Action shape: {action.shape}")
break # just first step
RLDS Vor- und Nachteile
Pros
- Das standardisierte Schema ermöglicht das Training zwischen Datensätzen
- Effizientes Streaming über tf.data-Pipelines
- Cloud-native (Streaming von GCS/S3 ohne Download)
- 50+ Datensätze in kompatibelem Format verfügbar
- Native für Octo, RT-2 und OXE-Daten-Mix
- Eingebildetes Sprachunterrichtfeld
Kons
- Abhängigkeit von TensorFlow (schwer für PyTorch-Teams)
- Nur Sequenzzugriff (keine effiziente zufällige Rahmen)
- Starr Schema
benutzerdefinierte Sensoren benötigen DatasetBuilder - Das Schreiben eines DatasetBuilders dauert 2-4 Stunden
- Die Inspektion erfordert TF-Werkzeuge
- Weniger intuitiv als HDF5 für Debugging
LeRobot: Das Ökosystem der Umarmung
LeRobot, entwickelt von Hugging Face, verwendet Parquet-Dateien für Tabellendaten (gemeinsame Positionen, Aktionen, Metadaten) und MP4-Video-Dateien für Kamerabeobachtungen. Es ist für den Open-Source-Forschungs-Workflow entwickelt: lokal sammeln, auf Hugging Face Hub schieben, trainieren mit der LeRobot-Bibliothek, Ergebnisse mit der Gemeinschaft teilen.
Struktur des LeRobot Datensatzes
Ein LeRobot-Daten-Set auf Hugging Face Hub enthält:
my_dataset/
data/
train-00000-of-00001.parquet # tabular data (all episodes)
videos/
observation.images.cam_high/
episode_000000.mp4 # overhead camera video
episode_000001.mp4
observation.images.cam_wrist/
episode_000000.mp4 # wrist camera video
episode_000001.mp4
meta/
info.json # dataset metadata, features schema
episodes.jsonl # per-episode metadata
stats.json # per-feature mean/std/min/max
Die Parquet-Datei enthält eine Zeile pro Zeitschritt mit Spalten für
Lade von LeRobot-Daten
from lerobot.common.datasets.lerobot_dataset import LeRobotDataset
# Load a dataset from Hugging Face Hub
dataset = LeRobotDataset("lerobot/aloha_sim_transfer_cube_human")
# Access a single frame (returns a dict of tensors)
frame = dataset[0]
print(f"State: {frame['observation.state'].shape}") # [D]
print(f"Action: {frame['action'].shape}") # [D]
print(f"Image: {frame['observation.images.cam_high'].shape}") # [C, H, W]
# Get episode-level info
print(f"Number of episodes: {dataset.num_episodes}")
print(f"Number of frames: {dataset.num_frames}")
print(f"FPS: {dataset.fps}")
Vor- und Nachteile von LeRobot
Pros
- Ein-Befehls-Upload auf Hugging Face Hub
- Eingebildete Webvisualisierung unter hf.co/datasets/
- Kompaktes Speicher (MP4-Video 5-10x kleiner als Rohmaterial)
- 300+ öffentliche Datensätze und rasch wachsende
- Unterstützung der Ausbildung für Native ACT und Diffusionpolitik
- Statistiken (Mittel/Std) automatisch berechnet
Kons
- MP4-Kompression ist verlustlos
nicht Quelle-of-Wahrheit Qualität - Video-Decodierung erhöht die Latenz während des Trainings
- Parquet nicht ideal für Folgen mit variabler Länge
- Schemaänderungen erfordern eine vollständige Datensatzwiederherstellung
- Neues Format mit sich entwickelnden Werkzeugen
- Kein beliebiger Bildzugriff ohne Video-Decodierung
Formatvergleichstabelle
| Feature | HDF5 | RLDS / TFRecord | LeRobot / Parquet |
|---|---|---|---|
| Native frameworks | ACT, Diffusion Policy, custom | Octo, RT-2, OXE data mix | LeRobot, ACT (via lib), DP (via lib) |
| Storage size (500 eps, 3 cams) | 15-30 GB (compressed) | 20-40 GB | 3-8 GB (MP4) |
| Image fidelity | Lossless (raw uint8) | Lossless (raw uint8) | Lossy (MP4 H.264/H.265) |
| Random frame access | Efficient (chunked) | Inefficient (sequential) | Requires video decode |
| Cloud streaming | No (download required) | Yes (tf.data from GCS/S3) | Yes (HF Hub streaming) |
| Schema flexibility | High (any structure) | Low (fixed DatasetBuilder) | Medium (Parquet columns) |
| Sharing platform | None (manual hosting) | TFDS catalog | Hugging Face Hub |
| Community datasets | Many (no central catalog) | 50+ (Open X-Embodiment) | 300+ (Hugging Face Hub) |
| Python tooling | h5py (mature, lightweight) | tensorflow-datasets (heavy) | lerobot, datasets (growing) |
| Recommended for | Primary storage, ACT/DP training | Cross-embodiment, Octo training | Sharing, community, quick start |
Umwandlung zwischen den Formaten
Sie werden Daten in mehreren Formaten benötigen. Hier ist der praktische Leitfaden zur Konvertierung mit den Werkzeugen und geschätzten Aufwand für jeden Weg.
HDF5 an LeRobot
Die LeRobot-Bibliothek bietet eine native Konvertierung für ALOHA-Stil HDF5-Datenmengen:
# Convert ALOHA HDF5 to LeRobot format and push to Hub
python -m lerobot.scripts.push_dataset_to_hub \
--raw-dir /path/to/hdf5/episodes \
--raw-format aloha_hdf5 \
--repo-id your-org/dataset-name \
--push-to-hub 1
Für benutzerdefinierte HDF5-Schemas (nicht ALOHA) müssen Sie eine kleine Adapterfunktion schreiben, die Ihre Schlüsselnamen auf LeRobots erwartetes Schema abbildet.
HDF5 bis RLDS
Um RLDS zu konvertieren, ist ein benutzerdefinierter TensorFlow DatasetBuilder erforderlich. Dies ist die arbeitsintensivste Konvertierung (2-4 Stunden für ein neues Schema), ist jedoch ein einmaliger Preis pro Datensatzformat:
# Skeleton RLDS DatasetBuilder (simplified)
import tensorflow_datasets as tfds
class MyRobotDataset(tfds.core.GeneratorBasedBuilder):
VERSION = tfds.core.Version("1.0.0")
def _info(self):
return tfds.core.DatasetInfo(
builder=self,
features=tfds.features.FeaturesDict({
"steps": tfds.features.Dataset({
"observation": tfds.features.FeaturesDict({
"image": tfds.features.Image(shape=(480, 640, 3)),
"state": tfds.features.Tensor(shape=(14,), dtype=tf.float32),
}),
"action": tfds.features.Tensor(shape=(14,), dtype=tf.float32),
"is_terminal": tf.bool,
"is_first": tf.bool,
"is_last": tf.bool,
"language_instruction": tfds.features.Text(),
}),
}),
)
def _generate_examples(self, path):
# Read from your HDF5 files and yield episodes
for episode_path in sorted(path.glob("*.hdf5")):
with h5py.File(episode_path, "r") as f:
# Map HDF5 fields to RLDS schema
yield episode_id, {"steps": steps_list}
RLDS an LeRobot
LeRobot bietet einen integrierten Converter für RLDS-Datensätze, einschließlich aller Open X-Embodiment-Datensätze:
# Convert any RLDS dataset to LeRobot format
python -m lerobot.scripts.push_dataset_to_hub \
--raw-dir /path/to/rlds/dataset \
--raw-format rlds \
--repo-id your-org/converted-dataset \
--push-to-hub 1
LeRobot auf HDF5
Es gibt kein offizielles Instrument für diese Richtung, aber es ist einfach zu schreiben (30-60 Minuten):
from lerobot.common.datasets.lerobot_dataset import LeRobotDataset
import h5py
import numpy as np
dataset = LeRobotDataset("your-org/dataset-name")
for ep_idx in range(dataset.num_episodes):
ep_frames = [dataset[i] for i in range(len(dataset))
if dataset[i]["episode_index"] == ep_idx]
with h5py.File(f"episode_{ep_idx:05d}.hdf5", "w") as f:
qpos = np.stack([fr["observation.state"].numpy() for fr in ep_frames])
action = np.stack([fr["action"].numpy() for fr in ep_frames])
f.create_dataset("observations/qpos", data=qpos, chunks=(1, qpos.shape[1]))
f.create_dataset("action", data=action, chunks=(1, action.shape[1]))
# Decode and store video frames as image arrays
# ... (video decode step adds complexity)
** Wichtige Vorbeugung:** Die Umstellung von LeRobot zurück auf HDF5 kann die ursprüngliche Pixel-Eigenschaft nicht wiederherstellen, da LeRobot Bilder als MP4-Video speichert.
Übersetzungsvorlage
| From → To | Tool | Effort | Notes |
|---|---|---|---|
| HDF5 → LeRobot | lerobot.scripts.push_dataset_to_hub | 30 min | Native ALOHA support; custom schemas need adapter |
| HDF5 → RLDS | Custom DatasetBuilder | 2-4 hours | One-time per schema; requires TF knowledge |
| RLDS → LeRobot | lerobot.scripts.push_dataset_to_hub --raw-format rlds | 15 min | Works for all OXE datasets |
| LeRobot → HDF5 | Custom script | 30-60 min | Lossy: MP4 frames, not original raw images |
| Any → Any | RCSV Platform | 5 min | Upload once, export to any format via UI |
Wie RCSV Ihre Daten liefert
Wenn Sie RCSV für eine Daten-Sammel-Kampagne einbeziehen, verarbeiten wir so die Formatlieferung:
Sammelformat
Wir sammeln immer in HDF5 als unsere Quelle der Wahrheit. Rohsensordaten werden mit Zeitstempeln pro Rahmen, vollen Metadaten und zusammengefassten Datensätzen für effizienten Zugriff losslos gespeichert. Diese Master-Kopie wird für die Dauer Ihres Projekts aufbewahrt.
Lieferformat
Sie geben Ihr Zielformat in der Projektbeschreibung an.
- HDF5: Direktverfügung der Daten aus der Quelle der Wahrheit.
- RLDS / TFRecord: Konvertiert mit einem benutzerdefinierten DatasetBuilder, der mit Ihrem Schema übereinstimmt.
- LeRobot / Parquet: In ein privates Hugs Face Hub-Repository unter Ihrer Organisation verschoben.
- Nachgewählte Formate: ROS-Bag, CSV, JSON-Lines oder proprietäre Schemata.
Was ist enthalten
Jede Datenmenge enthält:
- Die Datensätze in Ihrem angeforderten Format
- Ein Datenmanifest (JSON), in dem alle Episoden mit Metadaten, Qualitätsscores und Statistiken aufgeführt sind
- Schema-Dokumentation, die jedes Feld, jeden Datentyp und jede Einheit beschreibt
- Ein Python-Beispielschrift, das eine Episode lädt und Formen und Bereiche druckt
- Statistiken über die Performance (Mittel, Std, Min, Max) für die Normalisierung während der Ausbildung
- Qualitätsberichterstattung, die Qualitätsmesswerte für den gesamten Datensatz zusammenfasst
Export der RCSV-Plattform
Wenn Sie die [RCSV Fearless Platform] (
Häufig gestellte Fragen
Welches Format sollte ich verwenden, wenn ich gerade anfange?
Sie können immer später auf LeRobot oder RLDS konvertieren. Wenn Sie Ihren Datensatz sofort auf Hugging Face Hub teilen möchten, verwenden Sie LeRobot von Anfang an
Ist LeRobots MP4-Kompression ein Problem für das Training?
Für die meisten Manipulationsarbeiten: Nein. Die visuellen Artefakte aus der Kompression von H.264 bei angemessenen Qualitätsanpassungen (CRF 20-23) liegen unter dem Lärmniveau typischer Kamerasensoren. Für Aufgaben, bei denen die Pixelpräzision wichtig ist, verwenden Sie jedoch
Kann ich Datenmengen aus verschiedenen Formaten für das Training mischen?
Ja, aber Sie müssen sie zuerst in ein gemeinsames Format normalisieren. Der praktischste Ansatz ist es, alles vor dem Training in ein einziges Format umzuwandeln. Wenn Sie mit Octo trainieren oder Kreuzkörperversuche durchführen, konvertieren Sie alles in RLDS. Wenn Sie mit der LeRobot-Bibliothek trainieren, konvertieren Sie alles in LeRobot-Format. Die RCSV-Plattform kann gemischte Format-Uploads in einen einheitlichen Datensatz normalisieren und exportieren.
Wie steuere ich die Versionen meiner Roboter-Daten?
Für LeRobot-Datensätze auf Hugging Face Hub ist Versionsverarbeitung über Git-lfs eingebaut. Für HDF5 verwenden Sie eine Datensatzdatei (JSON) neben Ihren HDF5-Dateien, die Schema_Version, Erstellungsdatum, Episodenliste und Statistiken aufzeichnet. Schemaversion bump, wenn Sie die Sensorkonfiguration ändern. Für Produktionsworkflows bietet die RCSV-Plattform vollständige Datensatzversion mit Rollback.
Was ist mit dem ROS-Taschenformat?
Die ROS-Tasche (ROSbag2 in ROS2) ist hervorragend für die Datenerfassung während der Sammlung, da sie alle ROS-Themen mit Zeitstempeln nativ erfasst. Der Standard-Workflow ist: Aufnahme in ROS-Tasche während der Sammlung, dann umwandeln Sie in HDF5 (oder LeRobot/RLDS) für Training und Weitergabe.
RCSV kann die Datenformatverarbeitung übernehmen
Laden Sie Ihre Roboterdaten auf die RCSV-Plattform für Visualisierung, Qualitätsprüfung und Export mit einem Klick in HDF5, LeRobot Parquet oder RLDS-Format hoch. Oder lassen Sie uns Ihre Daten sammeln und in dem genauen Format liefern, das Ihre Trainingsleitung benötigt.