VLA Treningskostnad: Hva en finjusteringskjøring egentlig koster

Regningen har fire poster, og GPU-en er den minste

Når folk spør hva det koster å finjustere en visjon-språk-handling-modell for en SO-100, mener de nesten alltid GPU-leien. Det er tallet som vises som en belastning på et kort, så det er det som føles reelt. Det er også, med stor margin, det minste av de fire tallene som bestemmer hva en fungerende policy faktisk koster deg.

Treningstider nedenfor kommer fra de fem modellenes egne artikler og repositorier, maskinvarekostnad fra den publiserte stykklisten, plattformtall fra AY-Robots policykatalog og prisside. Der plattformen ikke hjelper, sier denne artikkelen ifra.

Hva en GPU-time faktisk koster på spotmarkedet

Det finnes ingen enkeltpris for en A100-time. På en markedsplass som vast.ai setter hver vert sin egen pris, og treningskjøringen du starter lander på den maskinen som er billig og ledig i det øyeblikket. Det ærlige svaret er en distribusjon. Her er den, målt 23. august 2026 kl. 13:44 UTC: enkeltkort, on demand, filtrert etter reell 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-modellene ikke kan bruke det billige kortet

En 4090-time og en H100 80 GB-time skiller seg med omtrent seks ganger ved medianene ovenfor. Det som tvinger deg over på det dyre kortet er ikke hastighet, det er minne. openpi setter minimumskravet for en full Pi0.5 finjustering til 70 GB, og NVIDIA anbefaler 40 GB eller mer for GR00T. Merk hva GR00T-tallet ikke er. Standardkonfigurasjonen for finjustering fryser språkmodellen og den visuelle koderen som standard (tune_llm og tune_visual er False, projektoren og diffusjonshodet True), noe som er grunnen til at katalogen viser omtrent 40 M trente parametere av 3 B. De 40 GB er ikke optimaliseringsstatus for 3 B vekter, det er den frosne ryggraden pluss aktiveringer. Varianter med redusert omfang krever mindre: openpis LoRA-sti krever 22.5 GB og nevner 4090, og NVIDIAs Isaac Lab Arena-arbeidsflyt lister opp et 24 GB enkelt-GPU-alternativ for GR00T ettertrening. Plattformen deler inn i nivåer basert på minimumskravene hver leverandør publiserer for konfigurasjonen den faktisk kjører. pi0 flow-matching-artikkelen forklarer hvor det flow-matching fotavtrykket kommer fra.

Denne tabellen er grunnen til at plattformen deler de fem modellene inn i to nivåer. GR00T N1.7, GR00T N1.5 og Pi0.5 kjører på A100 80 GB eller H100 fordi det er det leverandørene krever. SmolVLA og ACT kjører på et RTX 4090 eller et hvilket som helst 24 GB kort fordi det er tilstrekkelig.

Hvor lenge hver av de fem modellene faktisk kjører

Kjøretid er den andre halvdelen av kostnaden: 2.00 USD per time er irrelevant hvis jobben er 40 minutter og ødeleggende hvis den er 40 timer. Dette er standardinnstillingene AY-Robots faktisk sender til treneren, med kjørevinduet og kostnaden for hvert nivå.

Hvor disse kjøretidsvinduene kommer fra oppstrøms

• SmolVLA: lerobot-dokumentasjonen angir at 20 000 trinn tar omtrent 4 timer på en enkelt A100. Plattformen kjører de samme 20 000 trinnene på det billigere 24 GB-nivået, derav et vindu i stedet for flate 4 timer.
• ACT: den originale ALOHA-artikkelen rapporterer rundt 5 timer på en enkelt 11 GB RTX 2080 Ti for en modell med 80M parametere. Et 4090 er flere generasjoner nyere, men plattformen budsjetterer 100 000 trinn, så vinduet havner på samme sted.
• GR00T: NVIDIAs referansearbeidsflyt for N1.6-generasjonen angir omtrent 4 til 8 timer for 20 000 trinn med batch 24 på åtte L40S-kort, og 2 til 3 timer for 30 000 trinn med batch 16 på et enkelt Ada 6000. Finjustering av en 3B VLA på et enkelt kort i løpet av noen timer er normalt, ikke optimistisk.
• Pi0.5: openpi publiserer ingen faktisk tidsbruk, men de publiserer 70 GB-gulvet for en full finjustering, noe som fastsetter kortet og dermed hastigheten.

Verdt å stoppe opp ved tallet du ikke betaler. GR00T N1-artikkelen rapporterer omtrent 50 000 H100 GPU-timer for å forhåndstrene 2.2B-modellen, på et klyngesystem med opptil 1024 GPUer, med en forhåndstreningsbatchstørrelse på 16 384 for 200 000 gradienttrinn. Med 1.34 til 2.34 USD per time målt ovenfor, er det i størrelsesorden 67 000 til 117 000 USD i leid datakraft. SmolVLA-artikkelen anslår prosjektet til omtrent 30 000 GPU-timer fordelt på 481 fellesskapsdatasett, 22.9K episoder og 10.6M rammer. Du arver alt dette for prisen av en nedlasting; dine 8 USD kjøper de siste 20 000 trinnene. Hvorfor VLAer er bygget på denne måten dekker den delingen.

Armen: en engangskostnad som dverger GPU-regningen

En treningskjøring koster mindre enn lunsj. Roboten gjør det ikke. Det er derfor SO-100 er viktig: det er den billigste armen hele imitasjonslæring verktøykjeden faktisk støtter.

Den oppstrøms materiallisten i SO-ARM100-repositoriet er mer detaljert og verdt å sjekke mot din region: dens Deler for to armer liste utgjør totalt 229.88 USD eller 226.30 EUR for et leder- pluss følgeroppsett, og dens Deler for én følgerarm liste utgjør totalt 121.94 USD eller 124.30 EUR. Seks STS3215-servoer til 13.89 USD hver utgjør 83.34 av de 121.94, så servoene er armen. Med 1 til 3 USD per SmolVLA- eller ACT-kjøring er ett par armer verdt mellom 77 og 230 treningskjøringer. Hvis du fortsatt velger, SO-100 mot SO-101 er sammenligningen som betyr noe, fordi de to er nære nok til at beslutningen handler om tilgjengelighet snarere enn kapasitet.

Mennesketimer: linjen ingen legger inn i regnearket

Dette er tallet som snur kostnadsdiskusjonen på hodet. Å registrere demonstrasjoner er en person som flytter en robotarm, én episode om gangen, i sanntid. Det er ingen batching av det og ingen leie per sekund. LeRobot-datasettet opptakeren leveres med standardinnstillinger som gjør regnestykket enkelt, alle tre bekreftet i DatasetRecordConfig: 60 sekunder per episode, 60 sekunder for å nullstille scenen, 50 episoder. Kolonnen for penger nedenfor antar 15 USD for en time av noens tid, noe som er en antagelse snarere enn et plattformtall. Erstatt med din egen sats; forholdet er poenget.

1. 1
   Ta opp datasettet med standardinnstillingene du faktisk vil bli fakturert for

   Dette er lerobot 0.6.1, versjonen på PyPI per 3. august 2026. Merk CLI-formen: opptak kjører gjennom lerobot-record konsollinngangspunktet (lerobot.scripts.lerobot_record), ikke den gamle python -m lerobot.scripts.record modulstien. AY-Robots retter seg mot 0.5.1, og 0.5.1-hjulet erklærer de samme lerobot-record og lerobot-train inngangspunktene, så formen nedenfor er stabil på tvers av begge. De tre tidsflaggene er standardinnstillingene fra oppstrøms, så dette er også kommandoen regnestykket i neste tabell antar.

   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å hva du har tatt opp før du leier et eneste GPU-minutt

   Å inspisere et datasett koster null USD per time. Å oppdage det samme problemet fra en tapskurve koster 2.00 USD per time på H100-nivået og forteller deg fire timer for sent. Last opp datasettet og skrubb det i LeRobot-visningsprogrammet, eller bla gjennom AY-Robots datasettkatalog.

   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
   Tren, og sørg for at sjekkpunktet overlever pod-en

   En leid maskin er per definisjon midlertidig, så skriv sjekkpunkter et holdbart sted under kjøringen. To flagg avgjør om du beholder det du betalte for. --save_freq er som standard 20 000 trinn, så en standard 20 000-trinns SmolVLA-kjøring skriver sitt første sjekkpunkt når kjøringen allerede er over; senk det før du leier noe som kan avbrytes. --save_checkpoint_to_hub krever --policy.repo_id og eksisterer ikke i lerobot 0.5.1, så på den versjonen kopierer du utdatakatalogen fra maskinen selv. Batchstørrelsen nedenfor er eksemplet fra oppstrømsdokumentasjonen; AY-Robots-skjemaet sender 2 for SmolVLA og skriver til objektlagring etter hvert som sjekkpunkter 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 høyre kolonne med de 1 til 12 USD kjøringen koster. Med den antatte prisen koster et datasett med 50 episoder to til syv ganger så mye å spille inn som det koster å trene på, før kalibrering, kameraoppsett og episodene du kaster. Det er derfor har en direkte dollarverdi. LeRobot-guiden foreslår minst 50 episoder med 10 per objektlokasjon; SmolVLA-dokumentene rapporterer at en 25-episodeversjon av samme oppgave ikke var nok.

Hvor pengene faktisk forsvinner

1. Kjøringer på data som aldri ville fungert

En 20 000-trinns GR00T-kjøring på et datasett med to byttede kamerastrømmer koster det samme som en på et rent datasett, tar like lang tid, og produserer en tapskurve som ser fin ut. Feilen viser seg på armen, timer senere. faktureres per time og diagnose faktureres i dager. To symptomer verdt å huske: betyr vanligvis at observasjonene ikke inneholder det oppgaven krever, og betyr at datasettet hadde mindre variasjon enn du trodde.

2. Betale grunnmodellpriser for en fastkameraoppgave

ACT har omtrent 80M parametere og ble designet for å trene fra bunnen av på 50 demonstrasjoner av én oppgave. GR00T N1.7 er omtrent 3B med en forhåndstrent ryggrad. For et fastmontert kamera, et fast bord og ett objekt, lykkes 80M-modellen ofte, kjører med omtrent 20 ms per handlingstrinn i stedet for 152 ms, og koster 1 til 3 USD per kjøring i stedet for 4 til 12. Bruk 3 USD på å finne ut om den billige modellen fungerer før du bruker 12 USD på den dyre. ACT mot SmolVLA og GR00T N1.7 mot Pi0.5 viser hvor hver av dem slutter å være det riktige svaret; modellarenaen har 85 modeller og 332 benchmark-resultater.

3. GPU-en du glemte

Den billigste feilen å forhindre og den vanligste å gjøre. En instans startet på en fredag for å feilsøke noe, faktureres gjennom helgen med samme pris som en ekte kjøring.

På AY-Robots er denne feilen eliminert for inferens: pods som er provisjonert av inferens-API-en, har en inaktivitetsovervåker og ødelegger seg selv etter en inaktiv periode. Hvis du leier kortet selv, er den overvåkeren din kalenderpåminnelse.

4. Betale dobbelt for det samme svaret

GR00Ts finjusteringsinngangspunkt er en tyro CLI som ikke eksponerer noe seed. Dette er ikke en plattformbegrensning, det er oppstrømsverktøyet: det er ingen seed-felt i gr00t/configs/finetune_config.py, og depotets egne treningstips advarer om at kjøringer varierer med 5 til 6 prosent fordi bildeforbedringene er ikke-deterministiske. lerobot bruker standard seed 1000 i både 0.5.1 og 0.6.1, slik at ACT-, SmolVLA- og Pi0.5-kjøringer i det minste kan kjøres på nytt fra samme initialisering og datarekkefølge. Dette er ikke et løfte om bit-identiske vekter på en GPU, men det er forskjellen mellom en gjentatt kjøring og et nytt eksperiment. Hvis en GR00T-kjøring produserer en policy som fungerer og du ikke beholdt sjekkpunkt, betaler du full pris for et resultat som kan avvike mer enn forskjellen du jaktet på. Det er en annen måte å miste et sjekkpunkt du har betalt for: CLI-en bruker standard --save-total-limit 5, dokumentert som det maksimale antallet sjekkpunkter som beholdes før eldre slettes. Lagring koster øre; en gjentatt kjøring er 4 til 12 USD og seks timer.

Gjøre det selv versus å la plattformen leie 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>

Hva plattformen tar betalt og hvordan den velger kortet

Logikken er bevisst kjedelig. Hver modell i katalogen, erklærer et GPU-nivå; bakenden tar den nødvendige VRAM og leier et matchende kort på det samme spotmarkedet målt ovenfor. Det er derfor den oppgitte kostnaden er et område, ikke en pris. GR00T og Pi0.5 er kun skybaserte her på grunn av 40 GB og 70 GB gulvene. SmolVLA og ACT kjører også lokalt på ditt eget 24 GB kort, hvor skykostnaden er null og strømmen er ditt problem.

Én innstilling fortjener en advarsel. Gradientakkumulering gjelder faktisk for begge GR00T-variantene, så å øke den kjøper en større effektiv batch på samme kort. For Pi0.5 og SmolVLA gjelder det ikke i det hele tatt: lerobot 0.5.1 har ingen gradientakkumuleringsalternativ i sin treningskonfigurasjon, så å sette feltet til 16 koster ingenting og kjøper ingenting. Hvis en køet jobb aldri starter, siden for jobber som sitter fast i kø, dekker hva du skal sjekke; hvis datasettet avvises før kjøringen begynner, er det nesten alltid v3.0 formatproblemet.

Et utarbeidet budsjett for en første fungerende policy

Alle fire linjene samlet, fra bunnen av. GPU-totalen antar 3 til 5 kjøringer: den første beviser at pipelinen fungerer, den andre avslører et dataproblem, den tredje eller fjerde er den du beholder.

Mønsteret gjelder også for denne robotstørrelsen: beregningskraft er en avrundingsfeil, maskinvare er en reell engangskostnad, menneskelige timer er den gjentakende utgiften. For å teste treningsdelen før du kjøper noe, lar deg sammenligne modeller og leie en GPU uten en arm, og er en fysisk SO-100 du kan styre i nettleseren uten registrering. For hele ende-til-ende-pipelinen, dekker oppsett, og trening, og er kortversjonen.