Come Addestrare ACT su SO-100 da Zero

ACT è l'eccezione tra le policy SO-100. GR00T N1.7 e N1.5 partono da nvidia/GR00T-N1.7-3B e nvidia/GR00T-N1.5-3B, Pi0.5 da lerobot/pi05_base. ACT parte da zero: non esiste un checkpoint di base, perché non è un modello fondamentale. È un trasformatore di circa 80 milioni di parametri che si addestra da zero su un singolo compito, sul proprio braccio, con la propria illuminazione.

Questo è anche il motivo per cui esegue un passo di controllo in 20 ms, mentre un VLA da 3 miliardi di parametri richiede da 152 a 485 ms e costa da 1 a 3 USD per esecuzione invece di 4 a 12. Questa guida illustra il percorso manuale con lerobot su un SO-100: la registrazione, la configurazione act, cosa controllano chunk_size e n_action_steps, la pianificazione di 100000 passi, il rollout. Poi lo stesso lavoro su AY-Robots, inclusi i casi in cui la piattaforma non è d'aiuto.

Cosa sia realmente ACT

Action Chunking with Transformers deriva dal paper ALOHA, Learning Fine-Grained Bimanual Manipulation with Low-Cost Hardware, di Zhao, Kumar, Levine e Finn, arXiv, 23 aprile 2023. L'attrezzatura registra a 50 Hz con quattro webcam che trasmettono 480x640 a 30 fps: due sulle pinze, una superiore, una frontale. L'abstract dichiara sei abilità con una percentuale di successo dall'80 al 90 percento, tra cui l'apertura di un contenitore per condimenti traslucido e l'inserimento di una batteria, da 10 minuti di dimostrazioni.

Il corpo è più utile quando si pianifica una sessione di registrazione: 50 dimostrazioni per compito, eccetto Thread Velcro a 100, che corrisponde a 10-20 minuti di dati e 30-60 minuti di tempo effettivo una volta contati i reset. Il successo non è uniforme: Thread Velcro termina al 20 percento, Put On Shoe al 92, Cup Open 84, Prep Tape 64.

L'action chunking è l'idea centrale

Il cloning comportamentale ordinario mappa un'osservazione a un'azione, e gli errori si accumulano: una deviazione porta il braccio fuori distribuzione, producendo un'azione peggiore, e trenta passi dopo la pinza non è da nessuna parte vicino all'oggetto. L'action chunking predice k azioni contemporaneamente e le esegue, riducendo l'orizzonte effettivo di un fattore k. Gestisce anche un inconveniente specifico dei dati umani: i teleoperatori fanno delle pause, e una policy Markoviana a singolo passo non può modellare una pausa che dipende da ciò che è venuto prima.

Il paper abla k piuttosto che affermarlo. Con l'ensembling temporale disattivato, mediato su quattro configurazioni, il successo sale dall'1 percento a k = 1 al 44 percento a k = 100, poi si stabilizza a 200 e 400 man mano che la policy si avvicina al controllo ad anello aperto. Quella curva è il motivo per cui il valore predefinito è 100.

• chunk_size: quante azioni future il decodificatore predice per ogni passaggio in avanti. Predefinito 100.
• n_action_steps: quante di esse vengono eseguite prima di interrogare nuovamente. Predefinito 100, quindi lerobot esegue l'intero chunk in open loop.
• lerobot convalida n_action_steps <= chunk_size e solleva un ValueError se i valori sono invertiti.

Ciò che conta operativamente è la dimensione del chunk divisa per il frame rate. Ai 30 fps utilizzati dagli esempi SO-100 di lerobot, un chunk di 100 impegna circa 3.3 secondi da una singola osservazione. Se il compito richiede una correzione all'interno di quella finestra, abbassare n_action_steps, non chunk_size: si mantiene la previsione lunga e si riosserva più spesso.

# 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 ACT supera un modello di base

Le cinque policy addestrabili affiancate, con i numeri che AY-Robots misura e utilizza per dimensionare la GPU che noleggia.

Scegli ACT quando il compito e la scena sono fissi e il movimento deve essere veloce e preciso. Scegli un quando un checkpoint deve coprire diverse istruzioni. Due pagine confrontano direttamente la decisione: e . Per i benchmark pubblicati, collega ogni numero alla sua fonte.

Cosa ti serve prima di iniziare

Un braccio follower, un braccio leader per la , almeno una telecamera, una GPU da 24 GB. ACT legge solo immagini e posizioni delle giunture. Due telecamere sono l'ideale: una vista frontale fissa per dove si trovano le cose, una telecamera da polso per ciò che l' sta per toccare, come su ALOHA.

Dal braccio nudo al dataset registrato

Il flusso seguente è lerobot 0.6.x. Saltalo se hai un braccio calibrato e un dataset. Altrimenti la guida introduttiva SO-100 copre l'assemblaggio, il tutorial di registrazione copre l'acquisizione e la documentazione del dataset il formato.

1. 1
   Installa lerobot con gli extra corretti

   La registrazione richiede core_scripts, l'addestramento training, i servi 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
   Trova la porta USB di ciascun braccio

   Eseguilo con entrambi i bracci collegati, scollegandone uno quando richiesto. Su Linux potrebbe essere necessario aprire i permessi del nodo.

   bash

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

3. 3
   Imposta gli ID dei motori e il baudrate

   Sull'SO-100 questo avviene prima dell'assemblaggio: a differenza dell'SO-101, i connettori sono irraggiungibili una volta costruito. Lo script percorre il bus un motore alla volta dalla pinza, scrivendo gli ID nella 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
   Calibra entrambi i bracci

   Imposta ogni giunto al centro del suo intervallo, premi Invio, quindi muovi ciascuno attraverso il suo intervallo completo. La calibrazione consente a una policy addestrata su un braccio di funzionare su un altro. Riutilizza lo stesso 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
   Teleopera una volta con le telecamere accese

   La regola empirica di lerobot: dovresti essere in grado di eseguire il compito guardando solo le immagini della telecamera. Se non puoi, nemmeno ACT può. Questo rileva più dataset errati che un debugging successivo.

   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
   Registra 50 episodi

   50 è il minimo di AY-Robots e ciò che ALOHA ha usato per compito. lerobot consiglia 10 per posizione dell'oggetto, telecamere fisse, presa coerente. n termina un episodio, r registra di nuovo, q si ferma 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

Prima dell'addestramento, riproduci almeno cinque episodi. memorizza i flussi della telecamera, gli stati dei giunti e le azioni per , e la riproduzione rimanda quelle azioni al braccio. Se la riproduzione non esegue il compito, i dati non lo contengono e l'addestramento non lo inventerà.

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

Addestramento della policy ACT

Questo è il comando completo. Tutto ciò che è specifico per ACT è già un'impostazione predefinita, motivo per cui la pagina ACT di lerobot consiglia di iniziare con essi.

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 carica ACTConfig, che si adatta al numero di motori e telecamere registrati dal tuo dataset, quindi non dichiari mai la forma dell'osservazione. --wandb.enable=true è opzionale e ne vale la pena: la curva di perdita è l'unico segnale economico in un'esecuzione di 100000 passi. La pianificazione proviene dalla configurazione di addestramento di lerobot, non da ACTConfig: 100000 passi, batch 8, seed 1000, un checkpoint ogni 20000 passi, logging ogni 200.

Un'esecuzione completa lascia cinque directory di checkpoint, da 020000 a 100000, più un symlink last. Conservali tutti: la migliore policy spesso non è l'ultima.

Durata: circa 5 ore su una RTX 2080 Ti da 11 GB nel paper, alcune ore per 100k passi secondo la pagina ACT di lerobot, da 2 a 5 ore sul livello da 24 GB di AY-Robots. Non interrompere prematuramente. Il README del repository di riferimento afferma che una policy a scatti o in pausa di solito necessita solo di più addestramento, perché il successo e la fluidità continuano a migliorare dopo che la perdita si stabilizza: per i dati del mondo reale sono necessari almeno 5000 epoche, o 3-4 volte la lunghezza dopo il plateau.

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

Esecuzione della policy addestrata sul braccio

Il deployment utilizza lerobot-rollout. Le chiavi della telecamera devono corrispondere a quelle registrate: una policy addestrata su front e wrist non accetterà cam0 e cam1, e rename_map non è d'aiuto, poiché richiede un checkpoint pre-addestrato. La stringa del task può essere omessa; l'esempio di lerobot la indica come skippabile per 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

Per fissare un checkpoint anziché il modello finale, aggiungi --policy.pretrained_revision. Ciò richiede che l'esecuzione sia iniziata con --save_checkpoint_to_hub=true, disattivato per impostazione predefinita: senza di esso lerobot carica solo il modello finale e nient'altro. Con esso, ogni checkpoint è etichettato con il suo passo riempito di zeri, quindi --policy.pretrained_revision=060000 recupera quello del passo 60000. Confrontarlo con quello del passo 100000 sul braccio reale è l'esperimento più economico disponibile.

Due percorsi allo stesso checkpoint

Tutto quanto sopra è il percorso manuale e funziona. Il percorso tramite piattaforma scambia il controllo con il non dover possedere una GPU o un 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

Cosa va effettivamente storto

Quasi nessuno dei problemi risiede nel comando di addestramento. Sono nelle cose che lo circondano, ordinate in base alla frequenza con cui si presentano per la prima volta.

Due righe meritano enfasi. ACT si addestra su LeRobot v3.0 mentre il loader di GR00T si blocca su di esso e richiede v2.1, quindi un dataset che addestra ACT può far fallire un'esecuzione di GR00T. E l'ultima riga presenta due soluzioni: gli autori di ACT rispondono al movimento a scatti con più addestramento, mentre con n_action_steps a 100 un vero e proprio blocco si verifica al confine di un chunk, una pausa visibile ogni 3.3 secondi a 30 fps. Altre due cose da sapere: un singolo giunto inattivo è solitamente un ID del servo che non è mai stato scritto, e una pinza che si avvicina ma non si chiude mai significa un intervallo di presa troppo limitato nelle dimostrazioni. Indice completo: le pagine delle modalità di errore.

Costo di un'esecuzione

Questo è l'argomento per iniziare con ACT anche se in seguito si desidera un VLA. Un'esecuzione ACT fallita costa il prezzo di un caffè e ti dice entro poche ore se il tuo dataset contiene il compito. Un'esecuzione GR00T fallita costa quattro volte tanto per la stessa lezione. Passare a GR00T N1.7 o SmolVLA in seguito è un cambio di forma, non una ricostruzione. Contesto: modelli visione-linguaggio-azione, la guida completa SO-100, addestra la tua prima policy e apprendimento per imitazione. Nessun braccio? La pagina live trasmette un vero SO-100 da guidare senza registrarsi.