Paano Sanayin ang ACT sa SO-100 mula sa Simula

Ang ACT ay ang naiiba sa mga patakaran ng SO-100. Ang GR00T N1.7 at N1.5 ay nagsisimula sa nvidia/GR00T-N1.7-3B at nvidia/GR00T-N1.5-3B, ang Pi0.5 naman ay mula sa lerobot/pi05_base. Ang ACT ay nagsisimula sa wala: walang base checkpoint, dahil hindi ito isang foundation model. Ito ay isang humigit-kumulang 80 milyong parameter na transformer na sinasanay mo mula sa simula sa isang gawain, sa iyong braso, sa ilalim ng iyong ilaw.

Ito rin ang dahilan kung bakit nagpapatakbo ito ng control step sa loob ng 20 ms kung saan ang isang 3 bilyong parameter na VLA ay nangangailangan ng 152 hanggang 485 ms, at nagkakahalaga ng 1 hanggang 3 USD bawat pagtakbo sa halip na 4 hanggang 12. Ang gabay na ito ay nagpapakita ng manu-manong ruta gamit ang lerobot sa isang SO-100: ang pag-record, ang act config, kung ano ang kinokontrol ng chunk_size at n_action_steps, ang 100000 step schedule, ang rollout. Pagkatapos ay ang parehong trabaho sa AY-Robots, kasama ang mga sitwasyon kung saan hindi nakakatulong ang platform.

Ano ba talaga ang ACT

Ang Action Chunking with Transformers ay nagmula sa ALOHA paper, Learning Fine-Grained Bimanual Manipulation with Low-Cost Hardware, nina Zhao, Kumar, Levine at Finn, arXiv, 23 Abril 2023. Ang rig ay nagre-record sa 50 Hz na may apat na webcam na nag-stream ng 480x640 sa 30 fps: dalawa sa mga gripper, isa sa itaas, isa sa harap. Ang abstract ay nag-aangkin ng anim na kasanayan na may 80 hanggang 90 porsiyentong tagumpay, kabilang ang pagbubukas ng translucent na condiment cup at pagpasok ng baterya, mula sa 10 minutong demonstrasyon.

Ang katawan ay mas kapaki-pakinabang kapag nagpaplano ng isang recording session: 50 demonstrasyon bawat gawain, maliban sa Thread Velcro sa 100, na 10 hanggang 20 minuto ng data at 30 hanggang 60 minuto ng wall-clock time kapag nabibilang na ang mga reset. Hindi rin pare-pareho ang tagumpay: Ang Thread Velcro ay nagtatapos sa 20 porsiyento, Put On Shoe sa 92, Cup Open 84, Prep Tape 64.

Ang action chunking ang buong ideya

Ang ordinaryong behavioural cloning ay nagmamapa ng isang obserbasyon sa isang aksyon, at ang mga error ay lumalala: ang isang paglihis ay naglalagay sa braso na wala sa distribusyon, na gumagawa ng mas masamang aksyon, at pagkatapos ng tatlumpung hakbang ang gripper ay malayo sa bagay. Pag-chunk ng aksyon ay naghuhula ng k aksyon nang sabay-sabay at isinasagawa ang mga ito, binabawasan ang epektibong horizon sa pamamagitan ng factor na k. Pinangangasiwaan din nito ang isang abala na partikular sa data ng tao: ang mga teleoperator ay nagpapahinga, at ang isang single-step na Markovian patakaran ay hindi kayang imodelo ang isang paghinto na nakasalalay sa kung ano ang nauna.

Ang papel ay nag-aablate ng k sa halip na igiit ito. Sa naka-off na temporal ensembling, na-average sa apat na setting, ang tagumpay ay tumataas mula 1 porsyento sa k = 1 hanggang 44 porsyento sa k = 100, pagkatapos ay bumababa sa 200 at 400 habang ang patakaran ay lumalapit sa open-loop control. Ang kurba na iyon ang dahilan kung bakit ang default ay 100.

• chunk_size: kung gaano karaming aksyon sa hinaharap ang hinuhulaan ng decoder sa bawat forward pass. Default 100.
• n_action_steps: ilan sa mga ito ang iyong isasagawa bago muling magtanong. Default 100, kaya ang lerobot ay nagpapatakbo ng buong chunk nang open loop.
• Binibigyang-bisa ng lerobot ang n_action_steps <= chunk_size at nagpapataas ng ValueError kung baliktad ang iyong pagkakakuha nito.

Ang mahalaga sa operasyon ay ang chunk_size na hinati sa frame rate. Sa 30 fps na ginagamit ng mga halimbawa ng SO-100 ng lerobot, ang isang chunk ng 100 ay nagbibigay ng humigit-kumulang 3.3 segundo mula sa isang obserbasyon. Kung kailangan ng gawain ng pagwawasto sa loob ng window na iyon, babaan ang n_action_steps, hindi ang chunk_size: pinapanatili mo ang mahabang prediksyon at mas madalas na muling nagmamasid.

# 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

Kapag nalampasan ng ACT ang isang foundation model

Ang limang trainable na patakaran na magkakatabi, kasama ang mga numerong sinusukat at ginagamit ng AY-Robots upang sukatin ang GPU na inuupahan nito.

Piliin ang ACT kapag ang gawain at eksena ay nakapirmi at ang galaw ay dapat mabilis at tumpak. Pumili ng isang kapag ang isang checkpoint ay dapat sumaklaw ng ilang tagubilin. Dalawang pahina ang nagtatrabaho sa desisyon nang harapan: at . Para sa mga nai-publish na benchmark, ay nagli-link ng bawat numero sa pinagmulan nito.

Ano ang kailangan mo bago ka magsimula

Isang follower arm, isang leader arm para sa , hindi bababa sa isang camera, isang 24 GB GPU. Binabasa lamang ng ACT ang mga imahe at posisyon ng joint. Ang dalawang camera ang pinakamainam: isang nakapirming front view para sa kinaroroonan ng mga bagay, isang wrist camera para sa kung ano ang ay malapit nang hawakan, tulad sa ALOHA.

Mula sa hubad na arm hanggang sa naitalang dataset

Ang daloy sa ibaba ay lerobot 0.6.x. Laktawan ito kung mayroon kang calibrated arm at dataset. Kung hindi, ang SO-100 gabay sa pagsisimula ay sumasaklaw sa pag-assemble, ang walkthrough ng pagre-record ay sumasaklaw sa pagkuha at ang mga dokumento ng dataset ang format.

1. 1
   I-install ang lerobot gamit ang tamang extras

   Ang pagre-record ay nangangailangan ng core_scripts, ang pagte-training ay training, ang Feetech servos ay 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
   Hanapin ang USB port ng bawat braso

   Patakbuhin ito nang nakasaksak ang parehong braso, at tanggalin ang isa kapag sinenyasan. Sa Linux, maaaring kailangan mong buksan ang mga pahintulot ng node.

   bash

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

3. 3
   Itakda ang mga ID ng motor at baudrate

   Sa SO-100, nangyayari ito bago ang pag-assemble: hindi tulad ng SO-101, hindi na maaabot ang mga konektor kapag nabuo na. Ang script ay naglalakad sa bus ng isang motor sa bawat pagkakataon mula sa gripper, at isinusulat ang mga ID sa 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
   I-calibrate ang parehong braso

   Itakda ang bawat joint sa gitna ng saklaw nito, pindutin ang Enter, pagkatapos ay i-sweep ang bawat isa sa buong saklaw nito. Ang Calibration ay nagpapahintulot sa isang policy na sinanay sa isang braso na tumakbo sa isa pa. Gamitin muli ang parehong 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
   Mag-teleoperate nang isang beses na nakabukas ang mga camera

   Ang patakaran ng lerobot: dapat mong magawa ang gawain sa pamamagitan lamang ng pagtingin sa mga imahe ng camera. Kung hindi mo magawa, hindi rin magagawa ng ACT. Mas maraming masamang dataset ang nahuhuli nito kaysa sa pag-debug sa huli.

   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
   Mag-record ng 50 episode

   Ang 50 ang minimum ng AY-Robots at ang ginamit ng ALOHA sa bawat gawain. Pinapayuhan ng lerobot ang 10 bawat lokasyon ng object, nakapirming camera, pare-parehong paghawak. Tinatapos ng n ang isang episode, muling nagre-record ang r, humihinto at nag-e-encode ang q.

   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

Bago mag-training, i-replay ang hindi bababa sa limang episode. ay nag-iimbak ng mga camera stream, joint state at aksyon bawat , at ang replay ay nagtutulak ng mga aksyon na iyon pabalik sa braso. Kung hindi ginagawa ng replay ang gawain, hindi ito naglalaman ng data at hindi ito iimbentuhin ng training.

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

Pagsasanay sa patakaran ng ACT

Ito ang buong command. Lahat ng ACT-specific ay default na, kaya sinasabi ng lerobot ACT page na simulan sa mga ito.

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 naglo-load ng ACTConfig, na umaangkop sa dami ng motor at camera na naitala ng iyong dataset, kaya hindi mo na kailangang ideklara ang hugis ng obserbasyon. --wandb.enable=true ay opsyonal at sulit: ang loss curve ang tanging murang signal sa isang 100000-step na pagtakbo. Ang iskedyul ay nagmumula sa train config ng lerobot, hindi sa ACTConfig: 100000 hakbang, batch 8, seed 1000, isang checkpoint bawat 20000 hakbang, at pag-log bawat 200.

Ang isang buong pagtakbo ay nag-iiwan ng limang direktoryo ng checkpoint, 020000 hanggang 100000, kasama ang isang huli symlink. Panatilihin ang lahat ng ito: ang pinakamahusay na patakaran ay madalas na hindi ang huli.

Tagal: humigit-kumulang 5 oras sa isang 11 GB RTX 2080 Ti sa papel, ilang oras para sa 100k na hakbang bawat pahina ng ACT ng lerobot, 2 hanggang 5 oras sa AY-Robots 24 GB tier. Huwag itong paikliin. Sinasabi ng README ng reference repo na ang isang patakarang pabago-bago o humihinto ay karaniwang nangangailangan lamang ng mas maraming pagsasanay, dahil ang tagumpay at kinis ay patuloy na bumubuti pagkatapos ng paghinto ng pagbaba ng loss: para sa real-world data, nangangailangan ito ng hindi bababa sa 5000 epochs, o 3 hanggang 4 na beses ang haba muli pagkatapos ng plateau.

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

Pagpapatakbo ng sinanay na patakaran sa braso

Gumagamit ang deployment ng lerobot-rollout. Dapat tumugma ang mga camera key sa mga naitala: ang isang patakarang sinanay sa front at wrist ay hindi tatanggap ng cam0 at cam1, at rename_map ay hindi makakatulong, dahil nangangailangan ito ng isang pretrained checkpoint. Maaaring alisin ang task string; minarkahan ito ng sariling halimbawa ng lerobot bilang skippable para sa 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 i-pin ang isang checkpoint sa halip na ang final model, idagdag ang --policy.pretrained_revision. Kailangan nito na nagsimula ang pagpapatakbo sa --save_checkpoint_to_hub=true, naka-off bilang default: kung wala ito, itutulak ng lerobot ang final model at wala nang iba. Sa pamamagitan nito, ang bawat checkpoint ay may tag na zero-padded step nito, kaya --policy.pretrained_revision=060000 ay nakakakuha ng 60000 step na isa. Ang paghahambing nito sa 100000 sa totoong braso ay ang pinakamurang eksperimento na magagamit.

Dalawang ruta patungo sa parehong checkpoint

Ang lahat ng nasa itaas ay ang manu-manong ruta at ito ay gumagana. Ang ruta ng platform ay nagpapalit ng kontrol para sa hindi pagmamay-ari ng isang GPU o isang Python environment.

# 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

Ano ang talagang nagiging mali

Halos wala sa sakit ay nasa training command. Ito ay nasa mga bagay sa paligid nito, nakaayos ayon sa kung gaano kadalas sila kumagat sa unang pagkakataon.

Dalawang row ang nararapat bigyan ng diin. Ang ACT ay nagsasanay sa LeRobot v3.0 habang ang loader ng GR00T ay nagka-crash dito at nangangailangan ng v2.1, kaya ang isang dataset na nagsasanay sa ACT ay maaaring magdulot ng pagkabigo sa pagpapatakbo ng GR00T. At ang huling row ay may dalawang solusyon: sinasagot ng mga may-akda ng ACT ang pabugso-bugsong galaw sa pamamagitan ng mas maraming training, habang sa n_action_steps sa 100 ang isang tunay na paghinto ay bumabagsak sa hangganan ng chunk, isang nakikitang paghinto bawat 3.3 segundo sa 30 fps. Dalawa pa ang dapat malaman: ang isang patay na joint ay karaniwang isang , at ay nangangahulugang masyadong maliit ang saklaw ng gripper sa mga demonstrasyon. Buong index: .

Magkano ang halaga ng isang pagpapatakbo

Ito ang argumento para sa pagsisimula sa ACT kahit na gusto mo ng VLA sa huli. Ang isang nabigong pagpapatakbo ng ACT ay nagkakahalaga ng presyo ng kape at nagsasabi sa iyo sa loob ng ilang oras kung ang iyong dataset ay naglalaman ng gawain. Ang isang nabigong pagpapatakbo ng GR00T ay nagkakahalaga ng apat na beses niyan para sa parehong aralin. Ang paglipat sa GR00T N1.7 o SmolVLA pagkatapos ay isang pagbabago sa anyo, hindi isang muling pagbuo. Background: mga modelo ng paningin-wika-aksyon, ang kumpletong gabay sa SO-100, sanayin ang iyong unang patakaran at pag-aaral ng panggagaya. Walang braso? Ang live na pahina ay nag-stream ng isang tunay na SO-100 upang patakbuhin nang hindi nagrerehistro.