באיזו מדיניות VLA כדאי להתאמן ב-2026?

חמש מדיניות ניתנות לאימון על זרוע מסוג SO-100 כיום. הן נבדלות בפקטור של 24 ב-זמן אחזור (latency) של הסקה, 37 במספר הפרמטרים ו-12 בעלות הרצה, ובשאלת האם מותר לשלוח את התוצאה. חמישה כרטיסי מודל לא יפתרו את זה: אף אחד מהם לא עונה על השאלה שיש לכם, באיזה מהם כדאי להשתמש קודם?

כל מספר להלן נקרא מתוך המאמרים, המאגרים והכרטיסים באוגוסט 2026. מספרי הפלטפורמה מגיעים מ-קטלוג המדיניות של AY-Robots; היכן שהשניים חלוקים, שניהם מוצגים.

טבלת ההחלטות

חמשת המועמדים

כל החמישה הם מדיניות: פריימים של מצלמה, מיקומי מפרקים ו, עבור ארבעה מהם, הוראת שפה, הממופה לגוש של יעדי מפרקים עתידיים. מה שמפריד ביניהם הוא כמה נלמד לפני שהגעת.

GR00T N1.7

מודל ה-ראייה-שפה-פעולה של NVIDIA הנוכחי, כ-3 מיליארד פרמטרים, כ-40 מיליון אומנו במהלך כוונון עדין. המאגר מפרט את ההבדלים מ-N1.6: עמוד שדרה מדגם Eagle מסופק ל-Cosmos-Reason2-2B על Qwen3-VL, שכבות דיפוזיה 32 ל-16, מימדי מצב ופעולה 29 ל-132, אופק פעולה 16 ל-40.

מה שחשוב בזרוע קטנה הוא מרחב הפעולה היחסי של קצה המפעיל: N1.7 מנבא דלתות מה-תנוחה הנוכחית, וזה מה שמאפשר ל-20 אלף שעות של וידאו אנושי מ-EgoScale לעבור למדיניות רובוט. מפרט ב-דף N1.7, הליך ב-מדריך N1.7 על SO-100.

GR00T N1.5

אותו קנה מידה של 3B, עמוד שדרה Eagle 2, SigLip2 ו-T5, ראש DiT להתאמת זרימה. הוא קיים כדי להרחיב שכבר יש לכם. שני דברים הופכים אותו לברירת מחדל גרועה: המשקלים נושאים NVIDIA's one-way non-commercial licence, וגרסאות LeRobot הנוכחיות הסירו תמיכה ב-N1.5. ראו .

Pi0.5

VLA של Physical Intelligence, VLA, סוג מדיניות pi05. המאמר מציג VLM בגודל 2B שאותחל מ-PaliGemma בתוספת מומחה פעולה של 300M, המניע את הרובוט ב-50 הרץ; תצורת pi05 של LeRobot מוגדרת כברירת מחדל לגוש של 50 צעדים, שנייה אחת בקצב זה. נקודת המכירה היא מקומות בלתי נראים: כ-400 שעות של מניפולציה ניידת בבתים אמיתיים, ומחקר קנה מידה על פני 3, 12, 22, 53, 82 ו-104 מיקומים, כאשר המודל של 104 המיקומים תאם לבקרה שאומנה על הבתים הנבדקים עצמם.

מגבלה אחת, המצוינת בכרטיס ה-lerobot/pi05_base :הפורט נושא רק את ה-ראש פעולה תואם זרימה. חיזוי תת-משימות, טוקניזציית פעולות ו-RL לא שוחררו במעלה הזרם, ו-openpi אומרת את אותו הדבר לגבי המאגר שלה. עמוד ה-Pi0.5 ו-מדריך ה-Pi0.5 על SO-100 מכילים את השאר.

SmolVLA

450 מיליון פרמטרים, כ-100 מיליון במומחה הפעולה, על SmolVLM-2 כשה-VLM קפוא ורק 16 שכבות מודל השפה הראשונות שלו בשימוש. האימון המוקדם היה נתוני קהילה: 481 מערכי נתונים, 10.6 מיליון פריימים, מאותן זרועות זולות שבהן אתה משתמש. ה-VLA היחיד כאן שמתאים לכרטיס 24 GB אחד, והיחיד עם רצפת אפיזודה של 30. ראה עמוד ה-SmolVLA.

ACT

לא מודל יסוד. ה-Action Chunking Transformer מבית ALOHA הוא בעל כ-80 מיליון פרמטרים שאומן מאפס לכל משימה, על 50 הדגמות ב-50 הרץ. המאמר מדווח על שש משימות דו-ידניות אמיתיות מכעשר דקות של הדגמות כל אחת, ב-80 עד 90 אחוז על הדוגמאות שהוא מדגיש. הרעיון שלו, קיבוץ פעולות, נמצא בכל מודל בדף זה, והאבלציה שלו עדיין מודדת את האפקט בצורה הטובה ביותר: על פני שתי משימות מדומה עם temporal ensembling כבוי, ההצלחה עולה מ-1 אחוז ב-k=1 ל-44 אחוז ב-k=100. דף ה-ACT מכיל את השאר.

מה מדדי הביצועים באמת אומרים

LIBERO הוא מדד הביצועים היחיד ששלושה מתוך חמשת אלה מדווחים עליו: משימות מותנות שפה על Franka Panda מדומה, מחולקות לארבע הסוויטות שלהלן, עשר משימות בכל אחת. NVIDIA ביצעה 200 ניסויים לכל סוויטה.

SimplerEnv מציג את הפיזור, מה ש-LIBERO אינו עושה. NVIDIA משווה את N1.7 מול N1.6, הדבר הציבורי הקרוב ביותר ל"פער דורי".

שורת Bridge היא השימושית: 5.7 נקודות בממוצע נצברו בעוד put_eggplant_in_basket הפסיד 36 ו-put_eggplant_in_sink ירד מ-33 ל-2. דור חדש מזיז את ההתפלגות במקום להרים אותה, כך שאם המשימה שלך נמצאת היכן ש-N1.7 נסוג, הממוצע לא אומר כלום.

מבין החמישה, רק המאמר של SmolVLA מדווח על זרוע מסוג SO-100: 78.3 אחוזים עבור SmolVLA ו-61.7 עבור Pi0 על פני שלוש משימות, שתיהן מרובות משימות, לעומת 48.3 עבור ACT שאומן למשימה יחידה, וזה לא השוואה הוגנת. ההתאמה הנקייה היא שניהם למשימה יחידה ב-SO-101 pick-and-place: 90 מול 70 בהתפלגות, 50 מול 40 מחוצה לה. השווה ב-ACT מול SmolVLA ו-Pi0.5 מול SmolVLA, או עיין ב-הזירה.

זמן השהיה ועלות קובעים את הפריסה

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

הערה אחת: הנתון של GR00T אינו תואם את כרטיס NVIDIA, אשר מודד 4 שלבי הסרת רעש ומצלמה אחת ב-85.8 אלפיות השנייה על H100 במצב eager, 48.6 אלפיות השנייה עם torch.compile, 27.9 אלפיות השנייה דרך TensorRT מלא. ה-152 אלפיות השנייה כאן הוא נתון של ערימה שלמה עם תקורה של שירות ויותר ממצלמה אחת, לא מעבר קדימה.

דרך אחת לקנות זמן מבלי לשנות מודל: מאמר SmolVLA מודד ביצוע סינכרוני, כאשר המדיניות מסיימת מקטע לפני חיזוי הבא, לעומת אסינכרוני, כאשר החיזוי חופף לביצוע. ההצלחה דומה, 78.3 לעומת 73.3, אך אותה פעולת איסוף והנחה אורכת 9.7 שניות במקום 13.75, ובחלון קבוע הרובוט מבצע 19 מחזורים במקום 9.

רישיונות, נבדקו כי אף אחד לא בודק אותם

השורה של Pi0.5 דורשת תשומת לב. התיעוד של LeRobot pi05 מציין Apache 2.0 באופן עקבי עם openpi, בעוד שכרטיס ה-Hub עבור lerobot/pi05_base נושא license: gemma. שניהם פעילים. ל-GR00T N1.7 יש גרסה מתונה יותר: קובץ ה-README של Isaac-GR00T מציין דרך אגב ש-N1.7 ניתן לרישוי מסחרי מלא תחת Apache 2.0, בעוד שסעיף הרישיון שלו וכרטיס המודל מציבים את הקוד בלבד תחת Apache 2.0 ואת המשקלים תחת ה-NVIDIA Open Model License.

ברירות המחדל שתריץ בפועל

כל טופס אימון מגיע עם ברירת מחדל, והן אינן שרירותיות. אלו של ACT הן של LeRobot עצמה: אצווה 8, lr 1e-5, 100000 שלבי אימון, גודל חתיכה 100, תואם ל-ACTConfig במעלה הזרם ו-k=100 ממאמר ACT. עמודה אחת למטה היא מלכודת.

הכפתור שחשוב יותר מבחירת המודל

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

• ACT: ACTConfig ברירת המחדל היא chunk_size 100 ו-n_action_steps 100. איגום זמני כבוי ודורש n_action_steps 1.
• GR00T N1.7: האופק הפנימי עבר מ-16 ל-40, אך הדוגמה SO-101 של LeRobot עדיין מריצה --policy.chunk_size=16 --policy.n_action_steps=16. הדגל rollout שונה שמו ל---execution-horizon.
• Pi0.5: מקטע של 50 צעדים, מתוכו מתכון LIBERO של LeRobot מבצע 10 באמצעות --policy.n_action_steps=10; עם --policy.pretrained_path הוא חוזר ל-50 אם תשמיט את הדגל.
• SmolVLA: מקטעי פעולה של 50, שני הכפתורים חשופים.

איך לסנן את כל החמישה אחר הצהריים אחד

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

1. 1
   הקלט 50 פרקים פעם אחת

   חמישים מכין את הקרקע עבור GR00T, Pi0.5 ו-ACT, ועבור 30 של SmolVLA. חזור על כל וריאציה במקום להתפזר: 50 פרקים על פני 5 מיקומי קוביות שאומנו, כאשר 25 לא אומנו. ראה הקלט את מערך הנתונים הראשון שלך.

   bash

   lerobot-record \
     --robot.type=so100_follower \
     --robot.port=/dev/ttyACM1 \
     --robot.id=my_follower_arm \
     --teleop.type=so100_leader \
     --teleop.port=/dev/ttyACM0 \
     --teleop.id=my_leader_arm \
     --dataset.repo_id=${HF_USER}/pick-place-50 \
     --dataset.num_episodes=50 \
     --dataset.single_task="Put the lego brick into the box"

2. 2
   אמן את ACT קודם, כי הוא לא יכול לשקר לך

   אין משקולות מאומנות מראש, כך שאם הוא מבצע את המשימה בכלל, מערך הנתונים שלך מכיל את המשימה. אם ACT משתטח, תקן את הנתונים. 1 עד 3 דולר, 2 עד 5 שעות על כרטיס 24 GB.

   bash

   lerobot-train \
     --dataset.repo_id=${HF_USER}/pick-place-50 \
     --policy.type=act \
     --policy.device=cuda \
     --batch_size=8 \
     --steps=100000 \
     --seed=1000 \
     --output_dir=outputs/train/act_pickplace \
     --job_name=act_pickplace

3. 3
   הרץ את SmolVLA על אותו מערך נתונים, ללא שינוי

   אותם נתונים, אותה זרוע, 450 מיליון פרמטרים במקום 80 מיליון, בתוספת התניה לשונית. LeRobot מריץ 20K צעדים בכ-4 שעות על A100 אחד. זה מה שאומר לך אם אימון מוקדם משיג משהו.

   bash

   lerobot-train \
     --policy.path=lerobot/smolvla_base \
     --dataset.repo_id=${HF_USER}/pick-place-50 \
     --batch_size=64 \
     --steps=20000 \
     --policy.device=cuda \
     --output_dir=outputs/train/smolvla_pickplace \
     --job_name=smolvla_pickplace

4. 4
   המר לגרסה v2.1 לפני שאתה נוגע ב-GR00T

   GR00T קורא גרסה של פורמט LeRobot v2 בתוספת קובץ meta/modality.json נוסף הממפה כיצד מערכי מצב ופעולה משורשרים מתפצלים לשדות בעלי שמות. מערך נתונים בגרסה v3.0 קורס את הטוען הזה, מכיוון ש-v3.0 אורז פרקים רבים לקבצים משותפים בעוד ש-v2 כתב אחד לכל פרק. Isaac-GR00T מספק את כלי העזר לשדרוג לאחור כ-scripts/lerobot_conversion/convert_v3_to_v2.py; דף דחיית v3 הוא הנתיב המהיר.

   text

   # GR00T expects this layout, not the v3.0 file-based one
   my_dataset/
     meta/
       info.json
       episodes.jsonl      # episode index and lengths
       tasks.jsonl         # language task descriptions
       modality.json       # GR00T-specific: state/action/video key mapping
     data/chunk-000/       # parquet, state and action per timestep
     videos/chunk-000/     # one mp4 per episode

5. 5
   הסלם ל-GR00T N1.7 רק אם השניים הראשונים השאירו משהו על השולחן

   באמצעות ה-CLI של NVIDIA, המוצג כאן, או סוג המדיניות groot של LeRobot. NVIDIA ממליצה על 40 GB או יותר של VRAM לכוונון עדין, 16 GB להסקה. במקרה של OOM, ראה דף ה-OOM.

   bash

   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 /tmp/test_finetune \
     --max-steps 2000 \
     --global-batch-size 32 \
     --dataloader-num-workers 4

שתי דרכים להריץ את מעבר הסינון הזה

# 1. LeRobot: ACT, SmolVLA, Pi0.5 and GR00T N1.7 via --policy.type=groot
pip install "lerobot[smolvla]"
pip install "lerobot[pi]"
pip install "lerobot[groot]"

# 2. GR00T reference implementation and benchmark examples
git clone https://github.com/NVIDIA/Isaac-GR00T

# 3. Physical Intelligence reference implementation
git clone --recurse-submodules https://github.com/Physical-Intelligence/openpi

מודל יסוד או מאפס

ההתלבטות האמיתית אינה איזה מודל 3B לבחור. היא האם להשתמש ב-VLA מאומן מראש בכלל, בהתחשב בכך ש-ACT למד שש משימות דו-ידניות אמיתיות מכעשר דקות של הדגמות לכל אחת, עם 80 מיליון פרמטרים ו-שום דבר לא אומן מראש.

המקרה של שחזור ריצה ישנה

רדיפה אחר נקודת בקרה של 2025 קובעת עבורך את בחירת המודל והופכת את הבעיה לקיבוע גרסאות: LeRobot הנוכחי דוחה את N1.5, אז אתה מקבע את lerobot==0.5.1. ללא שדה seed ועם שונות של 5 עד 6 אחוזים בין ריצות, השחזור הוא מקורב מעצם טבעו. ו- מכילים את צד הפלטפורמה.

הצטמצם לשניים? ACT מול GR00T N1.7 ו-GR00T N1.7 מול SmolVLA. שורות גולמיות נמצאות בערכי הזירה: GR00T N1.7, Pi0.5, SmolVLA ו-ACT.

היכן פלטפורמה זו אינה עוזרת לך

• היא אינה יכולה להפוך הסקה מרוחקת למהירה. לולאת ה-20 עד 485 אלפיות השנייה שייכת למודל; נסיעות הלוך ושוב באינטרנט מוסיפות לכך.
• היא אינה יכולה לכוונן עדין את GR00T או Pi0.5 על החומרה שלך. שניהם זמינים רק בענן כאן; רק SmolVLA ו-ACT רצים מקומית.
• היא אינה יכולה לתקן מערך נתונים. ההפסד יורד אך המדיניות אינה עושה דבר היא בעיית נתונים, מדיניות שעובדת רק בהגדרה אחת היא בעיית כיסוי.
• היא אינה יכולה להפוך הרצות של GR00T לשחזוריות: לקונפיגורציה במעלה הזרם אין שדה seed.

בוחרים אחד וממשיכים הלאה

ברירת מחדל אחת: הקלט 50 אפיזודות, אמן את ACT עבור 1 עד 3 דולר כדי להוכיח את הדאטה-סט, ואז את SmolVLA על האותם נתונים. יחד, בפחות מ-6 דולר, והם עונים על השאלה החשובה: האם אימון מקדים עוזר כאן, או האם צוואר הבקבוק הוא הנתונים. הסלם ל-GR00T N1.7 למשימות מרובות שלבים עשירות במגע, ל-Pi0.5 כאשר הסצנה משתנה.

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