HDF5 vs RLDS vs LeRobot: Comparado de los formatos del conjunto de datos del robot
Comparación completa de los formatos de conjunto de datos de robots <unk> HDF5, RLDS, LeRobot. Cuándo usar cada uno, cómo convertir entre ellos y cómo RCSV entrega sus datos.
[← Guías]
La guía definitiva para los ingenieros de robótica que necesitan entender, producir y convertir entre los tres formatos dominantes de conjuntos de datos de robots utilizados por ACT, Octo, LeRobot y Open X-Embodiment. Actualizado para 2026.
Por qué es importante el formato de los conjuntos de datos
El formato de los datos de entrenamiento de robots no es un detalle que puedas posponer.
1. Compatibilidad del marco de formación
Cada marco de entrenamiento principal espera datos en un formato específico. ACT y Política de difusión leen HDF5 de forma nativa. Octo y los guiones de mezcla de datos Open X-Embodiment esperan RLDS/TFRecord. La biblioteca de entrenamiento LeRobot lee LeRobot Parquet. Si sus datos están en el formato equivocado, está escribiendo scripts de conversión antes de poder entrenar
2. Eficiencia de almacenamiento y patrones de acceso
Un conjunto de datos de 500 episodios con 3 cámaras a 30 fps ocupa 25-50 GB en HDF5 crudo, 15-30 GB en HDF5 comprimido, 3-8 GB en LeRobot (vidéo MP4) o 20-40 GB en RLDS / TFRecord. La diferencia de almacenamiento importa para los costos de alojamiento en la nube, los tiempos de descarga y la velocidad de carga de datos de entrenamiento. Pero la eficiencia de almacenamiento se opone a la fidelidad de los datos: la compresión de MP4 de LeRobot es perdida, mientras que HDF5 y RLDS conservan valores de píxeles exactos.
3. Comunidad y participación
Si desea compartir su conjunto de datos públicamente, el formato LeRobot le da una sola orden de carga a Hugging Face Hub con visualización web integrada. RLDS le da compatibilidad con el ecosistema Open X-Embodiment (50+ conjuntos de datos, 22 tipos de robots). HDF5 le da la máxima flexibilidad pero no una plataforma de compartir estandarizada.
Nuestra recomendación: Utilice HDF5 como su formato de recogida y almacenamiento de la fuente de la verdad. Convertirse en LeRobot para compartir y en RLDS para entrenamiento de encarnación cruzada. Esto le da lo mejor de los tres ecosistemas sin las desventajas de ningún formato de bloqueo.
HDF5: El estándar de oro para el almacenamiento de datos de robots
HDF5 (Hirarchical Data Format 5) almacena datos en una jerarquía similar a un sistema de archivos de grupos (directorios) y conjuntos de datos (arrayes). Fue desarrollado originalmente para la computación científica y se ha convertido en el estándar de facto para los datos de demostración de robots gracias a su flexibilidad, herramientas maduras y acceso aleatorio eficiente.
Estructura de los episodios
El diseño estándar ACT/ALOHA HDF5 almacena cada episodio como un grupo de nivel superior con observaciones, acciones y atributos de metadatos:
/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"
Lectura de HDF5 con Python
La lectura de episodios con h5py es sencilla. Aquí hay un ejemplo completo que carga las observaciones y acciones de un episodio:
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}]")
Las mejores prácticas de HDF5
- ** Chunking:** Siempre fragmenta los conjuntos de datos a lo largo del eje temporal. Utilice chunk_size=1 para el acceso aleatorio (debugging, visualización) o chunk_size=32 para la eficiencia de lectura secuencial (entrenamiento). Nunca almacene datos de imagen no fragmentos
se carga como un solo bloque monolitico. - ** Compresión:** Utilice LZF para datos de imagen (3-5 veces más rápido que GZIP en proporciones similares para los marcos de cámara). Utilice GZIP nivel 4 para trayectorias conjuntas (proporción más alta, velocidad no crítica). No comprime imágenes en el momento de la recopilación
aplicar compresión en el archivo final después de la validación de calificación. - ** Atributos de metadatos:** Almacenar metadatos de episodios como atributos del grupo HDF5:
T10 , T11 , T12 , T13 . Incluir un atributo T14 en la raíz de archivo para rastrear los cambios de formato. - Un archivo por episodio frente a un archivo por conjunto de datos: Para conjuntos de datos menores a 1.000 episodios, un archivo HDF5 por episodio es más sencillo para el procesamiento paralelo y la recopilación parcial. Para conjuntos de datos más grandes, considere empacar 50-100 episodios por archivo para reducir el gasto general del sistema de archivos.
HDF5 Pros y Cons
Las cosas están bien.
- Soporte de bibliotecas maduras (h5py, HDFView, Julia, C++)
- Acceso aleatorio eficiente a cualquier marco
- Esquema flexible
agregar tipos de sensores personalizados libremente - El almacenamiento sin pérdidas conserva los valores exactos de los píxeles
- Nativo de la política de ACT, ALOHA y difusión
- Inspectable por el hombre con interfaz gráfica HDFView
Cons
- No se incluye versiones o seguimiento de procedencia
- No se puede transmitir en la nube (debe descargar el archivo completo)
- Tamaños de archivos grandes sin compresión de vídeo
- Incoherencias de esquemas entre laboratorios
- No hay plataforma de intercambio estandarizada
- Las escrituras concurrentes requieren un bloqueo cuidadoso
RLDS: La norma de los cuerpos X abiertos
RLDS (Reinforcement Learning Datasets) es el formato utilizado por el conjunto de datos Open X-Embodiment
Plan de RLDS
Cada conjunto de datos RLDS es definido por un TensorFlow DatasetBuilder que especifica el esquema de características. Los episodios se representan como secuencias de pasos, donde cada paso contiene:
# 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
}
Carga de datos RLDS
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
Los pros y los contras de RLDS
Las cosas están bien.
- El esquema estandarizado permite la formación de conjuntos de datos
- Transmisiones eficientes a través de las tuberías de tf.data
- Nativo en la nube (transmitido desde GCS/S3 sin descarga)
- 50 conjuntos de datos disponibles en formato compatible
- Nativo de la mezcla de datos Octo, RT-2 y OXE
- Campo de instrucción de idiomas incorporado
Cons
- Dependencia de TensorFlow (pesada para los equipos PyTorch)
- Solo acceso secuencial (no hay marco aleatorio eficiente)
- Esquema rígido
sensores personalizados necesitan DatasetBuilder - Escribir un DatasetBuilder toma 2-4 horas
- La inspección requiere herramientas TF
- Menos intuitiva que HDF5 para el depuración
El ecosistema de la cara abrazada
LeRobot, desarrollado por Hugging Face, utiliza archivos Parquet para datos tablales (posiciones conjuntas, acciones, metadatos) y archivos de video MP4 para observaciones de cámara.
Estructura del conjunto de datos de LeRobot
Un conjunto de datos de LeRobot en Hugging Face Hub contiene:
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
El archivo de Parquet contiene una fila por paso de tiempo con columnas para
Carga de datos de LeRobot
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}")
Los pros y los contras de LeRobot
Las cosas están bien.
- Carga de un solo comando en Hugging Face Hub
- Visualización web integrada en hf.co/datasets/
- Almacenamiento compacto (video MP4 5-10 veces más pequeño que el crudo)
- Más de 300 conjuntos de datos públicos y creciendo rápidamente
- Apoyo a la formación en materia de ACT y de política de difusión
- Estadísticas (medio/sd) calculadas automáticamente
Cons
- La compresión de MP4 es de pérdida
no fuente de la verdad calidad - El decodificación de video agrega latencia durante el entrenamiento
- Parquet no ideal para episodios de longitud variable
- Los cambios en el esquema requieren la reconstrucción completa del conjunto de datos
- Formatos más nuevos con herramientas en evolución
- No hay acceso al marco al azar sin decodificar el video
Tabla de comparación de formato
| 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 |
Convertir entre formatos
Con el tiempo necesitarás datos en múltiples formatos. Aquí está la guía práctica de conversión, con las herramientas y el esfuerzo estimado para cada camino.
HDF5 a LeRobot
La biblioteca LeRobot proporciona la conversión nativa para conjuntos de datos HDF5 de estilo ALOHA:
# 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
Para esquemas HDF5 personalizados (no ALOHA), es necesario escribir una pequeña función de adaptador que mapee los nombres de sus claves al esquema esperado de LeRobot.
HDF5 a RLDS
Convertir a RLDS requiere escribir un TensorFlow DatasetBuilder personalizado. Esta es la conversión más laboriosa (2-4 horas para un nuevo esquema), pero es un costo único por formato de conjunto de datos:
# 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 a LeRobot
LeRobot proporciona un convertidor incorporado para conjuntos de datos RLDS, incluyendo todos los conjuntos de datos Open X-Embodiment:
# 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 a HDF5
No existe una herramienta oficial para esta dirección, pero es sencillo escribir (30-60 minutos):
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)
** Importante advertencia:** Convertir de LeRobot de nuevo a HDF5 no puede recuperar la fidelidad original a nivel de píxeles porque LeRobot almacena imágenes como video MP4 de pérdida.
Cuadro de resumen de las conversiones
| 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 |
Cómo el RCSV entrega sus datos
Cuando usted involucra RCSV para una campaña de recopilación de datos, aquí es cómo manejamos la entrega de formato:
Formatos de recogida
Los datos de los sensores se almacenan sin pérdidas con timestamps por marco, metadatos completos y conjuntos de datos en pedazos para un acceso eficiente. Esta copia maestra se conserva durante la duración de su proyecto.
Formatos de entrega
Especifica tu formato objetivo en el informe del proyecto.
- HDF5: Entrega directa de los archivos de origen de la verdad. Incluye documentación de esquema y un guión de ejemplo de Python para cargar.
- RLDS / TFRecord: Conversado con un DatasetBuilder personalizado que coincida con su esquema. Incluye el código fuente de DatasetBuilder para que pueda volver a ejecutar la conversión usted mismo.
- LeRobot / Parquet: Empujado a un repositorio privado de Hugging Face Hub bajo su organización. Incluye tarjeta de conjunto de datos con metadatos completos, estadísticas y visualización.
- Formatos personalizados: bolso ROS, CSV, líneas JSON o esquemas propietarios. Escribemos el adaptador de exportación e incluimos en la entrega.
Lo que incluye
Cada entrega de conjunto de datos incluye:
- Los archivos del conjunto de datos en el formato solicitado
- Un manifiesto de datos (JSON) que enumera todos los episodios con metadatos, puntuaciones de calidad y estadísticas
- Documentación de esquema que describe cada campo, tipo de datos y unidad
- Un guión de Python que carga un episodio e imprime formas y rangos
- Estadísticas de las características (media, std, min, max) para la normalización durante la formación
- Informe de calificación que resume las métricas de calidad en todo el conjunto de datos
Exportación de la plataforma RCSV
Si utiliza la [RCSV Fearless Platform]
Preguntas frecuentes
¿Qué formato debería usar si estoy empezando?
Comienza con HDF5. Tiene el sistema de herramientas más simple (h5py), el esquema más flexible, y es nativo de los marcos de entrenamiento más populares (ACT, Política de difusión). Siempre puede convertirse a LeRobot o RLDS más tarde. Si desea compartir su conjunto de datos inmediatamente en Hugging Face Hub, use LeRobot desde el principio
¿La compresión de MP4 de LeRobot es un problema para el entrenamiento?
Para la mayoría de las tareas de manipulación, no. Los artefactos visuales de la compresión H.264 en configuraciones de calidad razonables (CRF 20-23) están por debajo del nivel de ruido de los sensores de cámara típicos. Sin embargo, para tareas donde la precisión a nivel de píxel importa
¿Puedo mezclar conjuntos de datos de diferentes formatos para entrenamiento?
Si estás entrenando con Octo o haciendo experimentos de encarnación cruzada, conviértelo todo en RLDS. Si estás entrenando con la biblioteca LeRobot, conviértelo todo en formato LeRobot. La plataforma RCSV puede normalizar y exportar cargas de formato mixto en un conjunto de datos unificado.
¿Cómo puedo controlar mis conjuntos de datos de robots?
Para los conjuntos de datos de LeRobot en Hugging Face Hub, la versión se construye a través de git-lfs. Para HDF5, use un archivo de manifiesto de datos (JSON) junto a sus archivos HDF5 que registra el esquema_versión, fecha de creación, lista de episodios y estadísticas.
¿Qué hay del formato de bolso ROS?
ROS bag (rosbag2 en ROS2) es excelente para la grabación de datos durante la recopilación porque capta todos los temas de ROS con sellos de tiempo de forma nativa. Sin embargo, no es adecuado como formato de entrenamiento porque requiere bibliotecas de ROS2 para leer, no tiene acceso aleatorio y almacena los datos en un formato optimizado para la repetición en lugar de entrenamiento ML. El flujo de trabajo estándar es: grabar en la bolsa ROS durante la recogida, luego convertir en HDF5 (o LeRobot/RLDS) para el entrenamiento y el intercambio.
Deja que RCSV maneje los formatos de tu conjunto de datos
Cargue sus datos de robots a la Plataforma RCSV para visualización, revisión de calificación y exportación con un clic al formato HDF5, LeRobot Parquet o RLDS. O permítanos recopilar sus datos y entregarlos en el formato exacto que su línea de entrenamiento necesita.
[Servicios de recogida de datos] [