Quelle politique VLA devriez-vous entraîner en 2026 ?

Cinq politiques sont entraînables sur un bras de classe SO-100 aujourd'hui. Elles diffèrent par un facteur de 24 en latence d'inférence, 37 en nombre de paramètres et 12 en coût d'exécution, et selon que vous pouvez ou non livrer le résultat. Cinq fiches de modèle ne suffiront pas : aucune ne répond à la question que vous vous posez, laquelle dois-je exécuter en premier ?

Chaque chiffre ci-dessous a été extrait des articles, dépôts et fiches en août 2026. Les chiffres de la plateforme proviennent du catalogue de politiques AY-Robots; lorsque les deux sont en désaccord, les deux sont affichés.

Le tableau de décision

Les cinq candidats

Les cinq sont des : des images de caméra, des positions d'articulations et, pour quatre d'entre elles, une instruction linguistique, mappée à un ensemble de cibles d'articulations futures. Ce qui les distingue, c'est la quantité de connaissances acquises avant votre arrivée.

GR00T N1.7

Le modèle actuel de NVIDIA, modèle vision-langage-action, d'environ 3 milliards de paramètres, dont environ 40 millions ont été entraînés pendant le fine-tuning. Le dépôt liste les deltas par rapport à N1.6 : le backbone est passé d'un modèle Eagle fourni à Cosmos-Reason2-2B sur Qwen3-VL, les couches de diffusion de 32 à 16, les dimensions d'état et d'action de 29 à 132, et l'horizon d'action de 16 à 40.

Ce qui importe sur un petit bras est l'espace d'action relatif de l'effecteur final : N1.7 prédit les deltas à partir de la pose actuelle, ce qui permet à 20K heures de vidéo humaine EgoScale d'être transférées dans une politique de robot. Les spécifications sont sur la page N1.7, la procédure dans le guide N1.7 sur SO-100.

GR00T N1.5

Même échelle 3 B, architecture Eagle 2, SigLip2 et T5, tête DiT de flow-matching. Il existe pour étendre un que vous possédez déjà. Deux choses en font un mauvais choix par défaut : les poids sont soumis à la licence non commerciale à sens unique de NVIDIA, et les versions actuelles de LeRobot ont supprimé le support de N1.5. Voir .

Pi0.5

Le VLA de Physical Intelligence utilisant le VLA, de type de politique pi05. L'article décrit un VLM de 2 B initialisé à partir de PaliGemma, plus un expert d'action de 300 M, pilotant le robot à 50 Hz ; la configuration pi05 de LeRobot utilise par défaut un segment de 50 étapes, soit une seconde à ce rythme. L'argument de vente est la capacité à opérer dans des lieux inconnus : environ 400 heures de manipulation mobile dans de vraies maisons, et une étude de mise à l'échelle sur 3, 12, 22, 53, 82 et 104 emplacements, où le modèle à 104 emplacements a égalé un contrôle entraîné sur les maisons de test elles-mêmes.

Une limite, indiquée sur la lerobot/pi05_base carte : le port ne transporte que la tête d'action de correspondance de flux. La prédiction de sous-tâches, la tokenisation d'actions et le RL n'ont pas été publiés en amont, et openpi dit la même chose de son propre dépôt. La page Pi0.5 et le guide Pi0.5 sur SO-100 contiennent le reste.

SmolVLA

450 M paramètres, dont environ 100 M dans l'expert d'action, sur SmolVLM-2 avec le VLM gelé et seulement ses 16 premières couches de modèle linguistique utilisées. Le pré-entraînement a été effectué sur des données communautaires : 481 jeux de données, 10,6 M de cadres, provenant des mêmes bras bon marché que vous utilisez. Le seul VLA ici qui tient sur une carte de 24 Go, et le seul avec un plancher de 30 épisodes. Voir la page SmolVLA.

ACT

Pas un modèle de fondation. L'Action Chunking Transformer d'ALOHA est d'environ 80 M de paramètres entraînés à partir de zéro par tâche, sur 50 démonstrations à 50 Hz. L'article rapporte six tâches bimanuelle réelles à partir d'environ dix minutes de démonstrations chacune, avec 80 à 90 pour cent sur les exemples qu'il met en évidence. Son idée, découpage d'actions, est présente dans chaque modèle de cette page, et son ablation mesure toujours le meilleur effet : sur deux tâches simulées avec l'ensemblage temporel désactivé, le succès passe de 1 pour cent à k=1 à 44 pour cent à k=100. La page ACT contient le reste.

Ce que disent réellement les benchmarks

LIBERO est le seul benchmark sur lequel trois de ces cinq modèles rapportent : des tâches conditionnées par le langage sur un Franka Panda simulé, divisées en les quatre suites ci-dessous, avec dix tâches chacune. NVIDIA a effectué 200 essais par suite.

SimplerEnv montre la dispersion, ce que LIBERO ne fait pas. NVIDIA compare N1.7 à N1.6, ce qui est le plus proche publiquement d'un delta générationnel.

La ligne Bridge est la plus utile : 5,7 points gagnés en moyenne tandis que put_eggplant_in_basket a perdu 36 et put_eggplant_in_sink est tombé de 33 à 2. Une nouvelle génération déplace la distribution plutôt que de la soulever, donc si votre tâche se situe là où N1.7 a régressé, la moyenne ne dit rien.

Parmi les cinq, seul l'article SmolVLA rapporte un bras de classe SO-100 : 78,3 pour cent pour SmolVLA et 61,7 pour Pi0 sur trois tâches, toutes deux multi-tâches, contre 48,3 pour ACT entraîné en tâche unique, ce qui n'est pas comparable. Le jumelage propre est en tâche unique sur SO-101 pick-and-place : 90 contre 70 en distribution, 50 contre 40 hors de celle-ci. Comparez sur ACT contre SmolVLA et Pi0.5 contre SmolVLA, ou parcourez l'arène.

La latence et le coût décident du déploiement

Latence d'inférence est la contrainte que l'on découvre en dernier et que l'on regrette en premier. Une politique cinq points meilleure sur un benchmark mais qui prend une demi-seconde par étape d'action semble pire sur votre bureau : la dynamique de contact n'attend pas.

Une mise en garde : le chiffre de GR00T est en désaccord avec la carte de NVIDIA, qui chronomètre 4 étapes de débruitage et une caméra à 85,8 ms sur un H100 en mode eager, 48,6 ms avec torch.compile, 27,9 ms via TensorRT complet. Les 152 ms ici sont un chiffre de pile complète avec la surcharge de service et plus d'une caméra, pas un passage avant.

Une façon de gagner du temps sans changer de modèle : l'article SmolVLA mesure l'exécution synchrone, où la politique termine un bloc avant de prédire le suivant, par rapport à l'asynchrone, où la prédiction chevauche l'exécution. Le succès est similaire, 78.3 contre 73.3, mais le même pick-and-place prend 9.7 secondes au lieu de 13.75, et dans une fenêtre fixe, le robot gère 19 cycles au lieu de 9.

Licences, vérifiées parce que personne ne les vérifie

La ligne Pi0.5 nécessite une attention particulière. La documentation LeRobot pi05 indique Apache 2.0, ce qui est cohérent avec openpi, tandis que la carte du Hub pour lerobot/pi05_base contient license: gemma. Les deux sont actifs. GR00T N1.7 a une version plus souple : le README d'Isaac-GR00T indique en passant que N1.7 est entièrement commercialisable sous licence Apache 2.0, tandis que sa propre section de licence et la carte du modèle ne placent que le code sous Apache 2.0 et les poids sous la NVIDIA Open Model License.

Les valeurs par défaut que vous exécuterez réellement

Chaque formulaire d'entraînement est livré avec une valeur par défaut, et celles-ci ne sont pas arbitraires. Celles d'ACT sont propres à LeRobot : batch 8, lr 1e-5, 100000 étapes d'entraînement, chunk size 100, matching ACTConfig upstream and k=100 from the ACT paper. Une colonne ci-dessous est un piège.

Le paramètre qui compte plus que le choix du modèle

C'est le bloc d'action. Des blocs plus longs donnent un mouvement plus fluide et moins d'erreurs cumulatives, mais la politique est engagée pendant l'exécution du bloc, elle réagit donc tardivement à tout ce qui bouge : confiante sur un cube statique, désespérée sur un cube roulant. Si elle dépasse, raccourcir la portion exécutée est préférable au réentraînement et est gratuit. Une articulation qui s'arrête trop tôt est un problème différent ; voir .

• ACT: ACTConfig utilise par défaut chunk_size 100 et n_action_steps 100. L'ensemble temporel est désactivé et nécessite n_action_steps 1.
• GR00T N1.7: l'horizon interne est passé de 16 à 40, pourtant l'exemple SO-101 de LeRobot exécute toujours --policy.chunk_size=16 --policy.n_action_steps=16. Le flag de déploiement a été renommé en --execution-horizon.
• Pi0.5: un bloc de 50 étapes, dont la recette LIBERO de LeRobot exécute 10 via --policy.n_action_steps=10 ; avec --policy.pretrained_path il revient à 50 si vous omettez le flag.
• SmolVLA: blocs de 50 actions, les deux paramètres sont exposés.

Comment passer les cinq au crible en un après-midi

La réponse la moins chère n'est pas de lire davantage. Dépensez environ 15 USD et laissez le bras vous dire : enregistrez une fois, entraînez d'abord le modèle bon marché, puis intensifiez une fois qu'il a prouvé la validité des données. La structure l'emporte sur le volume, c'est le but de et du .

1. 1
   Enregistrer 50 épisodes une seule fois

   Cinquante épisodes ouvrent la voie à GR00T, Pi0.5 et ACT, et aux 30 de SmolVLA. Répétez chaque variation plutôt que de vous disperser : 50 épisodes sur 5 positions de cube entraînés là où 25 ne l'ont pas été. Voir enregistrer votre premier jeu de données.

   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
   Entraînez ACT en premier, car il ne peut pas vous mentir

   Pas de poids pré-entraînés, donc si la tâche est effectuée, votre jeu de données contient la tâche. Si ACT ne progresse pas, corrigez les données. 1 à 3 USD, 2 à 5 heures sur une carte de 24 Go.

   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
   Exécutez SmolVLA sur le même jeu de données, inchangé

   Mêmes données, même bras, 450 M de paramètres au lieu de 80 M, plus le conditionnement linguistique. LeRobot estime une exécution de 20K étapes à environ 4 heures sur une A100. C'est ce qui vous indique si le pré-entraînement apporte un avantage.

   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
   Convertissez vers la v2.1 avant d'utiliser GR00T

   GR00T lit une variante du format LeRobot v2 avec un fichier supplémentaire meta/modality.json qui mappe la façon dont les tableaux d'état et d'action concaténés se divisent en champs nommés. Un jeu de données v3.0 fait planter ce chargeur, car v3.0 regroupe de nombreux épisodes dans des fichiers partagés là où v2 écrivait un fichier par épisode. Isaac-GR00T fournit l'outil de rétrogradation sous la forme de scripts/lerobot_conversion/convert_v3_to_v2.py ; la page de rejet v3 est le chemin rapide.

   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
   Passez à GR00T N1.7 uniquement si les deux premiers n'ont pas donné de résultats satisfaisants

   Via l'interface CLI de NVIDIA, présentée ici, ou le type de politique groot de LeRobot. NVIDIA recommande 40 Go ou plus de VRAM pour le fine-tuning, 16 Go pour l'inférence. En cas d'OOM, consultez la page 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

Deux façons d'exécuter ce passage de sélection

# 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

Modèle de fondation ou à partir de zéro

Le vrai dilemme n'est pas de choisir quel modèle 3B. Il s'agit de savoir s'il faut utiliser un VLA pré-entraîné, étant donné qu'ACT a appris six tâches bimanuales réelles à partir d'environ dix minutes de démonstrations chacune, avec 80 M de paramètres et rien de pré-entraîné.

Le cas de la reproduction d'une ancienne exécution

Poursuivre un checkpoint de 2025 fait le choix du modèle pour vous et transforme le problème en épinglage de version : LeRobot actuel rejette N1.5, vous épinglez donc lerobot==0.5.1. Sans champ de graine et avec 5 à 6 pour cent de variance entre les exécutions, la reproduction est approximative par construction. et gèrent le côté plateforme.

Réduit à deux ? ACT contre GR00T N1.7 et GR00T N1.7 contre SmolVLA. Les entrées brutes se trouvent dans les arènes : GR00T N1.7, Pi0.5, SmolVLA et ACT.

Où cette plateforme ne vous aide pas

• Elle ne peut pas accélérer l'inférence à distance. La boucle de 20 à 485 ms appartient au modèle ; les allers-retours internet s'y ajoutent.
• Elle ne peut pas affiner GR00T ou Pi0.5 sur votre propre matériel. Les deux sont uniquement disponibles dans le cloud ici ; seuls SmolVLA et ACT s'exécutent localement.
• Elle ne peut pas corriger un jeu de données. La perte diminue mais la politique ne fait rien est un problème de données, une politique qui ne fonctionne que dans une seule configuration est un problème de couverture.
• Elle ne peut pas rendre les exécutions de GR00T reproductibles : la configuration en amont n'a pas de champ de graine.

En choisir un et passer à l'étape suivante

Un défaut : enregistrer 50 épisodes, entraîner ACT pour 1 à 3 USD afin de prouver le jeu de données, puis SmolVLA sur les mêmes données. Moins de 6 USD au total, et ils répondent à la question qui compte : si le pré-entraînement aide ici, ou si le goulot d'étranglement est les données. Passer à GR00T N1.7 pour les tâches multi-étapes riches en contact, à Pi0.5 lorsque la scène change.

Présentation de la plateforme : entraîner votre première politique, puis exécuter votre première politique. Les documents de formation et les documents sur les jeux de données couvrent la forme et le format ; la page du SO-100 et le guide complet du SO-100 couvrent la construction et la calibration. Contexte : l'aperçu VLA et l'article sur le flow-matching Pi0. Celui qui fera progresser votre taux de réussite est le guide de qualité des données.