Gastos sa Pagsasanay ng VLA: Magkano Talaga ang Gastos ng Isang Fine-Tuning Run

Ang bill ay may apat na linya, at ang GPU ang pinakamaliit

Kapag tinatanong ng mga tao kung magkano ang gastos sa pag-fine-tune ng isang modelo ng vision-language-action para sa isang SO-100, halos palagi nilang ibig sabin ang pag-upa ng GPU. Iyan ang numerong lumalabas bilang singil sa isang card, kaya iyan ang nararamdaman na totoo. Ito rin, sa malaking pagkakaiba, ang pinakamaliit sa apat na numero na nagpapasya kung ano ang aktwal na gastos sa iyo ng isang gumaganang patakaran.

Ang mga oras ng pagsasanay sa ibaba ay mula sa sariling mga papel at repositoryo ng limang modelo, ang gastos sa hardware mula sa nailathalang bill of materials, ang mga numero ng platform mula sa AY-Robots katalogo ng patakaran at pahina ng pagpepresyo. Kung saan hindi nakakatulong ang platform, sinasabi ito ng artikulong ito.

Magkano talaga ang halaga ng isang oras ng GPU sa spot market

Walang iisang presyo para sa isang oras ng A100. Sa isang marketplace tulad ng vast.ai, bawat host ay nagtatakda ng sarili nitong rate, at ang pagpapatakbo ng pagsasanay na inilunsad mo ay mapupunta sa anumang makina na mura at libre sa sandaling iyon. Ang tapat na sagot ay isang distribusyon. Narito ito, sinukat noong 23 Agosto 2026 ng 13:44 UTC: solong buong card, on demand, na sinala ayon sa tunay na 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

Bakit hindi magagamit ng mga 3B model ang murang card

Ang isang 4090 oras at isang H100 80 GB oras ay nagkakaiba ng humigit-kumulang anim na beses sa mga median sa itaas. Ang nagtutulak sa iyo sa mamahaling card ay hindi bilis, kundi memorya. Itinatakda ng openpi ang minimum para sa isang buong Pi0.5 pag-fine-tune sa 70 GB, at inirerekomenda ng NVIDIA ang 40 GB o higit pa para sa GR00T. Tandaan kung ano ang hindi ang numero ng GR00T. Ang fine-tune config nito ay nagpi-freeze sa language model at visual encoder bilang default (tune_llm at tune_visual ay False, ang projector at diffusion head ay True), kaya naman ang katalogo ay naglilista ng humigit-kumulang 40 M na sinanay na parameter mula sa 3 B. Ang 40 GB ay hindi optimizer state para sa 3 B weights, ito ay ang frozen backbone kasama ang mga activation. Ang mga variant na may pinababang saklaw ay bumababa: ang LoRA path ng openpi ay nangangailangan ng 22.5 GB at binabanggit ang 4090, at ang workflow ng Isaac Lab Arena ng NVIDIA ay naglilista ng 24 GB single-GPU na opsyon para sa GR00T post-training. Ang platform ay nagtatakda ng mga tier batay sa minimum na inilalathala ng bawat vendor para sa configuration na talagang pinapatakbo nito. Ang pi0 flow-matching na sulatin nagpapaliwanag kung saan nagmula ang flow-matching footprint.

Iyan ang dahilan kung bakit hinahati ng platform ang limang modelo sa dalawang tier. GR00T N1.7, GR00T N1.5 at Pi0.5 ay gumagamit ng A100 80 GB o H100 dahil iyon ang hinihingi ng mga vendor. SmolVLA at ACT ay gumagamit ng RTX 4090 o anumang 24 GB card dahil iyon ay sapat na.

Gaano katagal tumatakbo ang bawat isa sa limang modelo

Ang oras ng pagtakbo ay ang kabilang kalahati ng gastos: Ang 2.00 USD kada oras ay walang saysay kung ang trabaho ay 40 minuto at nakakapinsala kung ito ay 40 oras. Ito ang mga default na talagang ipinapadala ng AY-Robots sa trainer, kasama ang run window at gastos para sa bawat tier.

Saan nagmumula ang mga run window na iyon mula sa upstream

• SmolVLA: Ayon sa dokumentasyon ng lerobot, ang 20,000 steps ay tumatagal ng humigit-kumulang 4 na oras sa isang A100. Pinapatakbo ng platform ang parehong 20,000 steps sa mas murang 24 GB tier, kaya't isang window sa halip na isang flat na 4 na oras.
• ACT: Ang orihinal na papel ng ALOHA ay nag-uulat ng humigit-kumulang 5 oras sa isang 11 GB RTX 2080 Ti para sa isang 80M-parameter na modelo. Ang isang 4090 ay ilang henerasyon na mas bago ngunit ang platform ay naglalaan ng 100,000 steps, kaya't ang window ay napupunta sa parehong lugar.
• GR00T: Ang reference workflow ng NVIDIA para sa henerasyon ng N1.6 ay nagbanggit ng humigit-kumulang 4 hanggang 8 oras para sa 20,000 steps sa batch 24 sa walong L40S card, at 2 hanggang 3 oras para sa 30,000 steps sa batch 16 sa isang Ada 6000. Ang single-card fine-tuning ng isang 3B VLA sa loob ng ilang oras ay normal, hindi optimistiko.
• Pi0.5: Walang inilalathala ang openpi na wall-clock figure, ngunit inilalathala nito ang 70 GB floor para sa isang buong fine-tune, na nagtatakda ng card at samakatuwid ang rate.

Sulit na pagtuunan ng pansin ang halagang hindi mo binabayaran. Ang papel ng GR00T N1 ay nag-uulat ng humigit-kumulang 50,000 H100 GPU hours upang i-pretrain ang 2.2B na modelo, sa isang cluster ng hanggang 1024 GPU, sa isang pretraining batch size na 16,384 para sa 200,000 gradient steps. Sa 1.34 hanggang 2.34 USD kada oras na sinukat sa itaas, ito ay nasa hanay ng 67,000 hanggang 117,000 USD ng inupahang compute. Ang papel ng SmolVLA ay naglalagay ng proyekto nito sa humigit-kumulang 30,000 GPU hours sa 481 community datasets, 22.9K episodes at 10.6M frames. Minana mo ang lahat ng ito sa presyo ng isang download; ang iyong 8 USD ay bumibili ng huling 20,000 steps. Bakit ganito ang pagkakagawa ng mga VLA ay sumasaklaw sa paghahating iyon.

Ang braso: isang one-time na gastos na mas malaki pa sa bayarin ng GPU

Ang isang training run ay mas mura kaysa tanghalian. Ang robot ay hindi. Kaya naman ang SO-100 ay mahalaga: ito ang pinakamurang braso na sinusuportahan ng buong pag-aaral sa pamamagitan ng panggagaya toolchain.

Ang upstream na bill of materials sa SO-ARM100 repository ay mas detalyado at nararapat suriin ayon sa iyong rehiyon: ang Mga Bahagi Para sa Dalawang Braso na listahan ay may kabuuang 229.88 USD o 226.30 EUR para sa isang leader plus follower setup, at ang Mga Bahagi Para sa Isang Follower Arm na listahan ay may kabuuang 121.94 USD o 124.30 EUR. Anim na STS3215 servo sa 13.89 USD bawat isa ay 83.34 ng 121.94 na iyon, kaya ang mga servo ang braso. Sa 1 hanggang 3 USD bawat SmolVLA o ACT run, ang isang pares ng braso ay nagkakahalaga sa pagitan ng 77 at 230 training run. Kung ikaw ay nagpipili pa rin, SO-100 laban sa SO-101 ang paghahambing na mahalaga, dahil ang dalawa ay sapat na magkalapit kaya ang desisyon ay tungkol sa availability sa halip na kakayahan.

Oras ng tao: ang linyang walang naglalagay sa spreadsheet

Ito ang bilang na nagpapabaliktad sa diskusyon tungkol sa gastos. Ang pagre-record ng mga demonstrasyon ay isang tao na nagpapagalaw ng robot arm, isang episode sa bawat pagkakataon, sa real time. Walang pagpapangkat-pangkat dito at walang pag-upa nito kada segundo. Ang LeRobot dataset recorder ay may kasamang mga default na nagpapadali sa aritmetika, lahat ng tatlo ay nakumpirma sa DatasetRecordConfig: 60 segundo bawat episode, 60 segundo upang i-reset ang eksena, 50 episode. Ang column ng pera sa ibaba ay nagpapalagay ng 15 USD para sa isang oras ng oras ng isang tao, na isang pagpapalagay sa halip na isang numero ng platform. Palitan ng sarili mong rate; ang ratio ang punto.

1. 1
   I-record ang dataset gamit ang mga default na aktwal mong babayaran

   Ito ang lerobot 0.6.1, ang bersyon sa PyPI noong 3 Agosto 2026. Tandaan ang hugis ng CLI: ang pagre-record ay tumatakbo sa pamamagitan ng lerobot-record console entry point (lerobot.scripts.lerobot_record), hindi ang lumang python -m lerobot.scripts.record module path. Ang AY-Robots ay nagta-target ng 0.5.1, at ang 0.5.1 wheel ay nagdedeklara ng parehong lerobot-record at lerobot-train entry points, kaya ang hugis sa ibaba ay matatag sa pareho. Ang tatlong timing flags ay ang mga upstream default, kaya ito rin ang command na ipinapalagay ng aritmetika sa susunod na talahanayan.

   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
   Tingnan ang iyong na-record bago ka umupa ng isang minuto ng GPU

   Ang pag-inspeksyon ng dataset ay walang gastos na zero USD kada oras. Ang pagtuklas ng parehong problema mula sa isang loss curve ay nagkakahalaga ng 2.00 USD kada oras sa H100 tier at sinasabi sa iyo nang apat na oras na huli. I-push ang dataset at suriin ito sa LeRobot viewer, o i-browse ang 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
   Mag-train, at tiyaking mas matagal ang checkpoint kaysa sa pod

   Ang inupahang makina ay pansamantala ayon sa depinisyon, kaya isulat ang mga checkpoint sa isang matibay na lugar sa panahon ng pagpapatakbo. Dalawang flag ang nagpapasya kung pananatilihin mo ang iyong binayaran. Ang --save_freq ay nagde-default sa 20,000 steps, kaya ang isang default na 20,000-step na SmolVLA run ay isinusulat ang unang checkpoint nito kapag tapos na ang pagpapatakbo; babaan ito bago ka umupa ng anumang maaaring maantala. Ang --save_checkpoint_to_hub ay nangangailangan ng --policy.repo_id at hindi umiiral sa lerobot 0.5.1, kaya sa bersyon na iyon ay kailangan mong kopyahin ang output directory mula sa makina nang ikaw mismo. Ang batch size sa ibaba ay ang halimbawa ng upstream doc; ang AY-Robots form ay nagpapadala ng 2 para sa SmolVLA at nagsusulat sa object storage habang lumalabas ang mga checkpoint.

   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

Ikumpara ang kanang column sa 1 to 12 USD na gastos ng pagpapatakbo. Sa inaasahang rate na iyon, ang isang 50-episode dataset ay nagkakahalaga ng dalawa hanggang pitong beses na mas mahal irekord kaysa sa gastos ng pag-train dito, bago ang calibration, camera setup at ang mga episode na itinatapon mo. Kaya naman ang ay may direktang halaga sa dolyar. Ang gabay ng lerobot ay nagmumungkahi ng hindi bababa sa 50 episode na may 10 bawat lokasyon ng bagay; ang mga dokumento ng SmolVLA ay nag-uulat na ang isang 25-episode na bersyon ng parehong gawain ay hindi sapat.

Kung saan talaga nawawala ang pera

1. Mga pagpapatakbo sa data na hindi kailanman gagana

Ang isang 20,000-step na pagpapatakbo ng GR00T sa isang dataset na may dalawang pinagpalit na camera stream ay pareho ang gastos sa isang malinis na dataset, pareho ang oras na kinakailangan, at gumagawa ng loss curve na mukhang maayos. Ang pagkabigo ay lumalabas sa braso, pagkalipas ng ilang oras. Ang ay sinisingil kada oras at ang diagnosis ay sinisingil sa mga araw. Dalawang sintomas na dapat tandaan: ang ay karaniwang nangangahulugang ang mga obserbasyon ay hindi nagdadala ng kailangan ng gawain, at ang ay nangangahulugang ang dataset ay may mas kaunting variation kaysa sa iyong inakala.

2. Pagbabayad ng presyo ng foundation-model para sa isang gawain na may nakapirming kamera

Ang ACT ay humigit-kumulang 80M na parameter at idinisenyo upang magsanay mula sa simula sa 50 demonstrasyon ng isang gawain. Ang GR00T N1.7 ay humigit-kumulang 3B na may pretrained na backbone. Para sa isang nakakabit na kamera, isang nakapirming mesa at isang bagay, ang 80M na modelo ay madalas na nakakamit ang layunin, tumatakbo sa humigit-kumulang 20 ms bawat hakbang ng aksyon sa halip na 152 ms, at nagkakahalaga ng 1 hanggang 3 USD bawat pagtakbo sa halip na 4 hanggang 12. Gumastos ng 3 USD upang malaman kung gumagana ang murang modelo bago gumastos ng 12 USD sa mahal na modelo. ACT laban sa SmolVLA at GR00T N1.7 laban sa Pi0.5 ay nagpapakita kung saan humihinto ang bawat isa sa pagiging tamang sagot; ang arena ng modelo ay may 85 modelo at 332 resulta ng benchmark.

3. Ang GPU na nakalimutan mo

Ang pinakamurang pagkakamali na maiiwasan at ang pinakakaraniwan na nagagawa. Ang isang instance na sinimulan noong Biyernes upang mag-debug ng isang bagay ay sinisingil sa buong weekend sa parehong rate ng isang tunay na pagtakbo.

Sa AY-Robots, ang pagkabigong ito ay idinisenyo upang maiwasan para sa inference: ang mga pod na inilaan ng inference API ay may idle watchdog at sinisira ang kanilang sarili pagkatapos ng isang idle period. Kung ikaw mismo ang umupa ng card, ang watchdog na iyon ay ang iyong paalala sa kalendaryo.

4. Pagbabayad nang dalawang beses para sa parehong sagot

Ang entry point ng fine-tuning ng GR00T ay isang tyro CLI na hindi naglalantad ng seed. Hindi ito limitasyon ng platform, ito ay ang upstream tool: walang seed field sa gr00t/configs/finetune_config.py, at ang sariling training tips ng repository ay nagbabala na ang mga pagtakbo ay nag-iiba ng 5 to 6 percent dahil ang mga image augmentation ay non-deterministic. Ang lerobot ay nagde-default sa seed 1000 sa parehong 0.5.1 at 0.6.1, kaya ang mga pagtakbo ng ACT, SmolVLA at Pi0.5 ay maaaring ulitin mula sa parehong initialization at data order. Hindi ito pangako ng bit-identical na weights sa isang GPU, ngunit ito ang pagkakaiba sa pagitan ng isang rerun at isang bagong eksperimento. Kung ang isang pagtakbo ng GR00T ay gumagawa ng isang policy na gumagana at hindi mo napanatili ang checkpoint, babayaran mo ang buong presyo para sa isang resulta na maaaring magkaiba nang higit pa sa pagkakaiba na iyong hinahabol. Mayroong pangalawang paraan upang mawala ang isang checkpoint na binayaran mo: ang CLI ay nagde-default sa --save-total-limit 5, na idinokumento bilang ang maximum na bilang ng mga checkpoint na pinananatili bago burahin ang mga mas luma. Ang storage ay sentimo; ang isang rerun ay 4 to 12 USD at anim na oras.

Ang paggawa nito nang mag-isa kumpara sa pagpaparenta ng platform ng card

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

Ano ang sinisingil ng platform at paano nito pinipili ang card

Ang lohika ay sadyang simple. Bawat modelo sa katalogo, ay nagdedeklara ng GPU tier; kinukuha ng backend ang kinakailangang VRAM at umuupa ng katugmang card sa parehong spot market na sinusukat sa itaas. Iyan ang dahilan kung bakit ang nakasaad na gastos ay isang saklaw, hindi isang presyo. Ang GR00T at Pi0.5 ay cloud-only dito dahil sa 40 GB at 70 GB na minimum. Ang SmolVLA at ACT ay tumatakbo rin nang lokal sa iyong sariling 24 GB card, kung saan ang gastos sa cloud ay zero at ang kuryente ay iyong problema.

Isang setting ang nangangailangan ng babala. Ang gradient accumulation ay tunay na nalalapat para sa parehong variant ng GR00T, kaya ang pagtaas nito ay nagbibigay ng mas malaking effective batch sa parehong card. Para sa Pi0.5 at SmolVLA, hindi ito nalalapat: ang lerobot 0.5.1 ay walang opsyon sa gradient-accumulation sa training config nito, kaya ang pagtatakda ng field sa 16 ay walang gastos at walang benepisyo. Kung ang isang queued job ay hindi kailanman nagsisimula, ang pahina ng stuck-in-queue, ay sumasaklaw sa kung ano ang dapat suriin; kung ang dataset ay tinanggihan bago magsimula ang pagpapatakbo, halos palaging ito ay ang problema sa format ng v3.0.

Isang detalyadong badyet para sa unang gumaganang patakaran

Lahat ng apat na linya nang magkasama, simula sa wala. Ang kabuuang GPU ay nagpapalagay ng 3 hanggang 5 pagtakbo: ang una ay nagpapatunay na gumagana ang pipeline, ang pangalawa ay naglalantad ng problema sa data, ang pangatlo o ikaapat ang siyang pananatilihin mo.

Ang pattern ay nananatili sa laki ng robot na ito: ang compute ay isang rounding error, ang hardware ay isang tunay na one-time cost, ang oras ng tao ang paulit-ulit na gastos. Upang subukan ang kalahati ng pagsasanay bago bumili ng anuman, hinahayaan kang maghambing ng mga modelo at magrenta ng GPU nang walang braso, at ay isang pisikal na SO-100 na maaari mong paandarin sa browser nang walang pagpaparehistro. Para sa buong pipeline mula simula hanggang dulo, ang sumasaklaw sa setup, at pagsasanay, at ang maikling bersyon.