איך לאמן Pi0.5 על נתוני רובוט משלך

Pi0.5 הוא המודל שאליו פונים כאשר מדיניות צריכה לעבוד בחדר שמעולם לא ראתה. הוא גם המסורבל ביותר מבין חמש המדיניות ניתנות לאימון כאן כדי לבצע כוונון עדין ידנית: המאגר המקורי הוא JAX תחילה, פורט LeRobot העביר את הפריסה מ-lerobot-record בגרסה 0.6.0 והפך את ההתקנה הבסיסית לקטנה מדי לאימון, וכוונון עדין מלא אינו מתאים ל-4090. להלן: מה ש התאמת זרימה עולה בהסקה, שני נתיבי הפקודה, והמספר 485 ms שמחליט אם התוצאה שמישה.

מהו Pi0.5 בפועל

Physical Intelligence פרסמה את pi0 באוקטובר 2024: מודל התאמת זרימה מודל ראייה-שפה-פעולה על VLM מאומן מראש: PaliGemma עם 3 מיליארד פרמטרים בתוספת מומחה פעולה בגודל 300M שאותחל מאפס, סך הכל 3.3 מיליארד. המאמר מדווח על אימון מוקדם של למעלה מ-10,000 שעות של נתוני רובוטים על פני 7 תצורות רובוטים ו-68 משימות. לפרטים נוספים ב מאמר ה-pi0.

Pi0.5 (arXiv 2504.16054, 22 April 2025) שומר על השלד הזה ומשנה את תזונת האימון: נתוני אינטרנט, זיהוי אובייקטים, הוראות מילוליות מבני אדם המאמנים את הרובוט, תוויות משימות משנה, נתונים חוצי-התגלמות מרובוטים בבתים רבים. התוצאה היא רובוט המנקה מטבחים בבתים שלא היו בקבוצת האימון. קובץ ה-README של openpi מוסיף פרט שהכותרת אינה כוללת: ה-pi0.5 ששוחרר אומן עם בידוד ידע (arXiv 2505.23705).

מה ש-flow matching משנה באימון ובהסקה

מדיניות מדיניות שניתן לאמן על SO-100 מבצעת רגרסיה ישירה של פעולות (ACT) או ממירה אותן לאסימונים ומפענחת באופן אוטורגרסיבי (pi0-FAST). התאמת זרימה אינה עושה אף אחד מאלה: היא לומדת שדה וקטורי המעביר רעש לנתח פעולה, ואז משלבת אותו. מאמר ה-pi0 משתמש ב-10 שלבי אינטגרציה בגודל צעד של 0.1; תצורת ה-pi05 של LeRobot מכילה את אותו num_inference_steps: int = 10.

• אימון: הפסד מבצע רגרסיה על נתח פעולה עם רעש. אין טוקנייזר לכוונון, אין דיסקרטיזציה של זוויות המפרקים שלך.
• הסקה: נתח אחד עולה עשרה מעברים קדימה דרך מומחה הפעולה. זה מבני, לא בעיית כוונון.
• פלט: פעולות רציפות במימד 32, מרופדות פנימית, הפסד נלקח על הממדים שיש לרובוט שלך. זרוע 6-DoF בתוספת תופסן משתמשת ב-7.

# openpi/src/openpi/models/pi0_config.py - the defaults every pi05 config inherits
@dataclasses.dataclass(frozen=True)
class Pi0Config(_model.BaseModelConfig):
    dtype: str = "bfloat16"
    paligemma_variant: _gemma.Variant = "gemma_2b"
    action_expert_variant: _gemma.Variant = "gemma_300m"

    action_dim: int = 32
    action_horizon: int = 50
    max_token_len: int = None      # 200 if pi05 else 48

    pi05: bool = False             # flips discrete_state_input to True

עמוד השדרה של PaliGemma, והשער שלפניו

PaliGemma (arXiv 2407.07726) הוא מקודד ראייה SigLIP-So400m על מודל שפה Gemma-2B, עם כ-3 מיליארד פרמטרים. Pi0.5 יורש את הטוקנייזר שלו, והטוקנייזר הזה נמצא במאגר מגודר. זו הדרך הנפוצה ביותר שבה הרצה ראשונה נכשלת, לפני ה-שלב אימון.

לפני שמתחילים: פורמט מערך נתונים, פרקים, חומרה

Pi0.5 ב-LeRobot קורא LeRobot dataset בפריסת v3.0, שהגיעה עם lerobot 0.4.0 באוקטובר 2025: פרקים רבים לכל קובץ Parquet ו-MP4 במקום קובץ אחד לכל פרק, עם גבולות ב-meta/episodes/ במקום בשמות קבצים. הקליטו עם ה-לקוח שולחני או עקבו אחר הקליטו את מערך הנתונים הראשון שלכם וכבר יש לכם את זה.

# v2.1 -> v3.0, run against a dataset already on the Hub
python -m lerobot.scripts.convert_dataset_v21_to_v30 --repo-id=<HF_USER/DATASET_ID>

# aggregates episode-0000.parquet, episode-0001.parquet, ... -> file-0000.parquet
# aggregates episode-0000.mp4, episode-0001.mp4, ...         -> file-0000.mp4
# rewrites meta/episodes/* with per-episode lengths, tasks and offsets

הפלטפורמה דורשת לפחות 50 פרקים עבור Pi0.5, אותו סף כמו GR00T ו-ACT. אימון מקדים עושה את העבודה הקשה, כך ש-50 פרקים נקיים עדיפים על 200 מרושלים. חדש בתחום? התחל עם מדריך איסוף הנתונים.

מסלול א': כוונון עדין עם מאגר openpi

היישום הייחוס: JAX ראשון, נבדק על Ubuntu 22.04 בלבד, מונע על ידי אובייקטי תצורה במקום דגלים. נתיב PyTorch הגיע בספטמבר 2025, מאומת על LIBERO. שלושה שלבים: המרת הנתונים שלך, הגדרת תצורה, אימון והגשה.

1. 1
   שכפול והתקנה

   openpi משתמש ב-uv. GIT_LFS_SKIP_SMUDGE הוא מה שמאפשר ל-LeRobot להיכנס כתלות ללא אובייקטי LFS.

   bash

   git clone --recurse-submodules git@github.com:Physical-Intelligence/openpi.git
   cd openpi
   
   GIT_LFS_SKIP_SMUDGE=1 uv sync
   GIT_LFS_SKIP_SMUDGE=1 uv pip install -e .

2. 2
   המרת הנתונים שלך למערך נתונים של LeRobot

   ה-upstream מספק ממירים עבור LIBERO ו-DROID ומצפה שתתאים אחד מהם. העבודה היא מיפוי המפתחות.

   bash

   uv run examples/libero/convert_libero_data_to_lerobot.py --data_dir /path/to/your/data

3. 3
   הוספת תצורת אימון

   תצורות הן ערכי TrainConfig בקובץ src/openpi/training/config.py. זו מתאימה את pi05_droid_finetune, כאשר טוען המשקלים מצביע על pi05_base.

   python

   TrainConfig(
       name="pi05_so100",
       model=pi0_config.Pi0Config(
           pi05=True,
           action_dim=32,        # pi05 is trained with 32-dim actions
           action_horizon=16,
       ),
       # Copy LeRobotLiberoDataConfig in the same file and rewrite the key
       # mapping for your camera names, then reference your copy here.
       data=LeRobotLiberoDataConfig(
           repo_id="your_hf_username/my_so100_dataset",
           base_config=DataConfig(prompt_from_task=True),
       ),
       weight_loader=weight_loaders.CheckpointWeightLoader(
           "gs://openpi-assets/checkpoints/pi05_base/params"
       ),
       batch_size=32,
       num_train_steps=20_000,
   )

4. 4
   חישוב סטטיסטיקות נורמליזציה

   רץ מול שם התצורה, לא מול מערך הנתונים. דילוג עליו הוא הכשל הקלאסי הראשון כאן.

   bash

   uv run scripts/compute_norm_stats.py --config-name pi05_so100

5. 5
   אימון

   המשתנה מאפשר ל-JAX להשתמש ב-90 אחוז מזיכרון ה-GPU במקום ב-75 אחוז ברירת המחדל. בכרטיס של 80 GB זה קובע אם הריצה תשרוד.

   bash

   XLA_PYTHON_CLIENT_MEM_FRACTION=0.9 uv run scripts/train.py pi05_so100 \
       --exp-name=my_experiment \
       --overwrite

6. 6
   הגש אותו

   השרת מאזין בפורט 8000 ועונה לשאילתות תצפית; סביבת הריצה של הרובוט שלך היא הלקוח.

   bash

   uv run scripts/serve_policy.py policy:checkpoint \
       --policy.config=pi05_so100 \
       --policy.dir=checkpoints/pi05_so100/my_experiment/20000

נתיב ב': כוונון עדין עם lerobot pi05

פורט LeRobot עוטף את אותם המשקלים בממשק שורת הפקודה שבו אתה כבר משתמש עבור ACT ו-SmolVLA. כל מה שלמטה נבדק מול lerobot 0.6.1, הגרסה שיצאה ב-3 באוגוסט 2026, ומסמכי pi05 מ-23 באוגוסט 2026. גרסאות חשובות כאן: מערכי נתונים v3.0 הגיעו עם 0.4.0 באוקטובר 2025, הבלוג 0.5.0 מ-9 במרץ 2026 מציג את pi0-FAST ו-Real-Time Chunking, ו-0.6.0 ב-6 ביולי 2026 הפך את חבילת הבסיס לקלה והעביר את הפריסה ל-lerobot-rollout.

דבר אחד לא זז: lerobot-train ו-lerobot-record כבר היו נקודות כניסה ב-0.3.2, אוגוסט 2025. מדריך שעדיין קורא ל-python -m lerobot.scripts.train קדם לשנה של שינויים ושווה לא לסמוך עליו גם בשאר.

1. 1
   התקנה עם התוספים הנכונים

   החל מגרסה 0.6.0, ההתקנה הבסיסית כוללת רק תלויות ליבה של למידת מכונה, והתוסף 'pi' אינו מוסיף קוד נתונים או אימון, ולכן כוונון עדין דורש גם את תוסף האימון. פקודות התקנה ישנות יותר נכשלות כאן בזמן הייבוא.

   bash

   # policy dependencies plus the training stack
   pip install 'lerobot[pi,training]'
   
   # from a source checkout
   pip install -e ".[pi,training]"
   
   # driving an SO-100 afterwards needs the robot extras too
   pip install 'lerobot[core_scripts,feetech]'

2. 2
   אימות

   אשר את רישיון paligemma-3b-pt-224 בדפדפן, ולאחר מכן התחבר למכונה המבצעת את האימון.

   bash

   hf auth login

3. 3
   הוספת סטטיסטיקות קוונטילים

   Pi0.5 מנרמל STATE ו-ACTION באמצעות קוונטילים, ולכן meta/stats.json דורש q01 ו-q99. מערכי נתונים ישנים יותר מכילים רק min, max, mean, std.

   bash

   lerobot-edit-dataset \
       --repo_id your_dataset \
       --new_repo_id your_dataset \
       --operation.type recompute_stats \
       --operation.overwrite true

4. 4
   כוונון עדין מ-lerobot/pi05_base

   הגדר את גודל האצווה למה שהכרטיס שלך יכול לעמוד בו; התיעוד משתמש ב-64 ב-LIBERO עם 80 GB. העבר bfloat16 במפורש, ברירת המחדל של התצורה היא float32.

   bash

   lerobot-train \
       --dataset.repo_id=${HF_USER}/my_so100_dataset \
       --policy.type=pi05 \
       --policy.pretrained_path=lerobot/pi05_base \
       --policy.gradient_checkpointing=true \
       --policy.dtype=bfloat16 \
       --policy.device=cuda \
       --policy.push_to_hub=false \
       --output_dir=./outputs/pi05_so100 \
       --job_name=pi05_so100 \
       --batch_size=4 \
       --num_workers=8 \
       --steps=30000 \
       --save_freq=5000 \
       --seed=1000

5. 5
   הפעלת המערכת על הזרוע

   בגרסה 0.6.x זוהי הפקודה lerobot-rollout: lerobot-record מסרבת למדיניות ודוחה שמות של מערכי נתונים מסוג eval_. 'Base' מניע את הזרוע, 'sentry' מתעד את ההרצה.

   bash

   lerobot-rollout \
       --strategy.type=base \
       --policy.path=${HF_USER}/my_policy \
       --robot.type=so100_follower \
       --robot.port=/dev/ttyACM1 \
       --robot.cameras="{ up: {type: opencv, index_or_path: /dev/video10, width: 640, height: 480, fps: 30}}" \
       --task="Put lego brick into the transparent box" \
       --duration=60
   
   # same run, recorded into an eval_ dataset
   lerobot-rollout \
       --strategy.type=sentry \
       --policy.path=${HF_USER}/my_policy \
       --robot.type=so100_follower \
       --robot.port=/dev/ttyACM1 \
       --dataset.repo_id=${HF_USER}/eval_so100 \
       --dataset.single_task="Put lego brick into the transparent box" \
       --duration=600

שלוש קבוצות של ברירות מחדל, ואילו מהן מגיעות למאמן

TrainConfig של openpi הוא ההתייחסות, PI05Config של LeRobot הוא מה ש-lerobot-train משתמש בו כשלא אומרים כלום, והטופס כאן שולח סט שלישי. ההפתעה היא קצב הלמידה: ברירות המחדל של שניהם מגיעות לשיא של 2.5e-5, בעוד שתצורת pi05_libero של openpi עצמה ופלטפורמה זו מעלות אותו ל-5e-5.

האם הפורט נאמן? צוות LeRobot כייל עדין את מודל הבסיס LIBERO ל-6k שלבים נוספים והשווה עם מספרי הייחוס של openpi בארבע חבילות: ממוצע של 97.5 אחוזים לעומת 96.85, מוביל ב-Libero 10, מאחור ב-Spatial. המסלול הוא בחירת כלי עבודה, לא בחירת איכות.

מציאות ה-485 מילישניות, והיכן היא מפסיקה להיות שמישה

זה קובע את הפרויקט שלך, ולכן הוא מופיע לפני טבלת העלויות. ה- לכל שלב פעולה שנמדדה כאן עבור Pi0.5 היא 485 מילישניות. לעומת ארבעת האחרים:

ל-Upstream יש תשובה, וחצי ממנה כבר נמצא במהדורה שתוכל להתקין. Real-Time Chunking מייצר את המקטע הבא בזמן שהזרוע עדיין מבצעת את המקטע הנוכחי, ולאחר מכן מנחה את השלבים החופפים של המקטע החדש להישאר קרובים לחלק שכבר בוצע, כך שהזרוע לא תיתקע או תזעזע בנקודת החיבור. הצורה בזמן הסקת המסקנות (inference-time form) נכללה ביומן השינויים 0.4.2 עבור Pi0, Pi0.5 ו-SmolVLA והיא דגל פריסה (rollout flag), לא אימון מחדש (retrain):

lerobot-rollout \
    --strategy.type=base \
    --policy.path=${HF_USER}/my_policy \
    --inference.type=rtc \
    --inference.rtc.execution_horizon=10 \
    --inference.rtc.max_guidance_weight=10.0 \
    --robot.type=so100_follower \
    --robot.port=/dev/ttyACM1 \
    --robot.cameras="{ up: {type: opencv, index_or_path: /dev/video10, width: 640, height: 480, fps: 30}}" \
    --task="Put lego brick into the transparent box" \
    --duration=60

זה לא מאיץ את המודל. זה מסתיר את הפער: 485 אלפיות השנייה עדיין מושקעות, אך מחוץ לנתיב הקריטי, כך שהתור לא מתרוקן בין מקטעים. הגרסה בזמן האימון (training-time variant) מ-arXiv 2512.05964 הולכת רחוק יותר: המודל לומד להתנות על קידומת פעולה נקייה, כך שבזמן הסקת המסקנות החפיפה נצבעת מחדש באופן קשיח עם צעדי זמן זרימה לכל פעולה במקום להיות מונחית, ומעבר ההכוונה לאחור נעלם. במהלך האימון הוא דוגם אורך קידומת לכל דוגמה ולוקח את אובדן הזרימה על הסיומת הנותרת. דגל זה קיים רק ב-main, לא ב-0.6.1, והעיכוב שעבורו אתה מאמן חייב להישאר מתחת ל-chunk_size.

שתי דרכים להשיג נקודת ביקורת (checkpoint) של Pi0.5

lerobot-train \
    --dataset.repo_id=${HF_USER}/my_so100_dataset \
    --policy.type=pi05 \
    --policy.pretrained_path=lerobot/pi05_base \
    --policy.rtc_training_max_delay=10 \
    --policy.gradient_checkpointing=true \
    --policy.dtype=bfloat16 \
    --batch_size=4 --steps=30000 --seed=1000

כאשר זה לא עובד

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

עלות הרצה אחת

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

לפני שמתחייבים לערב שלם: GR00T N1.7 מול Pi0.5 ו-Pi0.5 מול SmolVLA מציגים את אותם נתונים זה מול זה. ה-זירה מכילה 85 מודלי VLA עם 332 תוצאות בנצ'מרק, כל אחת מקושרת למקור שלה, ורקע על המשפחה נמצא ב-סקירת ה-VLA שלנו.