Hur man tränar ACT på SO-100 från grunden

ACT är undantaget bland SO-100-policyerna. GR00T N1.7 och N1.5 utgår från nvidia/GR00T-N1.7-3B och nvidia/GR00T-N1.5-3B, Pi0.5 från lerobot/pi05_base. ACT börjar från noll: det finns ingen bas-checkpoint, eftersom det inte är en grundmodell. Det är en transformator med ungefär 80 miljoner parametrar som du tränar från grunden för en uppgift, på din arm, under din belysning.

Det är också därför den kör ett kontrollsteg på 20 ms där en VLA med 3 miljarder parametrar behöver 152 till 485 ms, och kostar 1 till 3 USD per körning istället för 4 till 12. Denna guide beskriver den manuella vägen med lerobot på en SO-100: inspelning, act konfigurationen, vad chunk_size och n_action_steps kontrollerar, schemat med 100000 steg, och utrullningen. Därefter samma jobb på AY-Robots, inklusive där plattformen inte hjälper till.

Vad ACT faktiskt är

Action Chunking with Transformers kommer från ALOHA-artikeln, Learning Fine-Grained Bimanual Manipulation with Low-Cost Hardware, av Zhao, Kumar, Levine och Finn, arXiv, 23 april 2023. Riggen spelar in med 50 Hz med fyra webbkameror som strömmar 480x640 vid 30 fps: två på gripklorna, en uppifrån, en framifrån. Abstraktet hävdar sex färdigheter med 80 till 90 procents framgång, bland annat att öppna en genomskinlig kryddkopp och att sätta i ett batteri, från 10 minuters demonstrationer.

Brödtexten är mer användbar vid planering av en inspelningssession: 50 demonstrationer per uppgift, förutom Trä kardborreband vid 100, vilket är 10 till 20 minuters data och 30 till 60 minuters realtid när återställningar räknats. Framgången är inte heller enhetlig: Trä kardborreband slutar på 20 procent, Ta på sko på 92, Öppna kopp 84, Förbered tejp 64.

Action chunking är hela idén

Vanlig beteendekloning mappar en observation till en handling, och fel ackumuleras: en avvikelse placerar armen utanför distributionen, vilket producerar en sämre handling, och trettio steg senare är griparen ingenstans nära objektet. Action chunking förutsäger k handlingar samtidigt och utför dem, vilket minskar den effektiva horisonten med en faktor k. Det hanterar också ett problem som är specifikt för mänsklig data: teleoperatörer pausar, och en enstegs Markovisk policy kan inte modellera en paus som beror på vad som kom före.

Artikeln ablaterar k snarare än att hävda det. Med temporal ensembling avstängd, i genomsnitt över fyra inställningar, stiger framgången från 1 procent vid k = 1 till 44 procent vid k = 100, för att sedan avta vid 200 och 400 när policyn närmar sig öppen-loop-kontroll. Den kurvan är anledningen till att standardvärdet är 100.

• chunk_size: hur många framtida åtgärder avkodaren förutsäger per framåtkörning. Standard 100.
• n_action_steps: hur många av dem du utför innan du frågar igen. Standard 100, så lerobot kör hela chunken i öppen slinga.
• lerobot validerar n_action_steps <= chunk_size och utlöser ett ValueError om du anger det felaktigt.

Vad som är viktigt operationellt är chunk_size dividerat med bildfrekvensen. Vid de 30 fps som lerobots SO-100-exempel använder, motsvarar en chunk på 100 cirka 3,3 sekunder från en observation. Om uppgiften kräver en korrigering inom det fönstret, sänk n_action_steps, inte chunk_size: du behåller den långa prediktionen och observerar om oftare.

# 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

När ACT överträffar en grundmodell

De fem träningsbara policyerna sida vid sida, med siffrorna AY-Robots mäter och använder för att dimensionera den GPU de hyr.

Välj ACT när uppgift och scen är fasta och rörelsen måste vara snabb och precis. Välj en när en kontrollpunkt måste täcka flera instruktioner. Två sidor jämför beslutet direkt: och . För publicerade riktmärken, länkar varje siffra till dess källa.

Vad du behöver innan du börjar

En följararm, en ledararm för , minst en kamera, en 24 GB GPU. ACT läser endast bilder och ledpositioner. Två kameror är optimalt: en fast frontvy för var saker befinner sig, en handledskamera för vad är på väg att röra, som på ALOHA.

Från bar arm till inspelad datamängd

Flödet nedan är lerobot 0.6.x. Hoppa över det om du har en kalibrerad arm och en datamängd. Annars täcker SO-100 startguide, monteringen, inspelningsgenomgången täcker insamlingen och datamängdsdokumentationen formatet.

1. 1
   Installera lerobot med rätt tillägg

   Inspelning kräver core_scripts, träning training, Feetech-servon 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
   Hitta USB-porten för varje arm

   Kör den med båda armarna inkopplade, koppla ur en när du uppmanas. På Linux kan du behöva öppna nodbehörigheterna.

   bash

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

3. 3
   Ställ in motor-ID:n och baudrate

   På SO-100 sker detta före montering: till skillnad från SO-101 är kontakterna oåtkomliga när den väl är byggd. Skriptet går igenom bussen en motor i taget från griparen och skriver ID:n till 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
   Kalibrera båda armarna

   Ställ in varje led till mitten av dess rörelseområde, tryck Enter och svep sedan varje led genom hela dess rörelseområde. Kalibrering låter en policy tränad på en arm köras på en annan. Återanvänd samma 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
   Teleoperera en gång med kamerorna på

   Lerobots tumregel: du bör kunna utföra uppgiften genom att bara titta på kamerabilderna. Om du inte kan det, kan inte ACT heller. Detta fångar fler dåliga dataset än senare felsökning.

   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
   Spela in 50 episoder

   50 är AY-Robots minimum och vad ALOHA använde per uppgift. lerobot rekommenderar 10 per objektplats, fasta kameror, konsekvent grepp. n avslutar en episod, r spelar in igen, q stoppar och kodar.

   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

Före träning, spela upp minst fem episoder. LeRobot-datasetformatet lagrar kameraströmmar, ledtillstånd och åtgärder per episod, och uppspelning skickar tillbaka dessa åtgärder till armen. Om uppspelningen inte utför uppgiften, innehåller datan den inte och träningen kommer inte att uppfinna den.

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

Träna ACT-policyn

Detta är hela kommandot. Allt ACT-specifikt är redan standard, vilket är anledningen till att lerobot ACT-sidan säger att man ska börja med dem.

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 laddar ACTConfig, som anpassar sig till hur många motorer och kameror din datamängd registrerade, så du behöver aldrig deklarera observationsformen. --wandb.enable=true är valfritt och värt det: förlustkurvan är den enda billiga signalen i en körning på 100000 steg. Schemat kommer från lerobot:s träningskonfiguration, inte ACTConfig: 100000 steg, batch 8, seed 1000, en checkpoint var 20000:e steg, loggning var 200:e.

En fullständig körning lämnar fem checkpoint-kataloger, 020000 till 100000, plus en last symlänk. Behåll dem alla: den bästa policyn är ofta inte den sista.

Varaktighet: cirka 5 timmar på ett 11 GB RTX 2080 Ti i artikeln, några timmar för 100k steg enligt lerobots ACT-sida, 2 till 5 timmar på AY-Robots 24 GB-nivå. Korta inte av det. Referens-repots README säger att en ryckig eller pausande policy vanligtvis bara behöver mer träning, eftersom framgång och jämnhet fortsätter att förbättras efter att förlusten planar ut: för verklig data krävs minst 5000 epoker, eller 3 till 4 gånger längden igen efter platån.

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

Köra den tränade policyn på armen

Distribution använder lerobot-rollout. Kameranycklar måste matcha de inspelade: en policy tränad på front och wrist kommer inte att acceptera cam0 och cam1, och rename_map hjälper inte, eftersom den behöver en förtränad kontrollpunkt. Uppgiftssträngen kan utelämnas; lerobots eget exempel markerar den som valfri för 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

För att fästa en checkpoint snarare än den slutliga modellen, lägg till --policy.pretrained_revision. Det kräver att körningen har startat med --save_checkpoint_to_hub=true, avstängt som standard: utan det laddar lerobot upp den slutliga modellen och inget annat. Med det taggas varje checkpoint med dess nollutfyllda steg, så --policy.pretrained_revision=060000 återställer den med 60000 steg. Att jämföra den med 100000 på den riktiga armen är det billigaste experimentet som finns tillgängligt.

Två vägar till samma checkpoint

Allt ovan är den manuella vägen och den fungerar. Plattformsvägen byter kontroll mot att slippa äga en GPU eller en Python-miljö.

# 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

Vad som faktiskt går fel

Nästan inget av besväret ligger i träningskommandot. Det ligger i sakerna runt omkring det, ordnade efter hur ofta de orsakar problem första gången.

Två rader förtjänar att lyftas fram. ACT tränar på LeRobot v3.0 medan GR00T:s laddare kraschar på det och behöver v2.1, så ett dataset som tränar ACT kan misslyckas med en GR00T-körning. Och den sista raden har två lösningar: ACT-författarna svarar på ryckig rörelse med mer träning, medan med n_action_steps vid 100 landar ett verkligt stopp vid en chunk-gräns, en synlig paus var 3,3 sekund vid 30 fps. Ytterligare två att känna till: en enskild död led är vanligtvis ett servo-ID som aldrig skrevs, och en gripklo som närmar sig men aldrig stänger betyder för litet gripområde i demonstrationerna. Fullständigt index: sidorna för fellägen.

Vad en körning kostar

Detta är argumentet för att börja med ACT även om du vill ha en VLA senare. En misslyckad ACT-körning kostar som en kopp kaffe och berättar inom några timmar om din datamängd innehåller uppgiften. En misslyckad GR00T-körning kostar fyra gånger så mycket för samma lärdom. Att sedan gå vidare till GR00T N1.7 eller SmolVLA efteråt är en formförändring, inte en ombyggnad. Bakgrund: vision-language-action-modeller, den kompletta SO-100-guiden, träna din första policy och imitationsinlärning. Ingen arm? Livesidan streamar en riktig SO-100 att köra utan att registrera dig.