Gharama ya Mafunzo ya VLA: Uendeshaji wa Kurekebisha Kweli Unagharimu Kiasi Gani

Bili ina mistari minne, na GPU ndio mdogo zaidi

Watu wanapouliza inagharimu kiasi gani kurekebisha modeli ya lugha-maono-vitendo kwa SO-100, karibu kila mara wanamaanisha kukodisha GPU. Hiyo ndiyo namba inayoonekana kama malipo kwenye kadi, kwa hivyo ndiyo inayohisi halisi. Pia, kwa tofauti kubwa, ndiyo ndogo zaidi kati ya namba nne zinazoamua ni kiasi gani sera inayofanya kazi inakugharimu.

Nyakati za mafunzo hapa chini zinatokana na karatasi na hifadhi za miundo mitano yenyewe, gharama ya maunzi kutoka kwenye orodha ya vifaa iliyochapishwa, namba za jukwaa kutoka AY-Robots orodha ya sera na ukurasa wa bei. Pale ambapo jukwaa halisaidii, makala haya yanasema hivyo.

Gharama halisi ya saa ya GPU kwenye soko la papo hapo

Hakuna bei moja ya saa ya A100. Kwenye soko kama vast.ai kila mwenyeji huweka kiwango chake, na mchakato wa mafunzo unaozindua hutua kwenye mashine yoyote iliyo nafuu na huru kwa wakati huo. Jibu la uaminifu ni usambazaji. Hapa ndio, iliyopimwa Agosti 23, 2026 saa 13:44 UTC: kadi kamili moja, kwa mahitaji, iliyochujwa na VRAM halisi.

# 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

Kwa nini mifumo ya 3B haiwezi kutumia kadi ya bei nafuu

Saa ya 4090 na saa ya H100 80 GB hutofautiana kwa takriban mara sita kwenye wastani ulio hapo juu. Kinachokulazimisha kutumia kadi ghali si kasi, bali ni kumbukumbu. openpi inaweka kiwango cha chini kwa Pi0.5 kamili urekebishaji-laini kwa 70 GB, na NVIDIA inapendekeza 40 GB au zaidi kwa GR00T. Kumbuka nambari ya GR00T si nini. Usanidi wake wa urekebishaji-laini hugandisha modeli ya lugha na kirekebisha-taswira kwa chaguo-msingi (tune_llm na tune_visual ni False, projekta na kichwa cha usambazaji ni True), ndiyo maana katalogi inaorodhesha takriban vigezo 40 M vilivyofunzwa kati ya 3 B. 40 GB si hali ya kiboreshaji kwa uzito wa 3 B, bali ni uti wa mgongo uliogandishwa pamoja na uanzishaji. Toleo zenye wigo uliopunguzwa hushuka chini: njia ya LoRA ya openpi inahitaji 22.5 GB na inataja 4090, na mtiririko wa kazi wa Isaac Lab Arena wa NVIDIA unaorodhesha chaguo la 24 GB la GPU moja kwa mafunzo ya baada ya GR00T. Jukwaa linaweka viwango kulingana na kiwango cha chini ambacho kila muuzaji huchapisha kwa usanidi unaoendeshwa. Maelezo ya pi0 flow-matching inaeleza ni wapi upatanishi wa mtiririko nyayo hiyo inatoka.

Jedwali hilo ndilo sababu jukwaa linagawanya modeli tano katika viwango viwili. GR00T N1.7, GR00T N1.5 na Pi0.5 huendeshwa kwenye A100 80 GB au H100 kwa sababu ndicho wanachohitaji wauzaji. SmolVLA na ACT huendeshwa kwenye RTX 4090 au kadi yoyote ya 24 GB kwa sababu hiyo inatosha kabisa.

Muda halisi wa uendeshaji wa kila moja ya mifumo mitano

Muda wa uendeshaji ni nusu nyingine ya gharama: 2.00 USD kwa saa hauna maana ikiwa kazi ni dakika 40 na ni mbaya ikiwa ni saa 40. Hizi ndizo mipangilio chaguomsingi AY-Robots hutuma kwa mkufunzi, pamoja na dirisha la uendeshaji na gharama kwa kila ngazi.

Vyanzo vya makadirio hayo ya muda wa utekelezaji kutoka juu

• SmolVLA: nyaraka za lerobot zinasema kuwa hatua 20,000 huchukua takriban saa 4 kwenye A100 moja. Jukwaa huendesha hatua hizo 20,000 kwenye kiwango cha bei nafuu cha 24 GB, hivyo basi kuna dirisha la muda badala ya saa 4 kamili.
• ACT: karatasi asili ya ALOHA inaripoti takriban saa 5 kwenye RTX 2080 Ti moja ya 11 GB kwa modeli yenye vigezo milioni 80. Kadi ya 4090 ni ya vizazi kadhaa vipya zaidi lakini jukwaa linatenga bajeti ya hatua 100,000, kwa hivyo dirisha la muda linaangukia mahali pale pale.
• GR00T: Mfumo wa kazi wa marejeleo wa NVIDIA kwa kizazi cha N1.6 unataja takriban saa 4 hadi 8 kwa hatua 20,000 kwa batch 24 kwenye kadi nane za L40S, na saa 2 hadi 3 kwa hatua 30,000 kwa batch 16 kwenye Ada 6000 moja. Kufanya 'fine-tuning' ya VLA ya 3B kwa kutumia kadi moja ndani ya saa chache ni jambo la kawaida, si matumaini makubwa.
• Pi0.5: openpi haichapishi takwimu za muda halisi, lakini inachapisha kiwango cha chini cha 70 GB kwa 'fine-tune' kamili, jambo linalobainisha kadi na hivyo basi kasi.

Inafaa kusitisha kidogo kwenye namba ambayo hulipi. Karatasi ya GR00T N1 inaripoti takriban saa 50,000 za H100 GPU kwa ajili ya kutoa mafunzo ya awali kwa modeli ya 2.2B, kwenye kundi la hadi GPU 1024, kwa ukubwa wa batch ya mafunzo ya awali ya 16,384 kwa hatua 200,000 za gradient. Kwa USD 1.34 hadi 2.34 kwa saa iliyopimwa hapo juu, hiyo ni takriban USD 67,000 hadi 117,000 za kompyuta iliyokodishwa. Karatasi ya SmolVLA inaweka mradi wake kwa takriban saa 30,000 za GPU kwenye seti data 481 za jamii, vipindi 22.9K na fremu 10.6M. Unarithi yote kwa bei ya kupakua; USD 8 zako zinanunua hatua 20,000 za mwisho. Kwa nini VLAs hujengwa kwa njia hii inafafanua mgawanyiko huo.

Mkono: gharama ya mara moja inayofunika bili ya GPU

Mafunzo hugharimu chini ya chakula cha mchana. Roboti haigharimu hivyo. Ndiyo maana SO-100 ni muhimu: ni mkono wa bei nafuu zaidi ambao mfumo mzima wa zana wa ujifunzaji wa kuiga unasaidia.

Orodha ya vifaa vya juu katika hazina ya SO-ARM100 ni ya kina zaidi na inafaa kuangaliwa kulingana na eneo lako: orodha yake ya Sehemu za Mikono Miwili inafikia jumla ya 229.88 USD au 226.30 EUR kwa usanidi wa kiongozi na mfuasi, na orodha yake ya Sehemu za Mkono Mmoja wa Mfuasi inafikia jumla ya 121.94 USD au 124.30 EUR. Servos sita za STS3215 kwa 13.89 USD kila moja ni 83.34 ya 121.94 hiyo, kwa hivyo servos ndio mkono. Kwa 1 hadi 3 USD kwa kila SmolVLA au ACT run, jozi moja ya mikono ina thamani ya kati ya mafunzo 77 na 230. Ikiwa bado unachagua, SO-100 dhidi ya SO-101 ndio ulinganisho muhimu, sababu hizo mbili ziko karibu kiasi kwamba uamuzi unahusu upatikanaji badala ya uwezo.

Saa za binadamu: mstari ambao hakuna anayeweka kwenye lahajedwali

Huu ndio namba inayogeuzia mjadala wa gharama kichwa chini. Kurekodi maonyesho ni mtu kusogeza mkono wa roboti, kipindi kimoja kwa wakati mmoja, kwa wakati halisi. Hakuna kuikusanya kwa wingi wala kuikodisha kwa sekunde. Kinasa cha seti ya data ya LeRobot kinakuja na mipangilio chaguomsingi inayofanya hesabu kuwa rahisi, zote tatu zimethibitishwa katika DatasetRecordConfig: sekunde 60 kwa kila kipindi, sekunde 60 kuweka upya eneo, vipindi 50. Safu wima ya pesa hapa chini inachukulia Dola 15 kwa saa moja ya muda wa mtu, ambayo ni dhana badala ya namba ya jukwaa. Badilisha kiwango chako mwenyewe; uwiano ndio muhimu.

1. 1
   Rekodi seti ya data kwa mipangilio chaguomsingi utakayotozwa gharama halisi

   Huu ni lerobot 0.6.1, toleo lililopo kwenye PyPI kufikia Agosti 3, 2026. Kumbuka umbo la CLI: kurekodi hupitia sehemu ya kuingilia ya koni ya lerobot-record (lerobot.scripts.lerobot_record), si njia ya moduli ya zamani ya python -m lerobot.scripts.record. AY-Robots inalenga 0.5.1, na gurudumu la 0.5.1 linatangaza sehemu zile zile za kuingilia za lerobot-record na lerobot-train, kwa hivyo umbo hapa chini ni thabiti kwa zote mbili. Bendera tatu za muda ni mipangilio chaguomsingi ya juu, kwa hivyo hii pia ndio amri ambayo hesabu katika jedwali linalofuata inachukulia.

   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
   Angalia ulichorekodi kabla ya kukodisha hata dakika moja ya GPU

   Kukagua seti ya data hugharimu Dola sifuri kwa saa. Kugundua tatizo lile lile kutoka kwenye mkondo wa hasara hugharimu Dola 2.00 kwa saa kwenye kiwango cha H100 na kukujulisha saa nne baadaye. Sukuma seti ya data na uichunguze kwenye kitazamaji cha LeRobot, au vinjari saraka ya seti za data ya 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
   Funza, na hakikisha sehemu ya kukagua inabaki hai baada ya pod

   Mashine iliyokodishwa ni ya muda mfupi kwa ufafanuzi, kwa hivyo andika sehemu za kukagua mahali salama wakati wa uendeshaji. Bendera mbili huamua kama utahifadhi ulicholipia. --save_freq inachaguomsingi hatua 20,000, kwa hivyo uendeshaji chaguomsingi wa SmolVLA wa hatua 20,000 huandika sehemu yake ya kwanza ya kukagua wakati uendeshaji tayari umekwisha; ipunguze kabla ya kukodisha chochote kinachoweza kukatizwa. --save_checkpoint_to_hub inahitaji --policy.repo_id na haipo katika lerobot 0.5.1, kwa hivyo kwenye toleo hilo unanakili saraka ya matokeo kutoka kwenye mashine mwenyewe. Ukubwa wa kundi hapa chini ni mfano wa hati ya juu; fomu ya AY-Robots hutuma 2 kwa SmolVLA na kuandika kwenye hifadhi ya vitu kadri sehemu za kukagua zinavyoonekana.

   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

Linganisha safu ya kulia na gharama ya uendeshaji ya 1 hadi 12 USD. Kwa kiwango hicho kilichokadiriwa, seti ya data ya vipindi 50 inagharimu mara mbili hadi saba zaidi kurekodi kuliko inavyogharimu kufundisha, kabla ya urekebishaji, usanidi wa kamera na vipindi unavyotupa. Ndiyo maana ina thamani ya moja kwa moja ya dola. Mwongozo wa lerobot unapendekeza angalau vipindi 50 na 10 kwa kila eneo la kitu; nyaraka za SmolVLA zinaripoti kuwa toleo la vipindi 25 la kazi hiyo hiyo halikutosha.

Ambapo pesa hupotea kweli

1. Uendeshaji kwenye data ambayo haingewahi kufanya kazi

Uendeshaji wa GR00T wa hatua 20,000 kwenye seti ya data yenye mitiririko miwili ya kamera iliyobadilishana inagharimu sawa na ule kwenye seti ya data safi, inachukua muda sawa, na inazalisha mkondo wa hasara unaoonekana sawa. Kushindwa huonekana kwenye mkono, masaa kadhaa baadaye. hulipwa kwa saa na utambuzi hulipwa kwa siku. Dalili mbili zinazostahili kukumbukwa: kwa kawaida inamaanisha kuwa uchunguzi haubebi kile ambacho kazi inahitaji, na inamaanisha kuwa seti ya data ilikuwa na tofauti ndogo kuliko ulivyofikiria.

2. Kulipa bei za modeli msingi kwa kazi ya kamera isiyohamishika

ACT ina takriban vigezo milioni 80 na iliundwa kufunzwa kuanzia mwanzo kwa maonyesho 50 ya kazi moja. GR00T N1.7 ina takriban bilioni 3 ikiwa na uti wa mgongo uliofunzwa awali. Kwa kamera iliyofungwa chini, meza isiyohamishika na kitu kimoja, modeli ya milioni 80 mara nyingi hufikia lengo, huendeshwa kwa takriban milisekunde 20 kwa kila hatua ya kitendo badala ya milisekunde 152, na gharama yake ni kati ya dola 1 hadi 3 kwa kila uendeshaji badala ya dola 4 hadi 12. Tumia dola 3 kujua kama modeli ya bei nafuu inafanya kazi kabla ya kutumia dola 12 kwa ile ya gharama kubwa. ACT dhidi ya SmolVLA na GR00T N1.7 dhidi ya Pi0.5 huonyesha wapi kila moja huacha kuwa jibu sahihi; uwanja wa modeli una modeli 85 na matokeo 332 ya vigezo.

3. GPU uliyoisahau

Kosa la bei nafuu zaidi kuzuia na la kawaida zaidi kufanya. Kifaa kilichoanzishwa Ijumaa kwa ajili ya kurekebisha hitilafu huhesabiwa gharama kwa wikiendi nzima kwa kiwango sawa na uendeshaji halisi.

Katika AY-Robots, hitilafu hii imeondolewa kwa ajili ya inference: pods zinazotolewa na inference API hubeba watchdog isiyofanya kazi na hujiharibu zenyewe baada ya kipindi cha kutofanya kazi. Ukikodi kadi mwenyewe, watchdog hiyo ni kikumbusho chako cha kalenda.

4. Kulipa mara mbili kwa jibu lile lile

Sehemu ya kuanzia ya GR00T ya fine-tuning ni tyro CLI ambayo haionyeshi seed yoyote. Hiyo siyo kikwazo cha jukwaa, ni zana ya asili: hakuna sehemu ya seed katika gr00t/configs/finetune_config.py, na vidokezo vya mafunzo vya hazina hiyo vinaonya kuwa majaribio hutofautiana kwa asilimia 5 hadi 6 kwa sababu nyongeza za picha si za uhakika. lerobot huweka seed 1000 kama chaguo-msingi katika 0.5.1 na 0.6.1, hivyo majaribio ya ACT, SmolVLA na Pi0.5 yanaweza angalau kurudiwa kutoka kwa uanzishaji na mpangilio wa data ule ule. Hiyo si ahadi ya uzito unaofanana kabisa kwenye GPU, lakini ni tofauti kati ya kurudia na jaribio jipya. Ikiwa jaribio la GR00T linazalisha sera inayofanya kazi na hukuhifadhi sehemu ya kukagua, unalipa bei kamili kwa matokeo ambayo yanaweza kutofautiana zaidi ya tofauti uliyokuwa ukiifuata. Kuna njia ya pili ya kupoteza sehemu ya kukagua uliyolipia: CLI huweka chaguo-msingi la --save-total-limit 5, iliyoandikwa kama idadi ya juu zaidi ya sehemu za kukagua zinazohifadhiwa kabla ya zile za zamani kufutwa. Hifadhi ni senti; kurudia ni 4 hadi 12 USD na saa sita.

Kufanya mwenyewe dhidi ya kuruhusu jukwaa kukodisha kadi

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

Jinsi jukwaa linavyotoza na jinsi linavyochagua kadi

Mantiki imekusudiwa kuwa rahisi. Kila modeli katika orodha inatangaza kiwango cha GPU; mfumo wa nyuma huchukua VRAM inayohitajika na kukodisha kadi inayolingana kwenye soko lile lile la papo hapo lililopimwa hapo juu. Ndiyo maana gharama iliyonukuliwa ni safu, si bei. GR00T na Pi0.5 zinapatikana kwenye wingu pekee hapa kwa sababu ya viwango vya chini vya 40 GB na 70 GB. SmolVLA na ACT pia huendeshwa ndani ya nchi kwenye kadi yako mwenyewe ya 24 GB, ambapo gharama ya wingu ni sifuri na umeme ni tatizo lako.

Kipengele kimoja kinahitaji onyo. Mkusanyiko wa gradient unatumika kikweli kwa aina zote mbili za GR00T, kwa hivyo kuongeza huku kunanunua kundi kubwa zaidi la ufanisi kwenye kadi ile ile. Kwa Pi0.5 na SmolVLA haitumiki kabisa: lerobot 0.5.1 haina chaguo la mkusanyiko wa gradient katika usanidi wake wa mafunzo, kwa hivyo kuweka uga kuwa 16 hakugharimu chochote na hakununui chochote. Ikiwa kazi iliyopangwa haianzi kamwe, ukurasa wa kazi iliyokwama kwenye foleni inashughulikia nini cha kuangalia; ikiwa seti ya data inakataliwa kabla ya uendeshaji kuanza, karibu kila mara ni tatizo la umbizo la v3.0.

Bajeti iliyofanyiwa kazi kwa sera ya kwanza inayofanya kazi

Mistari yote minne pamoja, kuanzia mwanzo. Jumla ya GPU inachukua mizunguko 3 hadi 5: wa kwanza unathibitisha kuwa bomba linafanya kazi, wa pili unafunua tatizo la data, wa tatu au wa nne ndio unaohifadhi.

Mfumo huu unatumika kwa ukubwa huu wa roboti: hesabu ni makosa madogo, maunzi ni gharama halisi ya mara moja, saa za binadamu ndio gharama inayojirudia. Ili kujaribu nusu ya mafunzo kabla ya kununua chochote, hukuruhusu kulinganisha mifumo na kukodisha GPU bila mkono, na ni SO-100 halisi unayoweza kuendesha kwenye kivinjari bila kujisajili. Kwa mchakato mzima kuanzia mwanzo hadi mwisho, inashughulikia usanidi, na mafunzo, na ni toleo fupi.