
הקלט מערך נתונים שמיש של LeRobot עם SO-100: כיול, טלאופרציה במצב מוביל-עוקב, הדגלים והגדרות ברירת המחדל האמיתיים של lerobot-record, הגדרת מצלמה, מספר פרקים, והפגמים שהורסים ריצה.
עוקב SO-100, זרוע מובילה באותו עיצוב ושתי מצלמות USB יכולים לכוונן מדיניות אחר הצהריים. אותו ספסל יכול באותה קלות לייצר שישים פרקים שנראים תקינים בדפדפן קבצים ולבזבז ריצת GPU של שש שעות. ההבדל הוא לעיתים רחוקות המודל; זה מה שקרה בין הסרוו לקובץ ה-parquet.
הנה המסלול הידני, ואז הקצר יותר. כל פקודה היא מ-lerobot 0.6.1, שוחררה ב-3 באוגוסט 2026 ועדכנית ב-PyPI. היא עברה לנקודות כניסה של קונסולה, כך שמדריכים שמריצים python lerobot/scripts/control_robot.py מתארים קובץ שכבר לא קיים.
הגרסה הקצרה
- •lerobot 0.6.1 מקליט v3.0; GR00T N1.7 ו-N1.5 רוצים v2.1. קבעו את הפורמט לפני שתלחצו על הקלטה.
- •ארבע פקודות: lerobot-find-port, lerobot-setup-motors, lerobot-calibrate, lerobot-record. השתמשו באותם --robot.id ו- --teleop.id מהכיול לתוך סשן ההקלטה.
- •ברירות מחדל אמיתיות: 30 פריימים לשנייה, 60 שניות לפרק, 60 שניות איפוס, 50 פרקים, כ-100 דקות זמן שעון קיר.
- •מינימום פרקים כאן: 30 עבור SmolVLA, 50 עבור השאר.
- •גיוון עדיף על נפח. מערכי נתונים מתים מארבעה דברים: אינדקסי מצלמה שהוחלפו, פריימים שנשמטו או קפאו, מפרק שחנה בגבולו, מחרוזת משימה בלתי קריאה.
מה סשן הקלטה לוכד
מערך נתונים של LeRobot dataset אינו תיקיית סרטונים אלא טבלה עם אינדקס זמן וסרטון מצורף: כל פעימת לולאת בקרה כותבת שורה אחת המכילה את הפעולה המבוקשת, את המצב שאליו הגיע העוקב, פריים אחד לכל מצלמה, חותמת זמן ואינדקסים. המדיניות רואה רק עמודות אלו. הסכימה של lerobot/svla_so100_pickplace, נקראת מתוך meta/info.json שלה.
| מאפיין | סוג נתונים | צורה | תיאור |
|---|---|---|---|
| action | float32 | [6] | מטרות מפרקים מזרוע המנהיג |
| observation.state | float32 | [6] | מיקומי מפרקים שהעוקב הגיע אליהם |
| observation.images.top | video | [480, 640, 3] | מצלמת סצנה, MP4 (av1 כאן) |
| observation.images.wrist | video | [480, 640, 3] | מצלמת פרק כף היד, באותו קצב |
| timestamp | float32 | [1] | שניות מתחילת הפרק |
| frame_index, episode_index, index, task_index | int64 | [1] | רישום אוטומטי |
המפרקים הם main_shoulder_pan, main_shoulder_lift, main_elbow_flex, main_wrist_flex, main_wrist_roll ו-main_gripper: שש הדרגות חופש של SO-100. פעולה ומצב חולקים צורה מכיוון שטל-אופרציה של מנהיג-עוקב מתעדת יעד ואת המיקום שהושג צעד אחד מאוחר יותר. פער זה הוא מידע: היכן הזרוע נלחמה בכוח הכבידה או בחפץ תקוע. מחרוזות אלו שייכות למערך הנתונים הזה. סשן שתועד עם 0.6.1 היום כותב shoulder_pan.pos דרך gripper.pos, מזהים 1 עד 6 על האפיק: אותם שישה מפרקים, מפתחות שונים, מה שחשוב ברגע שתצורה מתייחסת למאפיין לפי שם.
מערך נתונים זה מכיל 50 פרקים ו-19,631 פריימים בקצב של 30 פריימים לשנייה: כ-393 פריימים, או 13 שניות, לפרק. אם שלכם ממוצע לדקה, אתם עושים משהו קשה יותר או מקליטים זמן מת בשני הקצוות.

מה שאתה צריך על השולחן
| פריט | פרט | הערה |
|---|---|---|
| זרוע עוקבת | SO-100, שישה סרוואים Feetech STS3215 | כ-110 עד 150 אירו בחלקים |
| זרוע מובילה | SO-100 שנייה, גלגלי שיניים הוסרו | גלגלי שיניים הופשטו מכל ששת מנועי הזרוע המובילה: מקודד בלבד, פחות חיכוך |
| ספק כוח | מותאם לגרסת ה-7.4 V של STS3215 ברשימת החומרים | ראה את האזהרה למטה |
| מצלמות | שתי מצלמות USB, 640x480 ב-30 פריימים לשנייה | תצוגת סצנה אחת, אחת על פרק כף היד |
| מחשב מארח | Python 3.12 או חדש יותר, ffmpeg | requires-python >= 3.12 |
| חשבון Hub | Hugging Face אסימון כתיבה | optional with --dataset.push_to_hub=false |
ה-STS3215 מגיע בשתי גרסאות: קובץ ה-README של SO-ARM100 מדרג את גרסת ה-7.4 V במומנט עצירה של 16.5 ק"ג-ס"מ הנמדד ב-6 V ואת גרסת ה-12 V ב-30 ק"ג-ס"מ, ומציין כי בחירת מנועי ה-12 V פירושה גם רכישת ספק כוח של 12 V 5 A+ במקום ספק ה-5 V. רשימת החומרים מפרטת סרוואים של 7.4 V. הזנת 12 V לסרוואים המדורגים ל-7.4 V הורסת אותם, לכן קרא את תווית המנוע לפני שאתה מחבר משהו. הסרוו אינו מגיב.
אם הזרוע עדיין לא נבנתה, זה ערב נפרד: התחילו ב-תחילת העבודה עם SO-100 וב-מדריך ההתקנה המלא של SO-100. אם עדיין לא קניתם כלום, קראו תחילה את השוואת SO-100 מול SO-101 תחילה: ה-SO-101 הוא הגרסה החדשה יותר עם חיווט משופר וללא שלב הסרת גלגלי שיניים, ותהליך ההקלטה זהה.
התקינו את lerobot 0.6.1
conda create -y -n lerobot python=3.12
conda activate lerobot
# TorchCodec is the default video decoder and needs ffmpeg
conda install ffmpeg -c conda-forge
# core_scripts = dataset + hardware + viz extras (record, replay, calibrate)
# feetech = SDK for the STS3215 bus servos in the SO-100
pip install 'lerobot[core_scripts,feetech]'
lerobot-infoתוספות מבלבלות אנשים לרוב. pip install lerobot מתקין רק תלויות ליבה של למידת מכונה, שום דבר שלא מתקשר עם רובוט. זרועות Koch זקוקות ל-dynamixel במקום feetech. אם ה-shell שלכם מעולם לא שמע על lerobot-record, זו הסיבה.
פורטים, מזהי מנועים וכיול
שלושה שלבים חד-פעמיים מפרידים בין החלקים ללולאת טל-אופ תקינה. מאפשר למדיניות שאומנה על הזרוע שלך לרוץ על זרוע של מישהו אחר, על ידי מיפוי ספירות מקודד גולמיות למוסכמת מפרקים משותפת.
- 1מצא את פורט ה-USB של כל זרוע
הפעל אותו כששתי הזרועות מחוברות, נתק את הזרוע שאתה מזהה כאשר תתבקש, ושים לב איזה פורט נעלם. בלינוקס ייתכן שתצטרך
sudo chmod 666 /dev/ttyACM0.bashlerobot-find-port # Finding all available ports for the MotorsBus. # Ports before disconnecting: ['/dev/ttyACM0', '/dev/ttyACM1'] # Remove the USB cable from your MotorsBus and press Enter when done. # The port of this MotorsBus is '/dev/ttyACM1' # Reconnect the USB cable. - 2כתוב מזהי מנועים וקצבי העברה
מזהים נכתבים מנוע אחד בכל פעם, והתיעוד קפדני לגבי אופן הפעולה: חבר מנוע אחד בלבד ללוח הבקר, לא מחובר עדיין בשרשרת למנוע אחר. הסקריפט עובר על השרשרת לאחור, מבקש תחילה את התופסן ונותן לו מזהה 6, לאחר מכן את wrist_roll כמזהה 5, ועד shoulder_pan כמזהה 1. בצע זאת לפני ההרכבה.
bashlerobot-setup-motors \ --robot.type=so100_follower \ --robot.port=/dev/ttyACM0 lerobot-setup-motors \ --teleop.type=so100_leader \ --teleop.port=/dev/ttyACM1 - 3כייל את שתי הזרועות
הזז כל מפרק לאמצע הטווח שלו, לחץ Enter, ולאחר מכן סרוק כל אחד מהם לאורך כל הטווח שלו. ה-
idהופך לשם קובץ הפרופיל.bashlerobot-calibrate \ --robot.type=so100_follower \ --robot.port=/dev/ttyACM0 \ --robot.id=my_so100_follower lerobot-calibrate \ --teleop.type=so100_leader \ --teleop.port=/dev/ttyACM1 \ --teleop.id=my_so100_leader - 4בצע טל-אופ לפני הקלטת כל דבר
בדיקת הקבלה לכל מה שלעיל. אם הטל-אופ קופצני, משתקף, או שמפרק אחד אינו עוקב, ההקלטה תשמר זאת ב-50 פרקים.
bashlerobot-teleoperate \ --robot.type=so100_follower \ --robot.port=/dev/ttyACM0 \ --robot.id=my_so100_follower \ --teleop.type=so100_leader \ --teleop.port=/dev/ttyACM1 \ --teleop.id=my_so100_leader \ --display_data=true
פרופילים נשמרים ב-$HF_LEROBOT_CALIBRATION, ברירת מחדל ~/.cache/huggingface/lerobot/calibration, וה-id הוא מפתח החיפוש. תן ל-lerobot-record מזהה מכויל והוא יציע Enter לשימוש חוזר בפרופיל או c לביצוע מחדש. תן לו מזהה לא ידוע ואין קובץ, כך שהוא יכנס לכיול באמצע הסשן.
מצלמות קובעות מה רואה המדיניות
lerobot-find-cameras opencv # or: lerobot-find-cameras realsense
# --- Detected Cameras ---
# Camera #0:
# Name: OpenCV Camera @ 0
# Type: OpenCV
# Id: 0
# Backend api: AVFOUNDATION
# Default stream profile:
# Format: 16.0
# Width: 1920
# Height: 1080
# Fps: 15.0שתי תצוגות, ומיקומן חשוב: מצלמת סצנה קבועה המכסה את סביבת העבודה, ומצלמת פרק כף יד ליד ה-קצה-אפקטור המראה מה הגריפר עומד לגעת. רשימת הבדיקה של מערכי הנתונים הקהילתיים של LeRobot מבקשת עדיף שתי תצוגות ב-480x640 / 720p או טוב יותר, רקע סטטי, תאורה ניטרלית ויציבה, והזרוע המובילה וגפיים אנושיות מחוץ לפריים. מדריך ההקלטה מוסיף כלל אצבע: עליך להיות מסוגל לבצע את המשימה בעצמך רק על ידי התבוננות בתמונות המצלמה.
אינדקסים של OpenCV נובעים מסדר הספירה, כך שהפעלה מחדש או חיבור מחדש יכולים לגרום לאינדקס 0 ו-2 להחליף מקומות ולמקם את תצוגת פרק כף היד בחריץ העליון למשך סשן שלם. lerobot אומר זאת בעצמו: מחלקת המצלמה שלו מקבלת נתיב התקן וגם מספר שלם, ומזהירה שאינדקסים אינם יציבים בין הפעלות מחדש או שינויי פורטים, במיוחד בלינוקס. כוון את index_or_path אל ה-symlink של udev תחת /dev/v4l/by-id/, העוקב אחר ההתקן ולא אחר סדר הספירה. זוהי הדרך הנפוצה ביותר שבה מערך נתונים הופך ללא עקבי פנימית, ואימון אינו יכול לתקן זאת. המצלמה לא זוהתה.
פקודת ההקלטה וכל הדגלים
HF_USER=$(NO_COLOR=1 hf auth whoami | awk -F': *' 'NR==1 {print $2}')
lerobot-record \
--robot.type=so100_follower \
--robot.port=/dev/ttyACM0 \
--robot.id=my_so100_follower \
--robot.cameras="{ top: {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_so100_leader \
--display_data=true \
--dataset.repo_id=${HF_USER}/so100_pick_cube \
--dataset.single_task="Pick the red cube and drop it in the box" \
--dataset.num_episodes=50 \
--dataset.fps=30 \
--dataset.episode_time_s=25 \
--dataset.reset_time_s=10 \
--dataset.streaming_encoding=true \
--dataset.encoder_threads=2ברירות המחדל שלהלן מגיעות מ-src/lerobot/configs/dataset.py ב-main, לא ממדריך. כמה מהן אינן מה שאנשים מניחים.
| דגל | ברירת מחדל | מה הוא עושה |
|---|---|---|
| --dataset.repo_id | ריק | שם; חותמת זמן מצורפת כברירת מחדל |
| --dataset.single_task | ריק | מחרוזת משימה הנשמרת עם כל פרק |
| --dataset.root | $HF_LEROBOT_HOME/repo_id | נתיב כתיבה, ברירת מחדל ~/.cache/huggingface/lerobot/ |
| --dataset.fps | 30 | קצב לולאת בקרה וקצב פריימים של מערך נתונים |
| --dataset.episode_time_s | 60 | שניות לפני שפרק מתקדם אוטומטית |
| --dataset.reset_time_s | 60 | איפוס סצנה; הזרוע נעה, דבר לא נשמר |
| --dataset.num_episodes | 50 | פרקים שהוקלטו בסשן זה |
| --dataset.push_to_hub | true | העלאה בסיום הסשן; false משאיר מקומי |
| --dataset.streaming_encoding | false in the dataclass, true in the docs table | קידוד במהלך לכידה; הגדר זאת במפורש |
| --dataset.encoder_queue_maxsize | 30 | פריימים בחוצץ לכל מצלמה, ~1 שניה ב-30 פריימים לשניה |
| --dataset.encoder_threads | null (codec decides) | תהליכונים לכל מקודד; נמוך יותר אם הלכידה מגמגמת |
| --dataset.no_stamp | false | שמור את repo_id בדיוק כפי שהוקלד |
| --resume | false | הוסף למערך נתונים קיים; דורש --dataset.root |
מערך הנתונים שלך לא נקרא בשם שהקלדת. lerobot מצרף תגית תאריך-שעה, כך ש-so100_pick_cube הופך ל-so100_pick_cube_20260823_141530. השתמש ב---dataset.no_stamp=true לשם יציב. המשך סופר תוספות, לא סכומים. עם --resume=true, --dataset.num_episodes סופר פרקים נוספים ו---dataset.root הופך לחובה. בקש 50 על מערך נתונים של 30 פרקים ותקבל 80.
שליטה באמצעות מקלדת במהלך סשן
- חץ ימינה או
n: סיים את הפרק או את שלב האיפוס מוקדם. המקש שבו תשתמש הכי הרבה, מכיוון שאחיזה נקייה כמעט אף פעם לא דורשת 25 שניות. - חץ שמאלה או
r: זרוק את הפרק ובצע אותו מחדש. צילום גרוע לא עולה כלום עכשיו והרבה אחר כך. - Escape או
q: עצור את הסשן, סיים קידוד, העלה. - אלה עובדים ב-X11, Wayland ו-SSH ללא ממשק גרפי: ללא קצה אחורי גלובלי למקשים, lerobot-record קורא את אותם מקשים מהטרמינל השולט. האותיות שורדות קישורי SSH איטיים, שבהם רצפי חצים מתפצלים.
- טלפרופרציה באמצעות מקלדת שונה וכן דורשת קצה אחורי גלובלי: X11, Windows, או macOS עם נגישות.
כמה פרקים, ואיך נראה פרק טוב
מדריך ההקלטה מציע לפחות 50 אפיזודות למשימה ראשונה, כ-10 לכל מיקום אובייקט. דפי המדיניות מפרטים מינימום לכל מודל, שמתחתיו הרצה אינה שווה את זמן ה-GPU.
| מדיניות | מינימום אפיזודות | פורמט מערך נתונים | רמת GPU | עלות להרצה |
|---|---|---|---|---|
| SmolVLA | 30 | LeRobot v3.0 | RTX 4090 or any 24 GB card | about 1 to 3 USD |
| ACT | 50 | LeRobot v3.0 | RTX 4090 or any 24 GB card | about 1 to 3 USD |
| GR00T N1.7 | 50 | LeRobot v2.0 or v2.1 | A100 80 GB or H100 80 GB | about 4 to 12 USD |
| GR00T N1.5 | 50 | LeRobot v2.0 or v2.1 | A100 80 GB or H100 80 GB | about 4 to 12 USD |
| Pi0.5 | 50 | LeRobot v3.0 | A100 80 GB or H100 80 GB | about 4 to 12 USD |
השאלה הטובה יותר היא כמה ממה. חוקי קנה מידה של נתונים בלמידת חיקוי למניפולציה רובוטית (לין ואח', 2024) אספו למעלה מ-40,000 הדגמות והריצו יותר מ-15,000 הרצות בעולם האמיתי. הכללה עקבה אחר יחס של חוק חזקה בקירוב עם מספר ה-סביבות ואובייקטים, ולאחר סף מסוים לכל סביבה או אובייקט, להדגמות נוספות הייתה השפעה מינימלית. על ספסל אחד: הזיזו את האובייקט, שנו את התאורה, החליפו את הקובייה, במקום לחזור על אותה פעולה.
- מסלולי מפרקים רציפים שסרוו יכול לשחזר, בניגוד למקלדת או גיימפאד
- פעולה ומצב חולקים מוסכמת קואורדינטות, כך שהמדיניות לומדת יעד שהיא יכולה לפקד עליו ישירות
- אפיזודה של 25 שניות בתוספת איפוס של 10 שניות היא בערך 100 אפיזודות בשעה
- המפעיל מרגיש את העוקב נתקע או נכבל, כך שתקלות צפות לפני שהנתונים נשמרים
- זרוע שנייה מכפילה בערך את עלות החלקים
- הדגמות יורשות הרגלי מפעיל; מנדלקאר ואח' מצאו שאיכות המדיניות תלויה במידה רבה באיכות ההדגמה
- המוביל נדגם בקצב הלולאה, כך שהפסקות הופכות לשורות כמעט זהות שמלמדות את המדיניות להמתין
- שום דבר לא אוכף עקביות בין סשנים: מצלמה שהוזזה ב-5 ס"מ היא שינוי התפלגות נסתר
פרק טוב הוא משעמם: תנוחת בית ניתנת לחזרה, דבר אחד שבוצע, הסתיים ברגע שהאובייקט נמצא בפח, מחרוזת משימה באורך 25 עד 50 תווים כפי שהרשימה ממליצה. הרם את הקובייה האדומה ושחרר אותה בקופסה היא מחרוזת משימה; task1 היא האנטי-תבנית שהרשימה מציינת במפורש. הערות מעורפלות עומדות בראש רשימת הבעיות שלה, והן חשובות ביותר עבור , כאשר המחרוזת היא קלט מודל, לא שם קובץ.
פגמים שהורסים בשקט מערך נתונים
אף אחד מהם לא זורק חריגה. כולם שורדים לאימון, ומופיעים כעקומת הפסד שנראית בסדר ורובוט שלא עושה כלום. בדוק בזמן שהסצנה מוגדרת.
| פגם | איך זה נראה | מאיפה זה מגיע | איך לתפוס את זה |
|---|---|---|---|
| תצוגות מצלמה שהוחלפו | תמונת פרק כף היד תחת המפתח העליון | הקצאה מחדש של אינדקס לאחר חיבור מחדש | lerobot-find-cameras בכל סשן; נתיבים לפי מזהה |
| פריימים קפואים | אותה תמונה לעשרות שורות | המצלמה מפסיקה לספק; הלולאה חוזרת על הפריים האחרון | בדוק את זה ב-lerobot-dataset-viz |
| פריימים שנשמטו | מספר שורות נמוך מ-fps כפול שניות | התור גולש, שומט במקום לחסום | 'Encoder queue full' ביומן; שורות לעומת fps כפול משך זמן |
| מפרק בגבולו | מפרק אחד שטוח במינימום או מקסימום | טווח המוביל חורג מזה של העוקב, או תנוחת אמצע גרועה | מינימום/מקסימום לכל מפרק ב-ds.meta.stats; lerobot-find-joint-limits מראש |
| תמונה ופעולה לא מסונכרנות | המדיניות מקדימה או מפגרת | מצלמות ב-fps שונה מהלולאה | שמור כל מצלמה ב- --dataset.fps |
| זמן מת | ריצות ארוכות של שורות פעולה זהות | מפעיל עצר כשהמקליט פועל | חלק משורות פעולה זהות עוקבות |
| מחרוזת משימה בלתי שמישה | task1, demo2, test | הקלדה מהירה | meta/tasks.parquet ב-v3.0 (זה היה meta/tasks.jsonl ב-v2.1); תקן עם lerobot-edit-dataset modify_tasks |
המקודד מחזיק תור מוגבל לכל מצלמה, 30 פריימים כברירת מחדל. כאשר הוא אינו יכול לעמוד בקצב, פריימים נשמטים במקום להיחסם: הלכידה נמשכת ושום דבר לא קורס. תקבלו Encoder queue full for {camera}, dropped N frame(s) וסיכום לכל מצלמה בסוף הפרק. סף ה-lerobot: כ-5 אחוז חסרים מצביעים על מערכת עמוסה, 2 אחוזים הם עומס אתחול צפוי. תיקונים לפי הסדר: --display_data=false, הפחתת --dataset.encoder_threads, vcodec=h264, כיבוי סטרימינג.
הערה אחת: הטבלה במדריך הקידוד-סטרימינג מפרטת את ברירת המחדל כ-True, בעוד ש-dataclass ב-main קורא streaming_encoding: bool = False. התיעוד והקוד אינם תואמים, לכן הגדירו זאת במפורש; lerobot רושם רמז הממליץ על כך בכל פעם שהוא מתחיל כשהדגל כבוי.
בדקו את מערך הנתונים לפני השכרת GPU
בדיקת הקבלה מהתיעוד: השוו את משך הווידאו למשך הפרק שדווח על ידי ה-CLI, ואשרו שמספר השורות שווה ל-fps כפול משך הזמן. לכל פרק, לא בסך הכל.
from lerobot.datasets import LeRobotDataset
ds = LeRobotDataset("your-user/so100_pick_cube_20260823_141530")
print("fps:", ds.fps, "frames:", ds.num_frames)
# In v3.0 the per-episode records live in meta/episodes/ as chunked parquet:
# lengths, tasks and offsets into the shared parquet and mp4 shards.
# They load through the datasets stack, so this is a datasets.Dataset --
# use .column_names and integer indexing, not pandas .columns / .head().
eps = ds.meta.episodes
print(eps.column_names)
print(eps[0])
# Global feature statistics, including per-joint min and max.
# A joint whose min equals its max never moved. A joint sitting at a
# hard limit for most of the run is the one that will stall the policy.
print(ds.meta.stats["observation.state"])ואז תסתכלו על זה. lerobot-dataset-viz מנגן פרק פריים אחר פריים עם עקבות מפרקים לצד תצוגות המצלמה, ב-Rerun או Foxglove. מצלמות שהוחלפו ופריימים קפואים יופיעו תוך עשר שניות. אנשים מדלגים על שלב זה.
# Replay one episode with camera views and joint traces
lerobot-dataset-viz \
--repo-id your-user/so100_pick_cube_20260823_141530 \
--episode-index 0
# Foxglove instead, for a seekable, scrubbable timeline
lerobot-dataset-viz \
--repo-id your-user/so100_pick_cube_20260823_141530 \
--episode-index 0 \
--display-mode foxglove
# Drop the episodes that did not survive review
lerobot-edit-dataset \
--repo_id your-user/so100_pick_cube_20260823_141530 \
--new_repo_id your-user/so100_pick_cube_clean \
--operation.type delete_episodes \
--operation.episode_indices "[3, 17, 41]"
v2.1 או v3.0: החליטו לפני שאתם מקליטים
v2.1 כתב קובץ parquet אחד וקובץ MP4 אחד לכל פרק. v3.0 משרשר פרקים רבים לשארדים משותפים ובונה מחדש גבולות מתוך מטא-דאטה, כך ש-info.json נושא תבניות נתיב כמו data/chunk-{chunk_index:03d}/file-{file_index:03d}.parquet במקום מספר פרק. ההצדקה במעלה הזרם היא פחות קבצים, גדולים יותר: אתחול מהיר יותר ופחות לחץ על מערכת הקבצים בקנה מידה גדול.
| LeRobot v2.1 | LeRobot v3.0 | |
|---|---|---|
| פריסה | קובץ parquet אחד וקובץ MP4 אחד לכל פרק | פרקים רבים לכל שארד |
| מטא-דאטה של פרק | קבצי JSONL | parquet מחולק לנתחים תחת meta/episodes/, דרך ערימת ה-datasets |
| הזרמה מה-Hub | לא | כן, דרך StreamingLeRobotDataset |
| נכתב על ידי lerobot 0.6.1 | לא | כן, מה שמקבלים היום |
| נקרא על ידי GR00T N1.7 ו-N1.5 | כן | לא, יש להמיר כלפי מטה |
lerobot 0.6.1 כותב v3.0, אך GR00T N1.7 ו-N1.5 קוראים v2.0 או v2.1 וקורסים עליו. שימו לב לכיוון התנועה: src/lerobot/scripts/ מכיל את convert_dataset_v21_to_v30.py ושום דבר לא הולך לכיוון השני. סגרו את זה לפני הסשן. תיקון: dataset נדחה כ-v3.
# Upgrade an older v2.1 dataset to v3.0
python -m lerobot.scripts.convert_dataset_v21_to_v30 \
--repo-id=your-user/so100_pick_cube
# By default it pushes the converted dataset back to the hub and tags it v3.0.
# To convert a local copy and keep it off the hub:
python -m lerobot.scripts.convert_dataset_v21_to_v30 \
--repo-id=your-user/so100_pick_cube \
--root=/path/to/dataset/directory \
--push-to-hub=falseשני מסלולים לאותו מערך נתונים
כל האמור לעיל, במחשב שלך: אתה הבעלים של ספירת ה-USB, בניית ה-ffmpeg, כיוונון המקודד וקובצי הכיול. המסלול הנכון להבנת הצינור, הפעלת מתקן מצלמה יוצא דופן, או שמירת נתונים מקומיים.
זמן: ערב אחד לכל זרוע להרכבה, כיול ראשוני מסובך, וסשן ראשון שאתה זורק כי מצלמה הייתה בחריץ הלא נכון.
לקוח שולחן העבודה מקליט מערכי נתונים בפורמט LeRobot, פרקים, זרמי מצלמה ומצבי מפרקים, ישירות מתוך סשן טלפרודוקציה. מערך נתונים זה מזין את טופס האימון: בחר מודל, מערך נתונים והיפרפרמטרים, והקצה האחורי שוכר GPU בגודל VRAM של המודל, מריץ את המאמן וכותב נקודות בקרה לאחסון אובייקטים.
- 1התקן את הלקוח
בדף ההורדה; הגדרה בתיעוד הלקוח.
- 2הקלט מסשן טלפרודוקציה
הפעל את הזרוע; הלקוח כותב פרקים בפורמט LeRobot. מדריך: הקלט את מערך הנתונים הראשון שלך.
- 3או הבא נתונים משלך
מערך נתונים יכול להגיע גם מ-Hugging Face repo id או מהמחשב שלך: תיעוד מערכי נתונים, מדריך ציבורי.
- 4אמן והרץ אותו בחזרה
בחר את השילוב במטריצת האימון, ולאחר מכן הרץ את המדיניות בחזרה על הזרוע. בערך 1 עד 3 USD בשכבת 24 GB, 4 עד 12 בשכבת A100 או H100.
הוא אינו מרכיב או מכייל את הזרוע שלך, והוא אינו מתקן פרק פגום, כך ששלב הבדיקה עדיין חל. יש גם מגבלה קשה בקצה השני: למשימות מהירות, הסקה צריכה לשבת ליד הסרווים. לולאת הבקרה פועלת 20 עד 485 אלפיות השנייה לכל שלב פעולה, ונסיעות הלוך ושוב באינטרנט הציבורי הופכות מדיניות עובדת למדיניות מהוססת.
הקלט מערכי נתונים של LeRobot מבלי לחבר את הצינור בעצמך
לקוח שולחן העבודה של AY-Robots מקליט פרקים, זרמי מצלמה ומצבי מפרקים בפורמט LeRobot מסשן טלפרודוקציה, ולאחר מכן מעביר את מערך הנתונים למאמן.
קבל את לקוח שולחן העבודהממערך נתונים למדיניות
חמישים אפיזודות נקיות מזינות כל למידת חיקוי הרצה כאן. ACT מתאמן מאפס על המשימה שלך בלבד, כ-80 מיליון פרמטרים בכ-20 אלפיות השנייה לצעד פעולה, היחיד מבין החמישה שנוח לו עם תנועה מהירה. SmolVLA הוא כ-450 מיליון פרמטרים על כרטיס 24 GB. GR00T N1.7 הוא מודל יסוד של כ-3 מיליארד פרמטרים שבו כוונון עדין נוגע בכ-40 מיליון פרמטרים, דורש A100 או H100, ורוצה את מערך הנתונים v2.1 הזה.
הבא, המדריך לשילוב שלך: ACT על SO-100, SmolVLA על SO-100 או GR00T N1.7 על SO-100; להרצה ראשונה, אמן את המדיניות הראשונה שלך קצר יותר. כאשר המדיניות עובדת על השולחן אך קורסת ברגע שאתה מזיז את השולחן, זו בעיית נתונים: מדיניות עובדת רק בהגדרה אחת ו-איסוף נתוני אימון VLA באיכות גבוהה מעמיקים יותר בנושא הגיוון.
כמה אפיזודות אני באמת צריך למדיניות עובדת ראשונה?▾
שלושים עבור SmolVLA, חמישים עבור ACT, Pi0.5, GR00T N1.5 ו-N1.7, המינימום שאוכפים המאמנים של AY-Robots. המדריך של LeRobot ממליץ באופן עצמאי על לפחות 50 למשימה ראשונה, בסביבות 10 למיקום אובייקט. עבודת קנה מידה של נתונים מצאה שהכללה מתרחבת עם סביבות ואובייקטים ולא עם ספירת הדגמות, כך שמאה צילומים של סצנה אחת גרועים מחמישים על פני חמישה מיקומים.
האם אני צריך זרוע מובילה, או שאני יכול לתפעל מרחוק עם מקלדת?▾
lerobot מספקת טלמפעילים למקלדת ולגיימפד, כך שזרוע מובילה אינה נדרשת בהכרח, אך היא עדיפה בהרבה: מצב מוביל-עוקב מספק מסלולי מפרקים רציפים במוסכמת הקואורדינטות של הפעולה המתועדת, בעוד קלט מקלדת מייצר תנועה מדורגת שמדיניות לומדת כקפיצה. תפעול מרחוק באמצעות מקלדת דורש גם קצה עורפי (backend) של מקשים גלובליים, ולכן הוא נכשל ב-Wayland ובמצב headless.
האם אני יכול להקליט על Raspberry Pi או מיני PC קטן?▾
כן, עם כוונון. המדריך לקידוד בסטרימינג כולל סעיף למשאבים נמוכים המכסה מכונות מודרניות עם 4 ליבות ו-Raspberry Pi 5, ומציב שתי מצלמות ברזולוציה 640x480 וב-30 פריימים לשנייה בעמודת 'דורש כוונון מסוים'. העצה שלו: עצור את המקודד מלהתחרות בלולאת הלכידה, באמצעות --dataset.rgb_encoder.vcodec=h264 ו- --dataset.streaming_encoding=false. הוא מדרג שתי מצלמות ב-640x480 ככ-55 מיליון פיקסלים לשנייה ושתיים ב-1920x1080 ככ-373 מיליון.
איך אני יודע שמערך הנתונים שהקלטתי זה עתה אכן תקין?▾
שלוש בדיקות פשוטות. השווה את משך הווידאו של כל אפיזודה למשך הזמן שדווח על ידי ה-CLI ואשר שספירת השורות שווה ל-fps כפול משך הזמן הזה, לכל אפיזודה ולא לסך הכל; זוהי בדיקת הקבלה שמספק מדריך הקידוד של lerobot. קרא את ds.meta.stats, כאשר מפרק שהמינימום שלו שווה למקסימום שלו מעולם לא זז. לאחר מכן, הפעל מחדש שתיים או שלוש אפיזודות ב-lerobot-dataset-viz, הדרך היחידה שבה מופיעות תצוגות שהוחלפו ופריימים קפואים. בנוגע לפריימים שנשמטו, המדריך מציב את הגבול בכ-5 אחוזים חסרים; כ-2 אחוזים הם עומס חולף רגיל, לרוב רק בהפעלה.
עבודת האימון שלי דחתה את מערך הנתונים כ-v3.0. מה עכשיו?▾
GR00T N1.7 ו-N1.5 קוראים LeRobot v2.0 או v2.1 וקורסים ב-v3.0, וזה מה ש-lerobot 0.6.1 מקליט. או קבע את הפורמט לפני האימון, או השתמש במדיניות שקוראת v3.0 באופן טבעי: Pi0.5, SmolVLA או ACT. lerobot מספקת ממיר מ-v2.1 ל-v3.0 ושום דבר בכיוון ההפוך.
Sources
- LeRobot: למידת חיקוי על רובוטים בעולם האמיתי
- LeRobot: הרכבת SO-100, הגדרת מנוע וכיול
- LeRobot: מצלמות ו-lerobot-find-cameras
- LeRobot: התקנה ומטריצת התוספות
- LeRobotDataset v3.0: מבנה והעברה מ-v2.1
- LeRobot: קידוד וידאו בסטרימינג ופריימים שנשמטו
- LeRobot: העברת מערכי נתונים גדולים ל-v3.0 (DROID)
- lerobot v0.6.1 שחרור, 3 August 2026
- DatasetRecordConfig: ברירות המחדל האמיתיות להקלטה
- lerobot_record.py: לולאת הקלטה וטיפול בהמשך
- TheRobotStudio/SO-ARM100: מאגר בנייה ורשימת חומרים
- Hugging Face: רשימת בדיקה למערכי נתונים קהילתיים של LeRobot
- lerobot/svla_so100_pickplace: 50 פרקים, 19,631 פריימים
- Lin et al. (2024), חוקי קנה מידה של נתונים בלמידת חיקוי
- Mandlekar et al. (2021), מה שחשוב בלמידה מהדגמות אנושיות לא מקוונות
Sources
- LeRobot: Imitation Learning on Real-World Robots
- LeRobot: SO-100 assembly, motor setup and calibration
- LeRobot: Cameras and lerobot-find-cameras
- LeRobot: Installation and the extras matrix
- LeRobotDataset v3.0: layout and v2.1 migration
- LeRobot: Streaming video encoding and dropped frames
- LeRobot: Porting large datasets to v3.0 (DROID)
- lerobot v0.6.1 release, 3 August 2026
- DatasetRecordConfig: the real recording defaults
- lerobot_record.py: record loop and resume handling
- TheRobotStudio/SO-ARM100: build repo and bill of materials
- Hugging Face: LeRobot Community Datasets checklist
- lerobot/svla_so100_pickplace: 50 episodes, 19,631 frames
- Lin et al. (2024), Data Scaling Laws in Imitation Learning
- Mandlekar et al. (2021), What Matters in Learning from Offline Human Demonstrations
Ready for high-quality robotics data?
AY-Robots connects your robots to skilled operators worldwide.
Get Started