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 घंटे लेते हैं। प्लेटफ़ॉर्म वही 20,000 स्टेप्स सस्ते 24 GB टियर पर चलाता है, इसलिए 4 घंटे के बजाय एक विंडो मिलती है।
• ACT: मूल ALOHA पेपर एक 80M-पैरामीटर मॉडल के लिए सिंगल 11 GB RTX 2080 Ti पर लगभग 5 घंटे की रिपोर्ट करता है। एक 4090 कई पीढ़ियों नया है, लेकिन प्लेटफ़ॉर्म 100,000 स्टेप्स का बजट रखता है, इसलिए विंडो उसी जगह पर आती है।
• GR00T: N1.6 जनरेशन के लिए NVIDIA का संदर्भ वर्कफ़्लो आठ 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 तक के क्लस्टर पर, 16,384 के प्रीट्रेनिंग बैच आकार पर 200,000 ग्रेडिएंट स्टेप्स के लिए है। ऊपर मापी गई 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 dataset रिकॉर्डर डिफ़ॉल्ट सेटिंग्स के साथ आता है जो गणना को आसान बनाती हैं, ये तीनों DatasetRecordConfig: प्रति एपिसोड 60 सेकंड, दृश्य को रीसेट करने के लिए 60 सेकंड, 50 एपिसोड। नीचे दी गई पैसे की कॉलम किसी व्यक्ति के एक घंटे के समय के लिए 15 USD मानती है, जो एक धारणा है न कि प्लेटफ़ॉर्म संख्या। अपनी दर बदलें; अनुपात ही मुख्य बात है।

1. 1
   डिफ़ॉल्ट सेटिंग्स के साथ डेटासेट रिकॉर्ड करें जिनके लिए आपको वास्तव में बिल किया जाएगा

   यह lerobot 0.6.1 है, जो 3 अगस्त 2026 तक PyPI पर उपलब्ध संस्करण है। CLI आकार पर ध्यान दें: रिकॉर्डिंग पुराने python -m lerobot.scripts.record मॉड्यूल पथ के बजाय lerobot-record कंसोल एंट्री पॉइंट (lerobot.scripts.lerobot_record) के माध्यम से चलती है। AY-Robots 0.5.1 को लक्षित करता है, और 0.5.1 व्हील समान 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 टियर पर प्रति घंटे 2.00 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 डिफ़ॉल्ट रूप से 20,000 स्टेप्स पर सेट होता है, इसलिए एक डिफ़ॉल्ट 20,000-स्टेप SmolVLA रन अपना पहला चेकपॉइंट तब लिखता है जब रन पहले ही खत्म हो चुका होता है; इसे किराए पर लेने से पहले कम करें। --save_checkpoint_to_hub को --policy.repo_id की आवश्यकता होती है और lerobot 0.5.1 में मौजूद नहीं है, इसलिए उस संस्करण पर आप आउटपुट डायरेक्टरी को मशीन से खुद कॉपी करते हैं। नीचे दिया गया बैच आकार अपस्ट्रीम डॉक का उदाहरण है; AY-Robots फॉर्म SmolVLA के लिए 2 भेजता है और चेकपॉइंट्स के प्रकट होने पर ऑब्जेक्ट स्टोरेज में लिखता है।

   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

दाहिने कॉलम की तुलना 1 से 12 USD के रन लागत से करें। उस अनुमानित दर पर, 50-एपिसोड वाले डेटासेट को रिकॉर्ड करने में प्रशिक्षण लागत से दो से सात गुना अधिक खर्च आता है, जिसमें कैलिब्रेशन, कैमरा सेटअप और हटाए गए एपिसोड शामिल नहीं हैं। यही कारण है कि का सीधा मौद्रिक मूल्य है। lerobot गाइड प्रति वस्तु स्थान पर 10 के साथ कम से कम 50 एपिसोड का सुझाव देती है; SmolVLA डॉक्स रिपोर्ट करते हैं कि उसी कार्य का 25-एपिसोड वाला संस्करण पर्याप्त नहीं था।

पैसा वास्तव में कहाँ गायब होता है

1. ऐसे डेटा पर रन जो कभी काम नहीं करने वाला था

दो स्वैप्ड कैमरा स्ट्रीम वाले डेटासेट पर 20,000-स्टेप का 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 पर, यह विफलता अनुमान के लिए डिज़ाइन की गई है: अनुमान API द्वारा प्रावधानित पॉड्स एक निष्क्रिय वॉचडॉग ले जाते हैं और एक निष्क्रिय अवधि के बाद खुद को नष्ट कर देते हैं। यदि आप कार्ड खुद किराए पर लेते हैं, तो वह वॉचडॉग आपका कैलेंडर रिमाइंडर है।

4. एक ही उत्तर के लिए दो बार भुगतान करना

GR00T का फाइन-ट्यूनिंग एंट्री पॉइंट एक टायरो CLI है जो कोई सीड उजागर नहीं करता है। यह कोई प्लेटफॉर्म सीमा नहीं है, यह अपस्ट्रीम टूल है: gr00t/configs/finetune_config.py में कोई सीड फ़ील्ड नहीं है, और रिपॉजिटरी के अपने प्रशिक्षण सुझाव चेतावनी देते हैं कि रन 5 से 6 प्रतिशत तक भिन्न होते हैं क्योंकि इमेज ऑग्मेंटेशन गैर-नियतात्मक होते हैं। lerobot 0.5.1 और 0.6.1 दोनों में सीड 1000 पर डिफ़ॉल्ट होता है, इसलिए ACT, SmolVLA और Pi0.5 रन को कम से कम उसी इनिशियलाइज़ेशन और डेटा ऑर्डर से फिर से चलाया जा सकता है। यह GPU पर बिट-आइडेंटिकल वेट्स का वादा नहीं है, लेकिन यह एक रीरन और एक नए प्रयोग के बीच का अंतर है। यदि एक GR00T रन एक ऐसी पॉलिसी बनाता है जो काम करती है और आपने चेकपॉइंट नहीं रखा, तो आप एक ऐसे परिणाम के लिए पूरी कीमत चुकाते हैं जो उस अंतर से अधिक भिन्न हो सकता है जिसका आप पीछा कर रहे थे। आपके द्वारा भुगतान किए गए चेकपॉइंट को खोने का एक दूसरा तरीका है: CLI डिफ़ॉल्ट रूप से --save-total-limit 5 पर सेट होता है, जिसे पुराने चेकपॉइंट्स को हटाए जाने से पहले रखे जाने वाले चेकपॉइंट्स की अधिकतम संख्या के रूप में प्रलेखित किया गया है। स्टोरेज कुछ सेंट का है; एक रीरन 4 से 12 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 है जिसे आप बिना साइनअप के ब्राउज़र में चला सकते हैं। पूरी एंड-टू-एंड पाइपलाइन के लिए, सेटअप, और प्रशिक्षण को कवर करती है, और इसका संक्षिप्त संस्करण है।