Quale politica VLA dovresti addestrare nel 2026?

Oggi, cinque politiche sono addestrabili su un braccio di classe SO-100. Differiscono per un fattore di 24 nella latenza di inferenza, 37 nel numero di parametri e 12 nel costo di un'esecuzione, e nella possibilità di spedire il risultato. Cinque schede modello non risolveranno la questione: nessuna risponde alla domanda che hai, quale eseguo per primo?

Ogni numero riportato di seguito è stato estratto da articoli, repository e schede nell'agosto 2026. I numeri della piattaforma provengono dal catalogo delle politiche AY-Robots; dove i due non concordano, entrambi sono mostrati.

La tabella decisionale

I cinque candidati

Tutti e cinque sono politiche: frame della telecamera, posizioni delle giunture e, per quattro di essi, un'istruzione linguistica, mappata a un blocco di futuri obiettivi di giuntura. Ciò che li distingue è quanto è stato appreso prima del tuo arrivo.

GR00T N1.7

L'attuale modello visione-linguaggio-azione, circa 3 miliardi di parametri, circa 40 milioni addestrati durante fine-tuning. Il repository elenca i delta da N1.6: backbone da un modello Eagle proprietario a Cosmos-Reason2-2B su Qwen3-VL, strati di diffusione da 32 a 16, dimensioni dello stato e dell'azione da 29 a 132, orizzonte d'azione da 16 a 40.

Ciò che conta su un braccio piccolo è lo spazio d'azione relativo dell'end-effector: N1.7 predice i delta dalla posa attuale, il che permette a 20K ore di video umani EgoScale di essere trasferite in una policy robotica. Specifiche su la pagina di N1.7, procedura nella guida N1.7 su SO-100.

GR00T N1.5

Stessa scala 3 B, backbone Eagle 2, SigLip2 e T5, testa DiT con flow-matching. Esiste per estendere un che hai già. Due cose lo rendono una scelta predefinita scadente: i pesi sono soggetti a licenza non commerciale unidirezionale di NVIDIA, e le attuali release di LeRobot hanno rimosso il supporto per N1.5. Vedi .

Pi0.5

VLA di Physical Intelligence con VLA, tipo di policy pi05. Il paper presenta un VLM da 2 B inizializzato da PaliGemma più un esperto di azioni da 300 M, che guida il robot a 50 Hz; la configurazione pi05 di LeRobot prevede di default un chunk di 50 passi, un secondo a quella velocità. Il punto di forza sono i luoghi mai visti: circa 400 ore di manipolazione mobile in case reali, e uno studio di scalabilità su 3, 12, 22, 53, 82 e 104 località, dove il modello a 104 località ha eguagliato un controllo addestrato sulle case di test stesse.

Un limite, dichiarato sulla lerobot/pi05_base scheda: la porta trasporta solo la testa d'azione con corrispondenza di flusso. La previsione di sottocompiti, la tokenizzazione delle azioni e l'RL non sono stati rilasciati a monte, e openpi afferma lo stesso per il proprio repository. La pagina di Pi0.5 e la guida di Pi0.5 su SO-100 contengono il resto.

SmolVLA

450 M parametri, circa 100 M nell'esperto di azione, su SmolVLM-2 con il VLM congelato e solo i suoi primi 16 strati del modello linguistico utilizzati. Il pre-addestramento è stato basato su dati della comunità: 481 dataset, 10.6 M frame, dagli stessi bracci economici che usi. L'unico VLA qui che si adatta a una scheda da 24 GB, e l'unico con un minimo di 30 episodi come minimo. Vedi la pagina di SmolVLA.

ACT

Non è un modello di base. L'Action Chunking Transformer di ALOHA è un modello di circa 80 milioni di parametri addestrato da zero per ogni compito, su 50 dimostrazioni a 50 Hz. Il documento riporta sei compiti bimani reali da circa dieci minuti di dimostrazioni ciascuno, con una percentuale di successo dall'80 al 90 percento sugli esempi evidenziati. La sua idea, suddivisione delle azioni, è presente in ogni modello di questa pagina, e la sua ablazione misura ancora l'effetto migliore: su due compiti simulati con l'ensembling temporale disattivato, il successo sale dall'1 percento a k=1 al 44 percento a k=100. La pagina di ACT contiene il resto.

Cosa dicono realmente i benchmark

LIBERO è l'unico benchmark su cui tre di questi cinque modelli riportano: compiti condizionati dal linguaggio su un Franka Panda simulato, suddivisi nelle quattro suite sottostanti con dieci compiti ciascuna. NVIDIA ha eseguito 200 prove per suite.

SimplerEnv mostra la dispersione, cosa che LIBERO non fa. NVIDIA confronta N1.7 con N1.6, la cosa pubblica più vicina a un delta generazionale.

La riga Bridge è quella utile: 5.7 punti guadagnati in media mentre put_eggplant_in_basket ha perso 36 e put_eggplant_in_sink è sceso da 33 a 2. Una nuova generazione sposta la distribuzione piuttosto che sollevarla, quindi se il tuo compito si trova dove N1.7 ha regredito, la media non dice nulla.

Dei cinque, solo il paper SmolVLA riporta un braccio di classe SO-100: 78.3 percento per SmolVLA e 61.7 per Pi0 su tre compiti, entrambi multi-task, contro 48.3 per ACT addestrato single-task, il che non è un confronto equo. L'abbinamento pulito è entrambi single-task su SO-101 pick-and-place: 90 contro 70 in distribuzione, 50 contro 40 fuori distribuzione. Confronta su ACT contro SmolVLA e Pi0.5 contro SmolVLA, o sfoglia l'arena.

Latenza e costo decidono il deployment

Latenza di inferenza è il vincolo che le persone scoprono per ultimo e rimpiangono per primo. Una policy cinque punti migliore su un benchmark ma con mezzo secondo per passo d'azione sembra peggio sulla tua scrivania: le dinamiche di contatto non aspettano.

Un'avvertenza: la cifra di GR00T non concorda con la scheda NVIDIA, che misura 4 passi di denoising e una telecamera a 85.8 ms su un H100 in modalità eager, 48.6 ms con torch.compile, 27.9 ms tramite TensorRT completo. I 152 ms qui sono un dato dell'intera stack con overhead di servizio e più di una telecamera, non un forward pass.

Un modo per guadagnare tempo senza cambiare modello: il paper SmolVLA misura l'esecuzione sincrona, dove la policy termina un blocco prima di predire il successivo, rispetto all'asincrona, dove la predizione si sovrappone all'esecuzione. Il successo è simile, 78.3 contro 73.3, ma lo stesso pick-and-place richiede 9.7 secondi invece di 13.75, e in una finestra fissa il robot gestisce 19 cicli invece di 9.

Licenze, verificate perché nessuno le verifica

La riga Pi0.5 richiede attenzione. La documentazione LeRobot pi05 dichiara Apache 2.0, coerente con openpi, mentre la scheda Hub per lerobot/pi05_base riporta license: gemma. Entrambi sono attivi. GR00T N1.7 ha una versione più blanda: il README di Isaac-GR00T afferma di sfuggita che N1.7 è completamente licenziabile commercialmente sotto Apache 2.0, mentre la sua sezione licenze e la scheda del modello pongono solo il codice sotto Apache 2.0 e i pesi sotto la NVIDIA Open Model License.

Le impostazioni predefinite che verranno effettivamente eseguite

Ogni modulo di addestramento include un valore predefinito, e questi non sono arbitrari. Quelli di ACT sono propri di LeRobot: batch 8, lr 1e-5, 100000 passi di addestramento, dimensione del chunk 100, corrispondente a ACTConfig upstream e k=100 dal paper ACT. Una colonna qui sotto è una trappola.

Il parametro che conta più della scelta del modello

È il chunk di azione. Chunk più lunghi producono movimenti più fluidi e meno errori cumulativi, ma la policy è impegnata mentre il blocco viene eseguito, quindi reagisce in ritardo a qualsiasi cosa si muova: sicura su un cubo statico, senza speranza su uno in movimento. Se va in overshoot, accorciare la porzione eseguita è meglio del retraining ed è gratuito. Un'articolazione che si ferma in anticipo è un problema diverso; vedi .

• ACT: ACTConfig predefinisce chunk_size 100 e n_action_steps 100. L'ensembling temporale è disattivato e richiede n_action_steps 1.
• GR00T N1.7: l'orizzonte interno è passato da 16 a 40, eppure l'esempio SO-101 di LeRobot esegue ancora --policy.chunk_size=16 --policy.n_action_steps=16. Il flag di rollout è stato rinominato in --execution-horizon.
• Pi0.5: un chunk di 50 passi, di cui la ricetta LIBERO di LeRobot ne esegue 10 tramite --policy.n_action_steps=10; con --policy.pretrained_path torna a 50 se si omette il flag.
• SmolVLA: chunk di 50 azioni, entrambi i parametri esposti.

Come testare tutti e cinque in un pomeriggio

La risposta più economica non è leggere di più. Spendi circa 15 USD e lascia che il braccio ti dica: registra una volta, addestra prima il modello economico, scala una volta che ha dimostrato che i dati sono validi. La struttura batte il volume, il punto di e il .

1. 1
   Registra 50 episodi una volta

   Cinquanta libera il campo per GR00T, Pi0.5 e ACT, e i 30 di SmolVLA. Ripetere ogni variazione piuttosto che diluire: 50 episodi su 5 posizioni del cubo addestrate dove 25 non lo erano. Vedi registra il tuo primo 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
   Addestra ACT per primo, perché non può mentirti

   Nessun peso pre-addestrato, quindi se esegue il compito, il tuo dataset contiene il compito. Se ACT si appiattisce, correggi i dati. Da 1 a 3 USD, da 2 a 5 ore su una scheda da 24 GB.

   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
   Esegui SmolVLA sullo stesso dataset, invariato

   Stessi dati, stesso braccio, 450 M parametri invece di 80 M, più condizionamento linguistico. LeRobot stima un'esecuzione di 20K passi a circa 4 ore su una A100. Questo è ciò che ti dice se il pre-addestramento porta benefici.

   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
   Converti a v2.1 prima di usare GR00T

   GR00T legge una variante del formato LeRobot v2 più un file extra meta/modality.json che mappa come gli array concatenati di stato e azione si dividono in campi nominati. Un dataset v3.0 blocca quel caricatore, perché v3.0 impacchetta molti episodi in file condivisi dove v2 ne scriveva uno per episodio. Isaac-GR00T fornisce l'utility di downgrade come scripts/lerobot_conversion/convert_v3_to_v2.py; la pagina di rifiuto v3 è il percorso più veloce.

   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
   Passa a GR00T N1.7 solo se i primi due hanno lasciato qualcosa in sospeso

   Tramite la CLI di NVIDIA, mostrata qui, o il tipo di policy groot di LeRobot. NVIDIA raccomanda 40 GB o più di VRAM per il fine-tuning, 16 GB per l'inferenza. In caso di OOM, vedi la pagina 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

Due modi per eseguire quel passaggio di screening

# 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

Modello di base o da zero

Il vero bivio non è quale modello 3B scegliere. È se usare o meno un VLA pre-addestrato, dato che ACT ha imparato sei compiti bimani reali da circa dieci minuti di dimostrazioni ciascuno, con 80 M di parametri e nulla di pre-addestrato.

Il caso della riproduzione di un'esecuzione precedente

Inseguire un checkpoint del 2025 fa la scelta del modello per te e trasforma il problema in un blocco di versione: l'attuale LeRobot rifiuta N1.5, quindi blocchi la versione a lerobot==0.5.1. Senza un campo seed e con una varianza del 5-6 percento tra le esecuzioni, la riproduzione è approssimativa per costruzione. e hanno il lato piattaforma.

Rimanere con due? e . Le righe grezze si trovano nelle voci dell'arena: , , e .

Dove questa piattaforma non ti aiuta

• Non può rendere l'inferenza remota veloce. Il ciclo da 20 a 485 ms appartiene al modello; i round trip di internet si aggiungono a questo.
• Non può effettuare il fine-tuning di GR00T o Pi0.5 sul tuo hardware. Entrambi sono solo cloud qui; solo SmolVLA e ACT funzionano localmente.
• Non può correggere un dataset. La perdita diminuisce ma la policy non fa nulla è un problema di dati, una policy che funziona solo in una configurazione è un problema di copertura.
• Non può rendere riproducibili le esecuzioni di GR00T: la configurazione upstream non ha un campo seed.

Scegliere e procedere

Un'impostazione predefinita: registra 50 episodi, addestra ACT per 1 a 3 USD per convalidare il dataset, poi SmolVLA sugli stessi dati. Meno di 6 USD in totale, e rispondono alla domanda che conta: se il pre-addestramento sia utile qui, o se il collo di bottiglia siano i dati. Passa a GR00T N1.7 per compiti multi-step ricchi di contatto, a Pi0.5 quando la scena cambia.

Panoramica della piattaforma: addestra la tua prima policy, poi esegui la tua prima policy. I documenti di addestramento e i documenti sui dataset coprono forma e formato; la pagina SO-100 e la guida completa SO-100 coprono costruzione e calibrazione. Contesto: la panoramica VLA e l'articolo sul flow-matching di Pi0. Quello che aumenterà il tuo tasso di successo è la guida alla qualità dei dati.