VLA பயிற்சி செலவு: ஒரு ஃபைன்-ட்யூனிங் ரன் உண்மையில் எவ்வளவு செலவாகும்

கணக்கிற்கு நான்கு வரிகள் உள்ளன, மேலும் GPU தான் மிகச்சிறிய ஒன்று

ஒரு பார்வை-மொழி-செயல் மாதிரி SO-100 க்காக நன்றாகச் சரிசெய்ய எவ்வளவு செலவாகும் என்று மக்கள் கேட்கும்போது, அவர்கள் கிட்டத்தட்ட எப்போதும் GPU வாடகையைக் குறிக்கிறார்கள். அது ஒரு கார்டில் கட்டணமாகத் தோன்றும் எண், எனவே அதுதான் உண்மையானதாக உணர்கிறது. இது ஒரு பெரிய வித்தியாசத்தில், ஒரு செயல்படும் கொள்கை உண்மையில் உங்களுக்கு எவ்வளவு செலவாகும் என்பதைத் தீர்மானிக்கும் நான்கு எண்களில் மிகச்சிறியதும் ஆகும்.

கீழே உள்ள பயிற்சி நேரங்கள் ஐந்து மாதிரிகளின் சொந்த ஆய்வுக் கட்டுரைகள் மற்றும் களஞ்சியங்களில் இருந்து பெறப்பட்டவை, வன்பொருள் செலவு வெளியிடப்பட்ட பொருட்களின் பட்டியலிலிருந்து பெறப்பட்டது, AY-Robots தள எண்கள் அதன் கொள்கை பட்டியல் மற்றும் விலை நிர்ணயப் பக்கம் ஆகியவற்றிலிருந்து பெறப்பட்டவை. தளம் உதவாத இடங்களில், இந்த கட்டுரை அதைக் குறிப்பிடுகிறது.

ஸ்பாட் சந்தையில் ஒரு GPU மணிநேரத்தின் உண்மையான செலவு என்ன?

ஒரு A100 மணிநேரத்திற்கு ஒரே விலை இல்லை. vast.ai போன்ற சந்தையில், ஒவ்வொரு ஹோஸ்டும் அதன் சொந்த கட்டணத்தை நிர்ணயிக்கிறது, மேலும் நீங்கள் தொடங்கும் பயிற்சி ஓட்டம் அந்த நேரத்தில் மலிவாகவும் இலவசமாகவும் இருக்கும் எந்த இயந்திரத்திலும் இறங்கும். உண்மையான பதில் ஒரு பரவல். இது 2026 ஆகஸ்ட் 23 அன்று 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 கார்டிலும் இயங்குகின்றன, ஏனெனில் அது உண்மையாகவே போதுமானது.

ஐந்து மாடல்களில் ஒவ்வொன்றும் உண்மையில் எவ்வளவு நேரம் இயங்குகிறது

இயக்க நேரம் என்பது செலவின் மறுபாதி: ஒரு மணி நேரத்திற்கு 2.00 USD என்பது வேலை 40 நிமிடங்கள் என்றால் பொருத்தமற்றது மற்றும் 40 மணிநேரம் என்றால் அழிவுகரமானது. இவை AY-Robots பயிற்சியாளருக்கு உண்மையில் அனுப்பும் இயல்புநிலைகள், ஒவ்வொரு அடுக்குக்கும் இயக்க சாளரம் மற்றும் செலவுடன்.

அந்த இயக்க சாளரங்கள் எங்கிருந்து வருகின்றன?

• SmolVLA: lerobot ஆவணங்கள் ஒரு A100 இல் 20,000 படிகள் தோராயமாக 4 மணிநேரம் எடுக்கும் என்று கூறுகின்றன. இந்த தளம் அதே 20,000 படிகளை மலிவான 24 GB அடுக்கில் இயக்குகிறது, எனவே ஒரு நிலையான 4 மணிநேரத்திற்கு பதிலாக ஒரு சாளரம்.
• ACT: அசல் ALOHA ஆய்வறிக்கை ஒரு 80M-parameter மாதிரிக்கு ஒரு 11 GB RTX 2080 Ti இல் சுமார் 5 மணிநேரம் ஆகும் என்று தெரிவிக்கிறது. ஒரு 4090 பல தலைமுறைகள் புதியது, ஆனால் இந்த தளம் 100,000 படிகளுக்கு பட்ஜெட் ஒதுக்குகிறது, எனவே சாளரம் அதே இடத்தில் அமைகிறது.
• GR00T: NVIDIA இன் N1.6 தலைமுறைக்கான குறிப்பு பணிப்பாய்வு, எட்டு L40S கார்டுகளில் batch 24 இல் 20,000 படிகளுக்கு தோராயமாக 4 முதல் 8 மணிநேரத்தையும், ஒரு Ada 6000 இல் batch 16 இல் 30,000 படிகளுக்கு 2 முதல் 3 மணிநேரத்தையும் குறிப்பிடுகிறது. ஒரு 3B VLA ஐ ஒரு சில மணிநேரங்களில் ஒற்றை கார்டு மூலம் fine-tune செய்வது சாதாரணமானது, நம்பிக்கையானது அல்ல.
• Pi0.5: openpi எந்த wall-clock மதிப்பையும் வெளியிடவில்லை, ஆனால் அது ஒரு முழு fine-tune க்கு 70 GB அடிப்படையை வெளியிடுகிறது, இது கார்டையும் அதன் மூலம் விகிதத்தையும் தீர்மானிக்கிறது.

நீங்கள் செலுத்தாத எண்ணில் ஒரு கணம் நிறுத்திப் பார்ப்பது மதிப்புமிக்கது. GR00T N1 ஆய்வறிக்கை, 2.2B மாதிரியைப் pretrain செய்ய, 1024 GPUs வரையிலான ஒரு கிளஸ்டரில், 16,384 என்ற pretraining batch size இல் 200,000 gradient படிகளுக்கு தோராயமாக 50,000 H100 GPU மணிநேரம் தேவைப்படுவதாகக் கூறுகிறது. மேலே அளவிடப்பட்ட ஒரு மணிநேரத்திற்கு 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: ஒரு எபிசோடுக்கு 60 வினாடிகள், காட்சியை மீட்டமைக்க 60 வினாடிகள், 50 எபிசோடுகள். கீழே உள்ள பணப் பத்தி ஒருவரின் ஒரு மணிநேரத்திற்கு 15 USD என்று கருதுகிறது, இது ஒரு தள எண் அல்ல, ஒரு அனுமானம். உங்கள் சொந்த கட்டணத்தை மாற்றவும்; விகிதமே முக்கியம்.

1. 1
   உங்களுக்கு உண்மையில் கட்டணம் விதிக்கப்படும் இயல்புநிலைகளுடன் தரவுத்தொகுப்பைப் பதிவுசெய்யவும்

   இது lerobot 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 தேவைப்படுகிறது மற்றும் 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 ரோபோ கை. முழுமையான செயல்முறையை முழுமையாகப் பார்க்க, அமைப்பை உள்ளடக்கியது, மற்றும் பயிற்சி, மேலும் என்பது சுருக்கமான பதிப்பு.