VLA Trainingskosten: Wat een Fine-Tuning Run Echt Kost

De rekening heeft vier posten, en de GPU is de kleinste

Wanneer mensen vragen wat het kost om een visie-taal-actie-model voor een SO-100 te fine-tunenen, bedoelen ze bijna altijd de GPU-huur. Dat is het bedrag dat als kostenpost op een kaart verschijnt, dus dat voelt reëel. Het is ook, met een ruime marge, het kleinste van de vier getallen die bepalen wat een werkend beleid je daadwerkelijk kost.

De trainingstijden hieronder komen uit de eigen papers en repositories van de vijf modellen, de hardwarekosten uit de gepubliceerde stuklijst, en de platformnummers van de AY-Robots beleidscatalogus en prijslijstpagina. Waar het platform niet helpt, vermeldt dit artikel dat.

Wat een GPU-uur daadwerkelijk kost op de spotmarkt

Er is geen vaste prijs voor een A100-uur. Op een marktplaats zoals vast.ai stelt elke host zijn eigen tarief in, en de trainingsrun die u start, komt terecht op de machine die op dat moment goedkoop en vrij is. Het eerlijke antwoord is een verdeling. Hier is het, gemeten op 23 augustus 2026 om 13:44 UTC: enkele volledige kaarten, on demand, gefilterd op werkelijk VRAM.

# 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

Waarom de 3B modellen de goedkope kaart niet kunnen gebruiken

Een 4090-uur en een H100 80 GB-uur verschillen ruwweg zes keer bij de bovengenoemde medianen. Wat je dwingt tot de dure kaart is niet snelheid, het is geheugen. openpi stelt de ondergrens voor een volledige Pi0.5 fine-tune op 70 GB, en NVIDIA beveelt 40 GB of meer aan voor GR00T. Merk op wat het GR00T-getal niet is. De fine-tune configuratie bevriest standaard het taalmodel en de visuele encoder (tune_llm en tune_visual zijn False, de projector en de diffusiekop True), daarom vermeldt de catalogus ruwweg 40 M getrainde parameters van de 3 B. De 40 GB is geen optimizer-status voor 3 B gewichten, het is de bevroren backbone plus activaties. Varianten met een kleinere scope vragen minder: openpi's LoRA-pad wil 22.5 GB en noemt de 4090, en NVIDIA's Isaac Lab Arena workflow vermeldt een 24 GB single-GPU optie voor GR00T post-training. Het platform baseert de lagen op de ondergrens die elke leverancier publiceert voor de configuratie die het daadwerkelijk draait. De pi0 flow-matching uiteenzetting legt uit waar die flow-matching voetafdruk vandaan komt.

Die tabel is de reden waarom het platform de vijf modellen in twee lagen verdeelt. GR00T N1.7, GR00T N1.5 en Pi0.5 draaien op A100 80 GB of H100 omdat dat is wat de leveranciers vragen. SmolVLA en ACT draaien op een RTX 4090 of elke 24 GB kaart omdat dat echt voldoende is.

Hoe lang elk van de vijf modellen daadwerkelijk draait

De looptijd is de andere helft van de kosten: 2.00 USD per uur is irrelevant als de taak 40 minuten duurt en ruïneus als deze 40 uur duurt. Dit zijn de standaardinstellingen die AY-Robots daadwerkelijk naar de trainer stuurt, met het uitvoervenster en de kosten voor elke laag.

Waar die uitvoervensters vandaan komen stroomopwaarts

• SmolVLA: de lerobot-documentatie stelt dat 20.000 stappen ongeveer 4 uur duren op een enkele A100. Het platform draait dezelfde 20.000 stappen op de goedkopere 24 GB-laag, vandaar een venster in plaats van een vaste 4 uur.
• ACT: het originele ALOHA-paper rapporteert ongeveer 5 uur op een enkele 11 GB RTX 2080 Ti voor een model met 80M parameters. Een 4090 is enkele generaties nieuwer, maar het platform budgetteert 100.000 stappen, dus het venster komt op dezelfde plek uit.
• GR00T: NVIDIA's referentieworkflow voor de N1.6-generatie vermeldt ongeveer 4 tot 8 uur voor 20.000 stappen bij batch 24 op acht L40S-kaarten, en 2 tot 3 uur voor 30.000 stappen bij batch 16 op een enkele Ada 6000. Fine-tuning van een 3B VLA op één kaart in een paar uur is normaal, niet optimistisch.
• Pi0.5: openpi publiceert geen 'wall-clock' cijfer, maar het publiceert wel de 70 GB ondergrens voor een volledige fine-tune, wat de kaart en daarmee de snelheid vastlegt.

Het is de moeite waard stil te staan bij het bedrag dat u niet betaalt. Het GR00T N1-paper rapporteert ongeveer 50.000 H100 GPU-uren om het 2.2B-model voor te trainen, op een cluster van maximaal 1024 GPU's, met een pretraining batchgrootte van 16.384 voor 200.000 gradiëntstappen. Tegen de hierboven gemeten 1,34 tot 2,34 USD per uur komt dat neer op ongeveer 67.000 tot 117.000 USD aan gehuurde rekenkracht. Het SmolVLA-paper schat het project op ongeveer 30.000 GPU-uren verdeeld over 481 community-datasets, 22.9K afleveringen en 10.6M frames. U erft dit alles voor de prijs van een download; uw 8 USD koopt de laatste 20.000 stappen. Waarom VLA's op deze manier zijn gebouwd behandelt die opsplitsing.

De arm: een eenmalige kostenpost die de GPU-rekening overschaduwt

Een trainingsrun kost minder dan lunch. De robot niet. Daarom is de SO-100 belangrijk: het is de goedkoopste arm die de hele imitatieleer toolchain daadwerkelijk ondersteunt.

De upstream stuklijst in de SO-ARM100 repository is gedetailleerder en de moeite waard om te controleren voor uw regio: de Onderdelen Voor Twee Armen lijst bedraagt in totaal 229.88 USD of 226.30 EUR voor een leider-plus-volger opstelling, en de Onderdelen voor Eén Volgerarm lijst bedraagt in totaal 121.94 USD of 124.30 EUR. Zes STS3215 servo's van elk 13.89 USD zijn 83.34 van die 121.94, dus de servo's zijn de arm. Met 1 tot 3 USD per SmolVLA of ACT run is één paar armen tussen de 77 en 230 trainingsruns waard. Als u nog steeds kiest, SO-100 versus SO-101 is de vergelijking die ertoe doet, omdat de twee dicht genoeg bij elkaar liggen dat de beslissing gaat over beschikbaarheid in plaats van capaciteit.

Menselijke uren: de regel die niemand in de spreadsheet zet

Dit is het getal dat de kostenbespreking op zijn kop zet. Het opnemen van demonstraties is een persoon die een robotarm beweegt, één episode tegelijk, in realtime. Er is geen batchverwerking en geen verhuur per seconde. De LeRobot dataset recorder wordt geleverd met standaardinstellingen die de berekening eenvoudig maken, alle drie bevestigd in DatasetRecordConfig: 60 seconden per episode, 60 seconden om de scène te resetten, 50 episodes. De geldkolom hieronder gaat uit van 15 USD voor een uur van iemands tijd, wat een aanname is in plaats van een platformgetal. Vervang dit door uw eigen tarief; de verhouding is het punt.

1. 1
   Neem de dataset op met de standaardinstellingen waarvoor u daadwerkelijk wordt gefactureerd

   Dit is lerobot 0.6.1, de versie op PyPI per 3 augustus 2026. Let op de CLI-vorm: opnemen gebeurt via het lerobot-record console-ingangspunt (lerobot.scripts.lerobot_record), niet via het oude python -m lerobot.scripts.record modulepad. AY-Robots richt zich op 0.5.1, en de 0.5.1 wheel declareert dezelfde lerobot-record en lerobot-train ingangspunten, dus de onderstaande vorm is stabiel voor beide. De drie timing-flags zijn de upstream-standaardwaarden, dus dit is ook de opdracht die de berekening in de volgende tabel aanneemt.

   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
   Bekijk wat u heeft opgenomen voordat u één GPU-minuut huurt

   Het inspecteren van een dataset kost nul USD per uur. Het ontdekken van hetzelfde probleem aan de hand van een loss curve kost 2.00 USD per uur op de H100-tier en vertelt u vier uur te laat. Push de dataset en bekijk deze in de LeRobot viewer, of blader door de AY-Robots dataset directory.

   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
   Train, en zorg ervoor dat het checkpoint de pod overleeft

   Een gehuurde machine is per definitie tijdelijk, dus schrijf checkpoints ergens duurzaam weg tijdens de uitvoering. Twee flags bepalen of u behoudt waarvoor u heeft betaald. --save_freq is standaard 20.000 stappen, dus een standaard 20.000-stappen SmolVLA-run schrijft zijn eerste checkpoint wanneer de run al voorbij is; verlaag dit voordat u iets onderbreekbaars huurt. --save_checkpoint_to_hub vereist --policy.repo_id en bestaat niet in lerobot 0.5.1, dus op die versie kopieert u de uitvoermap zelf van de machine. De batchgrootte hieronder is het voorbeeld uit de upstream-documentatie; het AY-Robots formulier stuurt 2 voor SmolVLA en schrijft naar objectopslag zodra checkpoints verschijnen.

   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

Vergelijk de rechterkolom met de 1 tot 12 USD die de run kost. Tegen dat veronderstelde tarief kost een dataset van 50 afleveringen twee tot zeven keer zoveel om op te nemen als om op te trainen, vóór kalibratie, camera-instelling en de afleveringen die je weggooit. Daarom heeft een directe geldwaarde. De lerobot-gids suggereert minstens 50 afleveringen met 10 per objectlocatie; de SmolVLA-documentatie meldt dat een 25-afleveringenversie van dezelfde taak niet voldoende was.

Waar het geld daadwerkelijk verdwijnt

1. Runs op gegevens die nooit zouden werken

Een GR00T-run van 20.000 stappen op een dataset met twee verwisselde camerastreams kost hetzelfde als een run op een schone dataset, duurt even lang en produceert een verliescurve die er goed uitziet. De storing verschijnt uren later op de arm. worden per uur gefactureerd en diagnose wordt in dagen gefactureerd. Twee symptomen die het waard zijn om te onthouden: betekent meestal dat de waarnemingen niet bevatten wat de taak nodig heeft, en betekent dat de dataset minder variatie had dan je dacht.

2. Foundation-model prijzen betalen voor een taak met vaste camera

ACT heeft ongeveer 80M parameters en is ontworpen om vanaf nul te trainen op 50 demonstraties van één taak. GR00T N1.7 heeft ongeveer 3B parameters met een voorgegetrainde backbone. Voor een vastgeschroefde camera, een vaste tafel en één object, bereikt het 80M model vaak het doel, draait het met ongeveer 20 ms per actiestap in plaats van 152 ms, en kost het 1 tot 3 USD per run in plaats van 4 tot 12. Besteed 3 USD om erachter te komen of het goedkope model werkt voordat u 12 USD uitgeeft aan het dure model. ACT versus SmolVLA en GR00T N1.7 versus Pi0.5 laten zien waar elk ophoudt het juiste antwoord te zijn; de modelarena heeft 85 modellen en 332 benchmarkresultaten.

3. De GPU die u vergeten bent

De goedkoopste fout om te voorkomen en de meest voorkomende om te maken. Een instantie die op een vrijdag is gestart om iets te debuggen, wordt het hele weekend gefactureerd tegen hetzelfde tarief als een echte run.

Op AY-Robots is deze fout voor inferentie uitgesloten: pods die door de inferentie-API worden geleverd, hebben een inactieve watchdog en vernietigen zichzelf na een inactieve periode. Als u de kaart zelf huurt, is die watchdog uw agendaherinnering.

4. Twee keer betalen voor hetzelfde antwoord

Het fine-tuning toegangspunt van GR00T is een tyro CLI die geen seed blootstelt. Dat is geen platformbeperking, het is de upstream tool: er is geen seed-veld in gr00t/configs/finetune_config.py, en de eigen trainingstips van de repository waarschuwen dat runs 5 tot 6 procent variëren omdat de beeldaugmentaties niet-deterministisch zijn. lerobot gebruikt standaard seed 1000 in zowel 0.5.1 als 0.6.1, zodat ACT, SmolVLA en Pi0.5 runs op zijn minst opnieuw kunnen worden uitgevoerd met dezelfde initialisatie en datavolgorde. Dat is geen belofte van bit-identieke gewichten op een GPU, maar het is het verschil tussen een heruitvoering en een nieuw experiment. Als een GR00T run een beleid produceert dat werkt en u hebt de checkpoint, betaalt u de volle prijs voor een resultaat dat meer kan verschillen dan het verschil dat u zocht. Er is een tweede manier om een betaald checkpoint te verliezen: de CLI gebruikt standaard --save-total-limit 5, gedocumenteerd als het maximale aantal checkpoints dat wordt bewaard voordat oudere worden verwijderd. Opslag kost centen; een heruitvoering kost 4 tot 12 USD en zes uur.

Zelf doen versus het platform de kaart laten huren

# 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>

Wat het platform in rekening brengt en hoe het de kaart kiest

De logica is opzettelijk saai. Elk model in de catalogus declareert een GPU-tier; de backend neemt het benodigde VRAM en huurt een bijpassende kaart op dezelfde hierboven gemeten spotmarkt. Daarom is de opgegeven kosten een bereik, geen prijs. GR00T en Pi0.5 zijn hier alleen cloud-gebaseerd vanwege de 40 GB en 70 GB ondergrenzen. SmolVLA en ACT draaien ook lokaal op je eigen 24 GB kaart, waar de cloudkosten nul zijn en de elektriciteit jouw probleem is.

Eén instelling verdient een waarschuwing. Gradiëntaccumulatie is werkelijk van toepassing op beide GR00T-varianten, dus het verhogen ervan levert een grotere effectieve batch op dezelfde kaart op. Voor Pi0.5 en SmolVLA is het helemaal niet van toepassing: lerobot 0.5.1 heeft geen gradiëntaccumulatie-optie in zijn trainingsconfiguratie, dus het instellen van het veld op 16 kost niets en levert niets op. Als een in de wachtrij geplaatst proces nooit start, de pagina over vastgelopen taken in de wachtrij behandelt wat je moet controleren; als de dataset wordt geweigerd voordat de run begint, is het bijna altijd het v3.0 formaatprobleem.

Een uitgewerkt budget voor een eerste werkend beleid

Alle vier de regels samen, beginnend vanaf nul. Het GPU-totaal gaat uit van 3 tot 5 runs: de eerste bewijst dat de pijplijn werkt, de tweede legt een dataprobbleem bloot, de derde of vierde is degene die u behoudt.

Het patroon geldt ook voor robots van dit formaat: rekenkracht is een afrondingsfout, hardware is een reële eenmalige kostenpost, menselijke uren zijn de terugkerende uitgave. Om de trainingshelft te testen voordat u iets koopt, laten u modellen vergelijken en een GPU huren zonder een arm, en is een fysieke SO-100 die u in de browser kunt besturen zonder aanmelding. Voor de gehele end-to-end pijplijn, de behandelt de installatie, en training, en is de korte versie.