ค่าใช้จ่ายในการฝึก 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 แบบเต็ม fine-tune ที่ 70 GB และ NVIDIA แนะนำ 40 GB หรือมากกว่าสำหรับ GR00T โปรดทราบว่าตัวเลข GR00T นี้ไม่ใช่สิ่งใด การตั้งค่า fine-tune ของมันจะตรึงโมเดลภาษาและตัวเข้ารหัสภาพไว้โดยค่าเริ่มต้น (tune_llm และ tune_visual เป็น False ส่วน projector และ diffusion head เป็น True) ซึ่งเป็นเหตุผลที่แค็ตตาล็อกระบุพารามิเตอร์ที่ได้รับการฝึกฝนประมาณ 40 ล้านจาก 3 พันล้าน 40 GB นี้ไม่ใช่สถานะ optimizer สำหรับน้ำหนัก 3 พันล้าน แต่เป็น backbone ที่ถูกตรึงไว้รวมถึง activations รุ่นที่มีขอบเขตลดลงจะใช้หน่วยความจำน้อยลง: เส้นทาง LoRA ของ openpi ต้องการ 22.5 GB และระบุ 4090 และเวิร์กโฟลว์ Isaac Lab Arena ของ NVIDIA ระบุตัวเลือก GPU เดี่ยว 24 GB สำหรับ GR00T หลังการฝึกอบรม แพลตฟอร์มจะจัดระดับตามขั้นต่ำที่ผู้จำหน่ายแต่ละรายเผยแพร่สำหรับการกำหนดค่าที่ใช้งานจริง บทความเกี่ยวกับ pi0 flow-matching อธิบายว่า flow-matching footprint มาจากไหน

ตารางนั้นคือเหตุผลที่แพลตฟอร์มแบ่งห้าโมเดลออกเป็นสองระดับ 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 ระบุว่า 20,000 ขั้นตอนใช้เวลาประมาณ 4 ชั่วโมงบน A100 เดี่ยว แพลตฟอร์มรัน 20,000 ขั้นตอนเท่ากันบนระดับ 24 GB ที่ถูกกว่า ดังนั้นจึงเป็นช่วงเวลาแทนที่จะเป็น 4 ชั่วโมงคงที่
• ACT: เอกสาร ALOHA ดั้งเดิมรายงานว่าใช้เวลาประมาณ 5 ชั่วโมงบน RTX 2080 Ti ขนาด 11 GB เดี่ยว สำหรับโมเดล 80M พารามิเตอร์ การ์ด 4090 เป็นรุ่นใหม่กว่าหลายเจนเนอเรชัน แต่แพลตฟอร์มตั้งงบประมาณไว้ที่ 100,000 ขั้นตอน ดังนั้นช่วงเวลาจึงอยู่ในตำแหน่งเดียวกัน
• GR00T: เวิร์กโฟลว์อ้างอิงของ NVIDIA สำหรับรุ่น N1.6 ระบุว่าใช้เวลาประมาณ 4 ถึง 8 ชั่วโมงสำหรับ 20,000 ขั้นตอนที่ batch 24 บนการ์ด L40S แปดใบ และ 2 ถึง 3 ชั่วโมงสำหรับ 30,000 ขั้นตอนที่ batch 16 บน Ada 6000 เดี่ยว การปรับแต่ง VLA ขนาด 3B ด้วยการ์ดเดี่ยวในไม่กี่ชั่วโมงเป็นเรื่องปกติ ไม่ใช่การมองโลกในแง่ดีเกินไป
• Pi0.5: openpi ไม่ได้เผยแพร่ตัวเลขเวลาจริง แต่เผยแพร่ขีดจำกัด 70 GB สำหรับการปรับแต่งเต็มรูปแบบ ซึ่งระบุการ์ดและอัตราการทำงาน

ควรหยุดพิจารณาตัวเลขที่คุณไม่ต้องจ่าย เอกสาร GR00T N1 รายงานว่าใช้เวลา GPU H100 ประมาณ 50,000 ชั่วโมงในการ pretrain โมเดล 2.2B บนคลัสเตอร์ที่มี GPU สูงสุด 1024 ตัว ด้วยขนาด batch สำหรับ pretraining ที่ 16,384 สำหรับ 200,000 gradient steps ด้วยอัตรา 1.34 ถึง 2.34 USD ต่อชั่วโมงที่วัดได้ข้างต้น นั่นคือค่าใช้จ่ายในการเช่าคอมพิวเตอร์ประมาณ 67,000 ถึง 117,000 USD เอกสาร SmolVLA ระบุว่าโครงการใช้เวลา GPU ประมาณ 30,000 ชั่วโมงจาก 481 ชุดข้อมูลชุมชน, 22.9K ตอน และ 10.6M เฟรม คุณได้รับทั้งหมดนี้ในราคาของการดาวน์โหลด; 8 USD ของคุณซื้อ 20,000 ขั้นตอนสุดท้าย ทำไม VLA จึงถูกสร้างขึ้นมาในลักษณะนี้ ครอบคลุมการแบ่งส่วนนั้น

แขนกล: ค่าใช้จ่ายครั้งเดียวที่ทำให้ค่า GPU ดูเล็กน้อยไปเลย

การฝึกอบรมหนึ่งครั้งมีค่าใช้จ่ายน้อยกว่าอาหารกลางวัน แต่หุ่นยนต์ไม่ได้เป็นเช่นนั้น นั่นคือเหตุผลที่ SO-100 มีความสำคัญ: เป็นแขนที่ถูกที่สุดที่ การเรียนรู้แบบเลียนแบบ toolchain รองรับได้จริง

รายการวัสดุต้นน้ำใน SO-ARM100 repository มีรายละเอียดมากขึ้นและควรตรวจสอบกับภูมิภาคของคุณ: รายการ ชิ้นส่วนสำหรับแขนสองข้าง มีมูลค่ารวม 229.88 USD หรือ 226.30 EUR สำหรับการตั้งค่าแบบ leader plus follower และรายการ ชิ้นส่วนสำหรับแขน follower หนึ่งข้าง มีมูลค่ารวม 121.94 USD หรือ 124.30 EUR. เซอร์โว STS3215 หกตัวในราคาตัวละ 13.89 USD คิดเป็น 83.34 จาก 121.94 ดังนั้นเซอร์โวจึงเป็นส่วนสำคัญของแขน. ที่ราคา 1 ถึง 3 USD ต่อการรัน SmolVLA หรือ ACT หนึ่งครั้ง แขนหนึ่งคู่มีมูลค่าเท่ากับการรันการฝึกอบรมระหว่าง 77 ถึง 230 ครั้ง. หากคุณยังคงเลือกอยู่, SO-100 เทียบกับ SO-101 คือการเปรียบเทียบที่สำคัญ เพราะทั้งสองรุ่นมีความใกล้เคียงกันมากจนการตัดสินใจขึ้นอยู่กับความพร้อมใช้งานมากกว่าความสามารถ

ชั่วโมงทำงานของคน: ตัวเลขที่ไม่มีใครใส่ในสเปรดชีต

นี่คือตัวเลขที่พลิกโฉมการอภิปรายเรื่องค่าใช้จ่าย การบันทึกการสาธิตคือการที่คนคนหนึ่งขยับแขนหุ่นยนต์ทีละตอนแบบเรียลไทม์ ไม่มีการประมวลผลเป็นชุดและไม่มีการเช่าเป็นวินาที เครื่องบันทึกชุดข้อมูล LeRobot มาพร้อมกับการตั้งค่าเริ่มต้นที่ทำให้การคำนวณง่ายขึ้น ทั้งสามรายการได้รับการยืนยันใน DatasetRecordConfig: 60 วินาทีต่อ ตอน, 60 วินาทีเพื่อรีเซ็ตฉาก, 50 ตอน คอลัมน์ค่าใช้จ่ายด้านล่างสมมติว่า 15 USD สำหรับเวลาทำงานหนึ่งชั่วโมงของคน ซึ่งเป็นข้อสมมติฐานมากกว่าตัวเลขจากแพลตฟอร์ม แทนที่ด้วยอัตราของคุณเอง; อัตราส่วนคือประเด็นสำคัญ

1. 1
   บันทึกชุดข้อมูลด้วยค่าเริ่มต้นที่คุณจะต้องจ่ายจริง

   นี่คือ lerobot 0.6.1 ซึ่งเป็นเวอร์ชันบน PyPI ณ วันที่ 3 สิงหาคม 2026 สังเกตรูปแบบ CLI: การบันทึกทำงานผ่านจุดเข้าใช้งานคอนโซล lerobot-record (lerobot.scripts.lerobot_record) ไม่ใช่เส้นทางโมดูลเก่า python -m lerobot.scripts.record AY-Robots กำหนดเป้าหมายที่ 0.5.1 และ wheel 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 ต่อชั่วโมง การค้นพบปัญหาเดียวกันจากกราฟ loss curve มีค่าใช้จ่าย 2.00 USD ต่อชั่วโมงบน H100 tier และจะบอกคุณช้าไปสี่ชั่วโมง พุชชุดข้อมูลและตรวจสอบใน LeRobot viewer หรือเรียกดู ไดเรกทอรีชุดข้อมูล ของ 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 สเต็ป ดังนั้นการรัน SmolVLA 20,000 สเต็ปตามค่าเริ่มต้นจะเขียนเช็คพอยต์แรกเมื่อการรันสิ้นสุดลงแล้ว; ให้ลดค่านี้ลงก่อนที่คุณจะเช่าอะไรที่อาจถูกขัดจังหวะได้ --save_checkpoint_to_hub ต้องใช้ --policy.repo_id และไม่มีอยู่ใน lerobot 0.5.1 ดังนั้นในเวอร์ชันนั้นคุณจะต้องคัดลอกไดเรกทอรีเอาต์พุตออกจากเครื่องด้วยตัวเอง ขนาดแบตช์ด้านล่างเป็นตัวอย่างจากเอกสารต้นน้ำ; ฟอร์ม AY-Robots ส่ง 2 สำหรับ 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

เปรียบคอลัมน์ด้านขวากับค่าใช้จ่ายในการรันที่ 1 ถึง 12 USD ด้วยอัตราที่ประมาณไว้นั้น ชุดข้อมูล 50 ตอนมีค่าใช้จ่ายในการบันทึกสูงกว่าค่าใช้จ่ายในการฝึกถึงสองถึงเจ็ดเท่า ก่อนที่จะมีการปรับเทียบ การตั้งค่ากล้อง และตอนที่คุณทิ้งไป นั่นคือเหตุผลว่าทำไม จึงมีมูลค่าเป็นเงินโดยตรง คู่มือ lerobot แนะนำอย่างน้อย 50 ตอน โดยมี 10 ตอนต่อตำแหน่งวัตถุ; เอกสาร SmolVLA รายงานว่าเวอร์ชัน 25 ตอนของงานเดียวกันนั้นไม่เพียงพอ

เงินหายไปไหนจริง ๆ

1. การรันบนข้อมูลที่ไม่มีทางใช้งานได้

การรัน GR00T 20,000 สเต็ปบนชุดข้อมูลที่มีสตรีมกล้องสลับกันสองตัวมีค่าใช้จ่ายเท่ากับการรันบนชุดข้อมูลที่สะอาด ใช้เวลาเท่ากัน และสร้างกราฟ loss ที่ดูดี ความล้มเหลวจะปรากฏบนแขนหุ่นยนต์ในอีกหลายชั่วโมงต่อมา ถูกเรียกเก็บเงินเป็นรายชั่วโมง และการวินิจฉัยถูกเรียกเก็บเป็นรายวัน สองอาการที่ควรจดจำ: มักหมายความว่าข้อมูลที่สังเกตได้ไม่ครอบคลุมสิ่งที่งานต้องการ และ หมายความว่าชุดข้อมูลมีความหลากหลายน้อยกว่าที่คุณคิด

2. การจ่ายราคาโมเดลพื้นฐานสำหรับงานกล้องแบบตายตัว

ACT มีพารามิเตอร์ประมาณ 80M และถูกออกแบบมาเพื่อฝึกฝนตั้งแต่เริ่มต้นด้วยการสาธิต 50 ครั้งสำหรับงานเดียว GR00T N1.7 มีขนาดประมาณ 3B พร้อมแบ็คโบนที่ได้รับการฝึกฝนล่วงหน้า สำหรับกล้องที่ยึดติด โต๊ะคงที่ และวัตถุเดียว โมเดล 80M มักจะทำงานได้ดี ทำงานที่ประมาณ 20 ms ต่อขั้นตอนการดำเนินการ แทนที่จะเป็น 152 ms และมีค่าใช้จ่าย 1 ถึง 3 USD ต่อการรัน แทนที่จะเป็น 4 ถึง 12 USD ใช้เงิน 3 USD เพื่อค้นหาว่าโมเดลราคาถูกใช้งานได้หรือไม่ ก่อนที่จะใช้เงิน 12 USD กับโมเดลราคาแพงACT เทียบกับ SmolVLA และ GR00T N1.7 เทียบกับ Pi0.5 แสดงให้เห็นว่าแต่ละโมเดลหยุดเป็นคำตอบที่ถูกต้องเมื่อใด; สนามประลองโมเดล มี 85 โมเดลและผลการทดสอบมาตรฐาน 332 รายการ

3. GPU ที่คุณลืมไป

ข้อผิดพลาดที่ป้องกันได้ง่ายที่สุดและพบได้บ่อยที่สุด อินสแตนซ์ที่เริ่มในวันศุกร์เพื่อดีบักบางอย่างจะถูกเรียกเก็บเงินตลอดสุดสัปดาห์ในอัตราเดียวกับการรันจริง

บน AY-Robots ข้อผิดพลาดนี้ถูกออกแบบมาเพื่อการอนุมาน: พ็อดที่จัดเตรียมโดย Inference API จะมีตัวเฝ้าระวังการไม่ได้ใช้งานและจะทำลายตัวเองหลังจากช่วงเวลาที่ไม่ได้ใช้งาน หากคุณเช่าการ์ดด้วยตัวเอง ตัวเฝ้าระวังนั้นก็คือการแจ้งเตือนในปฏิทินของคุณ

4. จ่ายซ้ำสองครั้งสำหรับคำตอบเดียวกัน

จุดเริ่มต้นของการปรับแต่งละเอียดของ GR00T คือ tyro CLI ที่ไม่เปิดเผย seed นั่นไม่ใช่ข้อจำกัดของแพลตฟอร์ม แต่เป็นเครื่องมือต้นน้ำ: ไม่มีฟิลด์ seed ใน gr00t/configs/finetune_config.py และคำแนะนำการฝึกอบรมของที่เก็บเองก็เตือนว่าผลลัพธ์อาจแตกต่างกัน 5 ถึง 6 เปอร์เซ็นต์เนื่องจากการเพิ่มประสิทธิภาพรูปภาพนั้นไม่สามารถกำหนดได้ lerobot กำหนดค่าเริ่มต้นเป็น seed 1000 ทั้งในเวอร์ชัน 0.5.1 และ 0.6.1 ดังนั้นการรันของ 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 ของคุณเอง โดยที่ค่าใช้จ่ายคลาวด์เป็นศูนย์และค่าไฟฟ้าเป็นปัญหาของคุณ

มีข้อควรระวังหนึ่งข้อ การสะสม Gradient (Gradient accumulation) ใช้ได้จริงสำหรับ GR00T ทั้งสองรุ่น ดังนั้นการเพิ่มค่านี้จะทำให้ได้แบทช์ที่มีประสิทธิภาพใหญ่ขึ้นบนการ์ดเดียวกัน สำหรับ Pi0.5 และ SmolVLA จะไม่สามารถใช้ได้เลย: lerobot 0.5.1 ไม่มีตัวเลือกการสะสม Gradient ในการตั้งค่าการฝึกอบรม ดังนั้นการตั้งค่าฟิลด์เป็น 16 จึงไม่มีค่าใช้จ่ายและไม่ได้อะไรเลย หากงานที่อยู่ในคิวไม่เคยเริ่มต้น หน้างานค้างในคิว จะครอบคลุมสิ่งที่จะต้องตรวจสอบ; หากชุดข้อมูลถูกปฏิเสธก่อนที่การรันจะเริ่มต้น มักจะเป็น ปัญหาฟอร์แมต v3.0.

งบประมาณที่คำนวณแล้วสำหรับนโยบายแรกที่ใช้งานได้

ทั้งสี่บรรทัดรวมกัน เริ่มจากศูนย์ การใช้ GPU ทั้งหมดสมมติว่ามีการรัน 3 ถึง 5 ครั้ง: ครั้งแรกเพื่อพิสูจน์ว่าไปป์ไลน์ทำงานได้, ครั้งที่สองเพื่อเปิดเผยปัญหาข้อมูล, ครั้งที่สามหรือสี่คือครั้งที่คุณจะเก็บไว้

รูปแบบนี้ยังคงใช้ได้กับหุ่นยนต์ขนาดนี้: การประมวลผลเป็นเพียงข้อผิดพลาดเล็กน้อย, ฮาร์ดแวร์เป็นค่าใช้จ่ายครั้งเดียวที่แท้จริง, ชั่วโมงการทำงานของมนุษย์คือค่าใช้จ่ายที่เกิดขึ้นซ้ำๆ หากต้องการทดสอบส่วนการฝึกอบรมก่อนที่จะซื้ออะไร , ช่วยให้คุณเปรียบเทียบโมเดลและเช่า GPU ได้โดยไม่ต้องมีแขนกล และ คือ SO-100 จริงที่คุณสามารถควบคุมได้ในเบราว์เซอร์โดยไม่ต้องลงทะเบียน สำหรับไปป์ไลน์ทั้งหมดตั้งแต่ต้นจนจบ ครอบคลุมการตั้งค่า และการฝึกอบรม และ คือฉบับย่อ