Como Treinar ACT no SO-100 do Zero

ACT é a exceção entre as políticas SO-100. GR00T N1.7 e N1.5 começam de nvidia/GR00T-N1.7-3B e nvidia/GR00T-N1.5-3B, Pi0.5 de lerobot/pi05_base. ACT começa do zero: não há checkpoint base, porque não é um modelo de fundação. É um transformador de aproximadamente 80 milhões de parâmetros que você treina do zero em uma única tarefa, no seu braço, sob sua iluminação.

É também por isso que ele executa uma etapa de controle em 20 ms, enquanto um VLA de 3 bilhões de parâmetros precisa de 152 a 485 ms, e custa de 1 a 3 USD por execução em vez de 4 a 12. Este guia percorre o caminho manual com lerobot em um SO-100: gravação, a configuração act, o que chunk_size e n_action_steps controlam, o cronograma de 100000 etapas, o rollout. Em seguida, o mesmo trabalho em AY-Robots, incluindo onde a plataforma não ajuda.

O que ACT realmente é

Action Chunking with Transformers vem do artigo ALOHA, Aprendizagem de Manipulação Bimanual Detalhada com Hardware de Baixo Custo, por Zhao, Kumar, Levine e Finn, arXiv, 23 de abril de 2023. O equipamento grava a 50 Hz com quatro webcams transmitindo 480x640 a 30 fps: duas nas garras, uma superior, uma frontal. O resumo afirma seis habilidades com 80 a 90 por cento de sucesso, entre elas abrir um copo de condimento translúcido e encaixar uma bateria, a partir de 10 minutos de demonstrações.

O corpo é mais útil ao planejar uma sessão de gravação: 50 demonstrações por tarefa, exceto Thread Velcro com 100, o que representa 10 a 20 minutos de dados e 30 a 60 minutos de tempo real (wall-clock time) uma vez que as reinicializações são contabilizadas. O sucesso também não é uniforme: Thread Velcro termina em 20 por cento, Put On Shoe em 92, Cup Open 84, Prep Tape 64.

O agrupamento de ações é a ideia principal

A clonagem comportamental comum mapeia uma observação para uma ação, e os erros se acumulam: um desvio coloca o braço fora da distribuição, produzindo uma ação pior, e trinta passos depois a garra não está nem perto do objeto. Agrupamento de ações prevê k ações de uma vez e as executa, diminuindo o horizonte efetivo por um fator de k. Também lida com um incômodo específico de dados humanos: teleoperadores pausam, e uma política markoviana de passo único não consegue modelar uma pausa que depende do que veio antes.

O artigo abla k em vez de afirmá-lo. Com o agrupamento temporal desativado, em média em quatro configurações, o sucesso aumenta de 1 por cento em k = 1 para 44 por cento em k = 100, depois diminui em 200 e 400 à medida que a política se aproxima do controle em malha aberta. Essa curva é o motivo pelo qual o padrão é 100.

• chunk_size: quantas ações futuras o decodificador prevê por passagem direta. Padrão 100.
• n_action_steps: quantas delas você executa antes de consultar novamente. Padrão 100, então o lerobot executa o chunk inteiro em loop aberto.
• O lerobot valida n_action_steps <= chunk_size e levanta um ValueError se você inverter a ordem.

O que importa operacionalmente é o chunk_size dividido pela taxa de quadros. A 30 fps, que os exemplos SO-100 do lerobot usam, um chunk de 100 compromete cerca de 3,3 segundos a partir de uma observação. Se a tarefa precisar de uma correção dentro dessa janela, diminua n_action_steps, não chunk_size: você mantém a previsão longa e reobserva com mais frequência.

# 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

Quando o ACT supera um modelo de base

As cinco políticas treináveis lado a lado, com os números que a AY-Robots mede e usa para dimensionar a GPU que aluga.

Escolha ACT quando a tarefa e a cena são fixas e o movimento deve ser rápido e preciso. Escolha um modelo de visão-linguagem-ação quando um checkpoint deve cobrir várias instruções. Duas páginas abordam a decisão diretamente: ACT vs SmolVLA e ACT vs GR00T N1.7. Para benchmarks publicados, a entrada da arena ACT vincula cada número à sua fonte.

O que você precisa antes de começar

Um braço seguidor, um braço líder para teleoperação, pelo menos uma câmera, uma GPU de 24 GB. ACT lê apenas imagens e posições de juntas. Duas câmeras é o ideal: uma visão frontal fixa para onde as coisas estão, uma câmera de pulso para o que o efetor final está prestes a tocar, como no ALOHA.

Do braço nu ao conjunto de dados gravado

O fluxo abaixo é lerobot 0.6.x. Ignore-o se você já tiver um braço calibrado e um conjunto de dados. Caso contrário, o guia de primeiros passos do SO-100 cobre a montagem, o passo a passo de gravação cobre a captura e a documentação do conjunto de dados o formato.

1. 1
   Instalar o lerobot com os extras corretos

   A gravação requer `core_scripts`, o treinamento `training`, os 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 a porta USB de cada braço

   Execute-o com ambos os braços conectados, desconectando um quando solicitado. No Linux, pode ser necessário abrir as permissões do nó.

   bash

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

3. 3
   Definir os IDs dos motores e a taxa de transmissão

   No SO-100, isso acontece antes da montagem: ao contrário do SO-101, os conectores ficam inacessíveis depois de montado. O script percorre o barramento um motor de cada vez a partir da garra, escrevendo IDs na 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 os braços

   Defina cada junta para o meio de seu alcance, pressione Enter e, em seguida, mova cada uma por todo o seu alcance. A calibração permite que uma política treinada em um braço seja executada em outro. Reutilize o mesmo 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 uma vez com as câmeras ligadas

   A regra geral do lerobot: você deve ser capaz de realizar a tarefa olhando apenas para as imagens da câmera. Se você não conseguir, o ACT também não conseguirá. Isso detecta mais conjuntos de dados ruins do que a depuração 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
   Gravar 50 episódios

   50 é o mínimo da AY-Robots e o que o ALOHA usava por tarefa. O lerobot aconselha 10 por localização de objeto, câmeras fixas, agarre consistente. n encerra um episódio, r regrava, q para e 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 do treinamento, reproduza pelo menos cinco episódios. O formato de conjunto de dados LeRobot armazena fluxos de câmera, estados de junta e ações por episódio, e a reprodução empurra essas ações de volta para o braço. Se a reprodução não realizar a tarefa, os dados não a contêm e o treinamento não a 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

Treinando a política ACT

Este é o comando completo. Tudo o que é específico do ACT já é um padrão, e é por isso que a página ACT do lerobot recomenda começar com eles.

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 carrega o ACTConfig, que se adapta ao número de motores e câmeras que seu conjunto de dados registrou, então você nunca declara o formato da observação. --wandb.enable=true é opcional e vale a pena: a curva de perda é o único sinal barato em uma execução de 100000 passos. O agendamento vem da configuração de treinamento do lerobot, não do ACTConfig: 100000 passos, lote 8, seed 1000, um checkpoint a cada 20000 passos, com registro a cada 200.

Uma execução completa deixa cinco diretórios de checkpoint, de 020000 a 100000, mais um último symlink. Mantenha todos eles: a melhor política muitas vezes não é a última.

Duração: cerca de 5 horas em uma RTX 2080 Ti de 11 GB no artigo, algumas horas para 100 mil passos por página ACT do lerobot, 2 a 5 horas na camada de 24 GB da AY-Robots. Não o interrompa. O README do repositório de referência diz que uma política instável ou com pausas geralmente só precisa de mais treinamento, porque o sucesso e a suavidade continuam a melhorar depois que a perda se estabiliza: para dados do mundo real, são necessários pelo menos 5000 épocas, ou 3 a 4 vezes o comprimento novamente após o platô.

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

Executando a política treinada no braço

A implantação usa lerobot-rollout. As chaves da câmera devem corresponder às gravadas: uma política treinada em front e wrist não aceitará cam0 e cam1, e rename_map não ajuda, pois precisa de um checkpoint pré-treinado. A string da tarefa pode ser omitida; o próprio exemplo do lerobot a 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 fixar um checkpoint em vez do modelo final, adicione --policy.pretrained_revision. Isso exige que a execução tenha começado com --save_checkpoint_to_hub=true, desativado por padrão: sem ele, o lerobot envia o modelo final e nada mais. Com ele, cada checkpoint é marcado com seu passo preenchido com zeros, então --policy.pretrained_revision=060000 recupera o de 60000 passos. Compará-lo com o de 100000 no braço real é o experimento mais barato disponível.

Duas rotas para o mesmo checkpoint

Tudo acima é a rota manual e funciona. A rota da plataforma troca controle por não possuir uma GPU ou um ambiente 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

O que realmente dá errado

Quase nenhuma da dificuldade está no comando de treinamento. Ela está nas coisas ao redor, ordenadas pela frequência com que causam problemas na primeira vez.

Duas linhas merecem destaque. O ACT treina no LeRobot v3.0, enquanto o carregador do GR00T falha nele e precisa da v2.1, então um conjunto de dados que treina o ACT pode falhar em uma execução do GR00T. E a última linha tem duas soluções: os autores do ACT respondem ao movimento irregular com mais treinamento, enquanto com n_action_steps em 100, uma paralisação genuína ocorre em um limite de chunk, uma pausa visível a cada 3.3 seconds a 30 fps. Mais duas coisas a saber: uma única junta morta é geralmente um ID de servo que nunca foi escrito, e uma garra que se aproxima mas nunca fecha significa pouca amplitude da garra nas demonstrações. Índice completo: as páginas de modos de falha.

O custo de uma execução

Este é o argumento para começar com ACT mesmo que você queira um VLA mais tarde. Uma execução ACT falha custa o preço de um café e informa em poucas horas se seu conjunto de dados contém a tarefa. Uma execução GR00T falha custa quatro vezes mais pela mesma lição. Passar para GR00T N1.7 ou SmolVLA depois é uma mudança de forma, não uma reconstrução. Contexto: modelos de visão-linguagem-ação, o guia completo do SO-100, treine sua primeira política e aprendizagem por imitação. Sem braço? A página ao vivo transmite um SO-100 real para operar sem precisar se inscrever.