
DROID, BridgeData V2 ו-Open X-Embodiment מומרים לפעולות קצה-אפקטור ב-7 מימדים על זרועות בעלות 6 ו-7 דרגות חופש. SO-100 מקבל 6 מיקומי מפרקים. מה עובר, מה לא, ומה לעשות במקום.
הגרסה הקצרה
- •הגרסאות של LeRobot של כל השלושה חולקות מוסכמה אחת: פעולת קצה-אפקטור 7-D [x, y, z, roll, pitch, yaw, gripper] ומצב 8-D עם חריץ ריפוד. SO-100 לוקח שישה מיקומי מפרקים מוחלטים.
- •וקטור 7-D זה הוא תוצר הלוואי של הממיר: שדה הפעולה RLDS של DROID עצמו הוא 6 מהירויות מפרקים בתוספת מיקום תופסן, עם התצוגה הקרטזית ב-action_dict.
- •ארבעה שעונים: DROID 15 פריימים לשנייה, BridgeData V2 5 פריימים לשנייה, פרוסת google_robot 3 פריימים לשנייה, הקלטת SO-100 ב-30 פריימים לשנייה.
- •אינך יכול למזג אותם עם הנתונים שלך. validate_all_metadata מעלה שגיאה על הראשון מבין fps, robot_type או features ששונה, וכל השלושה שונים.
- •מה שעובר הוא משקולות מאומנות מראש, לא אפיזודות. נתוני קוד פתוח הם 9.1 אחוז מתערובת האימון המוקדם של pi0.
- •השימוש האמיתי הזול ביותר שלהם הוא מתקן בדיקה: דגימת DROID תקינה ידועה של 2 GB, 100 אפיזודות, שמוכיחה את הצינור שלך לפני שאתה מקליט לסוף שבוע.
ישנו מערך נתונים ציבורי של מיליון מסלולים בדלי של Google Cloud ו-SO-100 על השולחן שעלה 110 עד 150 אירו בחלקים. מדוע הראשון לא יכול ללמד את השני? הוא יכול חלקית, אבל כמעט אף אחד מההעברה לא מתרחש היכן שאנשים מצפים, והחלק שנראה קל ביותר אינו עובד כלל.
להלן: מה נמצא בתוך DROID, BridgeData V2 ו-Open X-Embodiment, היכן שכל אחד מהם מתנגש עם זרוע 5-DoF בעלות נמוכה, ומה לעשות במקום זאת. כל מספר להלן הגיע מהמאמר, כרטיס מערך הנתונים או קובץ המקור שאליו הוא שייך.
מה מכילים שלושת מערכי הנתונים בפועל
| DROID | BridgeData V2 | Open X-Embodiment | |
|---|---|---|---|
| רובוט | Franka Panda, 7 DoF, Robotiq 2F-85 | WidowX 250, 6 DoF, ~4,000 USD rig | 22 embodiments, 60 datasets, 34 labs |
| קנה מידה | 76k trajectories, 350 hours | 60,096 trajectories | 1M+ trajectories, 527 skills |
| גיוון | 564 scenes, 84 tasks, 50 collectors | 24 environments, 13 skills | 160,266 tasks, 21 institutions |
| הרכב | כולם מופעלים מרחוק | 50,365 teleoperated, 9,731 scripted | לפי מעבדת מקור |
| קצב בקרה | 15 Hz | 5 Hz | משתנה, 3 פריימים לשנייה ומעלה |
| מצלמות | 2 x ZED 2 חיצוניות, 1 x ZED Mini לפרק כף היד | עד 4, ברוב הפרקים רק הקבועה | מה שהמעבדה השתמשה בו |
| הורדה גולמית | 1.7 TB RLDS, 8.7 TB raw stereo | ארכיוני JPEG | דליי TFDS לכל מערך נתונים |
מעט אנשים עדיין מורידים 1.7 TB של RLDS TFRecords. ארגון הקהילה IPEC-COMMUNITY פרסם מחדש את רוב Open X-Embodiment בפורמט מערך נתונים של LeRobot עם וידאו AV1, כאשר DROID מגיע ל-392 GB. זו הגרסה שאיתה תעבדו, ו-meta/info.json שלה הוא מה שצריך לקרוא קודם.
DROID
המתוכנן ביותר מבין השלושה. מתקן אחד בכל מקום: Franka Panda עם תופסן Robotiq 2F-85, שתי מצלמות סטריאו ZED 2 מתכווננות ו-ZED Mini לפרק כף היד, מופעל מרחוק עם בקרי Meta Quest 2, הוקלט דרך Polymetis ב-15 הרץ הן במרחב המפרקים והן במרחב קצה-אפקטור .תוויות שפה הגיעו מאוחר יותר דרך tasq.ai, עד שלוש לכל פרק.
- 76 אלף מסלולים, 350 שעות, 564 סצנות, 84 משימות, 50 אספנים בשלוש יבשות.
- התוצאה העיקרית היא אימון משותף (co-training), לא אימון עצמאי: אצוות מעורבות 50/50 עם הדגמות בתחום עקפו את השיטה הטובה הבאה ב-22 אחוז הצלחה מוחלטת בהתפלגות, ו-17 אחוז מחוצה לה.
- IPEC-COMMUNITY/droid_lerobot: 92,233 פרקים, 27,044,326 פריימים, franka, 15 פריימים לשנייה, codebase_version v2.0, שלושה זרמי AV1 ב-180x320, 392 ג'יגה-בייט.
- דגימת ניפוי באגים של 2 ג'יגה-בייט ו-100 פרקים נמצאת ב-gs://gresearch/robotics/droid_100. התחילו משם.
BridgeData V2
הקרוב ביותר להגדרת תחביב: זרוע WidowX 250 בעלת 6 דרגות חופש, 60,096 מסלולים ב-24 סביבות ו-13 מיומנויות ב-5 הרץ. שימו לב להרכב: 50,365 הדגמות מומחה מופעלות מרחוק בתוספת 9,731 ממדיניות אקראית של הרמה והנחה (pick-and-place), כך שכ-16 אחוז אינם הדגמה אנושית, וזה חשוב עבור למידת חיקוי איכות. ההורדה הרגילה, IPEC-COMMUNITY/bridge_orig_lerobot, מדווחת על 53,192 פרקים ו-1,893,026 פריימים ב-5 פריימים לשנייה, robot_type widowx: פחות מ-60,096 של המאמר, לכן קראו את הספירה מ-meta/info.json במקום לצטט אחד מהם.
Open X-Embodiment
לא מערך נתונים באותו מובן: 60 מערכי נתונים קיימים של רובוטים מ-34 מעבדות שאוחדו לאוסף RLDS אחד המכסה 22 התגלמויות ולמעלה ממיליון מסלולים. BridgeData V2 נמצא בתוכו כ-bridge_orig; החלק של google_robot, fractal20220817_data, מומר ל-87,212 פרקים ב-3 פריימים לשנייה.
האיחוד נושא אזהרה שהמאמר מצהיר עליה במפורש. עבור ניסויי RT-X, המחברים ממירים כל מקור לפעולת קצה-אפקטור של 7 דרגות חופש, אך אינם מיישרים מסגרות קואורדינטות בין מערכי נתונים, ומאפשרים לערכי הפעולה להיות מיקומים או מהירויות מוחלטים או יחסיים, לפי תוכנית הבקרה המקורית של כל רובוט. מסקנתם: אותו וקטור פעולה עשוי לגרום לתנועות שונות מאוד עבור רובוטים שונים.

אי ההתאמה, בארבעה חלקים
אי-התאמה בין התגלמויות (embodiment mismatch) נתפסת בדרך כלל כבעיה מעורפלת אחת. למעשה, מדובר בארבע בעיות שונות, כל אחת נכשלת באופן אחר, ושתיים מהן אינן ניתנות לתיקון באמצעות סקריפטים.
1. דרגות חופש
ל-SO-100 יש חמישה מפרקי זרוע בתוספת תופסן. אם נספור כמנועים, זוהי זרוע בעלת 6 דרגות חופש (DoF), ומאמר SmolVLA מתייחס אליה כך; אם נספור כמנגנון מיקום, זוהי זרוע בעלת 5 דרגות חופש, ו-LeRobot מתייחס אליה כך בתיעוד ה-inverse-kinematics שלה, המתאר IK עם אוריינטציה רכה ב-SO-101 בעל 5 דרגות חופש, שבו פרק כף היד עוקב אחר האוריינטציה רק באופן חלקי. לפרנקה יש שבעה מפרקי מיקום. פער זה קובע אילו תנוחות קיימות: זרוע בעלת 5 דרגות חופש אינה יכולה בדרך כלל להגיע למיקום ואוריינטציה שרירותיים בו-זמנית, ולכן הפותר מחזיר את הקרוב ביותר שהוא יכול, תנועה שונה מזו שהודגמה. רקע: דרגות חופש.
# src/lerobot/robots/so_follower/so_follower.py
motors = {
"shoulder_pan": Motor(1, "sts3215", norm_mode_body),
"shoulder_lift": Motor(2, "sts3215", norm_mode_body),
"elbow_flex": Motor(3, "sts3215", norm_mode_body),
"wrist_flex": Motor(4, "sts3215", norm_mode_body),
"wrist_roll": Motor(5, "sts3215", norm_mode_body),
"gripper": Motor(6, "sts3215", MotorNormMode.RANGE_0_100),
}
# action keys are "<motor>.pos"; send_action sync_writes them to
# "Goal_Position" -> a 6-D ABSOLUTE JOINT POSITION command
# openpi/src/openpi/policies/droid_policy.py
def make_droid_example() -> dict:
return {
"observation/exterior_image_1_left": np.random.randint(256, size=(224, 224, 3), dtype=np.uint8),
"observation/wrist_image_left": np.random.randint(256, size=(224, 224, 3), dtype=np.uint8),
"observation/joint_position": np.random.rand(7), # seven Franka joints
"observation/gripper_position": np.random.rand(1),
"prompt": "do something",
}
# state = concat(joint_position, gripper_pos) -> 8-Dלכן נקודת ביקורת (checkpoint) מוכנה של DROID אינה קיצור דרך. Physical Intelligence מספקת את pi05_droid ב-gs://openpi-assets/checkpoints/pi05_droid, ואותו קובץ README שמשבח את רוחב היריעה שלו מזהיר שנקודות ביקורת מומחים אלו עשויות שלא להתאים להגדרה שלך. המצב שלו הוא שמונה מספרי מפרקים של Franka ומפתחות התמונה שלו הם exterior_image_1_left ו-wrist_image_left. אין דגל שהופך זאת לפקודת SO-100 עם שישה מנועים.
2. מה וקטור הפעולה אומר בפועל
עמוק יותר מממדיות. בהמרות של LeRobot, כל השלושה מציינים לאן התופסן צריך ללכת, במרחב קרטזי. SO-100 מציין לאן שישה סרווים צריכים ללכת. ההמרה דורשת מודל קינמטי ופותר, לא שינוי צורה (reshape).
| מאפיין | OXE, DROID ו-Bridge בצורת LeRobot | SO-100 ב-LeRobot |
|---|---|---|
| וקטור פעולה | 7-ממדי: x, y, z, roll, pitch, yaw, תופסן | 6-ממדי: מיקום יעד אחד לכל מנוע |
| וקטור מצב | 8-ממדי, עם חריץ ריפוד (google_robot משתמש בקוורטרניון) | 6-ממדי, אחד לכל מנוע |
| מסגרת | קרטזי, לא מיושר בין מערכי נתונים | מרחב מפרקים, כיול לכל זרוע |
| מוחלט או יחסי | אחד מהם, נקבע על ידי מעבדת המקור | מיקומי יעד מוחלטים |
| יחידות | מנורמלות לכל מערך נתונים, ואז מפוצלות | מעלות כברירת מחדל (use_degrees=True), אחרת -100 עד 100 |
| כשל שקט | דלתא שנקראת כמוחלט | זרוע לא מכוילת |
קובץ ה-README של openx2lerobot מתעד מצב מאוחד של 8-ממדים ופעולה של 7-ממדים עבור כל dataset שהוא ממיר, ומשם מגיע חריץ ה-pad. סכימת ה-RLDS של DROID עצמה שונה: ה-action ברמה העליונה שלה הוא וקטור 7-ממדי של 6 מהירויות מפרקים בתוספת מיקום אחיזה אחד, עם cartesian_position, cartesian_velocity, joint_position ו-joint_velocity תחת action_dict. openpi קורא את תצוגת מרחב המפרקים, בעוד שגרסת LeRobot מספקת את התצוגה הקרטזיאנית. אף אחת מהן אינה שש זוויות סרוו מוחלטות.
LeRobot אכן מספק את החלק החסר: לעוקב ה-SO יש מעבד קינמטיקה עם שלבי InverseKinematicsEEToJoints ו-ForwardKinematicsJointsToEE. המפתחות שלו הם ee.x, ee.y, ee.z בתוספת וקטור סיבוב ee.wx, ee.wy, ee.wz ו-ee.gripper_pos, כך שאפילו קידוד האוריינטציה שונה מה-roll-pitch-yaw בקבצים. שלב ה-IK מקבל orientation_weight, ברירת מחדל 0.01, שה-docstring שלו מציין להגדיר 0.0 עבור IK מבוסס מיקום בלבד בזרועות עם תת-הפעלה. ניתן לבנות את הגשר, אך מחצית האוריינטציה של כל פעולה מושאלת נשארת מקורבת.
3. קצב בקרה
DROID הוא 15 הרץ, BridgeData V2 5 הרץ, פרוסת google_robot 3 פריימים לשנייה; מחברי pi0 מתארים את החלק בקוד הפתוח של התערובת שלהם כבקרה בתדר נמוך בין 2 ל-10 הרץ. ה-DatasetRecordConfig של LeRobot מוגדר כברירת מחדל ל-fps 30, episode_time_s 60, reset_time_s 60, num_episodes 50. שאומנה על נתוני 5 הרץ למדה שפעולה אחת מכסה 200 אלפיות השנייה. הפעלה חוזרת שלה ב-30 הרץ גורמת לזרוע לזחול; דגימה מחדש בדרך נאיבית תמרח את הפריימים שבהם האחיזה נסגרת. זה גם מקיים אינטראקציה גרועה עם : חבילת 100 צעדים היא 20 שניות ב-5 הרץ, 3.3 ב-30 הרץ.
4. מצלמות
BridgeData V2 הגריל שתי תנוחות מצלמה כל 50 מסלולים, ודף הפרויקט שלו מציין שרוב הנתונים מכילים רק את התצוגה הקבועה בכל מקרה. DROID השתמש במתקני ZED 2 מתכווננים בתוספת ZED Mini על פרק כף היד. יש לך שתי מצלמות רשת USB הממוקמות לפי העין. תנוחת מצלמה אינה משתנה מפריע עבור ; זהו חלק גדול ממה שהמקודד הוויזואלי התמקד בו, ושום דבר בפורמט הקובץ לא אומר לך שהתנוחות שונות.
החלקים מתאימים מספיק טוב כדי לרוץ. מערך הנתונים נטען, האימון מתחיל, ה-loss יורד, נקודות בקרה מופיעות, שום דבר לא שוגה. ואז המדיניות לא עושה שום דבר מוכר על הזרוע ואתה מבלה יום בחיפוש אחר באג בסקריפט האימון שלך. אין באג: המודל למד התפלגות פעולה קרטזית עבור רובוט שאינו קיים בחדר שלך. התחל ב-ה-loss יורד, המדיניות לא עושה כלום, לא בהיפרפרמטרים שלך.
מה קורה כשמנסים למזג את הנתונים בכל מקרה
התוכנית הברורה היא לשרשר: כמה אלפי פרקי DROID בתוספת 50 הפרקים שלך. LeRobot מסרב, והסירוב מציין את שלושת הדברים השונים.
- 1משוך את דגימת 100 הפרקים, לא את ה-1.7 TB המלאים
2 GB מספיקים כדי לראות את המבנה.
bashpip install gsutil tensorflow tensorflow-datasets gsutil -m cp -r gs://gresearch/robotics/droid_100 ~/tensorflow_datasets/ - 2המר RLDS לפורמט LeRobot
openx2lerobot עוטף את טרנספורמציות ה-OXE הסטנדרטיות ומציין את סוג הרובוט ותדירות הבקרה. קובץ ה-README ממקם זאת ב-convert.sh.
bashgit clone https://github.com/Tavish9/any4lerobot.git cd any4lerobot/openx2lerobot python openx_rlds.py \ --raw-dir ~/tensorflow_datasets/droid_100/1.0.0 \ --local-dir ~/lerobot_droid100 \ --repo-id you/droid100_lerobot \ --use-videos - 3קרא את meta/info.json לפני כל דבר אחר
קובץ זה קובע אם שאר היום שלך יעבוד.
bashpython -c "import json;d=json.load(open('meta/info.json'));\ print(d['codebase_version'], d['robot_type'], d['fps']);\ print(d['features']['action']['shape'], d['features']['observation.state']['shape'])" - 4נסה את המיזוג וקרא את השגיאה
merge טוען כל מערך נתונים, ואז validate_all_metadata בודק את fps, robot_type ותכונות מול הראשון ברשימה, ומעלה שגיאה בהתאמה הראשונה.
bashlerobot-edit-dataset \ --new_repo_id you/mixed \ --operation.type merge \ --operation.repo_ids "['you/droid100_lerobot', 'you/my_so100_task']" # ValueError: Same fps is expected, but got fps=30 instead of 15.
ערכי הייחוס מגיעים מכל מערך נתונים שציינת ראשון, ולכן ההודעה מתלוננת על 30 ה-fps שלך במקום 15 ה-fps של DROID. תקן את ה-fps ותיתקל בבדיקת robot_type; תקן זאת ותיתקל בבדיקת התכונות, 7 מול 6 עבור הפעולה. שום סדר לא עובר, ואותו מנגנון הגנה פועל בזמן ההקלטה באמצעות sanity_check_dataset_robot_compatibility.
בגרסה הנוכחית של LeRobot main so100_follower ו-so101_follower רשומים שניהם על SOFollowerRobotConfig משותף אחד, כך שהמחרוזת מהקלטה אמיתית אינה בהכרח זו שאתה מצפה לה. קרא אותה מתוך meta/info.json שלך, והתייחס לבדיקה שנאלצת להשבית כבדיקה שאמרה לך משהו.
אז מה בעצם עובר?
משקולות, לא אפיזודות. כל מדיניות כללית מודרנית ספגה חלק מזה באימון מוקדם, וכאשר אתה מתוך אתה יורש אותו כבר מיושב על ידי אנשים עם כוח המחשוב לבצע זאת כראוי. המאמר של pi0 גלוי לגבי הפרופורציה: 9.1 אחוז מתערובת האימון המוקדם שלו, הנספרת בצעדי זמן, היא נתונים בקוד פתוח הכוללים את OXE, Bridge v2 ו-DROID. נתון זה הוא של pi0; התערובת של כל ספק שונה.
- פרייורים ויזואליים ושפתיים: המקודד ראה אלפי מטבחים וספלים ויודע למה מתייחס "הבלוק האדום".
- פרייור על מבנה מניפולציה: גישה, סגירה, הרמה, שינוע, שחרור, בלתי תלוי בהתגלמות גם כאשר המספרים אינם כאלה.
- מערך נתונים ידוע וטוב לבדיקה. אם המשימה שלך לא יכולה לבצע התאמת יתר ל-100 אפיזודות DROID, הבעיה היא ההגדרה שלך.
- נקודות ייחוס: בתחומי מערכי נתונים בקנה מידה קטן, RT-1-X הגיע לשיעור הצלחה ממוצע גבוה ב-50 אחוז מהשיטה המקורית או RT-1, ו-RT-2-X עלה על RT-2 פי 3 בקירוב במיומנויות מתפתחות.
- אין פיקוח פעולה שמיש. יעד קרטזיאני 7-D אינו פקודת מפרק 6-D.
- אין העברת תנוחת מצלמה, ושום דבר בנתונים לא אומר לך שהתנוחות שונות.
- אין העברת תזמון: מקורות של 3, 5 ו-15 פריימים לשנייה מול מקליט של 30 פריימים לשנייה.
- אין העברת תופסן. Robotiq 2F-85 ולסת מודפסת על STS3215 שונים בכוח, מהלך ודינמיקה.
- קנה מידה לבדו לא הספיק אפילו למחבריו: בתחומי מערכי נתונים גדולים, RT-1-X לא עלה על RT-1 שאומן על מערך נתונים זה בלבד.
- אין הפחתה במספר האפיזודות שלך שאתה צריך.
| שכבת המודל | עובר? | למה |
|---|---|---|
| Vision encoder | כן, בחוזקה | אובייקטים וסצנות אינם תלויים בהתגלמות |
| Language grounding | כן | הוראות הן טקסט, לא גיאומטריה |
| Cross-modal fusion | בעיקר | מתייחס לאובייקט הנקוב בהנחיה |
| Proprioception encoder | לא | ממד הקלט וסמנטיקת המפרקים שונים |
| Action head | לא | אומן על מרחב קרטזיאני 7-D שאתה לא נמצא בו |
| Normalisation statistics | לא, ומסוכן | סטטיסטיקות זרות מזיזות כל פקודה |
זו הסיבה ש-SmolVLA מתנהג אחרת על זרוע בעלות נמוכה. המאמר שלו בוחר 481 מערכי נתונים קהילתיים מ-Hugging Face, המסוננים לפי סוג התגלמות, ספירת פרקים, איכות נתונים וכיסוי פריימים: 22.9K פרקים, 10.6M פריימים, הוערכו על זרועות SO-100 ו-SO-101 אמיתיות. קטן ותואם עדיף על גדול ולא תואם. השווה ב-ACT מול SmolVLA.
שלושה נתיבים שכדאי ללכת בהם
נתיב א': כוונון עדין מנקודת ביקורת שכבר קלטה את הנתונים
רוב האנשים צריכים לבחור בזה. לעולם אל תיגע ב-DROID או Open X-Embodiment: בחר מדיניות שהאימון המוקדם שלה כבר קלט נתונים חוצי-התגלמות, הקלט פרקים משלך, בצע כוונון עדין.
| מדיניות | פרמטרים | מינימום פרקים | פורמט מערך נתונים | רמת GPU | הסקה | נקודת ביקורת בסיסית |
|---|---|---|---|---|---|---|
| GR00T N1.7 | ~3 B, ~40 M אומן בכוונון עדין | 50 | LeRobot v2.0 or v2.1 | A100 or H100 80 GB | 152 ms לכל צעד | nvidia/GR00T-N1.7-3B |
| GR00T N1.5 | ~3 B | 50 | LeRobot v2.0 or v2.1 | A100 or H100 80 GB | 165 ms | nvidia/GR00T-N1.5-3B |
| Pi0.5 | ~3 B, עמוד שדרה PaliGemma | 50 | LeRobot v3.0 | A100 or H100 80 GB | 485 ms | lerobot/pi05_base |
| SmolVLA | ~450 M | 30 | LeRobot v3.0 | RTX 4090 או כל 24 GB | 245 ms | lerobot/smolvla_base |
| ACT | ~80 M | 50 | LeRobot v3.0 | RTX 4090 או כל 24 GB | 20 ms | אין, מאפס |
ACT הוא מקרה הקצה הכנה: אין מודל בסיס, כך שאף אחד מהנתונים הציבוריים לא מגיע אליו. זה לא בהכרח חיסרון, שכן ב-20 ms לכל צעד פעולה הוא היחיד מבין החמישה שיכול לסגור לולאה מהירה, כפי שדף ה-ACT מפורט. בחר לפי משימה באמצעות כל החמישה בהשוואה, GR00T N1.7 מול Pi0.5, ו-332 תוצאות הבנצ'מרק על פני 85 מודלים ב-הזירה.
נתיב ב': השתמש ב-DROID כמתקן בדיקה
דגימת 100 הפרקים היא ה-2 GB הטובים ביותר שתורידו החודש, ולא לאימון. זהו מערך נתונים שאתם יודעים שהוא נכון. הפעילו עליו את הממיר, הטוען ועבודת GPU קצרה; כל דבר שנכשל הוא באג תשתית שנמצא בזמן שהיה זול. NVIDIA עושה את אותו הדבר בקנה מידה: כרטיס ה-GR00T N1.7 מפרט ארבע גרסאות מאומנות לאחר מכן, עבור Bridge ו-Fractal ב-SimplerEnv, DROID ו-LIBERO.
נתיב C: הקלט בעצמך, במכוון
שלושים עד חמישים נשמע מעט ליד 76,000 עד שאתה זוכר ששלך הן היחידות עם הזרוע שלך, המצלמות שלך והשולחן שלך. בברירות המחדל של LeRobot, חמישים אפיזודות הן 100 דקות של זמן שעון קיר. ראה , ו-.

שתי דרכים לעבור מנתונים ציבוריים למדיניות עובדת
All of this runs on your own machine plus a rented GPU. Knowing the manual path matters because when something breaks you will know which layer broke.
- 1Install LeRobot with the extras the scripts need
The record and train entry points each declare their own extra.
bashpip install 'lerobot[core_scripts]' # lerobot-record pip install 'lerobot[training]' # lerobot-train pip install gsutil tensorflow tensorflow-datasets - 2Get a small, known-good slice
100 DROID episodes, 2 GB.
bashgsutil -m cp -r gs://gresearch/robotics/droid_100 ~/tensorflow_datasets/ - 3Convert to LeRobot form
Writes the unified 8-D state and 7-D action, annotating robot type and control frequency.
bashpython openx_rlds.py \ --raw-dir ~/tensorflow_datasets/droid_100/1.0.0 \ --local-dir ~/lerobot_droid100 \ --repo-id you/droid100_lerobot \ --use-videos - 4Check the version against your trainer
The converter README documents v3.0 output; the published IPEC-COMMUNITY datasets report v2.0. GR00T wants v2.0 or v2.1 and crashes on v3.0; Pi0.5, SmolVLA and ACT want v3.0. Mind the gap: the only conversion script on LeRobot main goes 2.1 to 3.0.
bashpython src/lerobot/scripts/convert_dataset_v21_to_v30.py \ --repo-id=you/droid100_lerobot - 5Record your own episodes
Defaults: 30 fps, 60 s per episode, 60 s reset, 50 episodes. The teleoperator type is so100_leader.
bashlerobot-record \ --robot.type=so100_follower \ --robot.port=/dev/ttyACM0 \ --robot.cameras="{front: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30}}" \ --teleop.type=so100_leader \ --teleop.port=/dev/ttyACM1 \ --dataset.repo_id=you/so100_pick_block \ --dataset.num_episodes=50 \ --dataset.single_task="Pick up the red block and put it in the bowl" - 6Fine-tune on your data only
Weights from public data, actions from your own. Do not mix the datasets.
bashlerobot-train \ --policy.path=lerobot/smolvla_base \ --dataset.repo_id=you/so100_pick_block \ --policy.device=cuda \ --batch_size=4 \ --steps=20000
Not in training; the GPU job is hours. The conversion, the version mismatch and the moment you find your dataset is v2.0 and your trainer wants v3.0 are days. Read dataset rejected as v3 first.
The platform removes the GPU and pipeline plumbing. It does not remove the embodiment mismatch: point the trainer at a converted DROID dataset and you get a policy trained on Franka actions, exactly as you would locally.
- 1Pick a policy, not a dataset
The five trainable policies, with parameter counts, GPU tiers and latencies, are at /policies.
- 2Record with the desktop client
It writes LeRobot-format datasets, episodes, camera streams and joint states, straight out of a teleop session. No conversion step to get wrong.
- 3Or bring a dataset you already have
The training form accepts one from /directory, a Hugging Face repo id, or your own machine. A repo id means a converted OXE dataset will load, and the mismatch loads with it.
- 4Train on a rented GPU
The backend rents a card on a spot market by required VRAM. SmolVLA or ACT on 24 GB: 2 to 5 hours, about 1 to 3 USD. GR00T or Pi0.5 on A100 or H100: 3 to 6 hours, about 4 to 12 USD. See /pricing.
- 5Serve it back to the arm
/api/inference/pod auto-provisions a GPU pod serving the policy; the local client talks to that endpoint. Pods carry an idle watchdog and destroy themselves, so nothing keeps billing silently.
Inference has to sit next to the servos for fast tasks. The control loop is 20 to 485 ms per action step depending on the model, and public-internet round trips turn a working policy into a hesitant one. Remote inference is fine for slow pick-and-place, not fast reactive motion.
The platform helps with the boring parts: the right format for the right arm at the right frame rate, and no babysitting a spot instance. It helps with nothing else in this article.

עלות כל נתיב
| נתיב | אחסון | זמן אנושי | עלות GPU | סיכוי שיזיז את הזרוע שלך |
|---|---|---|---|---|
| DROID מומר בלבד | 392 GB | ימי המרה | 4 to 12 USD | נמוך מאוד, מרחב פעולה שגוי |
| DROID ממוזג עם הפרקים שלך | שניהם | חסום על ידי validate_all_metadata | n/a | אף אחד, הוא לא רץ |
| SmolVLA, 30 עד 50 פרקים משלך | מספר GB בודדים | 100 דקות הקלטה | 1 to 3 USD | גבוה |
| GR00T N1.7, 50 פרקים משלך | מספר GB בודדים | 100 דקות הקלטה | 4 to 12 USD | גבוה |
| ACT מאפס, 50 פרקים משלך | מספר GB בודדים | 100 דקות הקלטה | 1 to 3 USD | גבוה, 20 אלפיות השנייה הסקה |
| דוגמת DROID כמתקן בדיקה | 2 GB | אחר צהריים אחד | הרצה קצרה אחת | גבוה, כאימות |
האסימטריה היא העיקר: הנתיב ששואל הכי הרבה נתונים הוא היקר ביותר ובעל הסיכוי הנמוך ביותר להזיז את זרועך. פחות משעתיים של טלפרודוקציה שלך עדיפות על טרה-בייט של פרנקה של מישהו אחר. אין לך עדיין זרוע? /live מזרים SO-100 פיזי ללא הרשמה. לאחר מכן אמן את המדיניות הראשונה שלך, ו-SmolVLA על SO-100 למדריך הספציפי.
הורד את דגימת DROID בגודל 2 GB והשתמש בה כדי להוכיח את ה-pipeline שלך. התעלם מ-1.7 TB הנותרים. הקלט 50 פרקים של משימה אחת עם מצלמות קבועות. כוונן עדין את SmolVLA תחילה, מכיוון שעם מינימום 30 פרקים על כרטיס 24 GB, זו הדרך הזולה ביותר לבצע איטרציות, ולאחר מכן נסה את GR00T N1.7 על אותם נתונים. השווה על המשימה שלך, לא על benchmark.
הקלט מערכי נתונים שכבר תואמים את הזרוע שלך
לקוח שולחן העבודה כותב מערכי נתונים בפורמט LeRobot ישירות מסשן טלפרודוקציה: זרוע נכונה, קצב פריימים נכון, מרחב פעולה נכון. ללא המרה ל-RLDS, ללא מיפוי מחדש.
קבל את לקוח שולחן העבודההאם אוכל לאמן מדיניות על DROID ולהריץ אותה על ה-SO-100 שלי?▾
לא ישירות. בבניית LeRobot, פעולות DROID הן פקודות קצה-אפקטור 7-D על Franka Panda ב-15 פריימים לשנייה; ב-RLDS הגולמי הן 6 מהירויות מפרקים בתוספת מיקום תופסן. SO-100 מקבל 6 מיקומי מפרקים מוחלטים. תזדקק לשכבת קינמטיקה הפוכה, וגם אז פרק כף יד בעל 5 דרגות חופש אינו יכול לשחזר תנוחות 6-DoF שרירותיות.
האם אוכל לערבב פרקי DROID או Bridge עם פרקי ה-SO-100 שלי?▾
לא. validate_all_metadata דורש fps, robot_type ו-feature schema זהים ומעלה ValueError על ההתאמה השגויה הראשונה. כל השלושה שונים: 15 או 5 פריימים לשנייה לעומת 30, franka או widowx לעומת הזרוע שלך, צורות פעולה של 7 לעומת 6. שכתוב מטא-דאטה כדי לעבור את הבדיקה אינו מתקן את הסמנטיקה.
האם Open X-Embodiment חסר תועלת עבור זרוע בעלות נמוכה?▾
לא, אך ערכו מגיע אליך באמצעות משקלים מאומנים מראש, לא באמצעות פרקים. מערכי נתונים בקוד פתוח הכוללים OXE, Bridge v2 ו-DROID מהווים 9.1 אחוזים מתערובת האימון המוקדם של pi0, ו-NVIDIA מספקת גרסאות GR00T N1.7 שאומנו לאחר מכן על Bridge, Fractal, DROID ו-LIBERO. מה שאתה לא יכול לעשות הוא לצרף את הפרקים האלה להקלטה שלך.
איזו מדיניות מפיקה את מירב התועלת מנתוני cross-embodiment ציבוריים?▾
Pi0.5 ומודלי GR00T נושאים את מירב האימון המוקדם של cross-embodiment, אך SmolVLA מתנהג לעיתים קרובות בצורה הטובה ביותר על זרוע בעלות נמוכה: סט האימון המוקדם שלו כולל 481 מערכי נתונים קהילתיים, 22.9K פרקים ו-10.6M פריימים, שהוערכו על זרועות SO-100 ו-SO-101 אמיתיות. ACT הוא ההפך: אין מודל בסיס, 20 ms לכל שלב פעולה.
כמה פרקים משלי אני באמת צריך?▾
30 עבור SmolVLA, 50 עבור GR00T N1.7, GR00T N1.5, Pi0.5 ו-ACT. בברירות המחדל של LeRobot של 60 שניות לפרק ו-60 שניות איפוס, 50 פרקים הם 100 דקות זמן שעון קיר. נתוני cross-embodiment שאולים אינם מורידים את המספרים הללו.
Sources
- DROID: מערך נתונים בקנה מידה גדול למניפולציה רובוטית בסביבה טבעית
- תיעוד DROID: גדלי הורדה וסכימת פרקי RLDS
- BridgeData V2: מערך נתונים ללמידת רובוטים בקנה מידה
- עמוד פרויקט BridgeData V2: הרכב וכיסוי מצלמה
- Open X-Embodiment: מערכי נתונים ללמידה רובוטית ומודלי RT-X
- עמוד פרויקט Open X-Embodiment
- google-deepmind/open_x_embodiment: רשימת מערכי נתונים ונקודות בקרה של RT-1-X
- any4lerobot: הממיר openx2lerobot ומצב ה-8D המאוחד שלו, פעולת ה-7D
- IPEC-COMMUNITY/droid_lerobot: meta/info.json וגודל מאגר
- IPEC-COMMUNITY/bridge_orig_lerobot: meta/info.json
- IPEC-COMMUNITY/fractal20220817_data_lerobot: פרוסת google_robot ב-3 פריימים לשנייה
- huggingface/lerobot: עוקב SO, מעבד קינמטיקה, תצורות צבירה והקלטה
- openpi: קלטי מדיניות DROID ונקודת הבקרה pi05_droid
- pi0: מודל זרימת ראייה-שפה-פעולה לבקרת רובוטים כללית
- SmolVLA: מודל ראייה-שפה-פעולה לרובוטיקה חסכונית ויעילה
Sources
- DROID: A Large-Scale In-The-Wild Robot Manipulation Dataset
- DROID docs: download sizes and the RLDS episode schema
- BridgeData V2: A Dataset for Robot Learning at Scale
- BridgeData V2 project page: composition and camera coverage
- Open X-Embodiment: Robotic Learning Datasets and RT-X Models
- Open X-Embodiment project page
- google-deepmind/open_x_embodiment: dataset list and RT-1-X checkpoints
- any4lerobot: the openx2lerobot converter and its unified 8-D state, 7-D action
- IPEC-COMMUNITY/droid_lerobot: meta/info.json and repo size
- IPEC-COMMUNITY/bridge_orig_lerobot: meta/info.json
- IPEC-COMMUNITY/fractal20220817_data_lerobot: the google_robot slice at 3 fps
- huggingface/lerobot: SO follower, kinematics processor, aggregate and record configs
- openpi: DROID policy inputs and the pi05_droid checkpoint
- pi0: A Vision-Language-Action Flow Model for General Robot Control
- SmolVLA: A Vision-Language-Action Model for Affordable and Efficient Robotics
Ready for high-quality robotics data?
AY-Robots connects your robots to skilled operators worldwide.
Get Started