VLA Træningsomkostninger: Hvad en finjusteringskørsel virkelig koster

Regningen har fire poster, og GPU'en er den mindste

Når folk spørger, hvad det koster at finjustere en vision-sprog-handlingsmodel, til en SO-100, mener de næsten altid GPU-lejen. Det er det tal, der vises som en opkrævning på et kort, så det er det, der føles virkeligt. Det er også, med stor margin, det mindste af de fire tal, der afgør, hvad en fungerende politik faktisk koster dig.

Træningstiderne nedenfor kommer fra de fem modellers egne papirer og repositories, hardwareomkostninger fra den offentliggjorte stykliste, platformstal fra AY-Robots politik-katalog og prisside. Hvor platformen ikke hjælper, er det angivet i denne artikel.

Hvad en GPU-time faktisk koster på spotmarkedet

Der er ingen enkeltpris for en A100-time. På en markedsplads som vast.ai sætter hver vært sin egen pris, og den træningskørsel du starter, lander på den maskine, der er billig og ledig i det øjeblik. Det ærlige svar er en fordeling. Her er den, målt den 23. august 2026 kl. 13:44 UTC: enkelte fulde kort, on demand, filtreret efter reel 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

Hvorfor 3B-modellerne ikke kan bruge det billige kort

En 4090-time og en H100 80 GB-time adskiller sig med cirka seks gange ved de ovenstående medianer. Det, der tvinger dig over på det dyre kort, er ikke hastighed, det er hukommelse. openpi sætter minimumskravet for en fuld Pi0.5 finjustering til 70 GB, og NVIDIA anbefaler 40 GB eller mere til GR00T. Bemærk, hvad GR00T-tallet ikke er. Dets finjusteringskonfiguration fryser sprogmodellen og den visuelle encoder som standard (tune_llm og tune_visual er False, projektoren og diffusion head True), hvilket er grunden til, at kataloget angiver cirka 40 M trænede parametre ud af 3 B. De 40 GB er ikke optimizer-tilstand for 3 B vægte, det er den frosne backbone plus aktiveringer. Varianter med reduceret omfang falder lavere: openpis LoRA-sti kræver 22,5 GB og nævner 4090, og NVIDIAs Isaac Lab Arena-workflow angiver en 24 GB single-GPU-mulighed for GR00T eftertræning. Platformen inddeler sig efter det minimumskrav, hver leverandør offentliggør for den konfiguration, den faktisk kører. pi0 flow-matching-artiklen forklarer, hvor det flow-matching fodaftryk kommer fra.

Denne tabel er grunden til, at platformen opdeler de fem modeller i to niveauer. GR00T N1.7, GR00T N1.5 og Pi0.5 kører på A100 80 GB eller H100, fordi det er, hvad leverandørerne kræver. SmolVLA og ACT kører på et RTX 4090 eller et hvilket som helst 24 GB kort, fordi det er tilstrækkeligt.

Hvor længe hver af de fem modeller faktisk kører

Køretid er den anden halvdel af omkostningen: 2.00 USD per time er irrelevant, hvis jobbet er 40 minutter, og ødelæggende, hvis det er 40 timer. Dette er standardindstillingerne, som AY-Robots faktisk sender til træneren, med kørselsvinduet og omkostningerne for hvert niveau.

Hvor disse kørselsvinduer kommer fra opstrøms

• SmolVLA: lerobot-dokumentationen angiver, at 20.000 trin tager cirka 4 timer på en enkelt A100. Platformen kører de samme 20.000 trin på den billigere 24 GB-tier, deraf et vindue snarere end flade 4 timer.
• ACT: den originale ALOHA-artikel rapporterer omkring 5 timer på et enkelt 11 GB RTX 2080 Ti for en model med 80M parametre. Et 4090 er flere generationer nyere, men platformen budgetterer 100.000 trin, så vinduet lander samme sted.
• GR00T: NVIDIAs reference-workflow for N1.6-generationen angiver cirka 4 til 8 timer for 20.000 trin ved batch 24 på otte L40S-kort, og 2 til 3 timer for 30.000 trin ved batch 16 på et enkelt Ada 6000. Enkeltkort-finjustering af en 3B VLA på få timer er normalt, ikke optimistisk.
• Pi0.5: openpi offentliggør ingen wall-clock-tal, men den offentliggør dog 70 GB-gulvet for en fuld finjustering, hvilket fastlægger kortet og dermed hastigheden.

Det er værd at stoppe op ved det tal, du ikke betaler. GR00T N1-artiklen rapporterer cirka 50.000 H100 GPU-timer til fortræning af 2.2B-modellen på en klynge af op til 1024 GPU'er, med en fortræningsbatchstørrelse på 16.384 for 200.000 gradienttrin. Med de 1.34 til 2.34 USD per time målt ovenfor er det i størrelsesordenen 67.000 til 117.000 USD i lejet computerkraft. SmolVLA-artiklen anslår sit projekt til cirka 30.000 GPU-timer fordelt på 481 fællesskabsdatasæt, 22.9K episoder og 10.6M frames. Du arver det hele til prisen for en download; dine 8 USD køber de sidste 20.000 trin. Hvorfor VLA'er er bygget på denne måde dækker den opdeling.

Armen: en engangsomkostning, der overskygger GPU-regningen

En træningskørsel koster mindre end frokost. Robotten gør ikke. Derfor er SO-100 vigtig: det er den billigste arm, som hele imitation learning værktøjskæden faktisk understøtter.

Den overordnede stykliste i SO-ARM100-lageret er mere detaljeret og værd at tjekke op mod din region: dens Parts For Two Arms liste udgør i alt 229,88 USD eller 226,30 EUR for en leder- plus følgeropsætning, og dens Parts for One Follower Arm liste udgør i alt 121,94 USD eller 124,30 EUR. Seks STS3215 servomotorer til 13,89 USD stykket udgør 83,34 af de 121,94, så servomotorerne er armen. Med 1 til 3 USD pr. SmolVLA- eller ACT-kørsel er et par arme mellem 77 og 230 træningskørsler værd. Hvis du stadig vælger, er SO-100 mod SO-101 den sammenligning, der betyder noget, fordi de to er tæt nok på hinanden til, at beslutningen handler om tilgængelighed snarere end kapacitet.

Mennesketimer: den linje ingen sætter i regnearket

Dette er tallet, der vender omkostningsdiskussionen på hovedet. Optagelse af demonstrationer er en person, der bevæger en robotarm, én episode ad gangen, i realtid. Der er ingen batching af det, og ingen udlejning på sekundbasis. LeRobot datasæt optageren leveres med standardindstillinger, der gør regnestykket nemt, alle tre bekræftet i DatasetRecordConfig: 60 sekunder pr. episode, 60 sekunder til at nulstille scenen, 50 episoder. Pengekolonnen nedenfor antager 15 USD for en times arbejde, hvilket er en antagelse snarere end et platformstal. Erstat med din egen sats; forholdet er pointen.

1. 1
   Optag datasættet med de standardindstillinger, du faktisk vil blive faktureret for

   Dette er lerobot 0.6.1, versionen på PyPI pr. 3. august 2026. Bemærk CLI-formen: optagelse kører via lerobot-record konsolindgangspunktet (lerobot.scripts.lerobot_record), ikke den gamle python -m lerobot.scripts.record modulsti. AY-Robots sigter mod 0.5.1, og 0.5.1-hjulet erklærer de samme lerobot-record og lerobot-train indgangspunkter, så formen nedenfor er stabil på tværs af begge. De tre timing-flags er standardindstillingerne, så dette er også kommandoen, som regnestykket i den næste tabel antager.

   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
   Se på, hvad du har optaget, før du lejer et eneste GPU-minut

   Inspektion af et datasæt koster nul USD i timen. At opdage det samme problem fra en tabskurve koster 2.00 USD i timen på H100-niveauet og fortæller dig det fire timer for sent. Push datasættet og gennemgå det i LeRobot-viseren, eller gennemse AY-Robots datasætmappe.

   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
   Træn, og sørg for, at checkpointet overlever pod'en

   En lejet maskine er pr. definition midlertidig, så skriv checkpoints et holdbart sted under kørslen. To flags afgør, om du beholder det, du har betalt for. --save_freq er som standard 20.000 trin, så en standard 20.000-trins SmolVLA-kørsel skriver sit første checkpoint, når kørslen allerede er slut; sænk det, før du lejer noget, der kan afbrydes. --save_checkpoint_to_hub kræver --policy.repo_id og findes ikke i lerobot 0.5.1, så på den version kopierer du selv outputmappen fra maskinen. Batchstørrelsen nedenfor er eksemplet fra den oprindelige dokumentation; AY-Robots-formularen sender 2 for SmolVLA og skriver til objektlager, efterhånden som checkpoints vises.

   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

Sammenlign den højre kolonne med de 1 til 12 USD, som kørslen koster. Med den antagne sats koster et datasæt med 50 episoder to til syv gange så meget at optage, som det koster at træne på, før kalibrering, kameraopsætning og de episoder, du kasserer. Derfor har en direkte økonomisk værdi. LeRobot-guiden foreslår mindst 50 episoder med 10 pr. objektplacering; SmolVLA-dokumentationen rapporterer, at en 25-episode version af den samme opgave ikke var nok.

Hvor pengene reelt forsvinder

1. Kørsel på data, der aldrig ville have virket

En 20.000-trins GR00T-kørsel på et datasæt med to ombyttede kamerastrømme koster det samme som en på et rent datasæt, tager lige lang tid og producerer en tabskurve, der ser fin ud. Fejlen viser sig på armen, timer senere. faktureres pr. time, og diagnose faktureres i dage. To symptomer, der er værd at huske: betyder normalt, at observationerne ikke indeholder det, opgaven kræver, og betyder, at datasættet havde mindre variation, end du troede.

2. Betaling af grundmodelpriser for en opgave med fast kamera

ACT er cirka 80M parametre og blev designet til at træne fra bunden på 50 demonstrationer af én opgave. GR00T N1.7 er cirka 3B med en fortrænet backbone. For et fastmonteret kamera, et fast bord og ét objekt, når 80M-modellen ofte målet, kører med omkring 20 ms per handlingstrin i stedet for 152 ms, og koster 1 til 3 USD per kørsel i stedet for 4 til 12. Brug 3 USD på at finde ud af, om den billige model virker, før du bruger 12 USD på den dyre. ACT mod SmolVLA og GR00T N1.7 mod Pi0.5 viser, hvor hver især holder op med at være det rigtige svar; modelarenaen har 85 modeller og 332 benchmarkresultater.

3. Den GPU, du glemte

Den billigste fejl at forhindre og den mest almindelige at begå. En instans, der startes en fredag for at fejlfinde noget, faktureres gennem weekenden til samme pris som en reel kørsel.

På AY-Robots er denne fejl elimineret for inferens: pods, der er klargjort af inferens-API'en, har en inaktiv watchdog og ødelægger sig selv efter en inaktiv periode. Hvis du selv lejer kortet, er den watchdog din kalenderpåmindelse.

4. Betaling to gange for det samme svar

GR00T's finjusteringsindgangspunkt er en tyro CLI, der ikke eksponerer noget seed. Dette er ikke en platformsbegrænsning, det er det opstrøms værktøj: der er intet seed-felt i gr00t/configs/finetune_config.py, og repositoryets egne træningstips advarer om, at kørsler varierer med 5 til 6 procent, fordi billedforbedringerne er ikke-deterministiske. lerobot bruger som standard seed 1000 i både 0.5.1 og 0.6.1, så ACT-, SmolVLA- og Pi0.5-kørsler kan i det mindste genkøres fra den samme initialisering og datarækkefølge. Dette er ikke et løfte om bit-identiske vægte på en GPU, men det er forskellen mellem en genkørsel og et nyt eksperiment. Hvis en GR00T-kørsel producerer en politik, der virker, og du ikke gemte kontrolpunkt, betaler du fuld pris for et resultat, der kan afvige mere end den forskel, du jagtede. Der er en anden måde at miste et kontrolpunkt, du har betalt for: CLI'en bruger som standard --save-total-limit 5, dokumenteret som det maksimale antal kontrolpunkter, der beholdes, før ældre slettes. Lagring koster øre; en genkørsel koster 4 til 12 USD og seks timer.

Gør det selv versus at lade platformen leje kortet

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

Hvad platformen opkræver, og hvordan den vælger kortet

Logikken er bevidst kedelig. Hver model i kataloget erklærer et GPU-niveau; backend tager den nødvendige VRAM og lejer et matchende kort på det samme spotmarked, som målt ovenfor. Derfor er den angivne pris et interval, ikke en fast pris. GR00T og Pi0.5 er kun tilgængelige i skyen her på grund af grænserne på 40 GB og 70 GB. SmolVLA og ACT kører også lokalt på dit eget 24 GB kort, hvor cloud-omkostningerne er nul, og elektriciteten er dit problem.

Én indstilling fortjener en advarsel. Gradientakkumulering gælder reelt for begge GR00T-varianter, så ved at øge den opnår man en større effektiv batch på det samme kort. For Pi0.5 og SmolVLA gælder det slet ikke: lerobot 0.5.1 har ingen gradientakkumuleringsmulighed i sin træningskonfiguration, så at sætte feltet til 16 koster intet og giver intet. Hvis et job i kø aldrig starter, siden om fastlåste job i køen dækker, hvad man skal tjekke; hvis datasættet afvises, før kørslen begynder, er det næsten altid v3.0 formatproblemet.

Et udarbejdet budget for en første fungerende politik

Alle fire linjer samlet, startende fra ingenting. GPU-totalen antager 3 til 5 kørsler: den første beviser, at pipelinen virker, den anden afslører et dataproblem, den tredje eller fjerde er den, du beholder.

Mønsteret holder ved denne robotstørrelse: beregning er en afrundingsfejl, hardware er en reel engangsomkostning, menneskelige timer er den tilbagevendende udgift. For at teste træningsdelen, før du køber noget, lader dig sammenligne modeller og leje en GPU uden en arm, og er en fysisk SO-100, du kan styre i browseren uden tilmelding. For hele pipelinen fra start til slut, dækker den opsætning, og træning, og er den korte version.