LeRobot documentation
Guía de hardware para el entrenamiento de LeRobot
Guía de hardware para el entrenamiento de LeRobot
Dimensionamiento aproximado para entrenar una política de LeRobot: cuánta VRAM necesita cada política, cómo es el tiempo de entrenamiento y dónde ejecutarlo cuando el hardware local no es suficiente.
Los números siguientes son indicativos: cifras de orden de magnitud para elegir el hardware, no predicciones exactas. El rendimiento depende en gran medida de la entrada/salida del conjunto de datos, la resolución de las imágenes, el tamaño del lote y el número de GPUs.
Memoria por grupo de políticas
Las políticas se agrupan por tamaño de backbone; las agrupaciones siguientes proporcionan un único límite de VRAM por grupo en lugar de repetir los números por política. La memoria escala aproximadamente de forma lineal con el tamaño del lote; AdamW (el predeterminado de LeRobot) lleva un estado del optimizador que añade ~30–100% sobre una sola pasada de forward+backward.
| Grupo | Políticas | VRAM máxima (BS 8, AdamW) | Tarjetas gráficas adecuadas para empezar |
|---|---|---|---|
| Light BC | act, vqbet, tdmpc | ~2–6GB | GPU de portátil (RTX 3060), L4, A10G |
| Diffusion | diffusion, multi_task_dit | ~8–14GB | RTX 4070+ / L4 / A10G |
| VLA pequeño | smolvla | ~10–16GB | RTX 4080+ / L4 / A10G |
| VLA de gran tamaño | pi0, pi0_fast, pi05, xvla, wall_x | ~24–40GB | A100 40 GB+ (24 GB justo con BS 1) |
| Multimodal | groot, eo1 | ~24–40GB | A100 40 GB+ |
| RL | sac | config-dep. | Vea la guía de HIL-SERL |
¿Limitado por memoria? Reduce el tamaño del lote (aproximadamente lineal), usa la acumulación de gradientes para recuperar el lote efectivo o, en el caso de SmolVLA, deja freeze_vision_encoder=True.
Tiempo de entrenamiento
El aprendizaje por imitación en robótica suele converger en 5–10 épocas sobre el conjunto de datos, no en cientos de miles de pasos brutos. Una vez que conoces el número de épocas, el tiempo real es esencialmente:
total_frames = sum of frames over all episodes # 50 ep × 30 fps × 30 s ≈ 45,000 steps_per_epoch = ceil(total_frames / (num_gpus × batch_size)) total_steps = epochs × steps_per_epoch wall_clock ≈ total_steps × per_step_time
El tiempo por paso depende de la política y de la GPU. Las cifras de la tabla siguiente son puntos de referencia: elija la fila más cercana a su configuración y escale linealmente con total_steps si entrena durante más o menos tiempo.
Escenarios comunes
Tiempo real aproximado para 5 épocas en un conjunto de datos de ~50 episodios (~45k fotogramas a 30 fps × 30 s), optimizador predeterminado (AdamW), imágenes de 640×480:
| Configuración | Política | Lote | Tiempo real |
|---|---|---|---|
| RTX 4090 / RTX 3090 individual (24 GB) | act | 8 | ~30–60 min |
| RTX 4090 / RTX 3090 individual (24 GB) | diffusion | 8 | ~2–4h |
| Single L4 / A10G (24 GB) | act | 8 | ~1–2h |
| Single L4 / A10G (24 GB) | smolvla | 4 | ~3–6h |
| A100 40 GB individual | smolvla | 16 | ~1–2h |
| A100 40 GB individual | pi0 / pi05 | 4 | ~4–8h |
Clúster de 4× H100 80 GB (accelerate) | diffusion | 32 | ~30–60 min |
Clúster de 4× H100 80 GB (accelerate) | smolvla | 32 | ~1–2h |
| Apple Silicon M1/M2/M3 Max (MPS) | act | 4 | ~6–14h |
Estas son cifras de orden de magnitud. Las ejecuciones reales se desvían un ±50% dependiendo de la resolución de la imagen, la entrada/salida del conjunto de datos, el hilado del dataloader y el SKU exacto de la GPU. Son útiles como intuición para saber si una ejecución tomará una hora o un día, no como SLAs.
Multi-GPU es muy importante
accelerate launch --num_processes=N es la forma más sencilla de reducir el tiempo de entrenamiento. Cada paso del optimizador procesa N × batch_size muestras en aproximadamente el mismo tiempo real que un paso en una sola GPU, por lo que 4 GPUs ≈ 4× de aceleración para ejecuciones limitadas por el cómputo. Consulte la guía de Entrenamiento con varias GPUs para la configuración completa.
Puntos de referencia de datos en un clúster de 4×H100 80 GB (accelerate launch --num_processes=4), 5000 pasos, batch 32, AdamW, conjunto de datos imstevenpmwork/super_poulain_draft (~50 episodios, ~640×480 imágenes):
| Política | Tiempo real | update_s | dataloading_s | Uso de GPU | Banderas destacadas |
|---|---|---|---|---|---|
diffusion | 16m 17s | 0.167 | 0.015 | ~90% | valores predeterminados (entrenamiento desde cero) |
smolvla | 27m 49s | 0.312 | 0.011 | ~80% | --policy.path=lerobot/smolvla_base, freeze_vision_encoder=false, train_expert_only=false |
pi05 | 3h 41m | 2.548 | 0.014 | ~95% | --policy.pretrained_path=lerobot/pi05_base, gradient_checkpointing=true, dtype=bfloat16, codificador de visión + experto entrenado |
Los registros de entrenamiento dividen la iteración completa en dataloading_s (next(dl_iter)), preprocessing_s (conversión de imágenes y el pipeline de la política) y update_s (la actualización del optimizador). step_s abarca las tres y determina samples_per_s. El benchmark anterior a esta división incluye el preprocesamiento en su dataloading_s.
Programación y puntos de control
Si acorta el entrenamiento (p. ej., 5k–10k pasos en un conjunto de datos pequeño), también acorte el programa de LR con --policy.scheduler_decay_steps≈--steps. De lo contrario, la LR se mantendrá cerca de su pico y nunca decaerá. Lo mismo aplica para --save_freq.
Dónde ejecutar
La VRAM es el primer filtro. Dentro de un nivel, elija según el presupuesto y la disponibilidad: las columnas $–$$$$ son relativas; consulte los precios actuales en el proveedor que realmente utilice.
| Clase | VRAM | Nivel | Cómodo para |
|---|---|---|---|
| RTX 3090 / 4090 (consumo) | 24 GB | $ | Light BC, Diffusion, SmolVLA. Justo para VLAs con batch 1. |
| L4 / A10G (nube) | 24 GB | $–$$ | Mismo sobre; común en Google Cloud, RunPod, AWS g5/g6. |
| A100 40 GB | 40 GB | $$$ | Cualquier política con tamaños de lote razonables. |
| A100 80 GB / H100 80 GB | 80 GB | $$$$ | Clústeres multi-GPU; lotes grandes para VLAs. |
| Solo CPU | — | — | No entres en entrenamiento. Usa Colab o alquila una GPU. |
Empleos en Hugging Face
Hugging Face Jobs te permite ejecutar entrenamientos en la infraestructura gestionada de HF, con facturación por segundo, sin necesidad de poseer una GPU. lerobot-train envía y transmite el trabajo por ti: solo añade --job.target=<flavor> a un comando de entrenamiento normal:
lerobot-train \ --policy.type=act --dataset.repo_id=<USER>/<DATASET> \ --policy.repo_id=<USER>/act_<task> \ --job.target=a10g-large
Notas:
- Ejecuta
hf auth loginuna vez antes de enviar, el trabajo se ejecuta con tu token. --job.targetse corresponde con la tabla anterior:t4-small/t4-medium(T4, solo ACT),l4x1/l4x4(L4 24 GB),a10g-small/large/largex2/largex4(A10G 24 GB escalado horizontalmente),a100-large(A100). Consulte el catálogo actual con precios mediantehf jobs hardware, o consulte https://huggingface.co/docs/hub/jobs.- El trabajo tiene un tiempo de espera predeterminado de
2d(48 h). Sobrescríbelo con--job.timeout=4h(o cualquier otra cadena de duración válida) para acortar o extender el tiempo de espera. El trabajo se detiene automáticamente cuando el comando se completa. - Para la guía completa —carga del conjunto de datos, transmisión de puntos de control, reanudación de una ejecución en un trabajo—, consulte la guía de entrenamiento de aprendizaje por imitación.