Welk VLA-beleid moet u trainen in 2026?

Vijf beleidsregels zijn vandaag trainbaar op een SO-100 klasse arm. Ze verschillen met een factor 24 in inferentie latentie, 37 in parameteraantal en 12 in wat een run kost, en in de vraag of u het resultaat mag verzenden. Vijf modelkaarten zullen het niet oplossen: geen enkele beantwoordt de vraag die u heeft, welke moet ik als eerste uitvoeren?

Elk onderstaand getal is gelezen uit de papers, repositories en kaarten in augustus 2026. Platformnummers komen van de AY-Robots beleidscatalogus; waar de twee verschillen, worden beide getoond.

De beslissingstabel

De vijf kandidaten

Alle vijf zijn beleidsregels: cameraframes, gewrichtsposities en, voor vier ervan, een taalinstructie, toegewezen aan een reeks toekomstige gewrichtsdoelen. Wat hen onderscheidt, is hoeveel er werd geleerd voordat u arriveerde.

GR00T N1.7

NVIDIA's huidige visie-taal-actiemodel, ongeveer 3 miljard parameters, ruwweg 40 miljoen getraind tijdens fine-tuning. De repository vermeldt de verschillen ten opzichte van N1.6: backbone van een ingekocht Eagle-model naar Cosmos-Reason2-2B op Qwen3-VL, diffusielagen 32 naar 16, status- en actiedimensies 29 naar 132, actiehorizon 16 naar 40.

Wat belangrijk is bij een kleine arm, is de relatieve actieruimte van de eindeffector: N1.7 voorspelt delta's van de huidige pose, wat ervoor zorgt dat 20K uur aan EgoScale menselijke video kan worden overgedragen naar een robotbeleid. Specificaties op de N1.7-pagina, procedure in de N1.7 op SO-100 handleiding.

GR00T N1.5

Dezelfde 3 B schaal, Eagle 2 backbone, SigLip2 en T5, flow-matching DiT head. Het bestaat om een dat je al hebt uit te breiden. Twee dingen maken het een slechte standaard: de gewichten dragen NVIDIA's eenrichtings niet-commerciële licentie, en huidige LeRobot releases hebben N1.5 ondersteuning verwijderd. Zie .

Pi0.5

Physical Intelligence's VLA, beleidstype pi05. Het artikel beschrijft een 2 B VLM geïnitialiseerd vanuit PaliGemma plus een 300 M actie-expert, die de robot aanstuurt met 50 Hz; LeRobot's pi05 configuratie gebruikt standaard een 50-staps chunk, één seconde met die snelheid. Het verkoopargument zijn ongeziene plaatsen: ongeveer 400 uur mobiele manipulatie in echte huizen, en een schaalstudie over 3, 12, 22, 53, 82 en 104 locaties, waarbij het 104-locatie model overeenkwam met een controle getraind op de testhuizen zelf.

Eén beperking, vermeld op de lerobot/pi05_base kaart: de poort draagt alleen de flow-matching actiehoofd. Subtaakvoorspelling, actietokenisatie en RL zijn niet upstream vrijgegeven, en openpi zegt hetzelfde over zijn eigen repository. De Pi0.5 pagina en de Pi0.5 op SO-100 gids hebben de rest.

SmolVLA

450 M parameters, ongeveer 100 M in de actie-expert, op SmolVLM-2 met de VLM bevroren en alleen de eerste 16 taalmodel-lagen gebruikt. Pretraining was gemeenschapsdata: 481 datasets, 10.6 M frames, van dezelfde goedkope armen die je gebruikt. De enige VLA hier die op één 24 GB kaart past, en de enige met een 30 episode vloer. Zie de SmolVLA pagina.

ACT

Geen fundamenteel model. De Action Chunking Transformer van ALOHA heeft ongeveer 80 M parameters, getraind vanaf nul per taak, op 50 demonstraties met 50 Hz. Het artikel rapporteert zes echte bimanuele taken van ongeveer tien minuten demonstraties elk, met 80 tot 90 procent op de voorbeelden die het belicht. Het idee ervan, actie-chunking, zit in elk model op deze pagina, en de ablatie ervan meet nog steeds het effect het beste: over twee gesimuleerde taken met uitgeschakelde temporele ensembling, stijgt het succes van 1 procent bij k=1 naar 44 procent bij k=100. De ACT-pagina heeft de rest.

Wat de benchmarks werkelijk zeggen

LIBERO is de enige benchmark waar drie van deze vijf over rapporteren: taal-geconditioneerde taken op een gesimuleerde Franka Panda, verdeeld in de vier onderstaande suites met elk tien taken. NVIDIA voerde 200 proeven per suite.

SimplerEnv toont de spreiding, wat LIBERO niet doet. NVIDIA vergelijkt N1.7 met N1.6, het dichtstbijzijnde publieke equivalent van een "generational delta."

De Bridge-rij is de nuttige: gemiddeld 5,7 punten gewonnen terwijl put_eggplant_in_basket 36 verloor en put_eggplant_in_sink van 33 naar 2 daalde. Een nieuwe generatie verschuift de distributie in plaats van deze op te tillen, dus als uw taak zich bevindt waar N1.7 achteruitging, zegt het gemiddelde niets.

Van de vijf rapporteert alleen het SmolVLA-paper over een SO-100 klasse arm: 78,3 procent voor SmolVLA en 61,7 voor Pi0 over drie taken, beide multi-task, tegen 48,3 voor ACT getraind single-task, wat geen gelijke vergelijking is. De zuivere koppeling is beide single-task op SO-101 pick-and-place: 90 tegen 70 in distributie, 50 tegen 40 daarbuiten. Vergelijk op ACT tegen SmolVLA en Pi0.5 tegen SmolVLA, of blader door de arena.

Latentie en kosten bepalen de implementatie

Inferentielatentie is de beperking die mensen het laatst ontdekken en het eerst betreuren. Een beleid dat vijf punten beter scoort op een benchmark, maar een halve seconde per actiestap duurt, ziet er slechter uit op je bureau: contactdynamica wachten niet.

Eén kanttekening: het GR00T-cijfer komt niet overeen met de kaart van NVIDIA, die 4 denoising-stappen en één camera meet op 85,8 ms op een H100 in eager mode, 48,6 ms met torch.compile, 27,9 ms via volledige TensorRT. De 152 ms hier is een cijfer voor de hele stack met serving overhead en meer dan één camera, geen forward pass.

Eén manier om tijd te winnen zonder het model te veranderen: het SmolVLA-artikel meet synchrone uitvoering, waarbij het beleid een 'chunk' voltooit voordat het de volgende voorspelt, versus asynchrone uitvoering, waarbij voorspelling de uitvoering overlapt. Het succes is vergelijkbaar, 78,3 tegen 73,3, maar dezelfde pick-and-place duurt 9,7 seconden in plaats van 13,75, en in een vast venster beheert de robot 19 cycli in plaats van 9.

Licenties, gecontroleerd omdat niemand ze controleert

De Pi0.5 rij vereist aandacht. De LeRobot pi05 documentatie vermeldt Apache 2.0, consistent met openpi, terwijl de Hub-kaart voor lerobot/pi05_base vermeldt license: gemma. Beide zijn actief. GR00T N1.7 heeft een mildere versie: de Isaac-GR00T README vermeldt terloops dat N1.7 volledig commercieel licentieerbaar is onder Apache 2.0, terwijl de eigen licentiesectie en de modelkaart alleen de code onder Apache 2.0 plaatsen en de gewichten onder de NVIDIA Open Model License.

De standaardinstellingen die u daadwerkelijk zult uitvoeren

Elke trainerformulier wordt geleverd met een standaardinstelling, en deze zijn niet willekeurig. Die van ACT zijn van LeRobot zelf: batch 8, lr 1e-5, 100000 trainingsstappen, chunkgrootte 100, overeenkomend met ACTConfig upstream en k=100 uit het ACT-artikel. Eén kolom hieronder is een valstrik.

De instelling die meer telt dan de modelkeuze

Het is de actiechunk. Langere chunks zorgen voor vloeiendere beweging en minder cumulatieve fouten, maar het beleid wordt vastgelegd terwijl het blok wordt uitgevoerd, dus het reageert laat op alles wat beweegt: zelfverzekerd op een statische kubus, hopeloos op een rollende. Als het doorschiet, is het inkorten van het uitgevoerde gedeelte beter dan hertraining en is gratis. Een gewricht dat te vroeg stopt, is een ander probleem; zie .

• ACT: ACTConfig defaults to chunk_size 100 and n_action_steps 100. Temporele ensembling is uitgeschakeld en vereist n_action_steps 1.
• GR00T N1.7: de interne horizon ging van 16 naar 40, toch draait LeRobot's SO-101 voorbeeld nog steeds --policy.chunk_size=16 --policy.n_action_steps=16. De rollout-vlag is hernoemd naar --execution-horizon.
• Pi0.5: een chunk van 50 stappen, waarvan LeRobot's LIBERO recept er 10 uitvoert via --policy.n_action_steps=10; met --policy.pretrained_path valt het terug op 50 als je de vlag weglaat.
• SmolVLA: chunks van 50 acties, beide knoppen blootgelegd.

Hoe alle vijf in één middag te screenen

Het goedkoopste antwoord is niet meer lezen. Geef ongeveer 15 USD uit en laat de arm het je vertellen: neem één keer op, train eerst het goedkope model, schaal op zodra het de data als valide heeft bewezen. Structuur verslaat volume, het punt van en het .

1. 1
   Neem eenmalig 50 afleveringen op

   Vijftig maakt de weg vrij voor GR00T, Pi0.5 en ACT, en SmolVLA's 30. Herhaal elke variatie in plaats van te verspreiden: 50 afleveringen over 5 getrainde kubusposities waar 25 dat niet deden. Zie neem uw eerste dataset op.

   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
   Train ACT eerst, want het kan niet tegen u liegen

   Geen vooraf getrainde gewichten, dus als het de taak überhaupt uitvoert, bevat uw dataset de taak. Als ACT stagneert, corrigeer de gegevens. 1 tot 3 USD, 2 tot 5 uur op een 24 GB kaart.

   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
   Voer SmolVLA uit op dezelfde dataset, ongewijzigd

   Dezelfde gegevens, dezelfde arm, 450 M parameters in plaats van 80 M, plus taalconditionering. LeRobot schat een run van 20K stappen op ongeveer 4 uur op één A100. Dit vertelt u of voor-training iets oplevert.

   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
   Converteer naar v2.1 voordat u GR00T aanraakt

   GR00T leest een variant van het LeRobot v2-formaat plus een extra meta/modality.json die aangeeft hoe samengevoegde status- en actie-arrays worden opgesplitst in benoemde velden. Een v3.0-dataset laat die lader crashen, omdat v3.0 veel afleveringen in gedeelde bestanden verpakt waar v2 er één per aflevering schreef. Isaac-GR00T levert de downgrade-helper als scripts/lerobot_conversion/convert_v3_to_v2.py; de v3-afwijzingspagina is de snelle weg.

   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
   Schaal alleen op naar GR00T N1.7 als de eerste twee iets te wensen overlieten

   Via NVIDIA's CLI, hier getoond, of LeRobot's groot beleidstype. NVIDIA beveelt 40 GB of meer VRAM aan voor fine-tuning, 16 GB voor inferentie. Bij een OOM, zie de OOM-pagina.

   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

Twee manieren om die screening uit te voeren

# 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

Fundamentmodel of vanaf nul

De echte afweging is niet welk 3 B-model te kiezen. Het is of je überhaupt een voorgegetrainde VLA moet gebruiken, gezien dat ACT zes echte bimanuele taken leerde van elk ongeveer tien minuten aan demonstraties, met 80 M parameters en niets voorgegetraind.

Het geval van het reproduceren van een oude run

Het najagen van een 2025 checkpoint bepaalt de modelkeuze voor jou en verandert het probleem in versiepinning: huidige LeRobot accepteert N1.5 niet, dus je pint lerobot==0.5.1. Zonder seed-veld en 5 tot 6 procent variantie tussen runs, is de reproductie bij constructie bij benadering. en hebben de platformkant.

Nog twee over? ACT tegen GR00T N1.7 en GR00T N1.7 tegen SmolVLA. Ruwe rijen staan in de arena-vermeldingen: GR00T N1.7, Pi0.5, SmolVLA en ACT.

Waar dit platform u niet helpt

• Het kan externe inferentie niet versnellen. De lus van 20 tot 485 ms behoort tot het model; internet round trips voegen daaraan toe.
• Het kan GR00T of Pi0.5 niet fine-tunen op uw eigen hardware. Beide zijn hier alleen in de cloud beschikbaar; alleen SmolVLA en ACT draaien lokaal.
• Het kan een dataset niet repareren. Verlies daalt, maar het beleid doet niets is een dataprobbleem, een beleid dat alleen werkt in één opstelling is een dekkingsprobleem.
• Het kan GR00T-runs niet reproduceerbaar maken: de upstream-configuratie heeft geen seed-veld.

Eén kiezen en verdergaan

Eén standaard: neem 50 afleveringen op, train ACT voor 1 tot 3 USD om de dataset te bewijzen, dan SmolVLA op de zelfde data. Samen minder dan 6 USD, en ze beantwoorden de vraag die ertoe doet: of pretraining hier helpt, of de bottleneck de data is. Escaleer naar GR00T N1.7 voor contactrijke meerstaps taken, naar Pi0.5 wanneer de scène verandert.

Platformoverzicht: train je eerste beleid, dan voer je eerste beleid uit. De trainingsdocumentatie en datasetdocumentatie behandelen vorm en formaat; de SO-100 pagina en de complete SO-100 gids behandelen bouw en kalibratie. Achtergrond: het VLA-overzicht en het Pi0 flow-matching artikel. Degene die je slagingspercentage zal verhogen is de datakwaliteitsgids.