VLA Träningskostnad: Vad en finjusteringskörning verkligen kostar

Räkningen har fyra poster, och GPU:n är den minsta

När folk frågar vad det kostar att finjustera en vision-språk-handlingsmodell för en SO-100, menar de nästan alltid GPU-hyran. Det är den siffra som visas som en debitering på ett kort, så det är den som känns verklig. Det är också, med bred marginal, den minsta av de fyra siffror som avgör vad en fungerande policy faktiskt kostar dig.

Träningstiderna nedan kommer från de fem modellernas egna publikationer och arkiv, hårdvarukostnaden från den publicerade materiallistan, plattformsnumren från AY-Robots policykatalog och prissida. Där plattformen inte hjälper, anges detta i artikeln.

Vad en GPU-timme faktiskt kostar på spotmarknaden

Det finns inget enskilt pris för en A100-timme. På en marknadsplats som vast.ai sätter varje värd sin egen taxa, och den träningskörning du startar hamnar på den maskin som är billig och ledig just då. Det ärliga svaret är en distribution. Här är den, mätt den 23 augusti 2026 kl. 13:44 UTC: enskilda fulla kort, on demand, filtrerade efter verkligt 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

Varför 3B-modellerna inte kan använda det billiga kortet

En 4090-timme och en H100 80 GB-timme skiljer sig med ungefär sex gånger vid medianerna ovan. Det som tvingar dig till det dyra kortet är inte hastighet, det är minne. openpi sätter gränsen för en fullständig Pi0.5 finjustering vid 70 GB, och NVIDIA rekommenderar 40 GB eller mer för GR00T. Observera vad GR00T-siffran inte är. Dess finjusteringskonfiguration fryser språkmodellen och den visuella kodaren som standard (tune_llm och tune_visual är False, projektorn och diffusionshuvudet True), vilket är anledningen till att katalogen listar ungefär 40 M tränade parametrar av 3 B. De 40 GB är inte optimerartillstånd för 3 B vikter, det är den frysta ryggraden plus aktiveringar. Varianter med reducerad omfattning kräver mindre: openpis LoRA-väg vill ha 22.5 GB och nämner 4090, och NVIDIAs Isaac Lab Arena-arbetsflöde listar ett 24 GB enkel-GPU-alternativ för GR00T efterträning. Plattformen delar in sig i nivåer baserat på den lägsta konfiguration varje leverantör publicerar för den konfiguration den faktiskt kör. pi0 flow-matching-rapporten förklarar var det flödesmatchning fotavtrycket kommer ifrån.

Den tabellen är anledningen till att plattformen delar upp de fem modellerna i två nivåer. GR00T N1.7, GR00T N1.5 och Pi0.5 körs på A100 80 GB eller H100 eftersom det är vad leverantörerna kräver. SmolVLA och ACT körs på ett RTX 4090 eller vilket som helst 24 GB-kort eftersom det är genuint tillräckligt.

Hur länge var och en av de fem modellerna faktiskt körs

Körtid är den andra halvan av kostnaden: 2.00 USD per timme är irrelevant om jobbet är 40 minuter och förödande om det är 40 timmar. Dessa är standardinställningarna AY-Robots verkligen skickar till tränaren, med körtidsfönstret och kostnaden för varje nivå.

Varifrån dessa körfönster kommer uppströms

• SmolVLA: lerobot-dokumentationen anger att 20 000 steg tar ungefär 4 timmar på en enda A100. Plattformen kör samma 20 000 steg på den billigare 24 GB-nivån, därav ett fönster snarare än en fast 4 timmar.
• ACT: den ursprungliga ALOHA-artikeln rapporterar cirka 5 timmar på ett enda 11 GB RTX 2080 Ti för en modell med 80 miljoner parametrar. Ett 4090 är flera generationer nyare men plattformen budgeterar 100 000 steg, så fönstret hamnar på samma plats.
• GR00T: NVIDIAs referensarbetsflöde för N1.6-generationen anger ungefär 4 till 8 timmar för 20 000 steg vid batch 24 på åtta L40S-kort, och 2 till 3 timmar för 30 000 steg vid batch 16 på ett enda Ada 6000. Finjustering av en 3B VLA på ett enda kort på några timmar är normalt, inte optimistiskt.
• Pi0.5: openpi publicerar ingen faktisk tidsåtgång, men de publicerar den 70 GB gränsen för en fullständig finjustering, vilket fastställer kortet och därmed hastigheten.

Värt att stanna upp vid det antal du inte betalar för. GR00T N1-artikeln rapporterar ungefär 50 000 H100 GPU-timmar för att förträna 2.2B-modellen, på ett kluster med upp till 1024 GPU:er, med en förträningsbatchstorlek på 16 384 för 200 000 gradientsteg. Med den uppmätta kostnaden på 1.34 till 2.34 USD per timme ovan, uppgår det till cirka 67 000 till 117 000 USD i hyrd beräkningskraft. SmolVLA-artikeln anger att dess projekt omfattar cirka 30 000 GPU-timmar över 481 gemenskapsdatauppsättningar, 22.9K episoder och 10.6M bildrutor. Du ärver allt detta för priset av en nedladdning; dina 8 USD köper de sista 20 000 stegen. Varför VLA:er byggs på detta sätt täcker den uppdelningen.

Armen: en engångskostnad som förminskar GPU-räkningen

En träningskörning kostar mindre än lunch. Roboten gör det inte. Det är därför SO-100 är viktig: det är den billigaste armen som hela imitationsinlärning verktygskedjan faktiskt stöder.

Den uppströms materiallistan i SO-ARM100-förrådet är mer detaljerad och värd att kontrollera mot din region: dess Delar för två armar lista uppgår till 229.88 USD eller 226.30 EUR för en ledar- plus följaruppsättning, och dess Delar för en följararm lista uppgår till 121.94 USD eller 124.30 EUR. Sex STS3215-servon à 13.89 USD styck utgör 83.34 av de 121.94, så servona är armen. Med 1 till 3 USD per SmolVLA- eller ACT-körning är ett par armar värt mellan 77 och 230 träningskörningar. Om du fortfarande väljer, SO-100 mot SO-101 är jämförelsen som spelar roll, eftersom de två är tillräckligt lika för att beslutet handlar om tillgänglighet snarare än kapacitet.

Mänskliga timmar: raden ingen lägger in i kalkylbladet

Detta är siffran som vänder kostnadsdiskussionen upp och ner. Att spela in demonstrationer innebär att en person flyttar en robotarm, ett avsnitt i taget, i realtid. Det går inte att köra i batchar och inte att hyra per sekund. LeRobot-datasetet inspelaren levereras med standardinställningar som gör beräkningarna enkla, alla tre bekräftade i DatasetRecordConfig: 60 sekunder per avsnitt, 60 sekunder för att återställa scenen, 50 avsnitt. Kolumnen för pengar nedan antar 15 USD för en timmes arbete, vilket är ett antagande snarare än en plattformssiffra. Ersätt med din egen taxa; förhållandet är poängen.

1. 1
   Spela in datasetet med de standardinställningar du faktiskt kommer att debiteras för

   Detta är lerobot 0.6.1, versionen på PyPI per den 3 augusti 2026. Observera CLI-formen: inspelningen körs via konsolens startpunkt lerobot-record (lerobot.scripts.lerobot_record), inte den gamla modulvägen python -m lerobot.scripts.record. AY-Robots riktar sig mot 0.5.1, och 0.5.1-hjulet deklarerar samma startpunkter lerobot-record och lerobot-train, så formen nedan är stabil över båda. De tre tidsflaggorna är standardinställningarna uppströms, så detta är också kommandot som beräkningarna i nästa 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
   Titta på vad du spelade in innan du hyr en enda GPU-minut

   Att inspektera ett dataset kostar noll USD per timme. Att upptäcka samma problem från en förlustkurva kostar 2.00 USD per timme på H100-nivån och meddelar dig fyra timmar för sent. Pusha datasetet och granska det i LeRobot-visaren, eller bläddra i AY-Robots datasetkatalog.

   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äna, och se till att checkpointen överlever podden

   En hyrd maskin är per definition tillfällig, så skriv checkpoints någonstans hållbart under körningen. Två flaggor avgör om du behåller det du betalat för. --save_freq är som standard 20 000 steg, så en standardkörning av SmolVLA på 20 000 steg skriver sin första checkpoint när körningen redan är över; sänk den innan du hyr något avbrottsbenäget. --save_checkpoint_to_hub kräver --policy.repo_id och finns inte i lerobot 0.5.1, så på den versionen kopierar du själv utdatakatalogen från maskinen. Batchstorleken nedan är exemplet från uppströmsdokumentationen; AY-Robots-formuläret skickar 2 för SmolVLA och skriver till objektlagring när checkpoints dyker upp.

   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

Jämför den högra kolumnen med kostnaden för körningen, 1 till 12 USD. Med den antagna hastigheten kostar en datamängd med 50 episoder två till sju gånger så mycket att spela in som att träna på, före kalibrering, kamerainställning och de episoder du kastar bort. Det är därför har ett direkt ekonomiskt värde. LeRobot-guiden föreslår minst 50 episoder med 10 per objektplats; SmolVLA-dokumentationen rapporterar att en 25-episoders version av samma uppgift inte var tillräcklig.

Var pengarna faktiskt försvinner

1. Körningar på data som aldrig skulle fungera

En GR00T-körning på 20 000 steg på en datamängd med två omkastade kameraströmmar kostar lika mycket som en på en ren datamängd, tar lika lång tid och producerar en förlustkurva som ser bra ut. Felet visar sig på armen, timmar senare. debiteras per timme och diagnos debiteras i dagar. Två symptom värda att komma ihåg: betyder oftast att observationerna inte innehåller vad uppgiften kräver, och betyder att datamängden hade mindre variation än du trodde.

2. Betala grundmodellpriser för en uppgift med fast kamera

ACT har ungefär 80M parametrar och designades för att tränas från grunden på 50 demonstrationer av en uppgift. GR00T N1.7 har ungefär 3B med en förtränad ryggrad. För en fastskruvad kamera, ett fast bord och ett objekt, lyckas 80M-modellen ofta, körs med cirka 20 ms per åtgärdssteg istället för 152 ms, och kostar 1 till 3 USD per körning istället för 4 till 12. Spendera 3 USD på att ta reda på om den billiga modellen fungerar innan du spenderar 12 USD på den dyra. ACT mot SmolVLA och GR00T N1.7 mot Pi0.5 visar var respektive slutar vara det rätta svaret; modellarenan har 85 modeller och 332 benchmarkresultat.

3. GPU:n du glömde bort

Det billigaste misstaget att förhindra och det vanligaste att göra. En instans som startas på en fredag för att felsöka något faktureras över helgen med samma taxa som en riktig körning.

På AY-Robots är detta fel eliminerat för inferens: pods som tillhandahålls av inferens-API:et har en inaktivitetsvakt och förstör sig själva efter en inaktivitetsperiod. Om du hyr kortet själv är den vakten din kalenderpåminnelse.

4. Betala dubbelt för samma svar

GR00T:s finjusteringsingång är en tyro CLI som inte exponerar något seed. Detta är ingen plattformsbegränsning, det är det uppströmsverktyget: det finns inget seed-fält i gr00t/configs/finetune_config.py, och repositoryts egna träningstips varnar för att körningar varierar med 5 till 6 procent eftersom bildförbättringarna är icke-deterministiska. lerobot använder som standard seed 1000 i både 0.5.1 och 0.6.1, så ACT-, SmolVLA- och Pi0.5-körningar kan åtminstone köras om från samma initialisering och dataordning. Detta är inget löfte om bit-identiska vikter på en GPU, men det är skillnaden mellan en omkörning och ett nytt experiment. Om en GR00T-körning producerar en policy som fungerar och du inte behöll checkpointet, betalar du fullt pris för ett resultat som kan skilja sig mer än den skillnad du jagade. Det finns ett andra sätt att förlora ett checkpoint du betalat för: CLI:n använder som standard --save-total-limit 5, dokumenterat som det maximala antalet checkpoints som behålls innan äldre raderas. Lagring kostar ören; en omkörning är 4 till 12 USD och sex timmar.

Att göra det själv kontra att låta plattformen hyra 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>

Vad plattformen debiterar och hur den väljer kortet

Logiken är medvetet enkel. Varje modell i katalogen, deklarerar en GPU-nivå; backend tar den nödvändiga VRAM och hyr ett matchande kort på samma spotmarknad som mätts ovan. Det är därför den angivna kostnaden är ett intervall, inte ett pris. GR00T och Pi0.5 är endast molnbaserade här på grund av gränserna på 40 GB och 70 GB. SmolVLA och ACT körs också lokalt på ditt eget 24 GB-kort, där molnkostnaden är noll och elektriciteten är ditt problem.

En inställning förtjänar en varning. Gradientackumulering gäller verkligen för båda GR00T-varianterna, så att öka den ger en större effektiv batch på samma kort. För Pi0.5 och SmolVLA gäller det inte alls: lerobot 0.5.1 har inget alternativ för gradientackumulering i sin träningskonfiguration, så att ställa in fältet till 16 kostar inget och ger inget. Om ett köat jobb aldrig startar, sidan för fastnat-i-kö, beskriver vad du ska kontrollera; om datasetet avvisas innan körningen börjar, är det nästan alltid problemet med v3.0-formatet.

En utarbetad budget för en första fungerande policy

Alla fyra rader tillsammans, från grunden. GPU-totalen antar 3 till 5 körningar: den första bevisar att pipelinen fungerar, den andra avslöjar ett dataproblem, den tredje eller fjärde är den du behåller.

Mönstret gäller även för robotar av denna storlek: beräkningskostnaden är försumbar, hårdvaran är en verklig engångskostnad, och mänskliga timmar är den återkommande utgiften. För att testa träningsdelen innan du köper något, låter dig jämföra modeller och hyra en GPU utan en robotarm, och är en fysisk SO-100 som du kan styra i webbläsaren utan registrering. För hela pipeline från början till slut, täcker den installation, och träning, och är den korta versionen.