VLA प्रशिक्षण लागत: फाइन-ट्यूनिङ रनको वास्तविक लागत कति हुन्छ

बिलमा चार लाइनहरू छन्, र GPU सबैभन्दा सानो हो

जब मानिसहरूले SO-100 को लागि भिजन-भाषा-कार्य मोडेल लाई फाइन-ट्यून गर्न कति खर्च लाग्छ भनेर सोध्छन्, उनीहरूले प्रायः GPU भाडाको बारेमा सोधिरहेका हुन्छन्। त्यो संख्या कार्डमा शुल्कको रूपमा देखिन्छ, त्यसैले यो वास्तविक लाग्छ। यो चार संख्याहरू मध्ये सबैभन्दा सानो पनि हो जसले एक काम गर्ने नीति को वास्तविक लागत कति हुन्छ भनेर निर्धारण गर्छ।

तलका प्रशिक्षण समयहरू पाँच मोडेलका आफ्नै पेपर र भण्डारहरूबाट लिइएका हुन्, हार्डवेयर लागत प्रकाशित बिल अफ मेटेरियलबाट, प्लेटफर्म नम्बरहरू AY-Robots बाट नीति सूची र मूल्य निर्धारण पृष्ठ। जहाँ प्लेटफर्मले मद्दत गर्दैन, यो लेखले त्यही भन्छ।

स्पट बजारमा एक GPU घण्टाको वास्तविक लागत कति हुन्छ

A100 घण्टाको लागि कुनै एक मूल्य छैन। vast.ai जस्तो बजारमा प्रत्येक होस्टले आफ्नै दर तोक्छ, र तपाईंले सुरु गर्ने प्रशिक्षण रन जुन मेसिन सस्तो र खाली छ, त्यसमा जान्छ। इमानदार जवाफ एक वितरण हो। यहाँ यो 23 अगस्ट 2026 मा 13:44 UTC मा मापन गरिएको छ: एकल पूर्ण कार्डहरू, माग अनुसार, वास्तविक 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

3B मोडेलहरूले सस्तो कार्ड किन प्रयोग गर्न सक्दैनन्

माथिका मध्यकहरूमा, एउटा 4090 घण्टा र एउटा H100 80 GB घण्टा लगभग छ गुणा फरक पर्छ। तपाईंलाई महँगो कार्डमा जान बाध्य पार्ने कुरा गति होइन, यो मेमोरी हो। openpi ले पूर्ण Pi0.5 को लागि न्यूनतम आवश्यकता राख्छ फाइन-ट्यून 70 GB मा, र NVIDIA ले GR00T को लागि 40 GB वा सोभन्दा बढी सिफारिस गर्छ। GR00T संख्या के होइन, त्यो ध्यान दिनुहोस्। यसको फाइन-ट्यून कन्फिगरेसनले पूर्वनिर्धारित रूपमा भाषा मोडेल र भिजुअल एन्कोडरलाई फ्रिज गर्छ (tune_llm र tune_visual False छन्, प्रोजेक्टर र डिफ्युजन हेड True छन्), त्यसैले क्याटलगले 3 B मध्ये लगभग 40 M प्रशिक्षित प्यारामिटरहरू सूचीबद्ध गर्दछ। 40 GB 3 B वजनहरूको लागि अप्टिमाइजर अवस्था होइन, यो जमेको ब्याकबोन र सक्रियताहरू हो। घटाइएको दायराका भेरियन्टहरू कम हुन्छन्: openpi को LoRA पाथलाई 22.5 GB चाहिन्छ र 4090 लाई नाम दिन्छ, र NVIDIA को Isaac Lab Arena कार्यप्रवाहले GR00T पोस्ट-प्रशिक्षणको लागि 24 GB एकल-GPU विकल्प सूचीबद्ध गर्दछ। प्लेटफर्मले प्रत्येक विक्रेताले वास्तवमा चलाउने कन्फिगरेसनको लागि प्रकाशित गरेको न्यूनतम आवश्यकतामा आधारित हुन्छ। pi0 फ्लो-म्याचिङ लेख ले त्यो कहाँबाट आउँछ भनेर बताउँछ।फ्लो-म्याचिङ फुटप्रिन्ट आउँछ।

त्यो तालिकाले गर्दा प्लेटफर्मले पाँच मोडेललाई दुई तहमा विभाजन गर्छ। GR00T N1.7, GR00T N1.5 र Pi0.5 A100 80 GB वा H100 मा जान्छन् किनभने विक्रेताहरूले त्यही माग गर्छन्। SmolVLA र ACT RTX 4090 वा कुनै पनि 24 GB कार्डमा जान्छन् किनभने त्यो साँच्चै पर्याप्त छ।

पाँचवटै मोडेलहरू वास्तवमा कति समयसम्म चल्छन्

रन टाइम लागतको अर्को आधा हो: यदि काम 40 मिनेटको छ भने प्रति घण्टा 2.00 USD अप्रासंगिक हुन्छ र यदि यो 40 घण्टाको छ भने विनाशकारी हुन्छ। यी AY-Robots ले प्रशिक्षकलाई पठाउने पूर्वनिर्धारित सेटिङहरू हुन्, प्रत्येक टियरको लागि रन विन्डो र लागत सहित।

ती रन विन्डोहरू अपस्ट्रिमबाट कहाँ आउँछन्

• SmolVLA: lerobot को डकुमेन्टेसनले बताउँछ कि 20,000 स्टेप्स एउटा A100 मा लगभग 4 घण्टा लाग्छ। प्लेटफर्मले सस्तो 24 GB टियरमा उही 20,000 स्टेप्स चलाउँछ, त्यसैले 4 घण्टाको सट्टा एउटा विन्डो हुन्छ।
• ACT: मूल ALOHA पेपरले 80M-प्यारामिटर मोडेलका लागि एउटा 11 GB RTX 2080 Ti मा लगभग 5 घण्टा लाग्ने रिपोर्ट गर्छ। 4090 धेरै पुस्ता नयाँ भए पनि प्लेटफर्मले 100,000 स्टेप्सको बजेट राख्छ, त्यसैले विन्डो उही ठाउँमा पर्छ।
• GR00T: NVIDIA को N1.6 जेनेरेसनका लागि सन्दर्भ कार्यप्रवाहले आठ L40S कार्डहरूमा ब्याच 24 मा 20,000 स्टेप्सका लागि लगभग 4 देखि 8 घण्टा, र एउटा Ada 6000 मा ब्याच 16 मा 30,000 स्टेप्सका लागि 2 देखि 3 घण्टा लाग्ने उल्लेख गर्छ। केही घण्टामा 3B VLA को सिंगल-कार्ड फाइन-ट्युनिङ सामान्य हो, आशावादी होइन।
• Pi0.5: openpi ले कुनै वाल-क्लक फिगर प्रकाशित गर्दैन, तर यसले पूर्ण फाइन-ट्युनका लागि 70 GB को न्यूनतम आवश्यकता प्रकाशित गर्छ, जसले कार्ड र त्यसैले दर निर्धारण गर्छ।

तपाईंले भुक्तानी नगरेको संख्यामा विचार गर्न लायक छ। GR00T N1 पेपरले 2.2B मोडेललाई प्रिट्रेन गर्न लगभग 50,000 H100 GPU घण्टा लाग्ने रिपोर्ट गर्छ, जुन 1024 GPUs सम्मको क्लस्टरमा, 200,000 ग्रेडियन्ट स्टेप्सका लागि 16,384 को प्रिट्रेनिङ ब्याच साइजमा गरिएको थियो। माथि मापन गरिएको प्रति घण्टा 1.34 देखि 2.34 USD को दरमा, त्यो 67,000 देखि 117,000 USD बराबरको भाडाको कम्प्युट हो। SmolVLA पेपरले यसको परियोजनालाई 481 सामुदायिक डेटासेट, 22.9K एपिसोड र 10.6M फ्रेमहरूमा लगभग 30,000 GPU घण्टा लाग्ने बताउँछ। तपाईंले डाउनलोडको मूल्यमा यो सबै प्राप्त गर्नुहुन्छ; तपाईंको 8 USD ले अन्तिम 20,000 स्टेप्स खरिद गर्छ। VLAs यसरी किन बनाइन्छ ले त्यो विभाजनलाई समेट्छ।

आर्म: एक पटकको लागत जसले GPU बिललाई पनि सानो बनाउँछ

एक तालिम सञ्चालनको लागत खाजाभन्दा कम हुन्छ। रोबोटको हुँदैन। त्यसैले SO-100 महत्त्वपूर्ण छ: यो सम्पूर्ण नक्कल सिकाइ टूलचेनले वास्तवमा समर्थन गर्छ।

SO-ARM100 भण्डारमा रहेको अपस्ट्रिम सामग्रीको बिल अझ विस्तृत छ र तपाईंको क्षेत्र अनुसार जाँच गर्न लायक छ: यसको दुई आर्मका लागि पुर्जाहरू सूचीले लिडर प्लस फलोअर सेटअपका लागि कुल 229.88 USD वा 226.30 EUR देखाउँछ, र यसको एक फलोअर आर्मका लागि पुर्जाहरू सूचीले कुल 121.94 USD वा 124.30 EUR देखाउँछ। 13.89 USD प्रति सर्भोका दरले छ वटा STS3215 सर्भोहरू त्यस 121.94 मध्ये 83.34 हुन्छन्, त्यसैले सर्भोहरू नै आर्म हुन्। प्रति SmolVLA वा ACT सञ्चालन 1 देखि 3 USD मा, एक जोडी आर्मको मूल्य 77 देखि 230 तालिम सञ्चालन बराबर हुन्छ। यदि तपाईं अझै छनौट गर्दै हुनुहुन्छ भने, SO-100 बनाम SO-101 महत्त्वपूर्ण तुलना हो, किनभने दुई यति नजिक छन् कि निर्णय क्षमता भन्दा उपलब्धताको बारेमा हो।

मानव घण्टा: त्यो लाइन जुन कसैले स्प्रेडसिटमा राख्दैन

यो त्यो संख्या हो जसले लागतको छलफललाई उल्टो पार्छ। प्रदर्शन रेकर्ड गर्नु भनेको एक व्यक्तिले रोबोटको पाखुरालाई एक पटकमा एक एपिसोड, वास्तविक समयमा चलाउनु हो। यसलाई ब्याच गर्न सकिँदैन र प्रति सेकेन्ड भाडामा लिन सकिँदैन। LeRobot डेटासेट रेकर्डर पूर्वनिर्धारित सेटिङहरूसँग आउँछ जसले अंकगणितलाई सजिलो बनाउँछ, ती तीनवटै DatasetRecordConfig: ६० सेकेन्ड प्रति एपिसोड, ६० सेकेन्ड दृश्य रिसेट गर्न, ५० एपिसोड। तलको पैसा स्तम्भले कसैको एक घण्टाको समयको लागि १५ USD मान्छ, जुन प्लेटफर्मको संख्या भन्दा बढी अनुमान हो। आफ्नो दर बदल्नुहोस्; अनुपात नै मुख्य कुरा हो।

1. 1
   तपाईंलाई वास्तवमा बिल गरिने पूर्वनिर्धारित सेटिङहरूसँग डेटासेट रेकर्ड गर्नुहोस्

   यो lerobot ०.६.१ हो, PyPI मा ३ अगस्ट २०२६ सम्मको संस्करण। CLI आकारमा ध्यान दिनुहोस्: रेकर्डिङ lerobot-record कन्सोल एन्ट्री पोइन्ट (lerobot.scripts.lerobot_record) मार्फत चल्छ, पुरानो python -m lerobot.scripts.record मोड्युल पाथ मार्फत होइन। AY-Robots ले ०.५.१ लाई लक्षित गर्छ, र ०.५.१ व्हीलले उही lerobot-record र lerobot-train एन्ट्री पोइन्टहरू घोषणा गर्दछ, त्यसैले तलको आकार दुवैमा स्थिर छ। तीनवटा समय निर्धारण फ्ल्यागहरू अपस्ट्रीम पूर्वनिर्धारित हुन्, त्यसैले यो त्यो आदेश पनि हो जुन अर्को तालिकामा अंकगणितले मान्छ।

   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
   एउटै GPU मिनेट भाडामा लिनु अघि तपाईंले के रेकर्ड गर्नुभयो हेर्नुहोस्

   डेटासेट निरीक्षण गर्दा प्रति घण्टा शून्य USD लाग्छ। लस कर्भबाट उही समस्या पत्ता लगाउँदा H100 टियरमा प्रति घण्टा २.०० USD लाग्छ र तपाईंलाई चार घण्टा ढिलो जानकारी दिन्छ। डेटासेट पुश गर्नुहोस् र यसलाई LeRobot दर्शकमा स्क्रब गर्नुहोस्, वा 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
   तालिम दिनुहोस्, र सुनिश्चित गर्नुहोस् कि चेकपोइन्ट पोड भन्दा लामो समयसम्म रहन्छ

   भाडामा लिइएको मेसिन परिभाषा अनुसार अस्थायी हुन्छ, त्यसैले रनको समयमा चेकपोइन्टहरू कतै टिकाऊ ठाउँमा लेख्नुहोस्। दुई फ्ल्यागहरूले तपाईंले तिरेको कुरा राख्नुहुन्छ कि राख्नुहुन्न भनेर निर्णय गर्छन्। --save_freq पूर्वनिर्धारित रूपमा २०,००० स्टेप्समा हुन्छ, त्यसैले पूर्वनिर्धारित २०,०००-स्टेप SmolVLA रनले यसको पहिलो चेकपोइन्ट रन समाप्त भइसकेपछि लेख्छ; कुनै पनि अवरोधयोग्य चीज भाडामा लिनु अघि यसलाई कम गर्नुहोस्। --save_checkpoint_to_hub लाई --policy.repo_id चाहिन्छ र lerobot ०.५.१ मा अवस्थित छैन, त्यसैले त्यो संस्करणमा तपाईंले आउटपुट डाइरेक्टरी आफैं मेसिनबाट प्रतिलिपि गर्नुहुन्छ। तलको ब्याच साइज अपस्ट्रीम कागजातको उदाहरण हो; AY-Robots फारमले SmolVLA को लागि २ पठाउँछ र चेकपोइन्टहरू देखा पर्दा वस्तु भण्डारणमा लेख्छ।

   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

दायाँपट्टिको स्तम्भलाई रनको लागत १ देखि १२ USD सँग तुलना गर्नुहोस्। त्यो अनुमानित दरमा, क्यालिब्रेसन, क्यामेरा सेटअप र तपाईंले फ्याँक्ने एपिसोडहरू बाहेक, ५०-एपिसोडको डेटासेट रेकर्ड गर्न तालिम दिन लाग्ने भन्दा दुई देखि सात गुणा बढी खर्च लाग्छ। त्यसैले को प्रत्यक्ष डलर मूल्य छ। lerobot गाइडले प्रत्येक वस्तुको स्थानमा १० सहित कम्तिमा ५० एपिसोडहरू सुझाव दिन्छ; SmolVLA कागजातहरूले सोही कार्यको २५-एपिसोड संस्करण पर्याप्त नभएको रिपोर्ट गर्दछ।

पैसा वास्तवमा कहाँ हराउँछ

१. कहिल्यै काम नगर्ने डेटामा चल्ने रनहरू

दुईवटा साटिएका क्यामेरा स्ट्रिम भएको डेटासेटमा २०,०००-स्टेपको GR00T रनको लागत सफा डेटासेटमा भएको रन जत्तिकै हुन्छ, उही समय लाग्छ, र राम्रो देखिने लस कर्भ उत्पादन गर्छ। त्रुटि घण्टौंपछि पाखुरामा देखिन्छ। घण्टाको आधारमा बिल गरिन्छ र निदान दिनको आधारमा बिल गरिन्छ। याद राख्नुपर्ने दुई लक्षणहरू: सामान्यतया यसको अर्थ अवलोकनहरूले कार्यलाई चाहिने कुरा बोक्दैनन्, र यसको अर्थ डेटासेटमा तपाईंले सोचेभन्दा कम भिन्नता थियो।

2. स्थिर-क्यामेरा कार्यको लागि फाउन्डेसन-मोडेलको मूल्य तिर्दै

ACT लगभग 80M प्यारामिटरको छ र यसलाई एउटै कार्यको 50 प्रदर्शनबाट सुरुदेखि नै तालिम दिन डिजाइन गरिएको थियो। GR00T N1.7 लगभग 3B को छ जसमा पूर्व-प्रशिक्षित ब्याकबोन छ। बोल्ट गरिएको क्यामेरा, स्थिर टेबल र एउटा वस्तुको लागि, 80M मोडेल प्रायः त्यहाँ पुग्छ, 152 ms को सट्टा प्रति कार्य चरण लगभग 20 ms मा चल्छ, र 4 देखि 12 USD को सट्टा प्रति रन 1 देखि 3 USD खर्च हुन्छ। महँगो मोडेलमा 12 USD खर्च गर्नु अघि सस्तो मोडेलले काम गर्छ कि गर्दैन भनेर पत्ता लगाउन 3 USD खर्च गर्नुहोस्। ACT बनाम SmolVLA र GR00T N1.7 बनाम Pi0.5 ले देखाउँछ कि प्रत्येक कहाँ सही उत्तर हुन छोड्छ; मोडेल एरिना मा 85 मोडेल र 332 बेन्चमार्क परिणामहरू छन्।

3. तपाईंले बिर्सनुभएको GPU

रोक्नको लागि सबैभन्दा सस्तो गल्ती र गर्नको लागि सबैभन्दा सामान्य गल्ती। शुक्रबार डिबग गर्न सुरु गरिएको एउटा इन्स्ट्यान्सले सप्ताहन्तभरि वास्तविक रनको समान दरमा बिल गर्छ।

AY-Robots मा, यो त्रुटि अनुमान (inference) को लागि हटाइएको छ: अनुमान API द्वारा प्रदान गरिएका पोडहरूले निष्क्रिय वाचडग बोक्छन् र निष्क्रिय अवधि पछि आफैं नष्ट हुन्छन्। यदि तपाईंले कार्ड आफैं भाडामा लिनुभयो भने, त्यो वाचडग तपाईंको पात्रो रिमाइन्डर हो।

४. एउटै उत्तरको लागि दुई पटक भुक्तानी

GR00T को फाइन-ट्युनिङ प्रवेश बिन्दु एक tyro CLI हो जसले कुनै सीड (seed) देखाउँदैन। त्यो प्लेटफर्मको सीमा होइन, यो अपस्ट्रिम उपकरण हो: gr00t/configs/finetune_config.py मा कुनै सीड फिल्ड छैन, र भण्डारको आफ्नै प्रशिक्षण सुझावहरूले चेतावनी दिन्छ कि छवि वृद्धिहरू गैर-निर्धारित (non-deterministic) भएकाले रनहरू ५ देखि ६ प्रतिशतले फरक पर्न सक्छन्। lerobot ले 0.5.1 र 0.6.1 दुवैमा सीड १००० लाई पूर्वनिर्धारित गर्दछ, त्यसैले ACT, SmolVLA र Pi0.5 रनहरू कम्तिमा पनि समान प्रारम्भिकरण र डेटा क्रमबाट पुन: चलाउन सकिन्छ। त्यो GPU मा बिट-एकै वजनको प्रतिज्ञा होइन, तर यो पुन: रन र नयाँ प्रयोग बीचको भिन्नता हो। यदि GR00T रनले काम गर्ने नीति उत्पादन गर्छ र तपाईंले चेकपोइन्ट राख्नुभएन भने, तपाईंले खोजिरहनुभएको भिन्नता भन्दा बढी फरक हुन सक्ने परिणामको लागि पूरा मूल्य तिर्नुहुन्छ। तपाईंले भुक्तानी गरेको चेकपोइन्ट गुमाउने दोस्रो तरिका छ: CLI ले --save-total-limit 5 लाई पूर्वनिर्धारित गर्दछ, जुन पुराना चेकपोइन्टहरू मेटिनु अघि राखिने चेकपोइन्टहरूको अधिकतम संख्याको रूपमा दस्तावेज गरिएको छ। भण्डारण सेन्टमा छ; एक पुन: रन ४ देखि १२ USD र छ घण्टा लाग्छ।

आफैंले गर्ने कि प्लेटफर्मलाई कार्ड भाडामा दिन दिने

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

प्लेटफर्मले के शुल्क लिन्छ र यसले कार्ड कसरी छान्छ

तर्क जानाजानी सरल छ। प्रत्येक मोडेल क्याटलग मा GPU टियर घोषणा गर्दछ; ब्याकएन्डले आवश्यक VRAM लिन्छ र माथि मापन गरिएको सोही स्पट बजारमा मिल्दो कार्ड भाडामा लिन्छ। त्यसैले उद्धृत लागत एक दायरा हो, मूल्य होइन। GR00T र Pi0.5 यहाँ 40 GB र 70 GB को न्यूनतम आवश्यकताका कारण क्लाउड-मात्र हुन्। SmolVLA र ACT तपाईंको आफ्नै 24 GB कार्डमा स्थानीय रूपमा पनि चल्छन्, जहाँ क्लाउड लागत शून्य हुन्छ र बिजुली तपाईंको समस्या हो।

एउटा सेटिङमा चेतावनी आवश्यक छ। ग्रेडियन्ट एक्युमुलेसन GR00T का दुवै भेरियन्टहरूमा साँच्चै लागू हुन्छ, त्यसैले यसलाई बढाउँदा एउटै कार्डमा ठूलो प्रभावकारी ब्याच प्राप्त हुन्छ। Pi0.5 र SmolVLA को लागि यो बिल्कुल लागू हुँदैन: lerobot 0.5.1 को प्रशिक्षण कन्फिगमा कुनै ग्रेडियन्ट-एक्युमुलेसन विकल्प छैन, त्यसैले फिल्डलाई 16 मा सेट गर्दा केही खर्च हुँदैन र केही प्राप्त हुँदैन। यदि कतारमा रहेको काम कहिल्यै सुरु भएन भने, कतारमा अड्किएको पृष्ठ ले के जाँच गर्ने भनेर समेट्छ; यदि रन सुरु हुनु अघि डेटासेट अस्वीकृत भयो भने, यो प्रायः सधैं v3.0 ढाँचा समस्या।

पहिलो कार्यशील नीतिका लागि तयार पारिएको बजेट

सबै चार लाइनहरू एकसाथ, केही नभएकोबाट सुरु गर्दै। GPU कुलले 3 देखि 5 रन मान्छ: पहिलोले पाइपलाइनले काम गर्छ भनेर प्रमाणित गर्छ, दोस्रोले डेटा समस्या उजागर गर्छ, तेस्रो वा चौथो तपाईंले राख्नुहुनेछ।

यस आकारको रोबोटमा पनि ढाँचा उस्तै रहन्छ: कम्प्युट एक सामान्य त्रुटि हो, हार्डवेयर एक वास्तविक एक-पटकको लागत हो, मानव घण्टा आवर्ती खर्च हो। कुनै पनि चीज किन्नु अघि प्रशिक्षण आधा परीक्षण गर्न, ले तपाईंलाई मोडेलहरू तुलना गर्न र हात बिना नै GPU भाडामा लिन दिन्छ, र एउटा भौतिक SO-100 हो जसलाई तपाईं ब्राउजरमा कुनै साइनअप बिना चलाउन सक्नुहुन्छ। सम्पूर्ण पाइपलाइनको लागि, ले सेटअप, र प्रशिक्षण समेट्छ, र यसको छोटो संस्करण हो।