Coût de l'entraînement VLA : Ce que coûte réellement une exécution de fine-tuning

La facture comporte quatre lignes, et le GPU est la plus petite

Quand les gens demandent ce que coûte l'affinement d'un modèle vision-langage-action pour un SO-100, ils font presque toujours référence à la location de GPU. C'est le chiffre qui apparaît comme un débit sur une carte, c'est donc celui qui semble réel. C'est aussi, de loin, le plus petit des quatre chiffres qui décident du coût réel d'une politique fonctionnelle.

Les temps d'entraînement ci-dessous proviennent des articles et dépôts des cinq modèles, le coût matériel de la nomenclature publiée, les chiffres de la plateforme des AY-Robots catalogue de politiques et de la page de tarification. Lorsque la plateforme n'apporte pas d'aide, cet article le précise.

Ce que coûte réellement une heure de GPU sur le marché spot

Il n'y a pas de prix unique pour une heure d'A100. Sur une place de marché comme vast.ai, chaque hôte fixe son propre tarif, et le lancement d'entraînement que vous lancez atterrit sur la machine la moins chère et disponible à cet instant. La réponse honnête est une distribution. La voici, mesurée le 23 août 2026 à 13:44 UTC : cartes complètes uniques, à la demande, filtrées par VRAM réelle.

# Live, full-card, single-GPU, on-demand offers from the vast.ai public bundle API.
# No account and no API key needed. gpu_ram is in MB, so an 80 GB card is >= 80000.
python3 - <<'PY'
import json, statistics, urllib.parse, urllib.request

def offers(name, min_ram):
    q = {"rentable": {"eq": True}, "num_gpus": {"eq": 1}, "gpu_name": {"eq": name},
         "order": [["dph_total", "asc"]], "limit": 500, "type": "on-demand"}
    url = "https://console.vast.ai/api/v0/bundles/?q=" + urllib.parse.quote(json.dumps(q))
    with urllib.request.urlopen(url, timeout=60) as r:
        return [o for o in json.load(r)["offers"]
                if o["gpu_frac"] == 1.0 and o["gpu_ram"] >= min_ram]

groups = {
    "RTX 4090 24 GB": (["RTX 4090"], 24000),
    "RTX 5090 32 GB": (["RTX 5090"], 30000),
    "A100 80 GB":     (["A100 PCIE", "A100 SXM4"], 80000),
    "H100 80 GB":     (["H100 SXM", "H100 PCIE"], 80000),
    "H100 NVL 94 GB": (["H100 NVL"], 90000),
}
for label, (names, min_ram) in groups.items():
    o = [x for n in names for x in offers(n, min_ram)]
    if not o:
        print(label, "no offers"); continue
    p = sorted(x["dph_total"] for x in o)
    b = sorted(x["min_bid"] for x in o if x.get("min_bid"))
    bid = f"{b[0]:.2f}" if b else "n/a"
    print(f'{label}: n={len(p)} | {p[0]:.2f} / {statistics.median(p):.2f} / {p[-1]:.2f}'
          f' USD/h | bid floor {bid}')
PY

Pourquoi les modèles 3B ne peuvent pas utiliser la carte bon marché

Une heure de 4090 et une heure de H100 80 Go diffèrent d'environ six fois aux médianes ci-dessus. Ce qui vous force à utiliser la carte coûteuse n'est pas la vitesse, c'est la mémoire. openpi fixe le seuil pour un réglage fin complet de Pi0.5 à 70 Go, et NVIDIA recommande 40 Go ou plus pour GR00T. Notez ce que le chiffre GR00T n'est pas. Sa configuration de réglage fin gèle le modèle de langage et l'encodeur visuel par défaut (tune_llm et tune_visual sont False, le projecteur et la tête de diffusion True), c'est pourquoi le catalogue liste environ 40 M de paramètres entraînés sur 3 B. Les 40 Go ne sont pas l'état de l'optimiseur pour 3 B de poids, c'est le backbone gelé plus les activations. Les variantes à portée réduite descendent plus bas : le chemin LoRA d'openpi demande 22,5 Go et nomme la 4090, et le flux de travail Isaac Lab Arena de NVIDIA liste une option mono-GPU de 24 Go pour le post-entraînement de GR00T. La plateforme se base sur le seuil que chaque fournisseur publie pour la configuration qu'il exécute réellement. L'article sur le flow-matching de pi0 explique d'où vient cette empreinte de flow-matching.

Ce tableau explique pourquoi la plateforme divise les cinq modèles en deux niveaux. GR00T N1.7, GR00T N1.5 et Pi0.5 fonctionnent sur A100 80 Go ou H100 parce que c'est ce que les fournisseurs demandent. SmolVLA et ACT fonctionnent sur une RTX 4090 ou toute carte de 24 Go parce que c'est réellement suffisant.

Durée d'exécution réelle de chacun des cinq modèles

Le temps d'exécution est l'autre moitié du coût : 2.00 USD par heure est insignifiant si la tâche dure 40 minutes et ruineux si elle dure 40 heures. Ce sont les paramètres par défaut que AY-Robots envoie réellement à l'entraîneur, avec la fenêtre d'exécution et le coût pour chaque niveau.

D'où proviennent ces fenêtres d'exécution en amont

• SmolVLA: la documentation lerobot indique que 20,000 étapes prennent environ 4 heures sur une seule A100. La plateforme exécute les mêmes 20,000 étapes sur le niveau moins cher de 24 GB, d'où une fenêtre plutôt que 4 heures fixes.
• ACT: le document ALOHA original rapporte environ 5 heures sur une seule RTX 2080 Ti de 11 GB pour un modèle à 80 millions de paramètres. Une 4090 est de plusieurs générations plus récente, mais la plateforme prévoit 100,000 étapes, donc la fenêtre se situe au même endroit.
• GR00T: le flux de travail de référence de NVIDIA pour la génération N1.6 indique environ 4 à 8 heures pour 20,000 étapes par lot de 24 sur huit cartes L40S, et 2 à 3 heures pour 30,000 étapes par lot de 16 sur une seule Ada 6000. Le réglage fin sur une seule carte d'un VLA de 3B en quelques heures est normal, pas optimiste.
• Pi0.5: openpi ne publie aucun chiffre de temps réel, mais il publie le seuil de 70 GB pour un réglage fin complet, ce qui détermine la carte et donc le débit.

Il est bon de s'arrêter sur le coût que vous ne payez pas. Le document GR00T N1 rapporte environ 50,000 heures GPU H100 pour pré-entraîner le modèle 2.2B, sur un cluster allant jusqu'à 1024 GPU, avec une taille de lot de pré-entraînement de 16,384 pour 200,000 étapes de gradient. Au tarif de 1.34 à 2.34 USD par heure mesuré ci-dessus, cela représente de l'ordre de 67,000 à 117,000 USD de calcul loué. Le document SmolVLA estime son projet à environ 30,000 heures GPU sur 481 ensembles de données communautaires, 22.9K épisodes et 10.6M images. Vous héritez de tout cela pour le prix d'un téléchargement ; vos 8 USD achètent les 20,000 dernières étapes. Pourquoi les VLA sont construits de cette manière couvre cette répartition.

Le bras : un coût unique qui éclipse la facture GPU

Une session d'entraînement coûte moins cher qu'un déjeuner. Le robot, lui, non. C'est pourquoi le SO-100 est important : c'est le bras le moins cher que toute la apprentissage par imitation chaîne d'outils prend réellement en charge.

La nomenclature en amont dans le dépôt SO-ARM100 est plus granulaire et mérite d'être vérifiée en fonction de votre région : sa liste Pièces pour deux bras totalise 229.88 USD ou 226.30 EUR pour une configuration leader plus suiveur, et sa liste Pièces pour un bras suiveur totalise 121.94 USD ou 124.30 EUR. Six servos STS3215 à 13.89 USD chacun représentent 83.34 de ces 121.94, donc les servos constituent le bras. À 1 à 3 USD par exécution SmolVLA ou ACT, une paire de bras vaut entre 77 et 230 sessions d'entraînement. Si vous êtes encore en train de choisir, SO-100 contre SO-101 est la comparaison qui compte, car les deux sont suffisamment proches pour que la décision porte sur la disponibilité plutôt que sur la capacité.

Heures humaines : la ligne que personne ne met dans le tableur

C'est le chiffre qui bouleverse la discussion sur les coûts. L'enregistrement de démonstrations implique qu'une personne déplace un bras robotique, un épisode à la fois, en temps réel. Il n'y a pas de traitement par lots ni de location à la seconde. Le jeu de données LeRobot enregistreur est livré avec des valeurs par défaut qui facilitent l'arithmétique, toutes trois confirmées dans DatasetRecordConfig: 60 secondes par épisode, 60 secondes pour réinitialiser la scène, 50 épisodes. La colonne des coûts ci-dessous suppose 15 USD pour une heure de travail d'une personne, ce qui est une hypothèse plutôt qu'un chiffre de plateforme. Remplacez par votre propre taux ; le rapport est l'essentiel.

1. 1
   Enregistrez le jeu de données avec les valeurs par défaut qui vous seront réellement facturées

   Ceci est lerobot 0.6.1, la version sur PyPI au 3 août 2026. Notez la forme de la CLI : l'enregistrement s'effectue via le point d'entrée de la console lerobot-record (lerobot.scripts.lerobot_record), et non l'ancien chemin de module python -m lerobot.scripts.record. AY-Robots cible la version 0.5.1, et le wheel 0.5.1 déclare les mêmes points d'entrée lerobot-record et lerobot-train, donc la forme ci-dessous est stable pour les deux. Les trois drapeaux de temporisation sont les valeurs par défaut en amont, c'est donc aussi la commande que l'arithmétique du tableau suivant suppose.

   bash

   lerobot-record \
       --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} }" \
       --teleop.type=so100_leader \
       --teleop.port=/dev/ttyACM1 \
       --teleop.id=my_leader_arm \
       --dataset.repo_id=${HF_USER}/pick-place-cube \
       --dataset.num_episodes=50 \
       --dataset.episode_time_s=60 \
       --dataset.reset_time_s=60 \
       --dataset.single_task="Grab the black cube and put it in the bin"

2. 2
   Examinez ce que vous avez enregistré avant de louer une seule minute de GPU

   L'inspection d'un jeu de données coûte zéro USD par heure. Découvrir le même problème à partir d'une courbe de perte coûte 2.00 USD par heure sur le niveau H100 et vous le dit quatre heures trop tard. Poussez le jeu de données et examinez-le dans la visionneuse LeRobot, ou parcourez le répertoire de jeux de données d'AY-Robots.

   bash

   # the recorder pushes to the Hub by default; disable with --dataset.push_to_hub=False
   echo https://huggingface.co/datasets/${HF_USER}/pick-place-cube
   
   # then open https://huggingface.co/spaces/lerobot/visualize_dataset
   # and scrub through episodes: are both camera streams alive on every episode?
   # is the gripper actually closing? does the arm sit at a joint limit?

3. 3
   Entraînez-vous et assurez-vous que le point de contrôle survit au pod

   Une machine louée est temporaire par définition, alors écrivez les points de contrôle quelque part de durable pendant l'exécution. Deux drapeaux décident si vous conservez ce pour quoi vous avez payé. --save_freq est par défaut à 20 000 étapes, donc une exécution SmolVLA par défaut de 20 000 étapes écrit son premier point de contrôle lorsque l'exécution est déjà terminée ; réduisez-le avant de louer quoi que ce soit d'interruptible. --save_checkpoint_to_hub nécessite --policy.repo_id et n'existe pas dans lerobot 0.5.1, donc sur cette version, vous copiez vous-même le répertoire de sortie de la machine. La taille de lot ci-dessous est l'exemple de la documentation en amont ; le formulaire AY-Robots envoie 2 pour SmolVLA et écrit dans le stockage d'objets au fur et à mesure que les points de contrôle apparaissent.

   bash

   lerobot-train \
       --policy.path=lerobot/smolvla_base \
       --dataset.repo_id=${HF_USER}/pick-place-cube \
       --batch_size=64 \
       --steps=20000 \
       --save_freq=2000 \
       --output_dir=outputs/train/my_smolvla \
       --job_name=my_smolvla_training \
       --policy.device=cuda \
       --policy.repo_id=${HF_USER}/my_smolvla \
       --save_checkpoint_to_hub=true

Comparez la colonne de droite avec les 1 à 12 USD que coûte l'exécution. À ce taux supposé, un ensemble de données de 50 épisodes coûte deux à sept fois plus cher à enregistrer qu'à entraîner, avant la calibration, la configuration de la caméra et les épisodes que vous jetez. C'est pourquoi a une valeur monétaire directe. Le guide lerobot suggère au moins 50 épisodes avec 10 par emplacement d'objet ; la documentation SmolVLA rapporte qu'une version de 25 épisodes de la même tâche n'était pas suffisante.

Où l'argent disparaît réellement

1. Exécutions sur des données qui n'auraient jamais fonctionné

Une exécution GR00T de 20 000 étapes sur un ensemble de données avec deux flux de caméra inversés coûte le même prix qu'une exécution sur un ensemble de données propre, prend le même temps et produit une courbe de perte qui semble correcte. La défaillance apparaît sur le bras, des heures plus tard. sont facturées à l'heure et le diagnostic est facturé en jours. Deux symptômes à mémoriser : signifie généralement que les observations ne contiennent pas ce dont la tâche a besoin, et signifie que l'ensemble de données avait moins de variation que vous ne le pensiez.

2. Payer les prix des modèles de fondation pour une tâche à caméra fixe

ACT compte environ 80 millions de paramètres et a été conçu pour être entraîné à partir de zéro sur 50 démonstrations d'une seule tâche. GR00T N1.7 compte environ 3 milliards de paramètres avec un backbone pré-entraîné. Pour une caméra fixe, une table fixe et un seul objet, le modèle de 80 millions de paramètres y parvient fréquemment, s'exécute à environ 20 ms par étape d'action au lieu de 152 ms, et coûte de 1 à 3 USD par exécution au lieu de 4 à 12. Dépensez 3 USD pour savoir si le modèle bon marché fonctionne avant de dépenser 12 USD pour le modèle coûteux. ACT contre SmolVLA et GR00T N1.7 contre Pi0.5 montrent où chacun cesse d'être la bonne réponse ; l'arène des modèles contient 85 modèles et 332 résultats de benchmark.

3. Le GPU que vous avez oublié

L'erreur la moins chère à éviter et la plus courante à commettre. Une instance démarrée un vendredi pour déboguer quelque chose est facturée tout le week-end au même tarif qu'une exécution réelle.

Sur AY-Robots, cette défaillance est éliminée pour l'inférence : les pods provisionnés par l'API d'inférence intègrent un chien de garde d'inactivité et se détruisent après une période d'inactivité. Si vous louez la carte vous-même, ce chien de garde est votre rappel de calendrier.

4. Payer deux fois pour la même réponse

Le point d'entrée du fine-tuning de GR00T est une interface CLI tyro qui n'expose aucune graine. Ce n'est pas une limitation de la plateforme, c'est l'outil en amont : il n'y a pas de champ de graine dans gr00t/configs/finetune_config.py, et les conseils d'entraînement du dépôt avertissent que les exécutions varient de 5 à 6 pour cent car les augmentations d'image sont non déterministes. lerobot utilise par défaut la graine 1000 dans les versions 0.5.1 et 0.6.1, de sorte que les exécutions ACT, SmolVLA et Pi0.5 peuvent au moins être relancées à partir de la même initialisation et du même ordre de données. Ce n'est pas une promesse de poids bit-identiques sur un GPU, mais c'est la différence entre une relance et une nouvelle expérience. Si une exécution GR00T produit une politique qui fonctionne et que vous n'avez pas conservé le point de contrôle, vous payez le prix fort pour un résultat qui peut différer de plus que la différence que vous recherchiez. Il existe une deuxième façon de perdre un point de contrôle pour lequel vous avez payé : la CLI utilise par défaut --save-total-limit 5, documenté comme le nombre maximal de points de contrôle conservés avant que les plus anciens ne soient supprimés. Le stockage coûte des centimes ; une relance coûte de 4 à 12 USD et six heures.

Le faire soi-même ou laisser la plateforme louer la carte

# GR00T N1.7, single GPU, Isaac-GR00T as of August 2026.
# Note the entry point: gr00t/experiment/launch_finetune.py, a tyro CLI.
# scripts/gr00t_finetune.py does not exist in this repository; tutorials that
# still reference it are stale. The per-embodiment walkthrough is
# getting_started/finetune_new_embodiment.md.
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 ./so100-checkpoints \
    --max-steps 20000 \
    --global-batch-size 32 \
    --dataloader-num-workers 4

# v3.0 dataset? Convert it down first or the loader will crash. The helper
# has its own pyproject and must be installed in its own environment:
cd scripts/lerobot_conversion
uv venv && source .venv/bin/activate
uv pip install -e .
python convert_v3_to_v2.py --repo-id <DATASET_REPO_ID>

Ce que la plateforme facture et comment elle choisit la carte

La logique est délibérément simple. Chaque modèle du catalogue, déclare un niveau de GPU ; le backend prend la VRAM requise et loue une carte correspondante sur le même marché spot mesuré ci-dessus. C'est pourquoi le coût indiqué est une fourchette, et non un prix fixe. GR00T et Pi0.5 sont uniquement disponibles dans le cloud ici en raison des seuils de 40 Go et 70 Go. SmolVLA et ACT fonctionnent également localement sur votre propre carte de 24 Go, où le coût du cloud est nul et l'électricité est votre problème.

Un paramètre mérite une mise en garde. L'accumulation de gradient s'applique réellement aux deux variantes de GR00T, donc l'augmenter permet d'obtenir un lot effectif plus grand sur la même carte. Pour Pi0.5 et SmolVLA, cela ne s'applique pas du tout : lerobot 0.5.1 n'a pas d'option d'accumulation de gradient dans sa configuration d'entraînement, donc définir le champ à 16 ne coûte rien et n'apporte rien. Si un travail en file d'attente ne démarre jamais, la page des travaux bloqués en file d'attente couvre ce qu'il faut vérifier ; si le jeu de données est rejeté avant le début de l'exécution, il s'agit presque toujours de le problème de format v3.0.

Un budget détaillé pour une première politique fonctionnelle

Les quatre lignes ensemble, en partant de zéro. Le total GPU suppose 3 à 5 exécutions : la première prouve que le pipeline fonctionne, la seconde révèle un problème de données, la troisième ou la quatrième est celle que vous conservez.

Le schéma se maintient à cette taille de robot : le calcul est une erreur d'arrondi, le matériel est un coût unique réel, les heures humaines sont la dépense récurrente. Pour tester la partie entraînement avant d'acheter quoi que ce soit, vous permettent de comparer des modèles et de louer un GPU sans bras, et est un SO-100 physique que vous pouvez piloter dans le navigateur sans inscription. Pour l'ensemble du pipeline de bout en bout, le couvre la configuration, et l'entraînement, et est la version courte.