Hoe ACT te trainen op de SO-100 vanaf nul

ACT is de vreemde eend in de bijt onder de SO-100 beleidslijnen. GR00T N1.7 en N1.5 beginnen bij nvidia/GR00T-N1.7-3B en nvidia/GR00T-N1.5-3B, Pi0.5 bij lerobot/pi05_base. ACT begint vanuit het niets: er is geen basischeckpoint, omdat het geen funderingsmodel is. Het is een transformator met ongeveer 80 miljoen parameters die je vanaf nul traint voor één taak, op jouw robotarm, onder jouw verlichting.

Dat is ook de reden waarom het een controlestap uitvoert in 20 ms, terwijl een VLA met 3 miljard parameters 152 tot 485 ms nodig heeft, en 1 tot 3 USD per run kost in plaats van 4 tot 12. Deze gids beschrijft de handmatige route met lerobot op een SO-100: opnemen, de act configuratie, wat chunk_size en n_action_steps regelen, het 100000-stappen schema, de rollout. Daarna dezelfde taak op AY-Robots, inclusief waar het platform niet helpt.

Wat ACT precies is

Action Chunking with Transformers komt uit het ALOHA-artikel, Learning Fine-Grained Bimanual Manipulation with Low-Cost Hardware, door Zhao, Kumar, Levine en Finn, arXiv, 23 april 2023. De opstelling neemt op met 50 Hz met vier webcams die 480x640 streamen met 30 fps: twee op de grijpers, één bovenaan, één vooraan. Het abstract claimt zes vaardigheden met 80 tot 90 procent succes, waaronder het openen van een doorschijnend kruidenpotje en het plaatsen van een batterij, gebaseerd op 10 minuten aan demonstraties.

De hoofdtekst is nuttiger bij het plannen van een opnamesessie: 50 demonstraties per taak, behalve Thread Velcro met 100, wat 10 tot 20 minuten aan data en 30 tot 60 minuten aan totale tijd is zodra resets zijn meegeteld. Het succes is ook niet uniform: Thread Velcro eindigt op 20 procent, Put On Shoe op 92, Cup Open 84, Prep Tape 64.

Action chunking is het hele idee

Gewone gedragscloning brengt één observatie in kaart naar één actie, en fouten stapelen zich op: een afwijking brengt de arm buiten de distributie, wat een slechtere actie oplevert, en dertig stappen later is de grijper nergens in de buurt van het object. Actie-chunking voorspelt k acties tegelijk en voert deze uit, waardoor de effectieve horizon met een factor k wordt verlaagd. Het behandelt ook een specifieke hinder bij menselijke gegevens: teleoperatoren pauzeren, en een Markoviaans beleid kan een pauze die afhangt van wat eraan voorafging niet modelleren.

Het artikel ablateert k in plaats van het te bevestigen. Met temporele ensembling uitgeschakeld, gemiddeld over vier instellingen, stijgt het succes van 1 procent bij k = 1 naar 44 procent bij k = 100, en vlakt vervolgens af bij 200 en 400 naarmate het beleid open-loop controle nadert. Die curve is de reden waarom de standaardwaarde 100 is.

• chunk_size: hoeveel toekomstige acties de decoder per forward pass voorspelt. Standaard 100.
• n_action_steps: hoeveel daarvan je uitvoert voordat je opnieuw een query doet. Standaard 100, dus lerobot voert de hele chunk open loop uit.
• lerobot valideert n_action_steps <= chunk_size en genereert een ValueError als je het omgekeerd instelt.

Wat operationeel van belang is, is chunk_size gedeeld door de framerate. Bij de 30 fps die lerobot's SO-100 voorbeelden gebruiken, omvat een chunk van 100 ongeveer 3,3 seconden vanaf één observatie. Als de taak een correctie binnen dat venster vereist, verlaag dan n_action_steps, niet chunk_size: je behoudt de lange voorspelling en observeert vaker opnieuw.

# 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

Wanneer ACT een funderingsmodel verslaat

De vijf trainbare beleidsregels naast elkaar, met de cijfers die AY-Robots meet en gebruikt om de GPU te dimensioneren die het huurt.

Kies ACT wanneer taak en scène vastliggen en beweging snel en precies moet zijn. Kies een wanneer één checkpoint meerdere instructies moet dekken. Twee pagina's vergelijken de beslissing direct: en . Voor gepubliceerde benchmarks, linkt elk nummer aan de bron.

Wat je nodig hebt voordat je begint

Eén volgerarm, één leiderarm voor , minstens één camera, een 24 GB GPU. ACT leest alleen beelden en gewrichtsposities. Twee camera's is de ideale configuratie: een vaste vooraanzicht voor waar dingen zijn, een polscamera voor wat de gaat aanraken, zoals bij ALOHA.

Van kale arm tot opgenomen dataset

De onderstaande workflow is voor lerobot 0.6.x. Sla deze over als je een gekalibreerde arm en een dataset hebt. Anders behandelt de SO-100 handleiding voor beginners de montage, de opnamehandleiding de opname en de dataset documentatie het formaat.

1. 1
   Installeer lerobot met de juiste extra's

   Opnemen vereist core_scripts, training training, Feetech servo's 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
   Vind de USB-poort van elke arm

   Voer het uit met beide armen aangesloten, en koppel er één los wanneer daarom wordt gevraagd. Op Linux moet u mogelijk de node-permissies openen.

   bash

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

3. 3
   Stel de motor-ID's en baudrate in

   Bij de SO-100 gebeurt dit vóór de montage: in tegenstelling tot de SO-101 zijn de connectoren onbereikbaar zodra deze is gebouwd. Het script doorloopt de bus motor voor motor vanaf de grijper en schrijft ID's naar 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
   Kalibreer beide armen

   Zet elk gewricht in het midden van zijn bereik, druk op Enter en beweeg elk gewricht vervolgens door zijn volledige bereik. Kalibratie maakt het mogelijk dat een beleid dat op de ene arm is getraind, op een andere arm kan worden uitgevoerd. Hergebruik dezelfde 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
   Teleopereer één keer met de camera's aan

   De vuistregel van lerobot: u moet de taak kunnen uitvoeren door alleen naar de camerabeelden te kijken. Als u dat niet kunt, kan ACT dat ook niet. Dit vangt meer slechte datasets op dan later debuggen.

   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
   Neem 50 episodes op

   50 is het minimum van AY-Robots en wat ALOHA per taak gebruikte. lerobot adviseert 10 per objectlocatie, vaste camera's, consistente greep. n beëindigt een episode, r neemt opnieuw op, q stopt en codeert.

   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

Voordat u traint, speelt u minstens vijf episodes opnieuw af. slaat camerastromen, gewrichtstoestanden en acties op per , en het opnieuw afspelen stuurt die acties terug naar de arm. Als het opnieuw afspelen de taak niet uitvoert, bevatten de gegevens deze niet en zal de training deze ook niet uitvinden.

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

De ACT-policy trainen

Dit is de volledige opdracht. Alles wat ACT-specifiek is, is al een standaardinstelling, daarom staat op de lerobot ACT-pagina dat je hiermee moet beginnen.

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 laadt ACTConfig, die zich aanpast aan het aantal motoren en camera's dat uw dataset heeft opgenomen, zodat u nooit de observatievorm hoeft te declareren. --wandb.enable=true is optioneel en de moeite waard: de verliescurve is het enige goedkope signaal in een run van 100000 stappen. Het schema komt van lerobot's train config, niet ACTConfig: 100000 stappen, batch 8, seed 1000, een checkpoint elke 20000 stappen, loggen elke 200.

Een volledige run laat vijf checkpoint-mappen achter, 020000 tot en met 100000, plus een laatste symlink. Bewaar ze allemaal: het beste beleid is vaak niet het laatste.

Duur: ongeveer 5 uur op een 11 GB RTX 2080 Ti in het paper, een paar uur voor 100k stappen volgens de ACT-pagina van lerobot, 2 tot 5 uur op de 24 GB tier van AY-Robots. Kort het niet in. De README van de referentie-repo zegt dat een schokkerig of pauzerend beleid meestal gewoon meer training, omdat succes en vloeiendheid blijven verbeteren nadat het verlies stabiliseert: voor real-world data zijn minstens 5000 epochs nodig, of 3 tot 4 keer de lengte opnieuw na het plateau.

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

Het getrainde beleid uitvoeren op de arm

Implementatie gebruikt lerobot-rollout. Cameratoetsen moeten overeenkomen met de opgenomen toetsen: een beleid getraind op front en wrist accepteert niet cam0 en cam1, en rename_map helpt niet, aangezien het een vooraf getraind checkpoint nodig heeft. De taakstring kan worden weggelaten; lerobot's eigen voorbeeld markeert deze als over te slaan voor 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

Om een checkpoint vast te zetten in plaats van het uiteindelijke model, voeg toe --policy.pretrained_revision. Dat vereist dat de run is gestart met --save_checkpoint_to_hub=true, standaard uitgeschakeld: zonder dit pusht lerobot alleen het uiteindelijke model en niets anders. Hiermee wordt elk checkpoint getagd met zijn met nullen opgevulde stap, dus --policy.pretrained_revision=060000 herstelt die van stap 60000. Het vergelijken ervan met 100000 op de echte arm is het goedkoopste experiment dat beschikbaar is.

Twee routes naar hetzelfde checkpoint

Alles hierboven is de handmatige route en het werkt. De platformroute ruilt controle in voor het niet bezitten van een GPU of een Python-omgeving.

# 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

Wat er daadwerkelijk misgaat

Bijna geen van de problemen zit in het trainingscommando. Het zit in de zaken eromheen, gerangschikt naar hoe vaak ze de eerste keer problemen veroorzaken.

Twee rijen verdienen de nadruk. ACT traint op LeRobot v3.0 terwijl de loader van GR00T erop crasht en v2.1 nodig heeft, dus een dataset die ACT traint, kan een GR00T-uitvoering laten mislukken. En de laatste rij heeft twee oplossingen: de ACT-auteurs beantwoorden schokkerige bewegingen met meer training, terwijl met n_action_steps op 100 een echte blokkade op een blokgrens terechtkomt, een zichtbare pauze elke 3.3 seconden bij 30 fps. Nog twee om te weten: een enkel dood gewricht is meestal een servo-ID dat nooit is geschreven, en een grijper die nadert maar nooit sluit betekent te weinig grijperbereik in de demonstraties. Volledige index: de pagina's met storingsmodi.

Wat een run kost

Dit is het argument om met ACT te beginnen, zelfs als je later een VLA wilt. Een mislukte ACT-uitvoering kost de prijs van een kop koffie en vertelt je binnen enkele uren of je dataset de taak bevat. Een mislukte GR00T-uitvoering kost vier keer zoveel voor dezelfde les. Opschalen naar GR00T N1.7 of SmolVLA achteraf is een vormverandering, geen herbouw. Achtergrond: visie-taal-actie modellen, de complete SO-100 gids, train je eerste beleid en imitatie leren. Geen arm? De live pagina streamt een echte SO-100 om te besturen zonder aan te melden.