Aling Patakaran ng VLA ang Dapat Mong Sanayin sa 2026?

Limang patakaran ang maaaring sanayin sa isang SO-100 class arm ngayon. Nagkakaiba sila sa factor na 24 sa inference latency, 37 sa parameter count at 12 sa kung magkano ang gastos ng isang run, at kung maaari mong ipadala ang resulta. Limang model card ang hindi makakapagpasya nito: wala sa mga ito ang sumasagot sa tanong mo, alin ang una kong patatakbuhin?

Ang bawat numero sa ibaba ay nabasa mula sa mga papel, repo at card noong Agosto 2026. Ang mga numero ng platform ay nagmula sa katalogo ng patakaran ng AY-Robots; kung saan hindi nagkakasundo ang dalawa, pareho silang ipinapakita.

Ang talahanayan ng desisyon

Ang limang kandidato

Ang limang ito ay na mga polisiya: camera frames, joint positions at, para sa apat sa kanila, isang instruksyon sa wika, na naka-map sa isang bahagi ng mga target ng joint sa hinaharap. Ang naghihiwalay sa kanila ay kung gaano karami ang natutunan bago ka dumating.

GR00T N1.7

Ang kasalukuyang modelo ng vision-language-action ng NVIDIA, humigit-kumulang 3 B na parameter, halos 40 M ang sinanay sa panahon ng fine-tuning. Nakalista sa repo ang mga delta mula sa N1.6: backbone mula sa isang Eagle model na binili sa Cosmos-Reason2-2B sa Qwen3-VL, diffusion layers 32 hanggang 16, state at action dimensions 29 hanggang 132, action horizon 16 hanggang 40.

Ang mahalaga sa isang maliit na braso ay ang relative end-effector action space: Hinuhulaan ng N1.7 ang mga delta mula sa kasalukuyang pose, na siyang nagpapahintulot sa 20K oras ng EgoScale human video na mailipat sa isang robot policy. Ang spec ay nasa pahina ng N1.7, ang pamamaraan ay nasa gabay ng N1.7 sa SO-100.

GR00T N1.5

Parehong 3 B scale, Eagle 2 backbone, SigLip2 at T5, flow-matching DiT head. Ito ay umiiral upang palawigin ang isang na mayroon ka na. Dalawang bagay ang nagpapahirap dito bilang default: ang mga weights ay may NVIDIA's one-way non-commercial licence, at ang kasalukuyang mga release ng LeRobot ay inalis ang suporta sa N1.5. Tingnan ang .

Pi0.5

Ang Physical Intelligence's VLA, uri ng patakaran pi05. Ang papel ay nagbibigay ng isang 2 B VLM na sinimulan mula sa PaliGemma kasama ang isang 300 M action expert, na nagpapatakbo ng robot sa 50 Hz; Ang pi05 config ng LeRobot ay nagde-default sa isang 50-step chunk, isang segundo sa bilis na iyon. Ang pangunahing bentahe ay ang mga hindi pa nakikitang lugar: humigit-kumulang 400 oras ng mobile manipulation sa totoong mga tahanan, at isang pag-aaral sa scaling sa mahigit 3, 12, 22, 53, 82 at 104 na lokasyon, kung saan ang 104-lokasyon na modelo ay tumugma sa isang kontrol na sinanay sa mismong mga tahanan ng pagsubok.

Isang limitasyon, nakasaad sa lerobot/pi05_base card: ang port ay nagdadala lamang ng flow-matching action head. Ang subtask prediction, action tokenization at RL ay hindi inilabas sa upstream, at sinasabi ng openpi ang pareho para sa sarili nitong repository. Ang pahina ng Pi0.5 at ang gabay ng Pi0.5 sa SO-100 ang may iba pa.

SmolVLA

450 M na parameter, humigit-kumulang 100 M sa action expert, sa SmolVLM-2 na ang VLM ay frozen at tanging ang unang 16 na language-model layer lamang ang ginamit. Ang pretraining ay data ng komunidad: 481 dataset, 10.6 M frame, mula sa parehong murang braso na ginagamit mo. Ang tanging VLA dito na kasya sa isang 24 GB card, at ang tanging 30 yugto limitasyon. Tingnan ang pahina ng SmolVLA.

ACT

Hindi isang foundation model. Ang Action Chunking Transformer mula sa ALOHA ay humigit-kumulang 80 M na parameter na sinanay mula sa simula bawat gawain, sa 50 demonstrasyon sa 50 Hz. Ang papel ay nag-uulat ng anim na tunay na bimanual na gawain mula sa humigit-kumulang sampung minuto ng mga demonstrasyon bawat isa, sa 80 hanggang 90 porsiyento sa mga halimbawang binibigyang-diin nito. Ang ideya nito, action chunking, ay nasa bawat modelo sa pahinang ito, at ang ablation nito ay sumusukat pa rin ang epekto nang pinakamahusay: sa dalawang simulated na gawain na naka-off ang temporal ensembling, ang tagumpay ay tumataas mula 1 porsiyento sa k=1 hanggang 44 porsiyento sa k=100. Ang pahina ng ACT ay may iba pa.

Ano ang tunay na sinasabi ng mga benchmark

LIBERO ang isang benchmark na iniuulat ng tatlo sa limang ito: mga gawaing nakabatay sa wika sa isang simulated na Franka Panda, hinati sa apat na suite sa ibaba na may sampung gawain bawat isa. Ang NVIDIA ay nagpatakbo ng 200 pagsubok bawat suite.

Ipinapakita ng SimplerEnv ang pagkalat, na hindi ipinapakita ng LIBERO. Inihahambing ng NVIDIA ang N1.7 laban sa N1.6, ang pinakamalapit na pampublikong bagay sa isang generational delta.

Ang row ng Bridge ang kapaki-pakinabang: 5.7 puntos ang nakuha sa average habang ang put_eggplant_in_basket ay nawalan ng 36 at ang put_eggplant_in_sink ay bumaba mula 33 patungong 2. Isang bagong henerasyon ang naglilipat ng distribusyon sa halip na itaas ito, kaya kung ang iyong gawain ay nasa kung saan bumaba ang N1.7, walang sinasabi ang average.

Sa lima, tanging ang papel ng SmolVLA ang nag-uulat tungkol sa isang SO-100 class arm: 78.3 porsyento para sa SmolVLA at 61.7 para sa Pi0 sa tatlong gawain, parehong multi-task, laban sa 48.3 para sa ACT na sinanay na single-task, na hindi pareho. Ang malinis na pagpapares ay parehong single-task sa SO-101 pick-and-place: 90 laban sa 70 sa distribusyon, 50 laban sa 40 sa labas nito. Ikumpara sa ACT laban sa SmolVLA at Pi0.5 laban sa SmolVLA, o i-browse ang arena.

Ang latency at gastos ang nagpapasya sa deployment

Latency ng Inference ay ang limitasyon na huling nadiskubre ng mga tao at unang pinagsisisihan. Ang isang patakaran na limang puntos na mas mahusay sa isang benchmark ngunit kalahating segundo bawat hakbang ng aksyon ay mukhang mas masahol sa iyong mesa: hindi naghihintay ang dinamika ng kontak.

Isang paalala: ang figure ng GR00T ay hindi sumasang-ayon sa card ng NVIDIA, na nagtatala ng 4 na hakbang ng denoising at isang camera sa 85.8 ms sa isang H100 sa eager mode, 48.6 ms sa torch.compile, 27.9 ms sa buong TensorRT. Ang 152 ms dito ay isang buong-stack na figure na may serving overhead at higit sa isang camera, hindi isang forward pass.

Isang paraan upang makatipid ng oras nang hindi binabago ang modelo: sinusukat ng papel ng SmolVLA ang synchronous execution, kung saan tinatapos ng patakaran ang isang bahagi bago hulaan ang susunod, laban sa asynchronous, kung saan ang prediksyon ay nagsasapawan sa execution. Ang tagumpay ay magkatulad, 78.3 laban sa 73.3, ngunit ang parehong pick-and-place ay tumatagal ng 9.7 segundo sa halip na 13.75, at sa isang nakapirming window, ang robot ay nakakagawa ng 19 na cycle sa halip na 9.

Mga Lisensya, sinuri dahil walang sumusuri sa kanila

Ang row ng Pi0.5 ay nangangailangan ng pag-iingat. Ang dokumentasyon ng LeRobot pi05 ay nagsasaad ng Apache 2.0 na naaayon sa openpi, habang ang Hub card para sa lerobot/pi05_base ay naglalaman ng license: gemma. Pareho silang aktibo. Ang GR00T N1.7 ay may mas malumanay na bersyon: ang Isaac-GR00T README ay nagsasaad na ang N1.7 ay ganap na komersyal na lisensyado sa ilalim ng Apache 2.0, habang ang sarili nitong seksyon ng lisensya at ang model card ay inilalagay lamang ang code sa ilalim ng Apache 2.0 at ang weights sa ilalim ng NVIDIA Open Model License.

Ang mga default na aktwal mong patatakbuhin

Bawat form ng trainer ay may default, at hindi ito arbitraryo. Ang sa ACT ay sariling LeRobot: batch 8, lr 1e-5, 100000 mga hakbang sa pagsasanay, chunk size 100, na tumutugma sa ACTConfig upstream at k=100 mula sa ACT paper. Ang isang column sa ibaba ay isang bitag.

Ang kontrol na mas mahalaga kaysa sa pagpili ng modelo

Ito ang action chunk. Ang mas mahabang chunks ay nagbibigay ng mas makinis na galaw at mas kaunting nagpapataas na error, ngunit ang patakaran ay nakatuon habang isinasagawa ang block, kaya huli itong tumutugon sa anumang gumagalaw: kumpiyansa sa isang static na cube, walang pag-asa sa gumugulong. Kung ito ay lumampas, ang pagpapaikli ng isinagawang bahagi ay mas mahusay kaysa sa muling pagsasanay at libre. Ang isang joint na humihinto nang maaga ay ibang problema; tingnan ang .

• ACT: Ang ACTConfig ay nagde-default sa chunk_size 100 at n_action_steps 100. Ang temporal ensembling ay naka-off at nangangailangan ng n_action_steps 1.
• GR00T N1.7: Ang internal horizon ay naging 16 hanggang 40, gayunpaman ang halimbawa ng SO-101 ng LeRobot ay tumatakbo pa rin ng --policy.chunk_size=16 --policy.n_action_steps=16. Ang rollout flag ay pinalitan ng pangalan sa --execution-horizon.
• Pi0.5: isang 50-step chunk, kung saan ang LIBERO recipe ng LeRobot ay nagsasagawa ng 10 sa pamamagitan ng --policy.n_action_steps=10; sa --policy.pretrained_path ito ay babalik sa 50 kung aalisin mo ang flag.
• SmolVLA: 50-action chunks, parehong knobs ang nakalantad.

Paano i-screen ang lahat ng lima sa isang hapon

Ang pinakamurang sagot ay hindi mas maraming pagbabasa. Gumastos ng humigit-kumulang 15 USD at hayaang sabihin sa iyo ng braso: mag-record nang isang beses, sanayin muna ang murang modelo, itaas ang antas kapag napatunayan na nito na tama ang data. Ang istraktura ay mas mahalaga kaysa sa dami, ang punto ng at ang .

1. 1
   Mag-record ng 50 episode nang isang beses

   Limampu ang nagbibigay-daan para sa GR00T, Pi0.5 at ACT, at 30 para sa SmolVLA. Ulitin ang bawat variation sa halip na kumalat: 50 episode sa 5 posisyon ng cube ang sinanay, kumpara sa 25 na hindi. Tingnan ang pag-record ng iyong unang dataset.

   bash

   lerobot-record \
     --robot.type=so100_follower \
     --robot.port=/dev/ttyACM1 \
     --robot.id=my_follower_arm \
     --teleop.type=so100_leader \
     --teleop.port=/dev/ttyACM0 \
     --teleop.id=my_leader_arm \
     --dataset.repo_id=${HF_USER}/pick-place-50 \
     --dataset.num_episodes=50 \
     --dataset.single_task="Put the lego brick into the box"

2. 2
   Sanayin muna ang ACT, dahil hindi ito maaaring magsinungaling sa iyo

   Walang pretrained weights, kaya kung nagagawa nito ang gawain, ang iyong dataset ay naglalaman ng gawain. Kung mag-flatline ang ACT, ayusin ang data. 1 to 3 USD, 2 to 5 oras sa isang 24 GB card.

   bash

   lerobot-train \
     --dataset.repo_id=${HF_USER}/pick-place-50 \
     --policy.type=act \
     --policy.device=cuda \
     --batch_size=8 \
     --steps=100000 \
     --seed=1000 \
     --output_dir=outputs/train/act_pickplace \
     --job_name=act_pickplace

3. 3
   Patakbuhin ang SmolVLA sa parehong dataset, nang walang pagbabago

   Parehong data, parehong braso, 450 M parameter sa halip na 80 M, kasama ang language conditioning. Ang LeRobot ay nagpapatakbo ng 20K step sa humigit-kumulang 4 na oras sa isang A100. Ito ang magsasabi sa iyo kung may pakinabang ang pretraining.

   bash

   lerobot-train \
     --policy.path=lerobot/smolvla_base \
     --dataset.repo_id=${HF_USER}/pick-place-50 \
     --batch_size=64 \
     --steps=20000 \
     --policy.device=cuda \
     --output_dir=outputs/train/smolvla_pickplace \
     --job_name=smolvla_pickplace

4. 4
   I-convert pababa sa v2.1 bago mo galawin ang GR00T

   Binabasa ng GR00T ang isang bersyon ng LeRobot v2 format kasama ang isang karagdagang meta/modality.json na nagmamapa kung paano nahahati ang pinagsamang state at action arrays sa mga pinangalanang field. Nagka-crash ang loader sa isang v3.0 dataset, dahil ang v3.0 ay naglalagay ng maraming episode sa mga shared file kung saan ang v2 ay sumusulat ng isa bawat episode. Ipinapadala ng Isaac-GR00T ang downgrade helper bilang scripts/lerobot_conversion/convert_v3_to_v2.py; ang pahina ng pagtanggi sa v3 ang mabilis na daan.

   text

   # GR00T expects this layout, not the v3.0 file-based one
   my_dataset/
     meta/
       info.json
       episodes.jsonl      # episode index and lengths
       tasks.jsonl         # language task descriptions
       modality.json       # GR00T-specific: state/action/video key mapping
     data/chunk-000/       # parquet, state and action per timestep
     videos/chunk-000/     # one mp4 per episode

5. 5
   Mag-escalate sa GR00T N1.7 lamang kung may naiwan ang unang dalawa

   Sa pamamagitan ng CLI ng NVIDIA, na ipinapakita dito, o ang groot policy type ng LeRobot. Inirerekomenda ng NVIDIA ang 40 GB o higit pa ng VRAM para sa fine-tuning, 16 GB para sa inference. Sa isang OOM, tingnan ang pahina ng OOM.

   bash

   CUDA_VISIBLE_DEVICES=0 uv run python \
     gr00t/experiment/launch_finetune.py \
     --base-model-path nvidia/GR00T-N1.7-3B \
     --dataset-path demo_data/cube_to_bowl_5 \
     --embodiment-tag NEW_EMBODIMENT \
     --modality-config-path examples/SO100/so100_config.py \
     --num-gpus 1 \
     --output-dir /tmp/test_finetune \
     --max-steps 2000 \
     --global-batch-size 32 \
     --dataloader-num-workers 4

Dalawang paraan upang patakbuhin ang screening pass na iyon

# 1. LeRobot: ACT, SmolVLA, Pi0.5 and GR00T N1.7 via --policy.type=groot
pip install "lerobot[smolvla]"
pip install "lerobot[pi]"
pip install "lerobot[groot]"

# 2. GR00T reference implementation and benchmark examples
git clone https://github.com/NVIDIA/Isaac-GR00T

# 3. Physical Intelligence reference implementation
git clone --recurse-submodules https://github.com/Physical-Intelligence/openpi

Foundation model o mula sa simula

Ang tunay na pagpipilian ay hindi kung aling 3 B model ang pipiliin. Ito ay kung gagamit ba ng pretrained VLA, kung isasaalang-alang na ang ACT ay natuto ng anim na tunay na bimanual na gawain mula sa humigit-kumulang sampung minutong demonstrasyon bawat isa, na may 80 M na parameter at walang anumang pretrained.

Ang kaso ng pagkopya ng isang lumang pagtakbo

Ang paghabol sa isang 2025 checkpoint ay gumagawa ng pagpili ng modelo para sa iyo at ginagawang version pinning ang problema: tinatanggihan ng kasalukuyang LeRobot ang N1.5, kaya i-pin mo ang lerobot==0.5.1. Nang walang seed field at 5 hanggang 6 porsiyentong pagkakaiba sa pagitan ng mga pagtakbo, ang reproduksyon ay tinatayang ayon sa konstruksyon. at ay may panig ng platform.

Dalawa na lang? ACT laban sa GR00T N1.7 at GR00T N1.7 laban sa SmolVLA. Ang mga hilaw na row ay nasa mga entry ng arena: GR00T N1.7, Pi0.5, SmolVLA at ACT.

Kung saan hindi ka matutulungan ng platform na ito

• Hindi nito kayang pabilisin ang remote inference. Ang 20 hanggang 485 ms na loop ay pagmamay-ari ng modelo; nadaragdag dito ang mga round trip sa internet.
• Hindi nito kayang i-fine-tune ang GR00T o Pi0.5 sa sarili mong hardware. Pareho silang cloud-only dito; tanging SmolVLA at ACT lang ang tumatakbo nang lokal.
• Hindi nito kayang ayusin ang isang dataset. Ang pagbaba ng loss ngunit walang ginagawa ang policy ay problema sa data, ang isang policy na gumagana lamang sa isang setup ay problema sa coverage.
• Hindi nito kayang gawing reproducible ang mga GR00T run: walang seed field ang upstream config.

Pagpili ng isa at pagpapatuloy

Isang default: mag-record ng 50 episode, sanayin ang ACT sa halagang 1 hanggang 3 USD upang patunayan ang dataset, pagkatapos ay ang SmolVLA sa parehong data. Wala pang 6 USD ang kabuuan, at sinasagot nila ang mahalagang tanong: kung nakakatulong ba ang pretraining dito, o kung ang bottleneck ay ang data. Mag-escalate sa GR00T N1.7 para sa mga contact-rich multi-step tasks, sa Pi0.5 kapag nagbabago ang eksena.

Platform walkthrough: sanayin ang iyong unang polisiya, pagkatapos ay patakbuhin ang iyong unang polisiya. Ang mga dokumento sa pagsasanay at mga dokumento ng dataset ay sumasaklaw sa porma at format; ang pahina ng SO-100 at ang kumpletong gabay sa SO-100 ay sumasaklaw sa pagbuo at kalibrasyon. Background: ang pangkalahatang-ideya ng VLA at ang artikulo ng Pi0 flow-matching. Ang makakapagpataas ng iyong success rate ay ang gabay sa kalidad ng data.