Tutorial RoboMimic: Configuración, puntos de referencia y entrenamiento de su primera política

[← Guías] T17) / [Aprendizaje por imitación] T18)

Una completa experiencia de RoboMimic, el principal marco de aprendizaje de imitación fuera de línea para la manipulación de robots. Desde la instalación hasta la capacitación de su primera política de BC hasta la ejecución de la suite completa de benchmark.

¿Qué es RoboMimic?

RoboMimic es un marco de código abierto para estudiar y comparar algoritmos de aprendizaje de imitación fuera de línea para la manipulación robótica. Desarrollado por Ajay Mandlekar y colegas de Stanford y NVIDIA, fue lanzado por primera vez junto con el artículo _"Lo que importa en el aprendizaje de demostraciones humanas fuera de línea para la manipulación robótica" (CoRL 2021). El proyecto proporciona tres cosas que antes no existían en un paquete unificado: conjuntos de datos de demostración estandarizados recogidos en simulación robosuite, implementaciones de referencia de seis algoritmos de aprendizaje por imitación y protocolos de evaluación reproducibles para una comparación justa.

Los seis algoritmos soportados abarcan las principales familias de aprendizaje fuera de línea:

• **Cloning comportamental (BC) ** regresión supervisada de las observaciones a las acciones.
• BC-RNN BC con una columna vertebral LSTM que condiciona el historial de observación. Captura dependencias temporales que el BC de retroalimentación no tiene.
• **BCQ (Batch Constrained Q-Learning) ** un método de RL fuera de línea que limita la política a mantenerse cerca de la distribución de demostración mientras se optimizan los valores de Q.
• **CQL (Conservative Q-Learning) ** RL fuera de línea que penaliza los valores Q por acciones fuera de distribución, evitando la sobreestimación.
• **IQL (Q-Learning implícito) ** evita la consulta de acciones fuera de distribución por completo aprendiendo una función de valor a través de la regresión esperada.
• ** TD3-BC** TD3 con un término de regularización de clonación conductual que mantiene la política cerca de los datos mientras permite la mejora de RL.

RoboMimic es importante porque responde a una pregunta práctica: dado un conjunto de datos fijo de demostraciones humanas, ¿qué algoritmo extrae la mejor política? Antes de RoboMimic, cada documento utilizó diferentes entornos, datos diferentes y diferentes evaluaciones haciendo imposible la comparación manzana-manzana. El marco también admite [datos reales de robots]T19) en el mismo formato HDF5, por lo que los hallazgos se transfieren de los puntos de referencia de la simulación a la implementación de hardware.

Instalación

RoboMimic requiere Python 3.8+ y depende de robosuite para entornos de simulación.

# Create and activate conda environment
conda create -n robomimic python=3.10
conda activate robomimic

# Install robomimic and robosuite
pip install robomimic
pip install robosuite

# For development (editable install with source)
git clone https://github.com/ARISE-Initiative/robomimic.git
cd robomimic
pip install -e .

# Verify installation
python -c "import robomimic; print(robomimic.__version__)"

Para la capacitación acelerada con GPU (requiere para las políticas basadas en imágenes), instale PyTorch con soporte CUDA primero:

# PyTorch with CUDA 12.1 (adjust for your CUDA version)
pip install torch torchvision --index-url https://download.pytorch.org/whl/cu121

# Then install robomimic
pip install robomimic

Verifique si su GPU es visible para PyTorch antes de continuar:

python -c "import torch; print(f'CUDA available: {torch.cuda.is_available()}, Device: {torch.cuda.get_device_name(0)}')"

Datos de los conjuntos

RoboMimic proporciona conjuntos de datos de demostración pre-recolectados para cuatro tareas de manipulación robosuite.

Descargar conjuntos de datos utilizando el script incorporado:

# Download the Lift task dataset (low-dim, proficient-human, 200 demos)
python robomimic/scripts/download_datasets.py --tasks lift

# Download all four tasks
python robomimic/scripts/download_datasets.py --tasks all

# Download image observation datasets (larger, ~10 GB per task)
python robomimic/scripts/download_datasets.py --tasks lift --dataset_type image

Cada conjunto de datos se almacena como un archivo HDF5 con la siguiente estructura:

• datas/demo_0/obs/ matrículas de observación (posiciones conjuntas, posiciones de efecto final, estados de agarre, imágenes opcionales)
• datos/demo_0/acciones matrículas de acción (objetivos conjuntos de velocidad o posición)
• datos/demo_0/recompensas señal de recompensa escasa (1 en caso de éxito, 0 de lo contrario)
• datas/demo_0/dones Banderas de terminación del episodio
• Datos/máscara/ índices de división de tren/validación

Las observaciones de baja dimensión incluyen posiciones de las articulaciones del robot (7D), velocidades de las articulaciones (7D), posición del efecto final (3D), orientación del efecto final (4D cuaternion) y apertura del agarre (1D). Para tareas bimanual como el transporte, todas las matrices se duplican (una por brazo).

Entrenando su primera política

El camino más rápido para una política entrenada es BC en la tarea Lift con observaciones de baja dimensión.

** Paso 1: Generar una configuración de entrenamiento.**

# Generate a default BC config for the Lift task
python robomimic/scripts/generate_config.py \
  --algo bc \
  --task lift \
  --dataset_path datasets/lift/ph/low_dim.hdf5 \
  --output_dir configs/

** Paso 2: Revise y modifique la configuración.** La configuración generada JSON controla todos los parámetros de entrenamiento.

{
  "algo_name": "bc",
  "experiment": {
    "name": "bc_lift_lowdim",
    "epoch_every_n_steps": 500,
    "validation_epoch_every_n_steps": 50,
    "save.enabled": true
  },
  "train": {
    "data": "datasets/lift/ph/low_dim.hdf5",
    "batch_size": 100,
    "num_epochs": 2000,
    "seed": 1
  },
  "observation": {
    "modalities": {
      "obs": {
        "low_dim": ["robot0_eef_pos", "robot0_eef_quat", "robot0_gripper_qpos", "object"]
      }
    }
  }
}

** Paso 3: Ejecutar el entrenamiento.**

python robomimic/scripts/train.py --config configs/bc_lift_lowdim.json

# Training logs to stdout and TensorBoard
# Monitor: tensorboard --logdir trained_models/

** Paso 4: Evaluar la política de formación.**

# Run 50 evaluation rollouts
python robomimic/scripts/run_trained_agent.py \
  --agent trained_models/bc_lift_lowdim/models/model_best.pth \
  --n_rollouts 50 \
  --render

Si su tasa de éxito es inferior al 80%, compruebe si está utilizando el camino correcto del conjunto de datos y que la formación se realizó durante las épocas 2000.

Comparación de algoritmos

La elección del algoritmo adecuado depende de su presupuesto de datos, presupuesto de cálculo y complejidad de tareas.

Algorithm	Type	Data Efficiency	Compute Cost	Best For	Key Limitation
BC	Supervised	High	Low	Simple tasks, good data	Compounding errors on long horizons
BC-RNN	Supervised	High	Medium	Multi-step tasks, temporal reasoning	Slower inference, harder to tune
BCQ	RL Offline	Medium	High	Suboptimal data, needs improvement	Sensitive to hyperparameters
CQL	RL Offline	Medium	High	Conservative policies from noisy data	Can be overly conservative
IQL	RL Offline	Medium	Medium	Mixed-quality datasets	Requires careful expectile tuning
TD3-BC	RL Offline	Medium	High	Refining near-optimal demonstrations	Unstable with small datasets

Guía general: Comience con BC. Si BC falla debido a un error de composición de largo horizonte, pruebe BC-RNN. Si sus datos son de calidad mixta (algunas demostraciones son subóptimas), pruebe IQL. Solo use BCQ/CQL/TD3-BC si tiene una razón específica para creer que la mejora de RL fuera de línea sobre la distribución de datos es necesaria y alcanzable. En la práctica, BC-RNN es el algoritmo más confiable en las tareas de referencia de RoboMimic.

El análisis de los puntos de referencia

RoboMimic define cuatro tareas de manipulación de creciente dificultad, todas implementadas en robosuite:

• Levante recoge un cubo de la mesa. Un brazo, 1 objeto. La tarea más fácil, útil para verificar el funcionamiento de tu línea de entrenamiento.
• Can recoger una lata y colocarla en una contención de destino. Requiere una captura y colocación precisas. éxito BC: 80-95%. éxito BC-RNN: 90-98%.
• ** Cuadrado** recoger un nudo cuadrado y colocarlo en una peg. Requiere una alineación y inserción precisas. éxito BC: 40-70%. éxito BC-RNN: 60-85%.
• Transporte tarea bimanual: un brazo escoge un objeto de una contención, lo entrega al otro brazo, que lo coloca en una ubicación objetivo. La tarea más difícil, que requiere coordinación entre dos brazos.

Para ejecutar el índice de referencia completo:

# Generate configs for all tasks and algorithms
python robomimic/scripts/generate_paper_configs.py --output_dir benchmark_configs/

# Run all experiments (use a cluster or run overnight)
python robomimic/scripts/train.py --config benchmark_configs/lift/bc.json
python robomimic/scripts/train.py --config benchmark_configs/can/bc.json
python robomimic/scripts/train.py --config benchmark_configs/square/bc_rnn.json
python robomimic/scripts/train.py --config benchmark_configs/transport/bc_rnn.json

# Evaluate all trained models
python robomimic/scripts/run_trained_agent.py \
  --agent trained_models/lift/bc/models/model_best.pth \
  --n_rollouts 100

Para ejecutar el benchmark completo en todos los algoritmos y tareas se necesitan aproximadamente 3-5 días en un solo RTX 3090. Para los experimentos basados en imágenes, espere 2-3 veces más tiempo de entrenamiento.

Usando las imágenes

La capacitación de políticas basadas en imágenes es donde RoboMimic se vuelve más valiosa para la transferencia del mundo real. Los robots reales no tienen acceso a posiciones de objetos de la verdad en el suelo tienen cámaras. La capacitación de políticas visuales en la simulación y la transferencia al hardware real es la principal tubería para el despliegue de [imitación de aprendizaje] T20).

Para entrenar una política visual de BC, cambie la modalidad de observación en su configuración:

{
  "observation": {
    "modalities": {
      "obs": {
        "low_dim": ["robot0_eef_pos", "robot0_gripper_qpos"],
        "rgb": ["agentview_image", "robot0_eye_in_hand_image"]
      }
    },
    "encoder": {
      "rgb": {
        "core_class": "VisualCore",
        "core_kwargs": {
          "backbone_class": "ResNet18Conv",
          "pool_class": "SpatialSoftmax"
        }
      }
    }
  }
}

Para mejores representaciones visuales, utilice un codificador pre-entrenado como R3M (de Nair et al., 2022) en lugar de entrenar desde cero:

# Install R3M
pip install r3m

# In your config, set the encoder to use R3M
"backbone_class": "R3MConv",
"backbone_kwargs": {"r3m_model_class": "resnet18"}

** Requisitos de GPU:** El entrenamiento basado en imágenes con ResNet18 requiere al menos 8 GB de VRAM. Con R3M y tamaño de lote 16, espere un uso de 10-12 GB. Se recomienda un RTX 3080 (10 GB) o RTX 4090 (24 GB). El tiempo de entrenamiento aumenta de ~30 minutos (bajo tono) a 4-8 horas (basado en imágenes) en una sola GPU.

Recopilar sus propios datos

RoboMimic acepta cualquier conjunto de datos HDF5 que siga su formato, lo que significa que puede recopilar demostraciones en robosuite o en hardware real y entrenar con los mismos algoritmos.

Recolección en robosuite por teleoperación:

# Launch robosuite teleoperation data collection
python robosuite/scripts/collect_human_demonstrations.py \
  --environment Lift \
  --robots Panda \
  --controller OSC_POSE \
  --device keyboard

Los dispositivos de entrada soportados incluyen teclado, SpaceMouse (3Dconnexion) y controladores VR a través del puente del dispositivo. Para la recopilación a gran escala, SpaceMouse proporciona la mejor compensación entre la calidad de los datos y la fatiga del operador.

Convertir datos personalizados a formato RoboMimic: Sus datos deben organizarse como episodios en un archivo HDF5. Cada episodio necesita: observaciones (dicto de matrices), acciones (array), recompensas (array) y dones (array). Utilice la utilidad de conversión:

import h5py
import numpy as np

with h5py.File("my_dataset.hdf5", "w") as f:
    grp = f.create_group("data")
    for i, episode in enumerate(episodes):
        demo = grp.create_group(f"demo_{i}")
        obs = demo.create_group("obs")
        obs.create_dataset("robot0_eef_pos", data=episode["eef_positions"])
        obs.create_dataset("robot0_gripper_qpos", data=episode["gripper_states"])
        demo.create_dataset("actions", data=episode["actions"])
        demo.create_dataset("rewards", data=episode["rewards"])
        demo.create_dataset("dones", data=episode["dones"])

    # Create train/val split
    mask = grp.create_group("mask")
    n = len(episodes)
    mask.create_dataset("train", data=np.arange(int(n * 0.9)))
    mask.create_dataset("valid", data=np.arange(int(n * 0.9), n))

Trasladar al hardware real

La transferencia de Sim a realidad con políticas entrenadas por RoboMimic requiere atención a tres brechas críticas:

• Gapas de observación: Las imágenes reales de la cámara difieren de las simulaciones. Utilice la aleatorización de dominios en robosuite (texturas, iluminación, postura de la cámara) durante el entrenamiento, o ajuste a la perfección con un pequeño número de demostraciones reales (10-50 episodios son suficientes a menudo).
• Locar el espacio de acción: Asegúrese de que su controlador robot real acepte el mismo tipo de acción (velocidad conjunta frente a la posición OSC) a la misma frecuencia de control (normalmente 20 Hz para RoboMimic) que el entorno de entrenamiento.
• Gap de dinámica: La fricción de los objetos, la dinámica de las articulaciones del robot y el comportamiento del agarre difieren entre la simulación y la realidad.

Para su implementación en un verdadero Franka Panda (el robot RoboMimic predeterminado), utilice la interfaz del controlador T13, que proporciona el mismo espacio de acción OSC_POSE que el robosuite.

Errores y soluciones comunes

• "KeyError: 'robot0_eef_pos'" durante el entrenamiento su conjunto de datos no contiene las claves de observación esperadas por la configuración. ejecuta T14 para ver las claves disponibles, luego actualice su configuración para que coincida.
• Las pérdidas de entrenamiento disminuyen, pero el éxito de la evaluación es de 0% La política se adapta demasiado a los datos de entrenamiento. Reducir el tamaño del lote, agregar el abandono (0.1-0.3), o aumentar el tamaño del conjunto de datos. También verifique si su entorno de evaluación utiliza la misma normalización de observación que la formación.
• "CUDA fuera de la memoria" durante el entrenamiento de imágenes reducir el tamaño del lote (comenzando con 8 o 16 para las políticas de imagen) o utilizar la acumulación de gradientes.
• **El entrenamiento BC-RNN es inestable (puntos de pérdida) ** reducir la tasa de aprendizaje a 1e-4, utilizar el recorte de gradientes (max_norm=1.0), y aumentar gradualmente la longitud de la secuencia.
• Erro "MuJoCo no se encuentra" en la importación desde que MuJoCo se convirtió en código abierto (v2.1.2+), instalar a través de T15. Eliminar cualquier instalación mujoco-py antigua que sea en conflicto: T16.
• La política entrenada funciona en sim pero falla en el robot real Compruebe la discrepancia en el espacio de acción (velocidad conjunta vs posición OSC), la discrepancia en la frecuencia de control y la normalización de la observación.

Integración con el hardware RCSV

RCSV proporciona configuraciones de robots preconfiguradas que son compatibles con los flujos de trabajo de RoboMimic, eliminando la carga de integración de hardware:

• OpenArm El brazo robótico de código abierto 6-DOF de RCSV. Proporcionamos un envoltorio de acción compatible con RoboMimic que mapea las acciones OSC_POSE al controlador conjunto de OpenArm a 20 Hz. La recopilación de conjuntos de datos utiliza el mismo formato HDF5, por lo que puede entrenarse directamente con algoritmos RoboMimic sin conversión de formato.
• Franka Panda el robot RoboMimic predeterminado. RCSV opera sistemas Franka con controladores de desoxis preconfigurados para la recopilación de datos y la implementación de políticas compatibles con RoboMimic.
• ** Configuraciones bimanual** para la tarea de transporte en hardware real, RCSV proporciona sistemas de doble brazo ALOHA con recopilación de datos sincronizada a 50 Hz. El formato de datos coincide directamente con la estructura bimanual de RoboMimic.

Todos los conjuntos de datos recogidos por el RCSV se validan con respecto al esquema RoboMimic HDF5 antes de la entrega, asegurando que se carguen directamente en la línea de entrenamiento sin modificaciones.

Preguntas frecuentes

• ** ¿Para qué se utiliza RoboMimic? ** RoboMimic es un marco para el benchmarking y el desarrollo de algoritmos de aprendizaje de imitación fuera de línea para la manipulación de robots. Proporciona conjuntos de datos estandarizados, tuberías de entrenamiento y protocolos de evaluación para que los investigadores puedan comparar justamente algoritmos como BC, BC-RNN, BCQ e IQL en las mismas tareas.
• ** ¿Qué algoritmos soporta RoboMimic? ** Seis algoritmos: BC, BC-RNN, BCQ, CQL, IQL y TD3-BC. Los usuarios también pueden agregar algoritmos personalizados a través del sistema de configuración modular.
• ** ¿Necesito una GPU para entrenar las políticas de RoboMimic? ** Para las políticas de observación de baja dimensión, una CPU moderna funciona pero es lenta. Para las políticas basadas en imágenes, se requiere una GPU NVIDIA con al menos 8 GB de VRAM. Se recomienda un RTX 3080 o mejor.
• ** ¿Puedo usar RoboMimic con datos reales de robots? ** Sí. RoboMimic acepta cualquier conjunto de datos HDF5 que siga su especificación de formato. Recoge demostraciones en un robot real, conviértelo en el formato RoboMimic HDF5 y entrénate con los mismos algoritmos.
• ** ¿Cómo se compara RoboMimic con LeRobot? ** RoboMimic se centra en los puntos de referencia de aprendizaje de imitación fuera de línea con robosuite. LeRobot (Hugging Face) es más amplio, cubriendo la recopilación de datos, múltiples fondos de simulación y el despliegue de robots reales. Muchos investigadores utilizan algoritmos RoboMimic dentro de las tuberías de LeRobot.
• ¿Qué tasas de éxito debería esperar en las tareas de referencia? Elevación: 95-100% (BC). Puede: 80-95% (BC). Cuadrado: 60-85% (BC-RNN). Transporte: 30-60% (BC-RNN). Estos varían con la calidad de los datos y los hiperparámetros.

¿Necesitas datos reales de entrenamiento de robots?

RCSV recopila conjuntos de datos de demostración compatibles con RoboMimic en sistemas reales de hardware Franka, OpenArm y ALOHA bimanual.

[Vea los servicios de datos]