Comment entraîner SmolVLA sur un GPU de 24 Go (lerobot 0.6.1)

La plupart des gens qui veulent un modèle d'action vision-langage sur un bras réel s'arrêtent à la ligne matérielle. GR00T N1.7 et Pi0.5 ont environ trois milliards de paramètres chacun et nécessitent une A100 80 Go ou une H100. Si vous possédez un PC de jeu avec une RTX 4090, c'est la fin du chemin. SmolVLA est l'exception : 450 millions de paramètres, au sein de LeRobot, conçu pour être affiné sur une carte grand public et servi depuis un CPU.

La voie manuelle d'abord : installez lerobot, téléchargez le lerobot/smolvla_base checkpoint, exécutez la commande réelle, lisez l'exécution pendant qu'elle se déroule. Ensuite, la voie de la plateforme, et là où elle n'aide pas.

Ce qu'est SmolVLA, en chiffres vérifiables

SmolVLA est une correspondance de flux politique boulonnée sur un petit modèle de langage visuel. L'architecture est SmolVLM2-500M-Video-Instruct ; l'article ne conserve que les 16 premières couches de son modèle de langage, limite chaque image de caméra à 64 jetons visuels avec un mélange de pixels (pixel shuffle) au lieu d'un pavage d'images, et intercale l'attention croisée avec une couche d'auto-attention tous les deux blocs. Le coût d'inférence était une contrainte de conception, pas une réflexion après coup.

Les benchmarks expliquent pourquoi les gens s'intéressent à un modèle de 450 M. Sur LIBERO, il obtient en moyenne 87,3 percent contre 76,5 pour OpenVLA à 7 B et 86,0 pour un Pi0 pré-entraîné en robotique à 3,3 B ; sur Meta-World, 57,3 contre 47,9. Sur du matériel SO-100 réel, l'entraînement multi-tâches donne 75 percent sur le ramassage et le placement, 90 sur l'empilement, 70 sur le tri, avec une moyenne de 78,3, là où ACT entraîné par tâche obtenait en moyenne 48,3. Les mêmes lignes figurent à côté de chaque VLA publié dans l' entrée de l'arène SmolVLA et la comparaison ACT contre SmolVLA.

Pourquoi une carte de 24 Go est le bon choix pour une première exécution

LeRobot fournit un guide de dimensionnement du calcul, la page la plus utile du dépôt à cet effet. Il regroupe les politiques par taille de backbone et attribue une enveloppe de VRAM par groupe, mesurée avec une taille de lot de 8 et AdamW, la valeur par défaut de lerobot. L'état de l'optimiseur seul ajoute 30 à 100 pour cent par rapport à un simple passage avant et arrière, il ne s'agit donc pas de chiffres basés uniquement sur les poids.

Dix à seize gigaoctets avec un lot de 8, tel est l'argument : une carte de 24 Go peut gérer cela plus le dataloader. AY-Robots place SmolVLA sur la RTX 4090 ou toute carte de 24 Go, avec un minimum de 30 épisodes, LeRobot v3.0 de données, 245 ms par étape d'action. En location, cela représente 2 à 5 heures à 0,30 à 0,60 USD de l'heure, soit environ 1 à 3 USD par réglage fin d'exécution, contre 4 à 12 USD sur le niveau de 80 Go dont GR00T et Pi0.5 ont besoin (tarification). Une exécution SmolVLA échouée coûte un café ; une exécution GR00T échouée, un déjeuner.

Étape 0 : le jeu de données décide de l'exécution, pas les drapeaux

Rien de ce qui suit n'a d'importance si l'enregistrement est mauvais. La page LeRobot SmolVLA est claire : le jeu de données de référence était de 50 épisodes répartis sur 5 positions de cube, 10 par position, et la même tâche avec 25 épisodes a mal fonctionné. La répétition par variation généralise, le nombre brut d'épisodes non. Vous n'en avez jamais enregistré ? Commencez par enregistrer votre premier jeu de données avec le client de bureau, qui écrit le format LeRobot à partir d'une téléopération session, ou empruntez-en un depuis le répertoire de jeux de données.

• Au moins 30 épisodes sur AY-Robots, environ 50 pour la recette de référence LeRobot.
• Chaque variation attendue lors du déploiement, répétée plusieurs fois.
• Une chaîne de caractères de tâche, orthographiée de manière identique lors de l'enregistrement et du déploiement. Le modèle est conditionné par ce texte.
• Caméras fixes. Une caméra déplacée entre l'enregistrement et le déploiement est la raison la plus courante pour laquelle une courbe de perte propre donne un bras immobile.
• Une variation mise de côté sur laquelle vous n'avez jamais entraîné, afin d'avoir quelque chose d'honnête à tester.

# v2.1 -> v3.0: aggregates per-episode files into shards and writes the episode offsets
python -m lerobot.scripts.convert_dataset_v21_to_v30 --repo-id=${HF_USER}/so100_pick_place

Plus d'informations à ce sujet dans comment collecter des données d'entraînement VLA de haute qualité. En bref : 30 à 50 épisodes propres d'une tâche avec une variation délibérée sont plus efficaces que 200 épisodes bâclés de trois tâches, avec une marge qu'aucun hyperparamètre ne peut combler.

Installer lerobot 0.6.1

# LeRobot needs Python 3.12 or newer as of 0.6.x
conda create -y -n lerobot python=3.12
conda activate lerobot

# TorchCodec decodes the dataset videos and wants ffmpeg
conda install ffmpeg -c conda-forge

# Base package is deliberately thin; extras pull the rest
pip install 'lerobot[smolvla,training,core_scripts]'

# Sanity check: prints the lerobot version, the GPU torch sees, and the console scripts you got
lerobot-info

L'installation de base lerobot est légère et masque les dépendances lourdes derrière des extras : smolvla ajoute transformers, num2words et accelerate, training la pile de données et wandb, core_scripts les dépendances matérielles et de visualisation. Sous Linux, le chemin d'installation détermine également votre roue CUDA : la valeur par défaut de PyPI est une roue cu130 avec un pilote minimum de 580.65, donc sur un pilote plus ancien, installez d'abord torch à partir de l'index cu128, puis lerobot.

L'exécution de l'entraînement, commande par commande

1. 1
   S'authentifier auprès du Hub

   Le point de contrôle de base provient du Hub, et votre jeu de données probablement aussi.

   bash

   hf auth login

2. 2
   Lire les options une fois

   Chaque champ de la configuration du pipeline et de la politique est un drapeau. Parcourez-le avant de plonger dans le code source.

   bash

   lerobot-train --help

3. 3
   Lancer le réglage fin

   L'exemple de la documentation exécute un lot de 64 sur une seule A100 ; l'ancre A100 40 Go du guide de calcul est un lot de 16, et 8 est l'équivalent pour 24 Go. Pas de drapeau de planificateur ici volontairement, voir ci-dessous.

   bash

   lerobot-train \
     --policy.path=lerobot/smolvla_base \
     --dataset.repo_id=${HF_USER}/so100_pick_place \
     --batch_size=8 \
     --steps=20000 \
     --save_freq=2000 \
     --log_freq=200 \
     --seed=1000 \
     --output_dir=outputs/train/smolvla_pick_place \
     --job_name=smolvla_pick_place \
     --policy.device=cuda \
     --wandb.enable=true

4. 4
   Lire la ligne de journal, pas seulement la perte

   Toutes les --log_freq étapes, lerobot affiche loss, grdn, lr, updt_s, data_s, smp/s et, sur CUDA, mem_gb. mem_gb indique si le lot tient, lr si le programme décroît, et data_s approchant updt_s signifie que le dataloader est le goulot d'étranglement, pas le GPU.

   bash

   # if data_s creeps toward updt_s
   lerobot-train ... --num_workers=8

5. 5
   Collecter les points de contrôle que vous pouvez comparer

   save_freq est par défaut à 20000, donc une exécution de 20000 étapes ne laisse qu'un seul point de contrôle et rien à comparer. Définissez 2000. Pousser vers le Hub nécessite --policy.repo_id.

   bash

   --save_freq=2000 \
   --policy.repo_id=${HF_USER}/smolvla_pick_place \
   --save_checkpoint_to_hub=true

6. 6
   Reprendre si la machine s'arrête

   Pointez --config_path vers le train_config.json à côté du point de contrôle. lerobot refuse de démarrer dans un output_dir existant à moins que vous ne repreniez, vous ne pouvez donc pas écraser une exécution par accident.

   bash

   lerobot-train \
     --config_path=<path to the saved train_config.json> \
     --resume=true

Les drapeaux qui modifient réellement le résultat

Les valeurs par défaut que vous héritez si vous ne touchez à rien

Une politique configuration dans lerobot contient son propre optimiseur et préréglage de planificateur, et à moins que vous ne définissiez use_policy_training_preset=false ces préréglages l'emportent. La moitié des questions que les gens posent sur l'entraînement de SmolVLA trouvent leur réponse dans une valeur par défaut dont ils ignoraient l'existence.

Les deux lignes qui surprennent sont freeze_vision_encoder et train_expert_only, toutes deux vraies. Par défaut, vous entraînez environ 100 millions de paramètres, pas 450 millions, c'est pourquoi cela tient sur 24 Go. L'exécution de référence de LeRobot sur un cluster H100 à quatre GPU les passe toutes deux à faux ; sur une carte de 24 Go, cela transforme une exécution fonctionnelle en .

Combien de temps dure l'exécution et combien d'étapes sont suffisantes

LeRobot publie des points de référence en temps réel pour cinq époques sur un ensemble de données d'environ 50 épisodes, soit environ 45000 images à 30 ips. Des chiffres d'ordre de grandeur, disent les documents, mais ils représentent la différence entre s'attendre à une heure et à une journée.

Exécuter la politique affinée sur le bras

lerobot-rollout \
  --strategy.type=base \
  --robot.type=so100_follower \
  --robot.port=/dev/ttyACM0 \
  --robot.id=my_follower_arm \
  --robot.cameras="{ front: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30}}" \
  --task="Grasp the cube and put it in the box." \
  --policy.path=${HF_USER}/smolvla_pick_place

Les 245 ms par étape d'action sont faciles à mal interpréter : la politique émet chunk_size = 50 actions par passe avant et exécute n_action_steps = 50 d'entre elles, donc la fréquence à laquelle vous payez ce coût est définie par ces paramètres, et non par la fréquence à laquelle les servomoteurs reçoivent une commande. C'est ce que le découpage d'actions permet, et pourquoi un modèle de 245 ms peut piloter un bras à 30 Hz. Ce qui reste est la latence d'inférence à la fin du chunk.

Cette troisième ligne est ce que la plupart des articles omettent. L'inférence asynchrone est environ 30 % plus rapide et double approximativement le débit dans une fenêtre fixe, et l'article qualifie les taux de succès de comparables, ce qu'ils sont en moyenne. En dessous, le tri est passé de 70 à 50 % tandis que la prise et dépose a gagné 5. lerobot 0.6.1 intègre l'autre levier dans le même binaire : --inference.type=rtc bascule le déploiement vers le découpage en temps réel, ce que le bloc d'utilisation du script recommande pour les VLAs lents, Pi0, Pi0.5 et SmolVLA.

Deux chemins vers le même point de contrôle

pip install 'lerobot[smolvla,training,core_scripts]'
hf auth login

lerobot-train \
  --policy.path=lerobot/smolvla_base \
  --dataset.repo_id=${HF_USER}/so100_pick_place \
  --batch_size=8 --steps=20000 \
  --save_freq=2000 --seed=1000 \
  --output_dir=outputs/train/smolvla_pick_place \
  --job_name=smolvla_pick_place \
  --policy.device=cuda --wandb.enable=true

Quand SmolVLA est le mauvais choix

Le critère pour savoir si SmolVLA était le bon premier essai n'est pas s'il a fonctionné, mais si l'échec vous a appris quelque chose. Atteignez 60 ou 70 pour cent et un modèle plus grand est un investissement raisonnable : les données contiennent un signal. Atteignez 10 pour cent et un modèle de 3 milliards atteindra très probablement aussi 10 pour cent, ce que vous venez d'apprendre pour trois dollars au lieu de douze.

À lire avant de dépenser plus : Pi0.5 contre SmolVLA pour plus de capacité sur la même idée, et GR00T N1.7 contre SmolVLA pour la voie NVIDIA, les deux en catégorie 80 Go à 4 à 12 USD par exécution. L'autre option, ACT est la base de référence moins chère : 80 M paramètres, 20 ms par étape d'action, pas de conditionnement linguistique. Les cinq se trouvent sur la page des politiques; l'arène contient 85 modèles et 332 résultats de benchmark.

La liste de contrôle avant de passer à l'échelle

1. Le lr a-t-il atteint son seuil de 2.5e-6 ? En dessous de 30000 étapes, lerobot rééchelonne la décroissance et l'indique au démarrage ; au-delà, définissez vous-même --policy.scheduler_decay_steps.
2. Plus d'un point de contrôle, et des épisodes mis de côté avec --dataset.eval_split pour que la perte d'évaluation ait un sens.
3. La politique bouge-t-elle du tout ? Une perte qui diminue avec un bras immobile a des causes spécifiques : la perte diminue, la politique ne fait rien.
4. Survit-elle à un changement de scène ? Sinon : la politique ne fonctionne que dans une seule configuration.
5. Avez-vous noté la graine (seed) ? lerobot utilise 1000 par défaut, de sorte que deux exécutions non modifiées restent comparables.
6. Seulement ensuite : plus d'épisodes, plus de variation, ou un modèle plus grand. Dans cet ordre.

Pour comprendre pourquoi ces modèles existent et ce qu'ils font avec l'entrée linguistique, est le contexte ; décrit l'assemblage, de la à la première exécution d'. Pour le point de contrôle final, ; si le bras n'apparaît jamais, consultez .