Hvilken VLA-policy bør du trene i 2026?

Fem retningslinjer kan trenes på en SO-100-klassearm i dag. De skiller seg med en faktor på 24 i inferensforsinkelse, 37 i antall parametere og 12 i hva en kjøring koster, og i om du kan sende resultatet. Fem modellkort vil ikke avgjøre det: ingen svarer på spørsmålet du har, hvilken skal jeg kjøre først?

Hvert tall nedenfor ble hentet fra artikler, repos og kort i august 2026. Plattformtall kommer fra AY-Robots retningslinjekatalog; der de to er uenige, vises begge.

Beslutningstabellen

De fem kandidatene

Alle fem er policyer: kamerarammer, leddposisjoner og, for fire av dem, en språkinstruksjon, kartlagt til en del av fremtidige leddmål. Det som skiller dem er hvor mye som ble lært før du ankom.

GR00T N1.7

NVIDIAs nåværende visjon-språk-handling-modell, omtrent 3 milliarder parametere, hvorav rundt 40 millioner er trent under finjustering. Repositoriet lister opp forskjellene fra N1.6: ryggrad fra en Eagle-modell fra tredjepart til Cosmos-Reason2-2B på Qwen3-VL, diffusjonslag 32 til 16, tilstands- og handlingsdimensjoner 29 til 132, handlingshorisont 16 til 40.

Det som betyr noe på en liten arm er det relative handlingsrommet for endeeffektor: N1.7 forutsier deltaer fra den nåværende posituren, noe som gjør at 20K timer med EgoScale menneskevideo kan overføres til en robotpolicy. Spesifikasjoner på N1.7-siden, prosedyre i N1.7 på SO-100-guiden.

GR00T N1.5

Samme 3 B-skala, Eagle 2-ryggrad, SigLip2 og T5, flow-matching DiT-hode. Den eksisterer for å utvide et du allerede har. To ting gjør den til et dårlig standardvalg: vektene har NVIDIAs enveis ikke-kommersielle lisens, og nåværende LeRobot-utgivelser fjernet N1.5-støtte. Se .

Pi0.5

Physical Intelligence sin VLA, policy-type pi05. Artikkelen beskriver en 2 B VLM initialisert fra PaliGemma pluss en 300 M handlings-ekspert, som driver roboten med 50 Hz; LeRobots pi05-konfigurasjon er som standard et 50-trinns segment, ett sekund med den hastigheten. Salgsargumentet er usette steder: omtrent 400 timer med mobil manipulering i virkelige hjem, og en skaleringsstudie over 3, 12, 22, 53, 82 og 104 lokasjoner, hvor 104-lokasjonsmodellen matchet en kontroll trent på testhjemmene selv.

Én begrensning, angitt på lerobot/pi05_base kortet: porten bærer kun den flyt-matchende handlingshodet. Deloppgaveprediksjon, handlingstokenisering og RL ble ikke utgitt oppstrøms, og openpi sier det samme om sitt eget depot. Pi0.5-siden og Pi0.5 på SO-100-guiden har resten.

SmolVLA

450 M parametere, omtrent 100 M i handlingseksperten, på SmolVLM-2 med VLM frosset og kun dens første 16 språkmodell-lag brukt. Førtrening var samfunnsdata: 481 datasett, 10.6 M rammer, fra de samme billige armene du bruker. Den eneste VLA-en her som passer på ett 24 GB kort, og den eneste 30 episode gulv. Se SmolVLA-siden.

ACT

Ikke en grunnmodell. Action Chunking Transformer fra ALOHA er omtrent 80 M parametere trent fra bunnen av per oppgave, på 50 demonstrasjoner ved 50 Hz. Artikkelen rapporterer seks virkelige bimanuelle oppgaver fra omtrent ti minutter med demonstrasjoner hver, med 80 til 90 prosent på eksemplene den fremhever. Dens idé, handlingssegmentering, er i hver modell på denne siden, og dens ablasjon måler fortsatt effekten best: over to simulerte oppgaver med temporal ensembling av, stiger suksessen fra 1 prosent ved k=1 til 44 prosent ved k=100. ACT-siden har resten.

Hva benchmarkene faktisk sier

LIBERO er den ene benchmarken tre av disse fem rapporterer om: språk-kondisjonerte oppgaver på en simulert Franka Panda, delt inn i de fire suitene nedenfor med ti oppgaver hver. NVIDIA kjørte 200 forsøk per suite.

SimplerEnv viser spredningen, noe LIBERO ikke gjør. NVIDIA sammenligner N1.7 mot N1.6, det nærmeste offentlige til en generasjonsdelta.

Bridge-raden er den nyttige: 5,7 poeng oppnådd i gjennomsnitt mens put_eggplant_in_basket tapte 36 og put_eggplant_in_sink falt fra 33 til 2. En ny generasjon flytter distribusjonen i stedet for å løfte den, så hvis oppgaven din ligger der N1.7 regredierte, sier gjennomsnittet ingenting.

Av de fem rapporterer kun SmolVLA-artikkelen om en SO-100-klassearm: 78,3 prosent for SmolVLA og 61,7 for Pi0 over tre oppgaver, begge multi-task, mot 48,3 for ACT trent single-task, noe som ikke er sammenlignbart. Den rene sammenkoblingen er begge single-task på SO-101 pick-and-place: 90 mot 70 i distribusjon, 50 mot 40 utenfor den. Sammenlign på ACT mot SmolVLA og Pi0.5 mot SmolVLA, eller bla gjennom arenaen.

Latens og kostnad avgjør utrulling

Inferensforsinkelse er begrensningen folk oppdager sist og angrer først. En policy som er fem poeng bedre på en benchmark, men et halvt sekund per handlingstrinn, ser verre ut på skrivebordet ditt: kontaktdynamikk venter ikke.

Én advarsel: GR00T-tallet stemmer ikke overens med NVIDIAs kort, som måler 4 denoising-trinn og ett kamera til 85.8 ms på en H100 i eager-modus, 48.6 ms med torch.compile, 27.9 ms gjennom full TensorRT. De 152 ms her er et tall for hele stakken med serving-overhead og mer enn ett kamera, ikke et forward pass.

Én måte å kjøpe tid på uten å endre modell: SmolVLA-artikkelen måler synkron utførelse, der policyen fullfører en del før den predikerer den neste, mot asynkron, der prediksjon overlapper utførelse. Suksessen er lik, 78.3 mot 73.3, men den samme pick-and-place tar 9.7 sekunder i stedet for 13.75, og i et fast vindu klarer roboten 19 sykluser i stedet for 9.

Lisenser, sjekket fordi ingen sjekker dem

Pi0.5-raden krever forsiktighet. LeRobot pi05-dokumentasjonen angir Apache 2.0 i samsvar med openpi, mens Hub-kortet for lerobot/pi05_base inneholder license: gemma. Begge er aktive. GR00T N1.7 har en mildere versjon: Isaac-GR00T README sier i forbifarten at N1.7 er fullt kommersielt lisensierbar under Apache 2.0, mens dens egen lisensseksjon og modellkortet kun plasserer koden under Apache 2.0 og vektene under NVIDIA Open Model License.

Standardinnstillingene du faktisk vil kjøre

Hver trenerform leveres med en standard, og de er ikke vilkårlige. ACTs er LeRobots egne: batch 8, lr 1e-5, 100000 treningssteg, chunkstørrelse 100, som matcher ACTConfig oppstrøms og k=100 fra ACT-artikkelen. Én kolonne nedenfor er en felle.

Innstillingen som betyr mer enn modellvalget

Det er handlingsbiten. Lengre biter gir jevnere bevegelse og færre sammensatte feil, men politikken er forpliktet mens blokken utføres, så den reagerer sent på alt som beveger seg: selvsikker på en statisk kube, håpløs på en rullende. Hvis den overskyter, slår forkorting av den utførte delen omskolering og er gratis. Et ledd som stopper for tidlig er et annet problem; se .

• ACT: ACTConfig standardinnstillinger er chunk_size 100 og n_action_steps 100. Temporal ensembling er av og krever n_action_steps 1.
• GR00T N1.7: intern horisont gikk fra 16 til 40, men LeRobots SO-101 eksempel kjører fortsatt --policy.chunk_size=16 --policy.n_action_steps=16. Rollout-flagget ble omdøpt til --execution-horizon.
• Pi0.5: en 50-trinns bit, hvorav LeRobots LIBERO-oppskrift utfører 10 via --policy.n_action_steps=10; med --policy.pretrained_path faller den tilbake til 50 hvis du utelater flagget.
• SmolVLA: 50-handlingsbiter, begge innstillinger eksponert.

Hvordan teste alle fem på én ettermiddag

Det billigste svaret er ikke mer lesing. Bruk rundt 15 USD og la armen fortelle deg: ta opp én gang, tren den billige modellen først, eskaler når den har bevist at dataene er solide. Struktur slår volum, poenget med og .

1. 1
   Ta opp 50 episoder én gang

   Femti rydder gulvet for GR00T, Pi0.5 og ACT, og SmolVLAs 30. Gjenta hver variasjon i stedet for å spre tynt: 50 episoder over 5 kubeposisjoner trent der 25 ikke gjorde det. Se ta opp ditt første datasett.

   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
   Tren ACT først, fordi den ikke kan lyve for deg

   Ingen forhåndstrente vekter, så hvis den utfører oppgaven i det hele tatt, inneholder datasettet ditt oppgaven. Hvis ACT flater ut, fiks dataene. 1 til 3 USD, 2 til 5 timer på et 24 GB kort.

   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
   Kjør SmolVLA på samme datasett, uendret

   Samme data, samme arm, 450 M parametere i stedet for 80 M, pluss språkkondisjonering. LeRobot anslår en 20K-trinns kjøring til omtrent 4 timer på én A100. Dette er det som forteller deg om forhåndstrening gir noe.

   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
   Konverter ned til v2.1 før du rører GR00T

   GR00T leser en variant av LeRobot v2-formatet pluss en ekstra meta/modality.json som mapper hvordan sammenkoblede tilstands- og handlingsarrayer deles inn i navngitte felt. Et v3.0-datasett krasjer den innlasteren, fordi v3.0 pakker mange episoder inn i delte filer der v2 skrev én per episode. Isaac-GR00T leverer nedgraderingshjelperen som scripts/lerobot_conversion/convert_v3_to_v2.py; siden for v3-avvisning er den raske veien.

   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
   Eskaler til GR00T N1.7 bare hvis de to første etterlot noe på bordet

   Via NVIDIAs CLI, vist her, eller LeRobots groot policy-type. NVIDIA anbefaler 40 GB eller mer VRAM for finjustering, 16 GB for inferens. Ved en OOM, se OOM-siden.

   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

To måter å kjøre den screeningrunden på

# 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

Grunnmodell eller fra bunnen av

Den virkelige utfordringen er ikke hvilken 3 B-modell man skal velge. Det er om man skal bruke en forhåndstrent VLA i det hele tatt, gitt at ACT lærte seks virkelige bimanuelle oppgaver fra omtrent ti minutter med demonstrasjoner hver, med 80 M parametere og ingenting forhåndstrent.

Tilfellet med å reprodusere en gammel kjøring

Å jage et 2025-sjekkpunkt gjør modellvalget for deg og gjør problemet til versjonslåsing: nåværende LeRobot avviser N1.5, så du låser lerobot==0.5.1. Uten et seed-felt og 5 til 6 prosent varians mellom kjøringer, er reproduksjonen omtrentlig av konstruksjon. N1.5 på SO-100-guiden og N1.5-policy-siden har plattform-siden.

Nede på to? ACT mot GR00T N1.7 og GR00T N1.7 mot SmolVLA. Rådata finnes i arenaoppføringene: GR00T N1.7, Pi0.5, SmolVLA og ACT.

Hvor denne plattformen ikke hjelper deg

• Den kan ikke gjøre fjerninferens rask. Løkken på 20 til 485 ms tilhører modellen; internett-rundturer legger til dette.
• Den kan ikke finjustere GR00T eller Pi0.5 på din egen maskinvare. Begge er kun skybaserte her; kun SmolVLA og ACT kjører lokalt.
• Den kan ikke fikse et datasett. Tapet faller, men policyen gjør ingenting er et dataproblem, en policy som bare fungerer i ett oppsett er et dekningsproblem.
• Den kan ikke gjøre GR00T-kjøringer reproduserbare: oppstrømskonfigurasjonen har ingen felt for 'seed'.

Velge én og gå videre

Ett utgangspunkt: ta opp 50 episoder, tren ACT for 1 til 3 USD for å bevise datasettet, deretter SmolVLA på samme data. Under 6 USD totalt, og de svarer på spørsmålet som betyr noe: om forhåndstrening hjelper her, eller om flaskehalsen er dataene. Eskaler til GR00T N1.7 for kontaktrike flertrinns oppgaver, til Pi0.5 når scenen endres.

Gjennomgang av plattformen: tren din første policy, deretter kjør din første policy. treningsdokumentasjonen og datasett-dokumentasjonen dekker form og format; SO-100-siden og den komplette SO-100-guiden dekker bygging og kalibrering. Bakgrunn: VLA-oversikten og Pi0 flow-matching-artikkelen. Den som vil forbedre suksessraten din er guiden for datakvalitet.