Modèles VLA compacts : TinyVLA, SmolVLA et le cas des modèles de moins d'un milliard de paramètres

Presque tous les modèles vision-langage-action dont on parle supposent une carte de centre de données. OpenVLA a 7 milliards de paramètres. GR00T N1.7 et Pi0.5 sont d'environ 3 milliards et nécessitent une A100 80 Go pour le réglage fin. Si la carte sur votre bureau est une 4090, cette classe de modèle est hors de portée.

Deux articles soutiennent que vous n'en avez pas besoin. TinyVLA (arXiv 2409.12514, accepté par IEEE Robotics and Automation Letters en février 2025) construit un VLA à partir d'un backbone de 400 millions à 1,3 milliard de paramètres, plus une tête d'action par diffusion. SmolVLA (arXiv 2506.01844, soumis le 2 juin 2025) est livré avec 450 millions de paramètres, des poids ouverts, des données ouvertes et un script qui s'exécute sur une seule carte grand public. Voici ce que les deux ont mesuré, et où l'argument du sous-milliard cesse d'être valable.

Qu'est-ce qui compte réellement comme un petit VLA

Le nombre de paramètres sur une fiche modèle n'est pas un chiffre unique. Il peut désigner le total des poids, les poids chargés lors de l'inférence, ou les poids qui reçoivent des gradients pendant le . TinyVLA rapporte les deux, et l'écart est important : TinyVLA-H est de 1,3 B au total mais 143 M sont entraînables, car la tour de vision et la majeure partie du modèle de langage restent figées tandis que les adaptateurs LoRA et la tête d'action se déplacent. L'article estime la part entraînable à environ 5 pour cent.

Deux lignes méritent d'être discutées. à environ 80 M est plus petit que tout le reste ici mais n'a pas de modèle de langage, ce n'est donc pas un VLA : il apprend une tâche et ne peut pas être instruit d'en faire une autre. à 27 M est conditionné par un encodeur de texte T5-Base, et non par un backbone LLM. Ce sont de bonnes bases de référence, mais aucune ne fournit le suivi d'instructions que l'étiquette implique.

TinyVLA : la vitesse vient de la tête, pas du backbone

La lecture évidente est qu'ils ont réduit la taille du modèle de langage, le rendant ainsi plus rapide. L'étude d'ablation de l'article indique le contraire. L'échange du backbone de 7 B d'OpenVLA contre un de 1 B a réduit la prédiction par action de 292 ms à 140 ms, soit un gain de 2x. TinyVLA-H, avec un nombre de paramètres comparable, fonctionne à 14 ms sur la même carte. L'autre facteur 10x est la tête d'action.

OpenVLA émet des actions sous forme de jetons discrétisés via la tête du modèle de langage, un par dimension d'action, de manière autorégressive. TinyVLA attache un décodeur de diffusion qui produit l'ensemble du bloc en une seule fois. Le Tableau V présente l'architecture de TinyVLA-H et n'échange que la tête, sur les cinq mêmes tâches de robot réel. C'est la preuve la plus claire dans les deux articles pour l'argument que les politiques d'appariement de flux produisent, et la raison pour laquelle Pi0 s'est éloigné du décodage de jetons.

Ce que TinyVLA a obtenu

La ligne bimanuelle a une explication ennuyeuse que l'article donne lui-même : OpenVLA est pré-entraîné sur Open X-Embodiment, qui se compose entièrement de données à bras unique, de sorte qu'un espace d'action à deux bras est hors distribution et obtient un score de zéro. La ligne de base de la politique de diffusion bat TinyVLA-H sur deux de ces trois tâches. Contexte dans l'article sur Open X-Embodiment.

Le dépôt TinyVLA, en août 2026

L'article est bon. Le code est une version de recherche. Le dépôt est github.com/liyaxuanliyaxuan/TinyVLA ; son README date la publication du code au 17 février 2025 et le dernier commit au 11 mars 2025. C'est bien pour reproduire un article, mais c'est un problème si vous vouliez une bibliothèque maintenue.

git clone https://github.com/liyaxuanliyaxuan/TinyVLA
conda create -n tinyvla python=3.10 -y
conda activate tinyvla
pip install --upgrade pip
pip install -r requirements.txt
cd policy_heads && pip install -e .
cd ../llava-pythia && pip install -e .

TinyVLA ne lit pas non plus les jeux de données LeRobot. Son format est HDF5 de style ACT : action, language_raw, et un groupe d'observations avec des images multi-vues, joint_positions, qpos et qvel. Le dépôt fournit data_utils/rlds_to_h5py.py pour l'entrée RLDS, et chaque tâche est enregistrée manuellement dans aloha_scripts/constants.py avec son dataset_dir, episode_len et camera_names. Si vos épisodes proviennent de lerobot ou du client de bureau, la conversion vous incombe.

# scripts/train.sh, the real flags from the repository
ACTION_HEAD=droid_diffusion

deepspeed --master_port 29600 --num_gpus=8 --num_nodes=1 ./train_tinyvla.py \
  --deepspeed scripts/zero2.json \
  --lora_enable True \
  --lora_module 'vit llm' \
  --lora_r 64 \
  --lora_alpha 256 \
  --non_lora_lr 2e-5 \
  --task_name "example_task_config" \
  --model_name_or_path /path/to/pretrained_vlm \
  --freeze_vision_tower True \
  --freeze_backbone True \
  --bf16 True \
  --max_steps 10000 \
  --per_device_train_batch_size 32 \
  --gradient_accumulation_steps 1 \
  --learning_rate 2e-4 \
  --lr_scheduler_type "cosine" \
  --warmup_ratio 0.005 \
  --save_steps 1000 \
  --action_head_type $ACTION_HEAD \
  --use_state True \
  --window_size 6

• --num_gpus=8 suppose un nœud à huit cartes. Réglez-le sur 1 et réduisez la taille du lot bien en dessous de 32. Aucune variante mono-GPU n'est fournie en amont, donc la commande ne peut pas être exécutée telle quelle sur une 4090.
• --deepspeed scripts/zero2.json pointe vers un fichier qui ne se trouve pas dans le répertoire scripts de niveau supérieur. Les configurations DeepSpeed sont fournies dans llava-pythia/scripts/zero2.json. Corrigez le chemin avant votre première exécution.
• Le README exige que le nom du répertoire de sortie contienne llava_pythia, plus lora si LoRA est activé.
• Le backbone est un téléchargement séparé : lesjie/Llava-Pythia-400M, -700M ou -1.3B. Il n'y a pas de point de contrôle de base unique vers lequel vous pointez une politique de la même manière que vous pointez vers lerobot/smolvla_base.

SmolVLA : le modèle de moins de 1 milliard de paramètres que vous pouvez exécuter cet après-midi

SmolVLA avance le même argument au sein d'une bibliothèque maintenue. Il compte 450 millions de paramètres sur un backbone SmolVLM2-500M-Video-Instruct, et l'efficacité provient des paramètres que vous pouvez lire dans configuration_smolvla.py plutôt que d'une affirmation de sa petite taille.

Le pré-entraînement a utilisé 481 jeux de données communautaires LeRobot, 22,9 K épisodes et 10,6 M images sur 4 GPU, 200 000 étapes avec un lot global de 256 ; l'article estime l'ensemble du projet à environ 30 K heures GPU. Un chiffre à surveiller : le blog de lancement de Hugging Face mentionne 487 jeux de données organisés là où le tableau de l'article indique 481. Nous utilisons le chiffre de l'article et signalons la divergence.

Un heureux hasard : le tableau Meta-World de l'article sur SmolVLA inclut les chiffres publiés de TinyVLA comme référence, ainsi pour une fois les deux modèles sont dans le même tableau, SmolVLA-0.45B à 57.3 contre TinyVLA-H à 31.6. Il rapporte également que l'entraînement de SmolVLA est environ 40 pour cent plus rapide que Pi0 avec 6x moins de mémoire. Tout cela provient des auteurs de SmolVLA ; l'entrée de l'arène lie chaque valeur à sa source.

Où SmolVLA passe son temps

AY-Robots liste SmolVLA à 245 ms par étape d'action et ACT à 20 ms dans le catalogue de politiques. TinyVLA rapporte 14 ms par prédiction d'action. Ces chiffres ne sont pas comparables, et les traiter comme tels est l'erreur la plus courante sur ce sujet : certains chronomètrent un passage avant, d'autres divisent ce passage sur un bloc une fois que le découpage d'actions l'amortit.

• SmolVLA émet 50 actions par passage avant et exécute les 50. Aux 30 ips que l'article utilise sur des robots réels, une inférence couvre environ 1.7 seconde de mouvement.
• L'inférence asynchrone calcule le bloc suivant pendant que le bloc actuel est encore en exécution : 9.7 s de temps moyen d'achèvement de tâche contre 13.75 s en synchrone, soit environ 30 pour cent plus rapide, et 19 cycles de prise et dépose dans une fenêtre fixe de 60 secondes contre 9.
• Les taux de réussite étaient comparables plutôt que meilleurs, 78.3 en synchrone contre 73.3 en asynchrone. L'asynchrone apporte du débit, pas de la précision.
• Le découpage masque la latence de calcul, pas la latence réseau, et il rend la politique moins réactive car elle est engagée sur 50 actions.

Fine-tuning de SmolVLA sur une carte grand public

Le chemin manuel, sur lerobot 0.6.1, la version PyPI actuelle au 23 août 2026. Tout ce qui suit provient de la documentation Hugging Face lerobot SmolVLA, récupérée le même jour ; la version guidée est plus douce.

1. 1
   Installer lerobot avec l'extra smolvla

   Les dépendances SmolVLA sont un extra optionnel, ne faisant pas partie de l'installation de base. L'installer sans et ensuite se demander pourquoi le type de politique est inconnu est une demi-heure souvent perdue.

   bash

   git clone https://github.com/huggingface/lerobot.git
   cd lerobot
   pip install -e ".[smolvla]"

2. 2
   Obtenir un jeu de données avec suffisamment d'épisodes

   La documentation recommande environ 50 épisodes et indique que la même tâche avec 25 n'était pas suffisante. AY-Robots fixe le minimum à 30. Enregistrez le vôtre, ou commencez à partir du répertoire des jeux de données.

   bash

   # any LeRobotDataset on the Hub works as --dataset.repo_id
   # lerobot/svla_so100_pickplace is the paper's own 50-episode set:
   # 5 cube positions, 10 episodes each

3. 3
   Lancer le fine-tuning

   La commande du guide lerobot, non modifiée. La documentation estime 20000 étapes à environ 4 heures sur une A100. Sur une carte de 24 Go, attendez-vous à plus long et mesurez-le.

   bash

   cd lerobot && lerobot-train \
     --policy.path=lerobot/smolvla_base \
     --dataset.repo_id=${HF_USER}/mydataset \
     --batch_size=64 \
     --steps=20000 \
     --output_dir=outputs/train/my_smolvla \
     --job_name=my_smolvla_training \
     --policy.device=cuda \
     --wandb.enable=true

4. 4
   Réduire la taille du lot jusqu'à ce qu'il tienne

   batch_size=64 est un exemple documenté, pas une promesse concernant votre carte. La documentation conseille de commencer petit et d'augmenter tant que les temps de chargement restent courts.

   bash

   lerobot-train --help

5. 5
   Déployer le checkpoint sur le bras

   Même bibliothèque, une seule commande. Les flags de découpage en temps réel sont commentés dans la documentation et sont ceux à utiliser sur du matériel à faible puissance.

   bash

   lerobot-rollout \
     --strategy.type=base \
     --robot.type=so101_follower \
     --robot.port=/dev/ttyACM0 \
     --robot.id=my_blue_follower_arm \
     --robot.cameras="{ front: {type: opencv, index_or_path: 8, width: 640, height: 480, fps: 30}}" \
     --task="Grasp a lego block and put it in the bin." \
     --policy.path=HF_USER/FINETUNE_MODEL_NAME

Deux façons de déployer un petit VLA sur un bras

Quand un petit modèle est le mauvais choix

Les deux articles sont plus prudents ici que ne le sont les résumés. L'analyse des défaillances de TinyVLA est spécifique : la variante de 0,4 B a échoué trois fois en interprétant mal l'instruction, ce que les auteurs attribuent à une compréhension linguistique limitée dans le VLM plus petit, et ce mode a disparu à 1,3 B. SmolVLA montre la même courbe de l'autre côté : la version de 2,25 B de l'architecture identique obtient 88,75 sur LIBERO et 68,24 sur Meta-World contre 87,3 et 57,3 pour le modèle de 0,45 B.

La comparaison pertinente n'est pas TinyVLA contre SmolVLA. C'est SmolVLA contre ACT sur votre propre tâche, et l'article de SmolVLA en est l'argument. Entraîné sur une seule tâche sans pré-entraînement robotique, SmolVLA a obtenu une moyenne de 40,0 sur trois tâches SO-100 où ACT en tâche unique a atteint 48,3. Ce qui le porte à 78,3 est le pré-entraînement communautaire et l'entraînement multi-tâches, et non l'architecture seule. Sur la tâche de lego SO-101, les deux en tâche unique, SmolVLA gagne : 90 contre 70 en distribution. Ensuite, SmolVLA contre Pi0.5 si le budget le permet.

Un tableau de décision sur lequel vous pouvez agir

Pour la dernière ligne, le bras en direct diffuse un SO-100 physique que vous pouvez piloter depuis le navigateur sans compte, et les trois façons de commencer couvrent le reste. Le SO-100 est le bras de référence ici, coûtant environ 110 à 150 EUR en pièces, avec un guide de configuration complète.

Ce qui vient après les modèles de moins de 1 milliard de paramètres

Réduire le nombre de paramètres est une façon de rendre un VLA bon marché et pas forcément la plus efficace. OpenVLA-OFT (arXiv 2502.19645) conserve le backbone de 7 milliards de paramètres et ne modifie que la façon dont les actions sont décodées, rapportant une augmentation de 26x du débit de génération d'actions et une hausse de LIBERO de 76,5 à 97,1 pour cent. BitVLA (arXiv 2506.07530) rend chaque poids d'un backbone BitNet b1.58 2B4T à 1 bit ternaire, rapportant 11.0x moins de mémoire et 4.4x moins de latence de bout en bout tout en égalant les performances d'OpenVLA-OFT en pleine précision. X-VLA-0.9B (arXiv 2510.10274) se situe sur la ligne des 1 milliard de paramètres avec le flow matching.

Le fil conducteur : le décodeur d'actions, et non le modèle de langage, est la source de la latence. Demandez comment une politique émet des actions avant de vous interroger sur son nombre de paramètres. L'arène contient 85 modèles et 332 résultats, chacun lié à sa source ; un aperçu plus large est disponible dans notre introduction aux VLA.