Cómo ajustar un modelo VLA para su robot
Guía paso a paso para ajustar bien OpenVLA o pi0 en su conjunto de datos de teleoperación <unk> preparación de datos, configuración de entrenamiento, evaluación y implementación.
Guía paso a paso para ajustar bien OpenVLA o pi0 en su conjunto de datos de teleoperación
Avanzado
1. Prerequisitos 2. Instalar 3. Dataset 4. Configurar 5. Tren 6. Monitorear 7. Evaluación 8. Cuantificar 9. Despliegue 10. Iterar
Pre-requisitos
- Un conjunto de datos de teleoperación con más de 300 episodios de alta calidad en formato RLDS (ver tutorial de recopilación de datos)
- GPU NVIDIA con 24 GB+ VRAM (RTX 4090 para LoRA, A100/H100 para ajuste fino completo)
- Python 3.10+ con CUDA 12.1+
- Familiarización con PyTorch y HuggingFace Transformers
- Cuenta de Pesos y Prejuicios (para la tala, obras gratuitas)
- ROS2 instalado en su máquina robot (ver guía de configuración)
Lo que construirás
Tomará un modelo VLA pre-entrenado (OpenVLA-7B), lo ajustará a los datos de demostración de su robot, lo evaluará con experimentos de implementación, lo cuantificará para inferir en tiempo real y lo implementará como un servidor de acción ROS2 en su robot.
Línea de regulación de la VLA
Datos de RLDS Más de 300 episodios
¿Qué es esto?
OpenVLA / pi0 7B pre-entrenado
¿Qué es esto?
El tono fino LoRA o lleno
¿Qué es esto?
Evaluar Pruebas de despliegue
¿Qué es esto?
Despliegue ROS2 + INT4
1 de la Comisión
Verifique los requisitos previos y la configuración de la GPU
Verifique su GPU, versión CUDA y VRAM disponible antes de comenzar.
| Method | Min VRAM | GPU | Cost Estimate |
|---|---|---|---|
| LoRA fine-tune | 24 GB | RTX 4090, A5000 | $50–150 |
| Full fine-tune | 40 GB | A100 40GB | $150–300 |
| Full fine-tune (multi-GPU) | 2x 40 GB | 2x A100 | $250–400 |
Copia# Verificar CUDA y GPU nvidia-smi python3 -c "importar antorcha; imprimir(f'CUDA: {torch.cuda.is_available() }, Dispositivo: {torch.cuda.get_device_name(0)}, VRAM: {torch.cuda.get_device_properties(0).total_mem / 1e9:.1f}GB')" # Verificar versión CUDA (necesita 12.1+ nvcc) --versión
** Consejo de presupuesto:** Utilice Vast.ai o Lambda Labs para alquilar GPU en la nube. Un A100 80GB cuesta $ 1.50
2 de la Comisión
Instalar dependiencias de OpenVLA
Clone OpenVLA e instale todos los paquetes necesarios.
Copia# Crea entorno virtual python3 -m venv ~/vla_env fuente ~/vla_env/bin/activar # Clone OpenVLA git clone
3 El
Prepara tu conjunto de datos
OpenVLA espera datos en un formato específico. Convierta su conjunto de datos RLDS o conjunto de datos LeRobot al formato de capacitación OpenVLA.
Copia# Convierta tu conjunto de datos RLDS al formato OpenVLA python3 scripts/convert_rlds_to_openvla.py \ --input-dir=/datasets/openarm_pick_place_rlds \ --output-dir=/datasets/openarm_openvla \ --image-key="observation/image" \ --state-key="observation/state" \ --action-key="action" \ --language-key="language_instruction" \ \"meta\"# Verifique el conjunto de datos convertido "import json, osson = json.open.py.odes.exp.opener'dimen/action/arm_open_data_((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((
** Verificación de formato de datos:** OpenVLA espera imágenes como 224x224 RGB (reajusta el tamaño internamente), acciones como vectores continuos 7D (6 DOF + pegamento), y una instrucción de lenguaje de texto por episodio.
4 de la Comisión
Configurar la formación
Crear una configuración de entrenamiento YAML. Estos hiperparámetros se ajustan para una corriente típica de ajuste fino de tarea única.
Copia# Guardar como configuración/finetune_openarm.yaml cat > configs/finetune_openarm.yaml << 'EOF' # OpenVLA Ajuste fino Config
Guía de hiperparámetro: La tasa de aprendizaje 2e-5 es una opción segura para LoRA. Para el ajuste fino completo, utilice 1e-5. Si la pérdida de entrenamiento no disminuye después de 500 pasos, pruebe 5e-5.
5 El
Lanza el ajuste
Para una GPU única, se utiliza
Copia# GPU único (RTX 4090 / A100) python3 scripts/finetune.py \ --config=configs/finetune_openarm.yaml \ --output-dir=runs/openarm-pick-place-v1 \ # Multi-GPU (2x A100) torchrunnproc-per-node=2 scripts/finetune.py \ config=configs/finetune_openarm.yaml \ --output-dir=runs/openarm-pick-place-v1 \ # Expectado de salida: # 10/5000 \ Loss: 2.34 \ LR: 2.0e-6\ DATA: 1.2s/paso # 100/5000 \ Loss: 0.87 \ LR: 1.1e-5 \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \
Estimativas de tiempo de formación:
| Setup | Steps/sec | Time for 5K steps | GPU Cost |
|---|---|---|---|
| RTX 4090 (LoRA) | ~0.8 | ~1.7 hours | $5–10 |
| A100 40GB (LoRA) | ~1.5 | ~55 min | $2–4 |
| A100 80GB (Full) | ~0.6 | ~2.3 hours | $5–8 |
| 2x A100 (Full) | ~1.0 | ~1.4 hours | $6–10 |
6
Monitorear la formación
Observe las normas de la curva de pérdida y gradiente en Pesos y Prejuicios.
- Las pérdidas deben disminuir constantemente para los primeros 1.000
2.000 pasos, luego la meseta - La norma de gradiente debe permanecer entre 0,1 y 10,0
picos superiores a 50 indican inestabilidad - Los puntos de control se guardan cada 500 pasos
puedes reanudar desde cualquier punto de control si el entrenamiento se estrella
Copia # Abre el tablero de control de la barra en el navegador abre la barra # O revise los registros de entrenamiento directamente cola -f ejecuciones/abrebrazo-pick-place-v1/training.log # Lista de puntos de control guardados ls -la ejecuciones/abrebrazo-pick-place-v1/ puntos de control/
Si las placas de pérdida son superiores a 1.0: Su conjunto de datos puede tener problemas de calidad. Compruebe si hay episodios mal etiquetados, escalas de acción inconsistentes o imágenes corruptas. Trate de aumentar la tasa de aprendizaje a 5e-5 o reducir el tamaño del lote a 4.
7
Evaluar el punto de control
Ejecutar una evaluación de implementación en su robot (o en simulación) para medir la tasa de éxito del modelo ajustado.
Copia# Evalúa el mejor punto de control (bajo valor de pérdida) python3 scripts/evaluate.py \ --checkpoint=runs/openarm-pick-place-v1/checkpoints/step-4500 \ --robot-type=openarm \ --robot-port=/dev/ttyUSB0 \ --num-rollouts=20 \ --task="Pick up the red block and place it on the green target zone" # Resultado esperado: # Rollout 1/20: SUCCES (14.2s) # Rollout 2/20: SUCCES (12.8s) # Rollout 3/20: FAILURE
Caso de éxito: 60
8 El
Cuantiza para el despliegue
Los modelos VLA de precisión completa funcionan a 2
Copie# Cuantice a INT4 usando bitsandbytes python3 scripts/quantize.py \ --checkpoint=runs/openarm-pick-place-v1/checkpoints/step-4500 \ --quantization=int4 \ --output-dir=runs/openarm-pick-place-v1/quantized # Velocidad de inferencia de referencia python3 scripts/benchmark_inference.py \ --checkpoint=runs/openarm-pick-place-v1/quantized \ num-steps=100 # Resultado esperado: # tamaño del modelo: 4.2 GB (bajo de 14.8 GB) # velocidad de inferencia: 18.3 Hz (±1.2 Hz) # Latencia: 54.6 ms por paso
| Precisión | Model Size | Inference Hz | Min GPU |
|---|---|---|---|
| FP16 (baseline) | 14.8 GB | 3–5 Hz | 24 GB VRAM |
| INT8 | 7.4 GB | 8–15 Hz | 12 GB VRAM |
| INT4 | 4.2 GB | 15–25 Hz | 8 GB VRAM |
9
Despliegue en Robot a través de ROS2
Crear un servidor de acción ROS2 que ejecuta el modelo VLA cuantizado y envía comandos al robot a 10
Copia# Copiar un paquete ROS2 para el nodo de inferencia VLA cd ~/ros2_ws/src ros2 pkg crear --build-type ament_python vla_inference \ --dependencies rclpy sensor_msgs std_msgs # Copia el guión de inferencia (versión simplificada a continuación) cat > ~/ros2_ws/srcvla_inference/vla_inference/inference\self_node.py.py 'PYEOF' importa rpy de rpy.node.py.py.py.py.py.py.py.py.py.py.py.py.py.py.py.py.py Imagen de importación conjunta, de la red de la red de la red de la red de la red de la red de la red de la red de la red de la red de la red de la red de la red de la red de la red de la red de la red de la red de la red de la red de la red de la red de la red.ms
Copia# Construir y ejecutar el nodo de inferencia cd ~/ros2_ws columna construir --paquetes-seleccionar vla_inferencia fuente de instalación/configuración.bash # Lanzar robot + cámaras + VLA inferencia ros2 lanzar brazo abierto_traer brazo abierto.lanzamiento.py & ros2 ejecutar vla_inferencia inferencia_node
10
Iterar: Recoger más datos, Reentrenar
El primer modelo tendrá modos de fallas. La forma más efectiva de mejorar es recopilar demostraciones específicas sobre los casos de fallas y retrenar.
Identificar los modos de falla de los despliegues de evaluación Los fallos comunes: objetos en posiciones de borde, orientaciones inusuales, cambios de iluminación, objetos que el modelo no ha visto. Recoger 50-100 demostraciones específicas para los casos de fallas lerobot registro \ --robot-type=openarm \ --task="pick_red_block_edge_positions" \ --num-episodes=50 \ --output-dir=~/datasets/openarm_pick_place_v2 # 3. Fusión con el conjunto de datos original python3 scripts/merge_datasets.py \ --datasets ~/datasets/openarm_pick_place ~/datasets/openarm_pick_place_v2 \ --output /datasets/openarm_pick_place_merged # 4. Fine-tune otra vez (desde el mejor punto de control anterior) python3 scripts/finetune.py \ --config=configs/finetune_openarm.yaml \ --resume-from=runs/openarm-pick-place-v1/checkpoints/step-4500 \ --output-dir=runs/openarm-pick-place-v2 \ --data.dataset_path=/datasets/openarm_pick_place_merged
Circuito de iteración
El bucle de DAgger (agregación de Datasets) ha demostrado mejorar el rendimiento de las políticas con cada ciclo: desplegar → identificar fallos → recoger demos dirigidos → Reentrenar → Evalua. La mayoría de los equipos ven una mejora del 5
Solución de problemas
CUDA Out of Memory (OOM) durante el entrenamiento
Reducir
La pérdida de entrenamiento es NaN
Esto generalmente significa una tasa de aprendizaje que es demasiado alta o los datos están corruptos. Reducir la tasa de aprendizaje a 1e-5. Compruebe los valores NaN en su conjunto de datos con
El modelo produce acciones constantes/identes
El modelo puede haber colapsado para predecir la acción media. Verifique si su espacio de acción está normalizado (cero media, variación unitaria). Compruebe si la descripción de tareas coincide con lo que se usó durante la recopilación de datos. Trate de aumentar los pasos de entrenamiento o la tasa de aprendizaje.
La interferencia es demasiado lenta para el control en tiempo real
Aplicar cuantización INT4 (paso 8). Utilice
El modelo cuantizado tiene una tasa de éxito mucho menor
Se espera una cierta pérdida de calidad (1
Tutoriales relacionados
¿Qué es esto?
Recopilar datos de entrenamiento de robots
El tutorial de pre-requisitos
[
LeRobot Quickstart
En el caso de las empresas de la Unión Europea, el objetivo de la política de difusión es el de mejorar la calidad de la información y la calidad de la información.
[
Guía de configuración de ROS2
Configurar ROS2 para el despliegue de robots y desarrollo de nodos de inferencia.
[
Preguntas frecuentes
¿Cuánto cuesta ajustar un modelo VLA?
Un funcionamiento típico de ajuste fino cuesta $ 150
¿Cuál es la diferencia entre OpenVLA y pi0?
OpenVLA es un modelo de acción de parámetro 7B de código abierto de Stanford que toma imágenes de la cámara y instrucciones de lenguaje como entrada y salidas de acciones de robots. pi0 (de la Inteligencia Física) es un VLA basado en flujo que se destaca en la manipulación hábil. OpenVLA es más fácil de ajustar; pi0 a menudo logra tasas de éxito más altas en tareas complejas.
¿Cuántos episodios de demostración necesito para ajustar el VLA?
Para una sola tarea, 300
¿Puedo ajustar un modelo VLA en una GPU de consumo?
Sí, utilizando LoRA (Low-Rank Adaptation) se puede ajustar bien OpenVLA en un RTX 4090 (24 GB VRAM) o incluso un RTX 3090.
¿Qué tasa de éxito debería esperar de un modelo de VLA ajustado?
Para las tareas de distribución (los mismos objetos, posiciones similares a los datos de entrenamiento), espere una tasa de éxito de 60
¿Fue útil este tutorial?
👍 Sí
Manténgase al frente en robótica
Obtenga las últimas noticias sobre las implementaciones de robots, la recopilación de datos y la IA física