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 వరకు ఉన్న క్లస్టర్‌లో, 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 అనేది ముఖ్యమైన పోలిక, ఎందుకంటే రెండూ చాలా దగ్గరగా ఉంటాయి కాబట్టి నిర్ణయం సామర్థ్యం కంటే లభ్యత గురించి ఉంటుంది.

మానవ గంటలు: స్ప్రెడ్‌షీట్‌లో ఎవరూ చేర్చని అంశం

ఇది ఖర్చు చర్చను తలక్రిందులు చేసే సంఖ్య. ప్రదర్శనలను రికార్డ్ చేయడం అంటే ఒక వ్యక్తి రోబోట్ ఆర్మ్‌ను, ఒక ఎపిసోడ్‌ను ఒకేసారి, నిజ సమయంలో కదపడం. దీన్ని బ్యాచ్‌గా చేయలేము మరియు సెకనుకు అద్దెకు తీసుకోలేము. ది లీరోబోట్ డేటాసెట్ రికార్డర్ డిఫాల్ట్‌లతో వస్తుంది, ఇవి గణనను సులభతరం చేస్తాయి, ఈ మూడు కూడా DatasetRecordConfig: ప్రతి 60 సెకన్లు ఎపిసోడ్, సన్నివేశాన్ని రీసెట్ చేయడానికి 60 సెకన్లు, 50 ఎపిసోడ్‌లు. దిగువన ఉన్న డబ్బు కాలమ్ ఒకరి సమయానికి గంటకు 15 USD అని ఊహిస్తుంది, ఇది ప్లాట్‌ఫారమ్ సంఖ్య కాకుండా ఒక ఊహ. మీ స్వంత రేటును ప్రత్యామ్నాయం చేయండి; నిష్పత్తి ముఖ్యం.

1. 1
   మీరు వాస్తవానికి బిల్ చేయబడే డిఫాల్ట్‌లతో డేటాసెట్‌ను రికార్డ్ చేయండి

   ఇది లీరోబోట్ 0.6.1, 2026 ఆగస్టు 3 నాటికి 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 అవసరం మరియు లీరోబోట్ 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. మొత్తం పైప్‌లైన్ ఎండ్-టు-ఎండ్ కోసం, పూర్తి SO-100 గైడ్ సెటప్, టెలిఆపరేషన్ మరియు శిక్షణను కవర్ చేస్తుంది, మరియు మీ మొదటి పాలసీకి శిక్షణ ఇవ్వండి అనేది సంక్షిప్త వెర్షన్.