עלות אימון 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 ממליצה על 40 GB או יותר עבור GR00T. שימו לב מה המספר של GR00T אינו. תצורת הכוונון העדין שלו מקפיאה את מודל השפה ואת המקודד הוויזואלי כברירת מחדל (tune_llm ו-tune_visual הם False, המקרן וראש הדיפוזיה הם True), ולכן הקטלוג מפרט כ-40 מיליון פרמטרים מאומנים מתוך 3 מיליארד. ה-40 GB אינו מצב אופטימייזר עבור 3 מיליארד משקלים, אלא עמוד השדרה הקפוא בתוספת הפעלות. גרסאות בהיקף מצומצם יורדות נמוך יותר: נתיב ה-LoRA של openpi דורש 22.5 GB ומציין את ה-4090, ותהליך העבודה של Isaac Lab Arena של NVIDIA מפרט אפשרות של 24 GB עם GPU יחיד עבור GR00T לאחר אימון. הפלטפורמה מדורגת לפי הרף שכל ספק מפרסם עבור התצורה שהוא מריץ בפועל. המאמר על התאמת זרימה של pi0 מסביר מאיפה מגיע התאמת זרימה טביעת הרגל הזו.

טבלה זו היא הסיבה לכך שהפלטפורמה מפצלת את חמשת המודלים לשתי רמות. GR00T N1.7, GR00T N1.5 ו-Pi0.5 פועלים על A100 80 GB או H100 מכיוון שזה מה שהספקים דורשים. SmolVLA ו-ACT פועלים על RTX 4090 או כל כרטיס 24 GB מכיוון שזה באמת מספיק.

כמה זמן כל אחד מחמשת המודלים באמת פועל

זמן הריצה הוא החצי השני של העלות: 2.00 דולר לשעה אינו רלוונטי אם העבודה היא 40 דקות והרסני אם היא 40 שעות. אלו הן הגדרות ברירת המחדל ש-AY-Robots באמת שולח למאמן, יחד עם חלון הריצה והעלות עבור כל רמה.

מאיפה מגיעים חלונות ההרצה האלה במעלה הזרם

• SmolVLA: התיעוד של lerobot מציין ש-20,000 צעדים אורכים כ-4 שעות על A100 יחיד. הפלטפורמה מריצה את אותם 20,000 צעדים על שכבת ה-24 GB הזולה יותר, ולכן מדובר בחלון זמן ולא ב-4 שעות קבועות.
• ACT: המאמר המקורי של ALOHA מדווח על כ-5 שעות על RTX 2080 Ti יחיד עם 11 GB עבור מודל עם 80 מיליון פרמטרים. כרטיס 4090 חדש יותר בכמה דורות, אך הפלטפורמה מתקצבת 100,000 צעדים, כך שחלון הזמן נוחת באותו מקום.
• GR00T: זרימת העבודה הייחוסית של NVIDIA עבור דור N1.6 מציינת כ-4 עד 8 שעות עבור 20,000 צעדים באצווה 24 על שמונה כרטיסי L40S, ו-2 עד 3 שעות עבור 30,000 צעדים באצווה 16 על כרטיס Ada 6000 יחיד. כוונון עדין (fine-tuning) של VLA בגודל 3B על כרטיס יחיד תוך מספר שעות הוא נורמלי, לא אופטימי.
• Pi0.5: openpi אינו מפרסם נתון זמן שעון קיר, אך הוא כן מפרסם את רף ה-70 GB עבור כוונון עדין מלא, מה שמקבע את הכרטיס ולכן את הקצב.

כדאי להתעכב על המספר שאתם לא משלמים עליו. המאמר של GR00T N1 מדווח על כ-50,000 שעות GPU של H100 לאימון מוקדם של מודל ה-2.2B, על אשכול של עד 1024 מעבדי GPU, בגודל אצווה של 16,384 עבור 200,000 צעדי גרדיאנט. במחיר של 1.34 עד 2.34 דולר לשעה שנמדד לעיל, מדובר בסדר גודל של 67,000 עד 117,000 דולר של כוח חישוב שכור. המאמר של SmolVLA מעריך את הפרויקט בכ-30,000 שעות GPU על פני 481 מערכי נתונים קהילתיים, 22.9K פרקים ו-10.6M פריימים. אתם יורשים את כל זה במחיר הורדה; 8 הדולרים שלכם קונים את 20,000 הצעדים האחרונים. מדוע VLAs נבנים באופן זה מכסה את החלוקה הזו.

הזרוע: עלות חד פעמית שמגמדת את חשבון ה-GPU

הרצת אימון עולה פחות מארוחת צהריים. הרובוט לא. זו הסיבה ש-SO-100 חשוב: זוהי הזרוע הזולה ביותר שכל למידת חיקוי שרשרת הכלים תומכת בה בפועל.

רשימת החומרים (BOM) במאגר SO-ARM100 מפורטת יותר ושווה בדיקה מול האזור שלכם: חלקים לשתי זרועות רשימה מסתכמת ב-229.88 USD או 226.30 EUR עבור הגדרת מנהיג ועוקב, ו-חלקים לזרוע עוקבת אחת רשימה מסתכמת ב-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 דולר לשעת עבודה של אדם, וזוהי הנחה ולא מספר פלטפורמה. החליפו בתעריף שלכם; היחס הוא העיקר.

1. 1
   הקליטו את מערך הנתונים עם ברירות המחדל שעבורן תחויבו בפועל

   זוהי גרסה 0.6.1 של lerobot, הגרסה ב-PyPI נכון ל-3 באוגוסט 2026. שימו לב למבנה ה-CLI: ההקלטה מתבצעת דרך נקודת הכניסה לקונסולה lerobot-record (lerobot.scripts.lerobot_record), ולא דרך נתיב המודול הישן python -m lerobot.scripts.record. AY-Robots מכוון לגרסה 0.5.1, וגלגל 0.5.1 מצהיר על אותן נקודות כניסה lerobot-record ו-lerobot-train, כך שהמבנה שלהלן יציב בשתיהן. שלושת דגלי התזמון הם ברירות המחדל של ה-upstream, כך שזו גם הפקודה שהחישוב בטבלה הבאה מניח.

   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 אחת

   בדיקת מערך נתונים עולה אפס דולר לשעה. גילוי אותה בעיה מעקומת הפסד עולה 2.00 דולר לשעה בשכבת H100 ומודיע לכם באיחור של ארבע שעות. דחפו את מערך הנתונים ובדקו אותו במציג של 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
   אמנו, וודאו שנקודת השמירה שורדת את הפוד

   מכונה שכורה היא זמנית בהגדרה, לכן כתבו נקודות שמירה (checkpoints) למקום עמיד במהלך הריצה. שני דגלים קובעים אם תשמרו את מה ששילמתם עבורו. --save_freq מוגדר כברירת מחדל ל-20,000 צעדים, כך שריצת SmolVLA של 20,000 צעדים כברירת מחדל כותבת את נקודת השמירה הראשונה שלה כשהריצה כבר הסתיימה; הורידו אותה לפני שאתם שוכרים משהו שניתן להפסיק. --save_checkpoint_to_hub דורש --policy.repo_id ואינו קיים ב-lerobot 0.5.1, כך שבגרסה זו תצטרכו להעתיק את ספריית הפלט מהמכונה בעצמכם. גודל האצווה שלהלן הוא הדוגמה של תיעוד ה-upstream; טופס 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 דולר ארה"ב. בשיעור משוער זה, מערך נתונים של 50 פרקים עולה פי שניים עד שבעה יותר להקלטה מאשר לאימון עליו, לפני כיול, הגדרת מצלמה והפרקים שאתם זורקים. זו הסיבה ש יש לה ערך כספי ישיר. מדריך LeRobot מציע לפחות 50 פרקים עם 10 לכל מיקום אובייקט; מסמכי SmolVLA מדווחים שגרסת 25 פרקים של אותה משימה לא הספיקה.

לאן הכסף באמת נעלם

1. הרצות על נתונים שמעולם לא היו עובדים

הרצת GR00T של 20,000 צעדים על מערך נתונים עם שני זרמי מצלמה שהוחלפו עולה כמו הרצה על מערך נתונים נקי, לוקחת את אותו זמן, ומייצרת עקומת הפסד שנראית בסדר. הכשל מופיע על הזרוע, שעות מאוחר יותר. מחויבים לפי שעה ואבחון מחויב בימים. שני סימפטומים שכדאי לזכור: בדרך כלל אומר שהתצפיות אינן נושאות את מה שהמשימה דורשת, ו- אומר שלמערך הנתונים הייתה פחות וריאציה ממה שחשבתם.

2. תשלום מחירי מודל יסוד עבור משימה עם מצלמה קבועה

ACT הוא בערך 80 מיליון פרמטרים ותוכנן להתאמן מאפס על 50 הדגמות של משימה אחת. GR00T N1.7 הוא בערך 3 מיליארד עם עמוד שדרה מאומן מראש. עבור מצלמה מקובעת, שולחן קבוע ואובייקט אחד, מודל ה-80 מיליון לעיתים קרובות מגיע ליעד, פועל בקצב של כ-20 אלפיות השנייה לכל שלב פעולה במקום 152 אלפיות השנייה, ועולה 1 עד 3 דולר לריצה במקום 4 עד 12. הוציאו 3 דולר כדי לגלות אם המודל הזול עובד לפני שתוציאו 12 דולר על היקר. ACT מול SmolVLA ו-GR00T N1.7 מול Pi0.5 מראים היכן כל אחד מפסיק להיות התשובה הנכונה; ה-זירת המודלים מכילה 85 מודלים ו-332 תוצאות בנצ'מרק.

3. ה-GPU ששכחתם

הטעות הזולה ביותר למנוע והנפוצה ביותר לעשות. מופע שהופעל ביום שישי כדי לנפות באגים במשהו מחויב לאורך סוף השבוע באותו קצב כמו ריצה אמיתית.

ב-AY-Robots, כשל זה מתוכנן מראש כך שלא יתרחש עבור הסקה (inference): פודים המסופקים על ידי ה-API של ההסקה נושאים 'כלב שמירה' (watchdog) של חוסר פעילות ומשמידים את עצמם לאחר תקופת בטלה. אם אתה שוכר את הכרטיס בעצמך, כלב השמירה הזה הוא תזכורת היומן שלך.

4. תשלום כפול עבור אותה תשובה

נקודת הכניסה לכוונון עדין (fine-tuning) של GR00T היא CLI מסוג tyro שאינו חושף seed. זו אינה מגבלת פלטפורמה, אלא הכלי במעלה הזרם (upstream): אין שדה seed ב-gr00t/configs/finetune_config.py, והטיפים לאימון של המאגר עצמו מזהירים שהרצות משתנות ב-5 עד 6 אחוזים מכיוון שהגדלות התמונה (image augmentations) אינן דטרמיניסטיות. lerobot מוגדר כברירת מחדל ל-seed 1000 גם בגרסאות 0.5.1 וגם ב-0.6.1, כך שהרצות של ACT, SmolVLA ו-Pi0.5 יכולות לפחות להיות מורצות מחדש מאותה אתחול וסדר נתונים. זו אינה הבטחה למשקלים זהים ברמת הביט (bit-identical) על GPU, אך זה ההבדל בין הרצה חוזרת לניסוי חדש. אם הרצת GR00T מייצרת מדיניות שעובדת ולא שמרת את ה-נקודת בקרה, אתה משלם מחיר מלא עבור תוצאה שעשויה להיות שונה ביותר מההבדל שרדפת אחריו. יש דרך שנייה לאבד נקודת בקרה ששילמת עליה: ה-CLI מוגדר כברירת מחדל ל---save-total-limit 5, המתועד כמספר המרבי של נקודות בקרה שנשמרות לפני שמחקות הישנות יותר. אחסון עולה סנטים; הרצה חוזרת עולה 4 עד 12 דולר ושש שעות.

לעשות זאת בעצמך לעומת לתת לפלטפורמה לשכור את הכרטיס

# 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; ה-backend לוקח את ה-VRAM הנדרש ושוכר כרטיס תואם באותו שוק ספוט שנמדד לעיל. זו הסיבה שהעלות המצוטטת היא טווח, לא מחיר. GR00T ו-Pi0.5 זמינים כאן רק בענן בגלל רצפות ה-40 GB וה-70 GB. SmolVLA ו-ACT פועלים גם מקומית על כרטיס ה-24 GB שלך, כאשר עלות הענן היא אפס והחשמל הוא הבעיה שלך.

פרמטר אחד ראוי לאזהרה. צבירת גרדיאנטים (Gradient accumulation) אכן חלה על שתי גרסאות GR00T, כך שהעלאתה קונה אצווה אפקטיבית גדולה יותר על אותו כרטיס. עבור Pi0.5 ו-SmolVLA היא אינה חלה כלל: ל-lerobot 0.5.1 אין אפשרות צבירת גרדיאנטים בתצורת האימון שלה, כך שהגדרת השדה ל-16 לא עולה כלום ולא קונה כלום. אם עבודה בתור לא מתחילה לעולם, העמוד על עבודה שנתקעה בתור מכסה מה לבדוק; אם מערך הנתונים נדחה לפני שהריצה מתחילה, זו כמעט תמיד בעיית פורמט v3.0.

תקציב מפורט עבור מדיניות עבודה ראשונה

כל ארבעת השורות יחד, החל מכלום. סך ה-GPU מניח 3 עד 5 הרצות: הראשונה מוכיחה שהצינור עובד, השנייה חושפת בעיית נתונים, השלישית או הרביעית היא זו שאתה שומר.

התבנית נשמרת בגודל רובוט זה: כוח חישוב הוא שגיאת עיגול, חומרה היא עלות חד-פעמית אמיתית, שעות אדם הן ההוצאה החוזרת. כדי לבדוק את חצי האימון לפני רכישת משהו, נקודות הכניסה ללא חומרה מאפשרות לך להשוות מודלים ולשכור GPU ללא זרוע, ו-הזרוע החיה היא SO-100 פיזית שתוכל להפעיל בדפדפן ללא הרשמה. עבור הצינור המלא מקצה לקצה, ה-מדריך SO-100 המלא מכסה הגדרה, טלאופרציה ואימון, ו-אמן את המדיניות הראשונה שלך היא הגרסה הקצרה.