Vilken VLA-policy ska du träna 2026?

Fem policyer kan tränas på en SO-100-klassad arm idag. De skiljer sig åt med en faktor 24 i inferens-latens, 37 i antal parametrar och 12 i vad en körning kostar, samt i huruvida du får leverera resultatet. Fem modellkort kommer inte att lösa det: inget svarar på frågan du har, vilken ska jag köra först?

Alla siffror nedan lästes ur artiklar, repos och kort i augusti 2026. Plattformssiffror kommer från AY-Robots policykatalog; där de två skiljer sig åt, visas båda.

Beslutstabellen

De fem kandidaterna

Alla fem är policyer: kamerabilder, ledpositioner och, för fyra av dem, en språkanvisning, mappad till en del av framtida ledmål. Vad som skiljer dem åt är hur mycket som lärdes innan du anlände.

GR00T N1.7

NVIDIAs nuvarande visions-, språk- och handlingsmodell, cirka 3 miljarder parametrar, varav ungefär 40 miljoner tränades under finjustering. Arkivet listar skillnaderna från N1.6: ryggrad från en levererad Eagle-modell till Cosmos-Reason2-2B på Qwen3-VL, diffusionslager 32 till 16, tillstånds- och handlingsdimensioner 29 till 132, handlingshorisont 16 till 40.

Vad som är viktigt på en liten arm är det relativa handlingsutrymmet för ändeffektorn: N1.7 förutsäger deltan från den nuvarande positionen, vilket är det som gör att 20 000 timmar av EgoScale mänsklig video kan överföras till en robotpolicy. Specifikationer finns på N1.7-sidan, procedur i guiden för N1.7 på SO-100.

GR00T N1.5

Samma 3 B-skala, Eagle 2-ryggrad, SigLip2 och T5, flow-matching DiT-huvud. Den finns för att utöka en du redan har. Två saker gör den till ett dåligt standardval: vikterna har NVIDIAs enkelriktade icke-kommersiella licens, och nuvarande LeRobot-utgåvor har tagit bort N1.5-stöd. Se .

Pi0.5

Physical Intelligence's VLA, policy type pi05. Artikeln beskriver en 2 B VLM initierad från PaliGemma plus en 300 M actionexpert, som driver roboten i 50 Hz; LeRobots pi05-konfiguration använder som standard en 50-stegs chunk, en sekund i den hastigheten. Försäljningsargumentet är okända platser: cirka 400 timmar mobil manipulation i verkliga hem, och en skalningsstudie över 3, 12, 22, 53, 82 och 104 platser, där modellen för 104 platser matchade en kontroll tränad på testhushållen själva.

En begränsning, angiven på lerobot/pi05_base kortet: porten bär endast den flödesmatchande action head. Förutsägelse av deluppgifter, action tokenization och RL släpptes inte uppströms, och openpi säger detsamma om sitt eget repository. Pi0.5-sidan och guiden för Pi0.5 på SO-100 har resten.

SmolVLA

450 M parametrar, cirka 100 M i action-experten, på SmolVLM-2 med VLM fryst och endast dess första 16 språkmodellager används. Förträning var gemenskapsdata: 481 dataset, 10.6 M ramar, från samma billiga armar du använder. Den enda VLA här som passar ett 24 GB kort, och den enda 30 episod golv. Se SmolVLA-sidan.

ACT

Inte en grundmodell. Action Chunking Transformer från ALOHA har cirka 80 M parametrar tränade från grunden per uppgift, på 50 demonstrationer vid 50 Hz. Artikeln rapporterar sex verkliga tvåhandsuppgifter från ungefär tio minuter demonstrationer vardera, med 80 till 90 procent på de exempel den lyfter fram. Dess idé, åtgärdssegmentering, finns i varje modell på denna sida, och dess ablation mäter fortfarande effekten bäst: över två simulerade uppgifter med temporal ensembling avstängd, framgången ökar från 1 procent vid k=1 till 44 procent vid k=100. ACT-sidan har resten.

Vad benchmark-testerna faktiskt säger

LIBERO är det enda benchmark som tre av dessa fem rapporterar om: språkstyrda uppgifter på en simulerad Franka Panda, uppdelade i de fyra sviterna nedan med tio uppgifter vardera. NVIDIA körde 200 försök per svit.

SimplerEnv visar spridningen, vilket LIBERO inte gör. NVIDIA jämför N1.7 med N1.6, det närmaste offentliga till en generationsdelta.

Raden Bridge är den användbara: 5.7 poäng i genomsnitt medan put_eggplant_in_basket förlorade 36 och put_eggplant_in_sink föll från 33 till 2. En ny generation flyttar distributionen snarare än lyfter den, så om din uppgift ligger där N1.7 regrederade, säger genomsnittet ingenting.

Av de fem rapporterar endast SmolVLA-publikationen om en SO-100-klass arm: 78.3 procent för SmolVLA och 61.7 för Pi0 över tre uppgifter, båda multi-task, mot 48.3 för ACT tränad single-task, vilket inte är jämförbart. Den rena parningen är båda single-task på SO-101 pick-and-place: 90 mot 70 i distribution, 50 mot 40 utanför den. Jämför på ACT mot SmolVLA och Pi0.5 mot SmolVLA, eller bläddra i arenan.

Latens och kostnad avgör driftsättning

Inferenslatens är den begränsning folk upptäcker sist och ångrar först. En policy som är fem poäng bättre på ett benchmark men tar en halv sekund per åtgärdssteg ser sämre ut på ditt skrivbord: kontaktdynamik väntar inte.

En brasklapp: GR00T-siffran stämmer inte överens med NVIDIAs kort, som mäter 4 denoisingssteg och en kamera till 85.8 ms på en H100 i eager mode, 48.6 ms med torch.compile, 27.9 ms genom full TensorRT. De 152 ms här är en helstackssiffra med serving overhead och mer än en kamera, inte en forward pass.

Ett sätt att vinna tid utan att ändra modell: SmolVLA-artikeln mäter synkron exekvering, där policyn avslutar en del innan den förutsäger nästa, jämfört med asynkron, där förutsägelse överlappar exekvering. Framgången är liknande, 78.3 mot 73.3, men samma pick-and-place tar 9.7 sekunder istället för 13.75, och i ett fast fönster klarar roboten 19 cykler istället för 9.

Licenser, kontrollerade eftersom ingen kontrollerar dem

Raden för Pi0.5 kräver uppmärksamhet. LeRobot pi05-dokumentationen anger Apache 2.0 i överensstämmelse med openpi, medan Hub-kortet för lerobot/pi05_base anger license: gemma. Båda är aktiva. GR00T N1.7 har en mildare version: Isaac-GR00T README nämner i förbigående att N1.7 är fullt kommersiellt licensierbar under Apache 2.0, medan dess egen licenssektion och modellkort endast placerar koden under Apache 2.0 och vikterna under NVIDIA Open Model License.

Standardinställningarna du faktiskt kommer att köra

Varje träningsformulär levereras med en standardinställning, och dessa är inte godtyckliga. ACT:s är LeRobots egna: batch 8, lr 1e-5, 100000 träningssteg, chunk size 100, matching ACTConfig upstream and k=100 from the ACT paper. En kolumn nedan är en fälla.

Inställningen som betyder mer än modellvalet

Det är åtgärdsbiten. Längre bitar ger jämnare rörelse och färre ackumulerande fel, men policyn är låst medan blocket exekveras, så den reagerar sent på allt som rör sig: självsäker på en statisk kub, hopplös på en rullande. Om den skjuter över målet, är det bättre att förkorta den exekverade delen än att omskola och det är gratis. En led som stannar för tidigt är ett annat problem; se .

• ACT: ACTConfig standardinställningar är chunk_size 100 och n_action_steps 100. Temporär ensembling är avstängd och kräver n_action_steps 1.
• GR00T N1.7: intern horisont gick från 16 till 40, men LeRobots SO-101-exempel kör fortfarande --policy.chunk_size=16 --policy.n_action_steps=16. Rollout-flaggan döptes om till --execution-horizon.
• Pi0.5: en 50-stegsbit, varav LeRobots LIBERO-recept exekverar 10 via --policy.n_action_steps=10; med --policy.pretrained_path återgår den till 50 om du utelämnar flaggan.
• SmolVLA: 50-åtgärdsbitar, båda inställningarna exponerade.

Hur man granskar alla fem på en eftermiddag

Det billigaste svaret är inte mer läsning. Spendera cirka 15 USD och låt armen berätta: spela in en gång, träna den billiga modellen först, eskalera när den har bevisat att datan är sund. Struktur slår volym, poängen med och .

1. 1
   Spela in 50 episoder en gång

   Femtio banar väg för GR00T, Pi0.5 och ACT, och SmolVLAs 30. Upprepa varje variation istället för att sprida ut tunt: 50 episoder över 5 kubpositioner tränades där 25 inte gjorde det. Se spela in din första datamängd.

   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
   Träna ACT först, eftersom den inte kan ljuga för dig

   Inga förtränade vikter, så om den överhuvudtaget utför uppgiften, innehåller din datamängd uppgiften. Om ACT inte ger resultat, åtgärda datan. 1 to 3 USD, 2 to 5 hours on a 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
   Kör SmolVLA på samma datamängd, oförändrad

   Samma data, samma arm, 450 M parametrar istället för 80 M, plus språkkonditionering. LeRobot uppskattar en körning på 20K steg till ungefär 4 timmar på en A100. Detta är vad som talar om för dig om förträning ger något.

   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
   Konvertera ner till v2.1 innan du rör GR00T

   GR00T läser en variant av LeRobot v2-formatet plus en extra meta/modality.json som mappar hur sammanfogade tillstånds- och åtgärdsarrayer delas upp i namngivna fält. En v3.0-datamängd kraschar den laddaren, eftersom v3.0 packar många episoder i delade filer där v2 skrev en per episod. Isaac-GR00T levererar nedgraderingshjälpen som scripts/lerobot_conversion/convert_v3_to_v2.py; sidan för v3-avvisning är den snabba vägen.

   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
   Eskalera till GR00T N1.7 endast om de första två lämnade något kvar

   Via NVIDIAs CLI, som visas här, eller LeRobots groot policytyp. NVIDIA rekommenderar 40 GB eller mer VRAM för finjustering, 16 GB för inferens. Vid ett OOM, se OOM-sidan.

   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

Två sätt att köra den screeningpassagen

# 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

Grundmodell eller från grunden

Den verkliga frågan är inte vilken 3 B-modell man ska välja. Det är snarare om man överhuvudtaget ska använda en förtränad VLA, med tanke på att ACT lärde sig sex verkliga tvåhandsuppgifter från cirka tio minuters demonstrationer vardera, med 80 M parametrar och inget förtränat.

Fallet med att reproducera en gammal körning

Att jaga en 2025-checkpoint gör modellvalet åt dig och förvandlar problemet till versionslåsning: nuvarande LeRobot avvisar N1.5, så du låser lerobot==0.5.1. Utan ett seed-fält och med 5 till 6 procents varians mellan körningar är reproduktionen approximativ per konstruktion. Guidingen för N1.5 på SO-100 och N1.5 policy-sidan hanterar plattformssidan.

Ner till två? ACT mot GR00T N1.7 och GR00T N1.7 mot SmolVLA. Rådata finns i arena-posterna: GR00T N1.7, Pi0.5, SmolVLA och ACT.

Där denna plattform inte hjälper dig

• Den kan inte göra fjärrinferens snabb. Loopen på 20 till 485 ms tillhör modellen; internetrundresor lägger till detta.
• Den kan inte finjustera GR00T eller Pi0.5 på din egen hårdvara. Båda är endast molnbaserade här; endast SmolVLA och ACT körs lokalt.
• Den kan inte fixa ett dataset. Förlusten minskar men policyn gör ingenting är ett dataprobem, en policy som bara fungerar i en inställning är ett täckningsproblem.
• Den kan inte göra GR00T-körningar reproducerbara: den uppströms konfigurationen har inget seed-fält.

Välja en och gå vidare

En standard: spela in 50 episoder, träna ACT för 1 till 3 USD för att bevisa datasetet, sedan SmolVLA på samma data. Under 6 USD totalt, och de svarar på den viktiga frågan: om förträning hjälper här, eller om flaskhalsen är datan. Eskalera till GR00T N1.7 för kontaktrika flerstegsuppgifter, till Pi0.5 när scenen ändras.

Plattformsgenomgång: träna din första policy, sedan köra din första policy. De träningsdokumenten och datasetdokumenten täcker form och format; SO-100-sidan och den kompletta SO-100-guiden täcker konstruktion och kalibrering. Bakgrund: VLA-översikten och Pi0 flow-matching-artikeln. Den som kommer att förbättra din framgångsfrekvens är guiden för datakvalitet.