Costo dell'addestramento VLA: Quanto costa realmente un'esecuzione di fine-tuning

Il conto ha quattro voci, e la GPU è la più piccola

Quando le persone chiedono quanto costa ottimizzare un modello visione-linguaggio-azione, per un SO-100, quasi sempre si riferiscono al noleggio della GPU. Questo è il numero che appare come addebito su una carta, quindi è quello che sembra reale. È anche, con ampio margine, il più piccolo dei quattro numeri che decidono quanto una strategia effettivamente ti costa.

I tempi di training riportati di seguito provengono dai documenti e dai repository dei cinque modelli, il costo dell'hardware dalla distinta base pubblicata, i numeri della piattaforma dai catalogo delle policy di AY-Robots e dalla pagina dei prezzi. Laddove la piattaforma non sia d'aiuto, questo articolo lo specifica.

Quanto costa effettivamente un'ora di GPU sul mercato spot

Non esiste un prezzo unico per un'ora di A100. Su un marketplace come vast.ai ogni host imposta la propria tariffa, e l'esecuzione di training che avvii viene assegnata alla macchina più economica e disponibile in quel momento. La risposta onesta è una distribuzione. Eccola, misurata il 23 agosto 2026 alle 13:44 UTC: schede singole complete, on demand, filtrate per VRAM reale.

# 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

Perché i modelli 3B non possono usare la scheda economica

Un'ora di 4090 e un'ora di H100 80 GB differiscono di circa sei volte rispetto alle mediane sopra. Ciò che ti costringe a usare la scheda costosa non è la velocità, è la memoria. openpi stabilisce un minimo di 70 GB per un fine-tune completo di Pi0.5, e NVIDIA raccomanda 40 GB o più per GR00T. Nota cosa non è il numero di GR00T. La sua configurazione di fine-tuning blocca il modello linguistico e l'encoder visivo per impostazione predefinita (tune_llm e tune_visual sono False, il proiettore e la testa di diffusione True), motivo per cui il catalogo elenca circa 40 M di parametri addestrati su 3 B. I 40 GB non sono lo stato dell'ottimizzatore per 3 B di pesi, ma il backbone congelato più le attivazioni. Le varianti a portata ridotta scendono più in basso: il percorso LoRA di openpi richiede 22.5 GB e nomina la 4090, e il flusso di lavoro Isaac Lab Arena di NVIDIA elenca un'opzione single-GPU da 24 GB per il post-training di GR00T. La piattaforma si basa sui requisiti minimi che ogni fornitore pubblica per la configurazione che effettivamente esegue. L'articolo sul flow-matching di pi0 spiega da dove proviene l'ingombro del flow-matching.

Questa tabella spiega perché la piattaforma divide i cinque modelli in due livelli. GR00T N1.7, GR00T N1.5 e Pi0.5 vanno su A100 80 GB o H100 perché è ciò che i fornitori richiedono. SmolVLA e ACT vanno su una RTX 4090 o qualsiasi scheda da 24 GB perché è effettivamente sufficiente.

Durata di esecuzione effettiva di ciascuno dei cinque modelli

Il tempo di esecuzione è l'altra metà del costo: 2.00 USD all'ora è irrilevante se il lavoro dura 40 minuti e rovinoso se dura 40 ore. Questi sono i valori predefiniti che AY-Robots invia effettivamente al trainer, con la finestra di esecuzione e il costo per ogni livello.

Da dove provengono quelle finestre di esecuzione a monte

• SmolVLA: la documentazione di lerobot afferma che 20.000 passi richiedono circa 4 ore su una singola A100. La piattaforma esegue gli stessi 20.000 passi sul livello più economico da 24 GB, quindi una finestra piuttosto che 4 ore fisse.
• ACT: il paper originale ALOHA riporta circa 5 ore su una singola RTX 2080 Ti da 11 GB per un modello da 80M parametri. Una 4090 è di diverse generazioni più recente, ma la piattaforma prevede 100.000 passi, quindi la finestra si posiziona nello stesso punto.
• GR00T: il workflow di riferimento di NVIDIA per la generazione N1.6 cita circa 4-8 ore per 20.000 passi con batch 24 su otto schede L40S, e 2-3 ore per 30.000 passi con batch 16 su una singola Ada 6000. Il fine-tuning su singola scheda di un VLA da 3B in poche ore è normale, non ottimistico.
• Pi0.5: openpi non pubblica alcuna cifra di tempo effettivo, ma pubblica il limite inferiore di 70 GB per un fine-tuning completo, il che fissa la scheda e quindi la tariffa.

Vale la pena soffermarsi sul costo che non state pagando. Il paper GR00T N1 riporta circa 50.000 ore GPU H100 per il pre-addestramento del modello 2.2B, su un cluster di fino a 1024 GPU, con una dimensione del batch di pre-addestramento di 16.384 per 200.000 passi di gradiente. Al costo di 1,34-2,34 USD all'ora misurato sopra, si tratta di un costo di calcolo noleggiato dell'ordine di 67.000-117.000 USD. Il paper SmolVLA stima il suo progetto a circa 30.000 ore GPU su 481 dataset della comunità, 22.9K episodi e 10.6M frame. Voi ereditate tutto questo al prezzo di un download; i vostri 8 USD acquistano gli ultimi 20.000 passi. Perché i VLA sono costruiti in questo modo copre questa divisione.

Il braccio: un costo una tantum che sminuisce la fattura della GPU

Un ciclo di addestramento costa meno di un pranzo. Il robot no. Ecco perché il SO-100 è importante: è il braccio più economico che l'intera apprendimento per imitazione catena di strumenti supporta effettivamente.

La distinta base a monte nel repository SO-ARM100 è più granulare e vale la pena verificarla in base alla propria regione: il suo elenco Pezzi per Due Bracci ammonta a 229.88 USD o 226.30 EUR per una configurazione leader più follower, e il suo elenco Pezzi per un Braccio Follower ammonta a 121.94 USD o 124.30 EUR. Sei servi STS3215 a 13.89 USD ciascuno fanno 83.34 di quei 121.94, quindi i servi sono il braccio. A 1 a 3 USD per ciclo SmolVLA o ACT, un paio di bracci vale tra 77 e 230 cicli di addestramento. Se stai ancora scegliendo, SO-100 contro SO-101 è il confronto che conta, perché i due sono abbastanza simili da rendere la decisione una questione di disponibilità piuttosto che di capacità.

Ore umane: la riga che nessuno inserisce nel foglio di calcolo

Questo è il numero che ribalta la discussione sui costi. Registrare dimostrazioni significa una persona che muove un braccio robotico, un episodio alla volta, in tempo reale. Non è possibile eseguirle in batch né noleggiarle al secondo. Il dataset LeRobot registratore viene fornito con impostazioni predefinite che semplificano l'aritmetica, tutte e tre confermate in DatasetRecordConfig: 60 secondi per episodio, 60 secondi per resettare la scena, 50 episodi. La colonna del denaro qui sotto assume 15 USD per un'ora del tempo di una persona, il che è un'ipotesi piuttosto che un numero della piattaforma. Sostituisci la tua tariffa; il rapporto è il punto.

1. 1
   Registra il dataset con le impostazioni predefinite per cui ti verrà effettivamente addebitato

   Questa è lerobot 0.6.1, la versione su PyPI al 3 agosto 2026. Si noti la forma della CLI: la registrazione avviene tramite il punto di ingresso della console lerobot-record (lerobot.scripts.lerobot_record), non il vecchio percorso del modulo python -m lerobot.scripts.record. AY-Robots si basa sulla versione 0.5.1, e il wheel 0.5.1 dichiara gli stessi punti di ingresso lerobot-record e lerobot-train, quindi la forma seguente è stabile per entrambi. I tre flag di temporizzazione sono le impostazioni predefinite a monte, quindi questo è anche il comando che l'aritmetica nella tabella successiva assume.

   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
   Guarda cosa hai registrato prima di noleggiare un singolo minuto di GPU

   Ispezionare un dataset costa zero USD all'ora. Scoprire lo stesso problema da una curva di perdita costa 2.00 USD all'ora sul livello H100 e te lo dice con quattro ore di ritardo. Carica il dataset e analizzalo nel visualizzatore LeRobot, oppure sfoglia la directory dei dataset di 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
   Addestra e assicurati che il checkpoint sopravviva al pod

   Una macchina noleggiata è temporanea per definizione, quindi scrivi i checkpoint in un luogo duraturo durante l'esecuzione. Due flag decidono se mantieni ciò per cui hai pagato. --save_freq ha un valore predefinito di 20.000 passi, quindi un'esecuzione predefinita di SmolVLA di 20.000 passi scrive il suo primo checkpoint quando l'esecuzione è già terminata; abbassalo prima di noleggiare qualsiasi cosa interrompibile. --save_checkpoint_to_hub richiede --policy.repo_id e non esiste in lerobot 0.5.1, quindi su quella versione devi copiare tu stesso la directory di output dalla macchina. La dimensione del batch qui sotto è l'esempio della documentazione a monte; il modulo AY-Robots invia 2 per SmolVLA e scrive nell'object storage man mano che i checkpoint appaiono.

   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

Confronta la colonna di destra con i costi di esecuzione da 1 a 12 USD. A quel tasso ipotizzato, un dataset di 50 episodi costa da due a sette volte di più per essere registrato di quanto costi per l'addestramento, prima della calibrazione, della configurazione della telecamera e degli episodi che vengono scartati. Ecco perché ha un valore economico diretto. La guida di lerobot suggerisce almeno 50 episodi con 10 per posizione dell'oggetto; la documentazione di SmolVLA riporta che una versione di 25 episodi dello stesso compito non era sufficiente.

Dove i soldi vanno effettivamente persi

1. Esecuzioni su dati che non avrebbero mai funzionato

Un'esecuzione GR00T di 20.000 passi su un dataset con due stream di telecamere scambiati costa quanto una su un dataset pulito, impiega lo stesso tempo e produce una curva di perdita che sembra a posto. Il fallimento si manifesta sul braccio, ore dopo. vengono fatturati all'ora e la diagnosi viene fatturata in giorni. Due sintomi da memorizzare: di solito significa che le osservazioni non contengono ciò che il compito richiede, e significa che il dataset aveva meno variazione di quanto pensassi.

2. Pagare prezzi da modello di fondazione per un compito con telecamera fissa

ACT ha circa 80M parametri ed è stato progettato per essere addestrato da zero su 50 dimostrazioni di un singolo compito. GR00T N1.7 ha circa 3B parametri con un backbone pre-addestrato. Per una telecamera fissa, un tavolo fisso e un oggetto, il modello da 80M spesso raggiunge l'obiettivo, funziona a circa 20 ms per passo d'azione invece di 152 ms, e costa da 1 a 3 USD per esecuzione invece di 4 a 12. Spendi 3 USD per scoprire se il modello economico funziona prima di spendere 12 USD per quello costoso. ACT contro SmolVLA e GR00T N1.7 contro Pi0.5 mostrano dove ciascuno smette di essere la risposta giusta; l' arena dei modelli ha 85 modelli e 332 risultati di benchmark.

3. La GPU che hai dimenticato

L'errore più economico da prevenire e il più comune da commettere. Un'istanza avviata di venerdì per il debug di qualcosa fattura per tutto il fine settimana alla stessa tariffa di un'esecuzione reale.

Su AY-Robots questo tipo di errore è stato eliminato per l'inferenza: i pod forniti dall'API di inferenza includono un watchdog per l'inattività e si autodistruggono dopo un periodo di inattività. Se noleggi la scheda tu stesso, quel watchdog è il tuo promemoria sul calendario.

4. Pagare due volte per la stessa risposta

Il punto di ingresso per il fine-tuning di GR00T è una CLI tyro che non espone alcun seed. Questa non è una limitazione della piattaforma, è lo strumento a monte: non esiste un campo seed in gr00t/configs/finetune_config.py, e i suggerimenti di training del repository stesso avvertono che le esecuzioni variano dal 5 al 6 percento perché le aumentazioni delle immagini non sono deterministiche. lerobot imposta il seed a 1000 sia in 0.5.1 che in 0.6.1, quindi le esecuzioni di ACT, SmolVLA e Pi0.5 possono almeno essere rieseguite dalla stessa inizializzazione e ordine dei dati. Questa non è una promessa di pesi bit-identici su una GPU, ma è la differenza tra una riesecuzione e un nuovo esperimento. Se un'esecuzione GR00T produce una policy che funziona e non hai conservato il checkpoint, paghi il prezzo intero per un risultato che potrebbe differire più della differenza che stavi cercando. Esiste un secondo modo per perdere un checkpoint per cui hai pagato: la CLI imposta di default --save-total-limit 5, documentato come il numero massimo di checkpoint conservati prima che quelli più vecchi vengano eliminati. Lo storage costa pochi centesimi; una riesecuzione costa da 4 a 12 USD e sei ore.

Far da sé contro lasciare che la piattaforma noleggi la scheda

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

Cosa addebita la piattaforma e come sceglie la scheda

La logica è volutamente semplice. Ogni modello nel catalogo, dichiara un livello di GPU; il backend prende la VRAM richiesta e noleggia una scheda corrispondente sullo stesso mercato spot misurato sopra. Ecco perché il costo quotato è un intervallo, non un prezzo. GR00T e Pi0.5 sono qui solo cloud a causa dei limiti inferiori di 40 GB e 70 GB. SmolVLA e ACT funzionano anche localmente sulla tua scheda da 24 GB, dove il costo del cloud è zero e l'elettricità è un tuo problema.

Un parametro merita un avvertimento. L'accumulo del gradiente si applica effettivamente a entrambe le varianti GR00T, quindi aumentarlo consente di ottenere un batch effettivo più grande sulla stessa scheda. Per Pi0.5 e SmolVLA non si applica affatto: lerobot 0.5.1 non ha un'opzione di accumulo del gradiente nella sua configurazione di training, quindi impostare il campo a 16 non costa nulla e non produce alcun risultato. Se un lavoro in coda non si avvia mai, la pagina sui lavori bloccati in coda, spiega cosa controllare; se il dataset viene rifiutato prima dell'inizio dell'esecuzione, è quasi sempre il problema del formato v3.0.

Un budget elaborato per una prima policy funzionante

Tutte e quattro le righe insieme, partendo da zero. Il totale della GPU presuppone 3-5 esecuzioni: la prima dimostra che la pipeline funziona, la seconda espone un problema di dati, la terza o la quarta è quella che mantieni.

Il modello si mantiene anche per robot di queste dimensioni: il calcolo è un errore di arrotondamento, l'hardware è un costo una tantum reale, le ore umane sono la spesa ricorrente. Per testare la parte di addestramento prima di acquistare qualsiasi cosa, i punti di accesso senza hardware ti permettono di confrontare modelli e noleggiare una GPU senza un braccio, e il braccio live è un SO-100 fisico che puoi controllare nel browser senza registrazione. Per l'intera pipeline end-to-end, la guida completa SO-100 copre la configurazione, la teleoperazione e l'addestramento, e addestra la tua prima policy è la versione breve.