Cómo Entrenar ACT en el SO-100 desde Cero

ACT es la excepción entre las políticas SO-100. GR00T N1.7 y N1.5 parten de nvidia/GR00T-N1.7-3B y nvidia/GR00T-N1.5-3B, Pi0.5 de lerobot/pi05_base. ACT parte de cero: no hay un punto de control base, porque no es un modelo fundacional. Es un transformador de aproximadamente 80 millones de parámetros que se entrena desde cero en una tarea, en su brazo, bajo su iluminación.

Esa es también la razón por la que ejecuta un paso de control en 20 ms, mientras que un VLA de 3 mil millones de parámetros necesita de 152 a 485 ms, y cuesta de 1 a 3 USD por ejecución en lugar de 4 a 12. Esta guía sigue la ruta manual con lerobot en un SO-100: grabar, la configuración act, qué controlan chunk_size y n_action_steps, el programa de 100000 pasos, el despliegue. Luego el mismo trabajo en AY-Robots, incluyendo dónde la plataforma no ayuda.

¿Qué es ACT en realidad?

Action Chunking with Transformers proviene del artículo ALOHA, Learning Fine-Grained Bimanual Manipulation with Low-Cost Hardware, por Zhao, Kumar, Levine y Finn, arXiv, 23 de abril de 2023. El equipo graba a 50 Hz con cuatro cámaras web transmitiendo 480x640 a 30 fps: dos en las pinzas, una superior, una frontal. El resumen afirma seis habilidades con un éxito del 80 al 90 por ciento, entre ellas abrir un vaso de condimento translúcido e insertar una batería, a partir de 10 minutos de demostraciones.

El cuerpo es más útil al planificar una sesión de grabación: 50 demostraciones por tarea, excepto Enhebrar Velcro con 100, lo que representa de 10 a 20 minutos de datos y de 30 a 60 minutos de tiempo real una vez que se cuentan los reinicios. El éxito tampoco es uniforme: Enhebrar Velcro termina en 20 por ciento, Poner Zapato en 92, Abrir Vaso en 84, Preparar Cinta en 64.

El chunking de acciones es la idea principal

La clonación de comportamiento ordinaria mapea una observación a una acción, y los errores se acumulan: una desviación saca el brazo de la distribución, produciendo una acción peor, y treinta pasos después el efector final no está cerca del objeto. Chunking de acciones predice k acciones a la vez y las ejecuta, reduciendo el horizonte efectivo en un factor de k. También maneja una molestia específica de los datos humanos: los teleoperadores hacen pausas, y una política markoviana de un solo paso no puede modelar una pausa que dependa de lo que vino antes.

El artículo abla k en lugar de afirmarlo. Con el ensamble temporal desactivado, promediado en cuatro configuraciones, el éxito aumenta del 1 por ciento en k = 1 al 44 por ciento en k = 100, luego disminuye en 200 y 400 a medida que la política se acerca al control de lazo abierto. Esa curva es la razón por la cual el valor predeterminado es 100.

• chunk_size: cuántas acciones futuras predice el decodificador por pasada hacia adelante. Por defecto 100.
• n_action_steps: cuántas de ellas ejecutas antes de volver a consultar. Por defecto 100, por lo que lerobot ejecuta todo el chunk en bucle abierto.
• lerobot valida n_action_steps <= chunk_size y lanza un ValueError si lo configuras al revés.

Lo que importa operativamente es chunk_size dividido por la velocidad de fotogramas (frame rate). A los 30 fps que usan los ejemplos SO-100 de lerobot, un chunk de 100 acciones compromete aproximadamente 3.3 segundos desde una observación. Si la tarea necesita una corrección dentro de esa ventana, reduce n_action_steps, no chunk_size: mantienes la predicción larga y re-observas con más frecuencia.

# predict 100 actions, re-query after 25 of them (about 0.8 s at 30 fps)
lerobot-train \
  --dataset.repo_id=${HF_USER}/so100_cube \
  --policy.type=act \
  --policy.chunk_size=100 \
  --policy.n_action_steps=25 \
  --policy.device=cuda

Cuando ACT supera a un modelo fundacional

Las cinco políticas entrenables una al lado de la otra, con los números que AY-Robots mide y utiliza para dimensionar la GPU que alquila.

Elige ACT cuando la tarea y la escena son fijas y el movimiento debe ser rápido y preciso. Elige un cuando un punto de control debe cubrir varias instrucciones. Dos páginas comparan la decisión directamente: y . Para los benchmarks publicados, enlaza cada número a su fuente.

Lo que necesitas antes de empezar

Un brazo seguidor, un brazo líder para , al menos una cámara, una GPU de 24 GB. ACT solo lee imágenes y posiciones de articulaciones. Dos cámaras son lo ideal: una vista frontal fija para saber dónde están las cosas, una cámara de muñeca para lo que el está a punto de tocar, como en ALOHA.

Del brazo desnudo al conjunto de datos grabado

El flujo a continuación es lerobot 0.6.x. Omítalo si tiene un brazo calibrado y un conjunto de datos. De lo contrario, la guía de inicio de SO-100, cubre el ensamblaje, el tutorial de grabación cubre la captura y la documentación del conjunto de datos el formato.

1. 1
   Instalar lerobot con los extras correctos

   La grabación necesita core_scripts, el entrenamiento training, los servos Feetech feetech. Python 3.12+.

   bash

   conda create -y -n lerobot python=3.12
   conda activate lerobot
   conda install ffmpeg -c conda-forge
   
   pip install 'lerobot[core_scripts,training,feetech]'
   lerobot-info

2. 2
   Encontrar el puerto USB de cada brazo

   Ejecútalo con ambos brazos conectados, desconectando uno cuando se te solicite. En Linux, es posible que necesites abrir los permisos del nodo.

   bash

   lerobot-find-port
   # on Linux, if the port exists but is unreadable:
   sudo chmod 666 /dev/ttyACM0

3. 3
   Establecer los IDs de los motores y la velocidad de transmisión

   En el SO-100 esto ocurre antes del montaje: a diferencia del SO-101, los conectores son inaccesibles una vez construido. El script recorre el bus un motor a la vez desde la pinza, escribiendo IDs en la EEPROM.

   bash

   lerobot-setup-motors \
       --robot.type=so100_follower \
       --robot.port=/dev/ttyACM0
   
   lerobot-setup-motors \
       --teleop.type=so100_leader \
       --teleop.port=/dev/ttyACM1

4. 4
   Calibrar ambos brazos

   Ajusta cada articulación al centro de su rango, presiona Enter y luego barre cada una a través de su rango completo. La calibración permite que una política entrenada en un brazo se ejecute en otro. Reutiliza el mismo id.

   bash

   lerobot-calibrate \
       --robot.type=so100_follower \
       --robot.port=/dev/ttyACM0 \
       --robot.id=my_follower
   
   lerobot-calibrate \
       --teleop.type=so100_leader \
       --teleop.port=/dev/ttyACM1 \
       --teleop.id=my_leader

5. 5
   Teleoperar una vez con las cámaras encendidas

   La regla general de lerobot: deberías poder realizar la tarea mirando solo las imágenes de la cámara. Si no puedes, ACT tampoco podrá. Esto detecta más conjuntos de datos defectuosos que la depuración posterior.

   bash

   lerobot-teleoperate \
       --robot.type=so100_follower \
       --robot.port=/dev/ttyACM0 \
       --robot.id=my_follower \
       --robot.cameras="{ front: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30}, wrist: {type: opencv, index_or_path: 1, width: 640, height: 480, fps: 30} }" \
       --teleop.type=so100_leader \
       --teleop.port=/dev/ttyACM1 \
       --teleop.id=my_leader \
       --display_data=true

6. 6
   Grabar 50 episodios

   50 es el mínimo de AY-Robots y lo que ALOHA usó por tarea. lerobot aconseja 10 por ubicación de objeto, cámaras fijas, agarre consistente. n finaliza un episodio, r vuelve a grabar, q detiene y codifica.

   bash

   HF_USER=$(NO_COLOR=1 hf auth whoami | awk -F': *' 'NR==1 {print $2}')
   
   lerobot-record \
       --robot.type=so100_follower \
       --robot.port=/dev/ttyACM0 \
       --robot.id=my_follower \
       --robot.cameras="{ front: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30}, wrist: {type: opencv, index_or_path: 1, width: 640, height: 480, fps: 30} }" \
       --teleop.type=so100_leader \
       --teleop.port=/dev/ttyACM1 \
       --teleop.id=my_leader \
       --dataset.repo_id=${HF_USER}/so100_cube \
       --dataset.num_episodes=50 \
       --dataset.single_task="Grab the black cube and put it in the bin" \
       --display_data=true

Antes de entrenar, reproduce al menos cinco episodios. El formato de conjunto de datos LeRobot almacena flujos de cámara, estados de articulaciones y acciones por episodio, y la reproducción devuelve esas acciones al brazo. Si la reproducción no realiza la tarea, los datos no la contienen y el entrenamiento no la inventará.

lerobot-replay \
    --robot.type=so100_follower \
    --robot.port=/dev/ttyACM0 \
    --robot.id=my_follower \
    --dataset.repo_id=${HF_USER}/so100_cube \
    --dataset.episode=0

Entrenamiento de la política ACT

Este es el comando completo. Todo lo específico de ACT ya es un valor predeterminado, por lo que la página de ACT de lerobot recomienda empezar con ellos.

lerobot-train \
  --dataset.repo_id=${HF_USER}/so100_cube \
  --policy.type=act \
  --output_dir=outputs/train/act_so100_cube \
  --job_name=act_so100_cube \
  --policy.device=cuda \
  --wandb.enable=true \
  --policy.repo_id=${HF_USER}/act_so100_cube

--policy.type=act carga ACTConfig, que se adapta a la cantidad de motores y cámaras que registró su conjunto de datos, por lo que nunca declara la forma de la observación. --wandb.enable=true es opcional y vale la pena: la curva de pérdida es la única señal económica en una ejecución de 100000 pasos. La programación proviene de la configuración de entrenamiento de lerobot, no de ACTConfig: 100000 pasos, lote 8, semilla 1000, un punto de control cada 20000 pasos, registrando cada 200.

Una ejecución completa deja cinco directorios de puntos de control, del 020000 al 100000, más un último enlace simbólico. Guárdelos todos: la mejor política a menudo no es la última.

Duración: alrededor de 5 horas en una RTX 2080 Ti de 11 GB según el artículo, unas pocas horas para 100k pasos según la página ACT de lerobot, de 2 a 5 horas en el nivel de 24 GB de AY-Robots. No lo acortes. El README del repositorio de referencia indica que una política inestable o con pausas generalmente solo necesita más entrenamiento, porque el éxito y la fluidez siguen mejorando después de que la pérdida se estabiliza: para datos del mundo real, requiere al menos 5000 épocas, o de 3 a 4 veces la duración nuevamente después de la estabilización.

lerobot-train \
  --config_path=outputs/train/act_so100_cube/checkpoints/last/pretrained_model/train_config.json \
  --resume=true

Ejecutando la política entrenada en el brazo

La implementación utiliza lerobot-rollout. Las claves de la cámara deben coincidir con las grabadas: una política entrenada en front y wrist no aceptará cam0 y cam1, y rename_map no ayuda, ya que necesita un punto de control preentrenado. La cadena de tarea puede omitirse; el propio ejemplo de lerobot la marca como opcional para ACT.

lerobot-rollout \
  --strategy.type=base \
  --policy.path=${HF_USER}/act_so100_cube \
  --robot.type=so100_follower \
  --robot.port=/dev/ttyACM0 \
  --robot.id=my_follower \
  --robot.cameras="{ front: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30}, wrist: {type: opencv, index_or_path: 1, width: 640, height: 480, fps: 30} }" \
  --display_data=true \
  --duration=60

Para fijar un punto de control en lugar del modelo final, añade --policy.pretrained_revision. Eso requiere que la ejecución haya comenzado con --save_checkpoint_to_hub=true, desactivado por defecto: sin él, lerobot sube el modelo final y nada más. Con él, cada punto de control se etiqueta con su paso rellenado con ceros, por lo que --policy.pretrained_revision=060000 recupera el de 60000 pasos. Compararlo con el de 100000 en el brazo real es el experimento más barato disponible.

Dos rutas al mismo punto de control

Todo lo anterior es la ruta manual y funciona. La ruta de la plataforma sacrifica el control a cambio de no poseer una GPU o un entorno Python.

# the two commands that matter, end to end
lerobot-record --robot.type=so100_follower --robot.port=/dev/ttyACM0 \
  --teleop.type=so100_leader --teleop.port=/dev/ttyACM1 \
  --dataset.repo_id=${HF_USER}/so100_cube --dataset.num_episodes=50 \
  --dataset.single_task="Grab the black cube"

lerobot-train --dataset.repo_id=${HF_USER}/so100_cube --policy.type=act \
  --output_dir=outputs/train/act_so100_cube --policy.device=cuda

Qué sale mal en realidad

Casi ninguno de los problemas está en el comando de entrenamiento. Está en las cosas que lo rodean, ordenadas por la frecuencia con la que fallan la primera vez.

Dos filas merecen énfasis. ACT entrena con LeRobot v3.0 mientras que el cargador de GR00T falla con él y necesita v2.1, por lo que un conjunto de datos que entrena ACT puede hacer fallar una ejecución de GR00T. Y la última fila tiene dos soluciones: los autores de ACT responden al movimiento brusco con más entrenamiento, mientras que con n_action_steps en 100, un bloqueo genuino ocurre en el límite de un fragmento, una pausa visible cada 3.3 segundos a 30 fps. Dos cosas más a saber: una sola articulación muerta suele ser un ID de servo que nunca fue escrito, y un efector final que se acerca pero nunca se cierra significa un rango de efector final demasiado pequeño en las demostraciones. Índice completo: las páginas de modos de fallo.

¿Qué cuesta una ejecución?

Este es el argumento para empezar con ACT incluso si más tarde quieres un VLA. Una ejecución fallida de ACT cuesta el precio de un café y te dice en horas si tu conjunto de datos contiene la tarea. Una ejecución fallida de GR00T cuesta cuatro veces eso por la misma lección. Pasar a GR00T N1.7 o SmolVLA después es un cambio de forma, no una reconstrucción. Antecedentes: modelos de visión-lenguaje-acción, la guía completa del SO-100, entrena tu primera política y aprendizaje por imitación. ¿No tienes brazo? La página en vivo transmite un SO-100 real para conducir sin registrarse.