איך לאמן את GR00T N1.7 על סט נתונים משלך של SO-100

NVIDIA מספקת דוגמת כוונון עדין בדיוק עבור הזרוע שכנראה בבעלותך. בתוך מאגר Isaac-GR00T קיימת תיקייה בשם demo_data/cube_to_bowl_5: חמישה פרקים, 4,148 פריימים ב-30 פריימים לשנייה, כתובים כבר בפורמט LeRobot v2.1, עם קונפיגורציית מודליות תואמת תחת examples/SO100/. ה-meta/info.json שלה מדווח על robot_type: so101_follower, אשר ב-LeRobot היא אותה מחלקת קונפיגורציה כמו so100_follower. זה שימושי באמת, כי זה אומר שנתיב הייחוס עבור GR00T N1.7 על זרוע תחביב בעלת שש דרגות חופש מתוחזק על ידי האנשים שכתבו את המודל. זו אינה הדגמה הומנואידית מוקטנת, זו אותה זרוע.

החדשות הרעות הן המרחק בין I recorded 60 episodes לבין the arm does the task. ישנם כששה מקומות שבהם צינור עבודה זה נכשל בשקט במקום ברעש, וארבעה מהם נמצאים בקבצים שרוב האנשים לעולם אינם פותחים: meta/modality.json, קונפיגורציית נתוני הפייתון, meta/relative_stats.json, ומחרוזת הגרסה של מערך הנתונים עצמו. מדריך זה מציג את המסלול הידני מקצה לקצה עם הפקודות האמיתיות, ולאחר מכן מראה את אותה עבודה כטופס ב-AY-Robots. כל מה שלמטה נבדק מול ענף ה-main של Isaac-GR00T נכון ל-20 באוגוסט 2026 (קו הגרסה n1.7-release) ו-lerobot 0.6.1, שפורסם ל-PyPI ב-3 באוגוסט 2026. ה-upstream מתפתח במהירות, ובמקרה שדגל שונה, מאמר זה מציין זאת.

מהו GR00T N1.7 בפועל

GR00T N1.7 הוא מודל ראייה-שפה-פעולה עם מבנה דו-מערכתי כפי שתואר במאמר המקורי של GR00T N1: מודול ראייה-שפה שקורא את המצלמות ואת ההוראה, וטרנספורמר דיפוזיה שהופך זאת למקטע של פקודות מנוע רציפות. N1.7 החליף את החצי הראשון. עמוד השדרה של Eagle מ-N1.6 הוסר, והוחלף ב-nvidia/Cosmos-Reason2-2B על ארכיטקטורת Qwen3-VL, והמודל אומן מראש על כ-20,000 שעות של וידאו אנושי אגוצנטרי בנוסף לנתוני הרובוט. התיאור של NVIDIA עצמה מציין את הנתון ב-20,854 שעות ומדווח כי מעבר מ-1k ל-20k שעות יותר ממכפיל את השלמת המשימות הממוצעת.

החצי השני השתנה גם הוא, בדרכים שחשובות להרצה שלך. ראש הפעולה ירד מ-32 שכבות דיפוזיה ל-16, מקטע הפעולה גדל מ-16 צעדים ל-40, ורוחב המצב והפעולה המקסימלי עבר מ-29 ל-132. שלושת המספרים הללו מגיעים מיומן השינויים בקובץ ה-README של המאגר; פוסט ההשקה של NVIDIA עצמה עדיין מתאר את מערכת 1 כ-DiT בעל 32 שכבות, כך שבמקום שבו השניים חלוקים, סמוך על המאגר שאתה עומד לשכפל. פעולות מבוטאות כברירת מחדל במרחב קצה-אפקטור יחסי, דלתות מהתנוחה הנוכחית ולא יעדים מוחלטים, וזה מה שמאפשר להעביר ידע קודם של מניפולציה שנלמד מוידאו אנושי לבקרת רובוטים בכלל. הראש עצמו הוא טרנספורמר דיפוזיה של התאמת זרימה, מאותה משפחה כמו Pi0.5 אך עם עמוד שדרה שונה לפניו. אם אתה עדיין בדור הקודם, N1.7 מול N1.5 מכסה האם השדרוג מצדיק את בניית ה-pipeline מחדש.

שלוש השורות האחרונות מסבירות את רוב האכזבה שאנשים מדווחים עליה. הכותרת של 27.9 אלפיות השנייה היא מנוע TensorRT על H100 עם מצלמה אחת וארבעה שלבי הסרת רעש. PyTorch רגיל על אותו כרטיס הוא 85.8 אלפיות השנייה, וכרטיס המודל מציין את הפער כ-3.08x. אף אחד מהמספרים אינו כולל שכבת שירות, מצלמה שנייה או קפיצת רשת. ה-152 אלפיות השנייה לכל שלב פעולה ש-AY-Robots מצטטת עבור GR00T N1.7 המוגש שלה הוא הנתון עם שירות בלולאה, ונסיעה הלוך ושוב באינטרנט ציבורי יושבת מעל זה. עוד על כך בסוף. עבור המספרים ליד מודלים אחרים, GR00T N1.7 מול Pi0.5 ו-GR00T N1.7 מול SmolVLA מציגים אותם זה לצד זה.

מה שההרצה דורשת לפני שתקלידו משהו

שלב 0: הפרקים עצמם

כל מה שלמטה מניח שכבר הקלטתם פרקים. אם לא, זהו הצעד הראשון האמיתי והוא זה שמחליט עד כמה התוצאה יכולה להיות טובה, מכיוון ש-למידת חיקוי אינה יכולה לשחזר מידע שאינו נמצא בנתונים. כיילו את שתי הזרועות תחילה, ולאחר מכן הניעו את העוקב עם זרוע מובילה בזמן ש-lerobot-record כותב את קבצי ה-parquet ואת זרמי המצלמה. אם כיול אינו מדויק, ערכי המפרקים במערך הנתונים שלכם מתארים רובוט שונה במקצת מזה שיבצע מאוחר יותר את המדיניות, ושום כמות אימונים לא תתקן זאת.

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}, wrist: {type: opencv, index_or_path: 2, width: 640, height: 480, fps: 30}}" \
    --teleop.type=so100_leader \
    --teleop.port=/dev/ttyACM1 \
    --teleop.id=my_leader_arm \
    --dataset.repo_id=${HF_USER}/cube-into-bowl \
    --dataset.num_episodes=60 \
    --dataset.single_task="put the cube in the yellow bowl" \
    --display_data=true

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

שלב 1: מערך הנתונים חייב להיות LeRobot v2.1

זוהי המכשלה הנפוצה ביותר. ה-LeRobot הנוכחי CODEBASE_VERSION ב-main הוא v3.0, כך שכל מה שתקליטו היום עם שרשרת כלים עדכנית יצא כ-v3.0. הטוען של GR00T מצפה ל-v2. המאגר מפרט מדוע: מערכי נתונים רבים במעלה הזרם כגון DROID, LIBERO ו-Bridge מתפרסמים ב-v2, ותמיכה מובנית בשניהם מתוכננת אך עדיין לא נשלחה. לכן ההמרה היא באחריותכם, והיא רצה בסביבה וירטואלית משלה מסיבה מוגדרת: scripts/lerobot_conversion נושא פרויקט פייתון משלו הדורש Python 3.10 או 3.11 ומקבע את lerobot לקומיט גיט אחד, בעוד ש-Isaac-GR00T עצמו דורש Python 3.12. התקינו את הממיר משורש המאגר ותקבלו את חבילת ה-gr00t במקום זאת, וזו הטעות שה-README שלו מזהיר מפניה. אם אתם חדשים לפורמט, ערך המילון מערך נתונים של LeRobot מסביר מה באמת נמצא בתוכו.

# from the Isaac-GR00T repo root
cd scripts/lerobot_conversion
uv venv
source .venv/bin/activate
uv pip install -e . --verbose

# pulls the dataset from the Hub and writes a v2.1 copy into the default cache
python convert_v3_to_v2.py --repo-id <your-hf-user>/<your-dataset>

# or, back in the repo root, keep it next to the SO-100 example
uv run --project scripts/lerobot_conversion \
  python scripts/lerobot_conversion/convert_v3_to_v2.py \
  --repo-id <your-hf-user>/<your-dataset> \
  --root examples/SO100/my_dataset_lerobot

המבנה ש-GR00T רוצה לאחר ההמרה הוא פריסת v2 הקלאסית: meta/info.json, meta/episodes.jsonl, meta/tasks.jsonl, קובצי parquet תחת data/chunk-000/, קובצי MP4 תחת videos/chunk-000/observation.images./, וקובץ נוסף אחד שאין ל-LeRobot הסטנדרטי. הקובץ הנוסף הזה הוא המקום שבו נמצאות רוב הכשלים הנותרים.

שלב 2: modality.json, ששת המספרים שמחליטים הכל

במערך נתונים של LeRobot, מצב הרובוט והפעולה מאוחסנים כמערכי float32 שטוחים. עבור SO-100, לשניהם יש צורה [6]: חמישה מפרקי זרוע ותופסן. מערך הנתונים לדוגמה קורא להם shoulder_pan.pos, shoulder_lift.pos, elbow_flex.pos, wrist_flex.pos, wrist_roll.pos, gripper.pos, אך שמות אלה נמצאים ב-info.json ושום דבר בקובץ ה-parquet לא מציין איזה אינדקס הוא איזה. meta/modality.json מספק את המיפוי הזה, ו-GR00T לא יתאמן בלעדיו. הנה הקובץ שהמאגר מספק עבור ה-SO-100, כלשונו.

{
  "state": {
    "single_arm": {
      "start": 0,
      "end": 5
    },
    "gripper": {
      "start": 5,
      "end": 6
    }
  },
  "action": {
    "single_arm": {
      "start": 0,
      "end": 5
    },
    "gripper": {
      "start": 5,
      "end": 6
    }
  },
  "video": {
    "front": {
      "original_key": "observation.images.front"
    },
    "wrist": {
      "original_key": "observation.images.wrist"
    }
  },
  "annotation": {
    "human.task_description": {
      "original_key": "task_index"
    }
  }
}

העתיקו אותו לסט הנתונים המומר שלכם ב-meta/modality.json ושנו את שמות מפתחות הווידאו לשמות המצלמות שלכם בפועל. אם הקלטתם עם מצלמת תקרה בודדת בשם top, אז original_key הוא observation.images.top והשם הידידותי הוא מה שתצורת הנתונים שלכם תתייחס אליו. השניים חייבים להיות תואמים, ואף אחד מהם לא בודק את השני עבורכם. הערת השפה גרועה יותר, מכיוון שאותו מפתח חייב להופיע בשלושה מקומות.

שלב 3: תצורת הנתונים, זרוע יחסית ותופסן מוחלט

קונפיגורציית המודאליות היא קובץ Python ולא JSON, מכיוון שהיא גם קובעת כיצד כל קבוצת פעולה מיוצגת. זהו החלק בזרימת העבודה של N1.7 שלא היה קיים באותה צורה ב-N1.5, והחלק ששווה לקרוא פעמיים. קונפיגורציית SO-100 המסופקת מנבאת את חמשת מפרקי הזרוע כ-RELATIVE דלתות מהמצב הנוכחי ואת התפסן כ-ABSOLUTE מיקום יעד, מכיוון שאות בינארי של פתוח-או-סגור מתנהג טוב יותר כיעד מאשר כדלתא.

from gr00t.configs.data.embodiment_configs import register_modality_config
from gr00t.data.embodiment_tags import EmbodimentTag
from gr00t.data.types import (
    ActionConfig, ActionFormat, ActionRepresentation, ActionType, ModalityConfig,
)

so100_config = {
    "video": ModalityConfig(
        delta_indices=[0],                       # current frame only
        modality_keys=["front", "wrist"],        # must match modality.json
    ),
    "state": ModalityConfig(
        delta_indices=[0],
        modality_keys=["single_arm", "gripper"],
    ),
    "action": ModalityConfig(
        delta_indices=list(range(0, 16)),        # predict 16 future steps
        modality_keys=["single_arm", "gripper"],
        action_configs=[
            ActionConfig(rep=ActionRepresentation.RELATIVE,   # arm joints
                         type=ActionType.NON_EEF,
                         format=ActionFormat.DEFAULT),
            ActionConfig(rep=ActionRepresentation.ABSOLUTE,   # gripper
                         type=ActionType.NON_EEF,
                         format=ActionFormat.DEFAULT),
        ],
    ),
    "language": ModalityConfig(
        delta_indices=[0],
        modality_keys=["annotation.human.task_description"],
    ),
}

register_modality_config(so100_config, embodiment_tag=EmbodimentTag.NEW_EMBODIMENT)

שני פרטים כאן יעלו לכם יום אם לא תדעו אותם. ראשית, action_configs הוא פוזיציונלי: התיעוד דורש את אותו אורך ואותו סדר כמו modality_keys, והם מפורשים לגבי ההשלכה של טעות, שהיא יישום שגוי של הייצוג בשקט. התפסן שלכם מאומן כדלתא והזרוע שלכם כיעד מוחלט, ואין הודעת שגיאה. שנית, register_modality_config מאשר שאין תגית כזו רשומה כבר, כך שקונפיגורציית NEW_EMBODIMENT שנייה באותו תהליך Python תיכשל עם Embodiment tag ... already registered. אינכם יכולים לייבא שתי קונפיגורציות כאלה לסקריפט אחד. כלל שלישי נאכף מאוחר יותר, בעת הפריסה: ה-delta_indices חייב להיות הטווח הרציף שמתחיל באפס. חלון דליל כגון [0, 4, 8] נדחה, מכיוון שכל מה שבהמשך מאנדקס את הנתח החזוי באופן ליניארי ואחרת יבצע את השורות הלא נכונות.

שלב 4: הסביבה

N1.7 העבירה את המאגר ל- ופייתון 3.12. הנתיב הישן של קונדה פלוס pip install -e . עדיין קיים בקטע מכווץ של קובץ ה-README, אך הוא מזהיר שתלויות GPU, כולל flash-attn ו-TensorRT, עשויות לדרוש התקנה ידנית. השתמש ב-uv אלא אם יש לך סיבה ספציפית שלא לעשות זאת. בנוגע ל-flash-attn, פרט אחד חוסך בלבול: תראה Installing flash-attn מודפס בכל uv run. הוא לא נבנה מחדש. uv מאמת מחדש גלגל מקושר ל-URL שכבר נשמר במטמון, וזה לוקח שתיים או שלוש שניות.

1. 1
   התקן git-lfs, ולאחר מכן שכפל עם תת-מודולים

   git-lfs נדרש, לא אופציונלי. בלעדיו קבצי ה-parquet ב-demo_data/ יורדים כקובצי מצביע (pointer stubs), והרצת ההדגמה נכשלת על מערך נתונים שנראה קיים ברשימת הקבצים.

   bash

   sudo apt install git-lfs && git lfs install
   git clone --recurse-submodules https://github.com/NVIDIA/Isaac-GR00T
   cd Isaac-GR00T

2. 2
   התקן uv וסנכרן את הסביבה

   ההתקנה המוגדרת כברירת מחדל מושכת את תלויות ה-GPU, כולל flash-attn ו-TensorRT. בתמונת A100 או H100 חדשה זהו השלב הבודד הארוך ביותר, לכן בצע אותו לפני שתתחיל לשים לב לכל דבר אחר.

   bash

   curl -LsSf https://astral.sh/uv/install.sh | sh
   sudo apt-get update && sudo apt-get install -y ffmpeg
   uv sync --python 3.12
   uv run python -c "import gr00t; print('GR00T installed successfully')"

3. 3
   אמת מול Hugging Face

   בצע זאת לפני ההשקה הראשונה של האימון, לא לאחר שהוא נכשל שמונה דקות לתוך התהליך.

   bash

   uv run huggingface-cli login   # or: export HF_TOKEN=<your_token>

4. 4
   בדיקת תקינות על נתוני הדגמה SO-100 המסופקים

   לפני שתתחיל לעבוד עם ההקלטה שלך, הרץ 2000 צעדים על demo_data/cube_to_bowl_5. אלה חמישה פרקים, זה מסתיים במהירות, וזה מוכיח את הסביבה ולא את הנתונים שלך. אם הרצה זו נכשלת, שום דבר שתעשה למערך הנתונים שלך לא יעזור.

   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

שלב 5: פקודת ה-fine-tune וברירות המחדל האמיתיות של הדגלים שלה

החליפו את מערך הנתונים של ההדגמה בשלכם והוסיפו את ההגדרות שאתם באמת רוצים. להלן הצורה המלאה שהמאגר משתמש בה במדריך ה-new-embodiment שלו, כולל דגלי ההרחבה (augmentation) ושמירת נקודות הבקרה (checkpointing) שהדוגמה הקצרה ב-README משמיטה. זהו במובן הצר: עמוד השדרה השפתי והמקודד החזותי נשארים קפואים, ומה שמתאמן הוא המקרן (projector) וראש הפעולה של הדיפוזיה (diffusion action head).

export NUM_GPUS=1
CUDA_VISIBLE_DEVICES=0 uv run python \
    gr00t/experiment/launch_finetune.py \
    --base-model-path nvidia/GR00T-N1.7-3B \
    --dataset-path ./my_dataset_lerobot \
    --embodiment-tag NEW_EMBODIMENT \
    --modality-config-path examples/SO100/so100_config.py \
    --num-gpus $NUM_GPUS \
    --output-dir /tmp/so100 \
    --save-total-limit 5 \
    --save-steps 2000 \
    --max-steps 20000 \
    --use-wandb \
    --global-batch-size 32 \
    --color-jitter-params brightness 0.3 contrast 0.4 saturation 0.5 hue 0.08 \
    --dataloader-num-workers 4

השורה האחרונה אינה טעות הקלדה. launch_finetune.py הוא CLI של tyro שנוצר מ-dataclass, ול-dataclass זה אין שדה seed. קובץ ה-README מציין בנפרד שונות של 5 עד 6 אחוזים בין הרצות, הנגרמת על ידי הגברת תמונה לא דטרמיניסטית. שתי הרצות עם דגלים זהים לא יפיקו נקודות ביקורת זהות, וזה חשוב מאוד כשמנסים להחליט אם שינוי היפרפרמטר עזר או אם היה מזל. לשם השוואה, המאמן של lerobot עצמו מוגדר כברירת מחדל ל-seed 1000, והמתכון של LeRobot GR00T מעביר --seed=42 במפורש.

כמה עולה הרצה של 20000 צעדים

GR00T N1.7 דורש כרטיס של 80 GB, ולכן לשאלת העלות יש תשובה מצומצמת. ב-AY-Robots, המאמן groot1.7 רץ על שכבת A100 80 GB או H100 80 GB, כאשר הרצה אורכת 3 עד 6 שעות בעלות של 1.20 עד 2.00 USD לשעה בשוק הספוט. זה בערך 4 עד 12 USD עבור משימת ברירת המחדל של 20000 צעדים. אותה משימה ב- SmolVLA או ACT נוחתת על כרטיס של 24 GB בעלות של 0.30 עד 0.60 USD לשעה ו-1 עד 3 USD להרצה. זהו הפשרה האמיתית: GR00T עולה בערך פי ארבעה לכל ניסיון, ואי אפשר להריץ אותו על ה-4090 שמתחת לשולחן שלך.

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

שלב 6: הערכת לולאה פתוחה לפני שאתה נוגע בזרוע

אל תשים נקודת ביקורת על זרוע פיזית כדי לגלות אם האימון עבד. הרץ תחילה את הערכת הלולאה הפתוחה. היא מפעילה מחדש פרק מוקלט, מבקשת מהמודל פעולות בכל שלב, ומשרטטת את החיזוי מול אמת הקרקע עם MSE ו-MAE. זה לא עולה כלום ותופס את טעויות המיפוי משלבים 2 ו-3.

uv run python gr00t/eval/open_loop_eval.py \
    --dataset-path ./my_dataset_lerobot \
    --embodiment-tag NEW_EMBODIMENT \
    --model-path /tmp/so100/checkpoint-20000 \
    --traj-ids 0 \
    --execution-horizon 16 \
    --steps 400 \
    --modality-keys single_arm gripper

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

הצורה היא האות, לא הערכים המוחלטים. השגיאה אמורה לרדת בהתמדה ככל ש- מצטברים. בממוצע על פני כל חמשת פרקי האימון במקום מסלול 0 בלבד, נקודת הבדיקה הסופית של המאגר השיגה בערך 7.5 MSE ו-1.5 MAE, כך שאפילו הרצת הייחוס נקראת אחרת בהתאם לפרקים שאתה ממוצע. רשום את קו הבסיס שלך בפקודת ההדגמה הלא משונת לפני שאתה משנה משהו בנתונים שלך: אם אינך יכול לשחזר הרצה ידועה וטובה, אינך יכול להבחין בין טעות הגדרה לבעיית נתונים. המאגר גם ממפה את התסמינים הנפוצים לסיבות, וכל אחד מהם הוא תפעולי ולא באג במודל.

המסלול האחר: lerobot-train במקום Isaac-GR00T

הגרסה הנוכחית של LeRobot, 0.6.1 ב-PyPI מאז 3 באוגוסט 2026, מציעה דרך שנייה ושונה למדי לכייל את אותם משקלי בסיס. LeRobot חושפת את GR00T N1.7 כסוג מדיניות ומאמנת אותה דרך נקודת הכניסה שלה lerobot-train נקודת כניסה. שני דברים חשובים כאן. ה-CLI של LeRobot הוא סט של סקריפטים לקונסולה, אז כל דבר שאתה קורא שאומר python lerobot/scripts/train.py מיושן ולא יפעל. ו-LeRobot הסירה תמיכה ב-GR00T N1.5 לחלוטין, דוחה נקודות בדיקה ותצורות של N1.5 עם הערת הגירה, אז אם אתה צריך N1.5 דרך LeRobot עליך לקבע את lerobot==0.5.1, הגרסה האחרונה שתומכת בו, שפורסמה ב-7 באפריל 2026.

pip install "lerobot[groot]" "lerobot[training]"
hf auth login

lerobot-train \
  --dataset.repo_id=$HF_USER/$DATASET_NAME \
  --dataset.image_transforms.enable=true \
  --policy.type=groot \
  --policy.device=cuda \
  --policy.base_model_path=nvidia/GR00T-N1.7-3B \
  --policy.embodiment_tag=new_embodiment \
  --policy.chunk_size=16 \
  --policy.n_action_steps=16 \
  --policy.use_relative_actions=true \
  --policy.relative_exclude_joints='["gripper"]' \
  --policy.use_bf16=true \
  --seed=42 \
  --batch_size=64 \
  --steps=20000 \
  --save_freq=5000 \
  --output_dir=$OUTPUT_DIR

שתי דרכים לקבל את אותה נקודת שמירה

החזרת נקודת השמירה לזרוע

Isaac-GR00T משתמש בפיצול שרת-לקוח מעל ZMQ. המדיניות רצה על ה-GPU, ולקוח דק על מכונת הרובוט שולח תצפיות ומקבל חלקי פעולה. דוגמת ה-SO-100 שלמה מספיק כדי להעתיק: הפעל run_gr00t_server.py עם נקודת השמירה שלך ו--embodiment-tag NEW_EMBODIMENT, ולאחר מכן הרץ eval_so100.py בצד הרובוט עם היציאה הטורית, מזהה הרובוט, אינדקסי המצלמה והוראת השפה. שמות המצלמות בפקודה זו חייבים להתאים לשמות הידידותיים מ-modality.json שלך, לא למספרי התקני מערכת ההפעלה.

# GPU side
uv run python gr00t/eval/run_gr00t_server.py \
  --model-path /tmp/so100/checkpoint-20000 \
  --embodiment-tag NEW_EMBODIMENT \
  --device cuda:0 \
  --host 0.0.0.0 --port 5555

# robot side, from gr00t/eval/real_robot/SO100
uv run --no-sync python eval_so100.py \
  --robot.type=so101_follower \
  --robot.port=/dev/ttyACM2 \
  --robot.id=orange_follower \
  --robot.cameras="{ front: {type: opencv, index_or_path: 6, width: 640, height: 480, fps: 30}, wrist: {type: opencv, index_or_path: 2, width: 640, height: 480, fps: 30}}" \
  --policy_host=localhost --policy_port=5555 \
  --lang_instruction="put the cube in the yellow bowl"

כעת החלק הכנה לגבי היכן המדיניות פועלת, מכיוון שלאימון והגשה יש סיפורי חומרה שונים. כוונון עדין דורש 40 GB או יותר. הסקה לא: קובץ ה-README מציין 16 GB או יותר ומזכיר במפורש את ה-RTX 4090, כך שכרטיס שכבר בבעלותך יכול להגיש נקודת בדיקה שהוא מעולם לא היה יכול לייצר. מה שמחליט אם המדיניות מרגישה מגיבה אינו VRAM, אלא היכן השרת ממוקם. ב-AY-Robots GR00T N1.7 הוא מבוסס ענן בלבד, כך שלולאת הבקרה משלמת על נסיעה הלוך ושוב באינטרנט ציבורי בנוסף ל-152 אלפיות השנייה לכל שלב פעולה, ורק SmolVLA ו- ACT פועלים גם מקומית. עבור איסוף והנחה איטיים, תא מרוחק הוא נסבל. עבור כל דבר תגובתי זה לא: המדיניות הופכת מהוססת באופן שנראה בדיוק כמו כשל אימון ואינו כזה. ACT ב-20 אלפיות השנייה לכל שלב פעולה הוא המודל הסובלני ביותר ללולאה הדוקה, SmolVLA יושב ב-245 אלפיות השנייה, ושום כמות של כוונון השהיה לא תחזיר נסיעה הלוך ושוב שכבר בוזבזה. הפעל את המדיניות הראשונה שלך עובר על צד ההגשה מקצה לקצה.

מה באמת משתבש

• GatedRepoError בהרצה הראשונה. לא קיבלת גישה ל-nvidia/Cosmos-Reason2-2B, או שלא אימתת את זהותך. זה קורה לאחר ששעון ה-GPU כבר התחיל לפעול.
• מערך נתונים נדחה בטעינה. כמעט תמיד מדובר במערך נתונים v3.0. המר אותו לגרסה קודמת. ראה מערך נתונים נדחה כ-v3.
• IndexError לגבי מימדי בוליאניים לא תואמים. שינית את delta_indices ולא יצרת מחדש את הסטטיסטיקות.
• חוסר זיכרון באצווה 32. צמצם את --global-batch-size והגדל את --gradient-accumulation-steps, או צמצם את --num-shards-per-epoch, מה שהקונפיגורציה מציעה במפורש כאשר VRAM מוגבל. ראה חוסר זיכרון במהלך אימון.
• ההפסד יורד, המדיניות לא עושה כלום. אין חלוקת ולידציה כברירת מחדל, כך שעקומת אימון נקייה מוכיחה מעט מאוד. עמוד זה מכסה את האבחון.
• עובד בהגדרה שלך ובשום מקום אחר. צפוי עם מערך נתונים קטן שצולם בתנאי תאורה אחד. NVIDIA ממליצה על הגברת רעידות צבע (colour jitter augmentation) בתוספת 20 עד 50 אפיזודות בתנאי תאורה שונים. עוד כאן.
• התפסן (gripper) לעולם אינו נסגר כראוי. ודא שפעולת התפסן היא ABSOLUTE ומפרקי הזרוע הם RELATIVE, בסדר זה ב-action_configs. התפסן אינו נסגר מפרט את הסיבות האחרות.
• מצלמה נופלת בשקט באמצע ההקלטה. האפיזודה עדיין נשמרת ומפתח הווידאו עדיין קיים, ולכן זהו מקרה מורכב. מצלמה לא מזוהה מכסה זאת.

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