ספריית מאגרי הנתונים הציבוריים של AY-Robots המציגה מאגרי נתונים של LeRobot שתועדו על זרועות מסוג SO-100
מאגרי נתוניםOpen X-EmbodimentDROIDSO-100LeRobot

שימוש ב-DROID, BridgeData V2 ו-Open X על SO-100

AY-Robots ResearchAugust 23, 202618 דקות קריאה

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 בעלות נמוכה, ומה לעשות במקום זאת. כל מספר להלן הגיע מהמאמר, כרטיס מערך הנתונים או קובץ המקור שאליו הוא שייך.

מה מכילים שלושת מערכי הנתונים בפועל

DROIDBridgeData V2Open X-Embodiment
רובוטFranka Panda, 7 DoF, Robotiq 2F-85WidowX 250, 6 DoF, ~4,000 USD rig22 embodiments, 60 datasets, 34 labs
קנה מידה76k trajectories, 350 hours60,096 trajectories1M+ trajectories, 527 skills
גיוון564 scenes, 84 tasks, 50 collectors24 environments, 13 skills160,266 tasks, 21 institutions
הרכבכולם מופעלים מרחוק50,365 teleoperated, 9,731 scriptedלפי מעבדת מקור
קצב בקרה15 Hz5 Hzמשתנה, 3 פריימים לשנייה ומעלה
מצלמות2 x ZED 2 חיצוניות, 1 x ZED Mini לפרק כף הידעד 4, ברוב הפרקים רק הקבועהמה שהמעבדה השתמשה בו
הורדה גולמית1.7 TB RLDS, 8.7 TB raw stereoארכיוני JPEGדליי TFDS לכל מערך נתונים
נקודת הכניסה היא ההמרה של LeRobot, לא הדלי המקורי

מעט אנשים עדיין מורידים 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 דרגות חופש, אך אינם מיישרים מסגרות קואורדינטות בין מערכי נתונים, ומאפשרים לערכי הפעולה להיות מיקומים או מהירויות מוחלטים או יחסיים, לפי תוכנית הבקרה המקורית של כל רובוט. מסקנתם: אותו וקטור פעולה עשוי לגרום לתנועות שונות מאוד עבור רובוטים שונים.

רשימת ספריית מערכי הנתונים של AY-Robots המציגה מערכי נתונים ציבוריים של LeRobot עם ספירת פרקים ותיאורי משימות.
ספריית מערכי הנתונים הציבורית ב-/directory: מערכי נתונים שכבר בפורמט LeRobot, וכבר תואמים זרוע נתמכת.

אי ההתאמה, בארבעה חלקים

אי-התאמה בין התגלמויות (embodiment mismatch) נתפסת בדרך כלל כבעיה מעורפלת אחת. למעשה, מדובר בארבע בעיות שונות, כל אחת נכשלת באופן אחר, ושתיים מהן אינן ניתנות לתיקון באמצעות סקריפטים.

1. דרגות חופש

ל-SO-100 יש חמישה מפרקי זרוע בתוספת תופסן. אם נספור כמנועים, זוהי זרוע בעלת 6 דרגות חופש (DoF), ומאמר SmolVLA מתייחס אליה כך; אם נספור כמנגנון מיקום, זוהי זרוע בעלת 5 דרגות חופש, ו-LeRobot מתייחס אליה כך בתיעוד ה-inverse-kinematics שלה, המתאר IK עם אוריינטציה רכה ב-SO-101 בעל 5 דרגות חופש, שבו פרק כף היד עוקב אחר האוריינטציה רק באופן חלקי. לפרנקה יש שבעה מפרקי מיקום. פער זה קובע אילו תנוחות קיימות: זרוע בעלת 5 דרגות חופש אינה יכולה בדרך כלל להגיע למיקום ואוריינטציה שרירותיים בו-זמנית, ולכן הפותר מחזיר את הקרוב ביותר שהוא יכול, תנועה שונה מזו שהודגמה. רקע: דרגות חופש.

python
# 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
משמאל: ה-SO follower של LeRobot, מתוך src/lerobot/robots/so_follower/so_follower.py. מימין: קלט מדיניות DROID של openpi. שישה מול שמונה.

לכן נקודת ביקורת (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 בצורת LeRobotSO-100 ב-LeRobot
וקטור פעולה7-ממדי: x, y, z, roll, pitch, yaw, תופסן6-ממדי: מיקום יעד אחד לכל מנוע
וקטור מצב8-ממדי, עם חריץ ריפוד (google_robot משתמש בקוורטרניון)6-ממדי, אחד לכל מנוע
מסגרתקרטזי, לא מיושר בין מערכי נתוניםמרחב מפרקים, כיול לכל זרוע
מוחלט או יחסיאחד מהם, נקבע על ידי מעבדת המקורמיקומי יעד מוחלטים
יחידותמנורמלות לכל מערך נתונים, ואז מפוצלותמעלות כברירת מחדל (use_degrees=True), אחרת -100 עד 100
כשל שקטדלתא שנקראת כמוחלטזרוע לא מכוילת
הווקטור הקרטזיאני ה-7-ממדי הוא מוסכמת הממיר, לא של DROID

קובץ ה-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. 1
    משוך את דגימת 100 הפרקים, לא את ה-1.7 TB המלאים

    2 GB מספיקים כדי לראות את המבנה.

    bash
    pip install gsutil tensorflow tensorflow-datasets
    gsutil -m cp -r gs://gresearch/robotics/droid_100 ~/tensorflow_datasets/
  2. 2
    המר RLDS לפורמט LeRobot

    openx2lerobot עוטף את טרנספורמציות ה-OXE הסטנדרטיות ומציין את סוג הרובוט ותדירות הבקרה. קובץ ה-README ממקם זאת ב-convert.sh.

    bash
    git 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. 3
    קרא את meta/info.json לפני כל דבר אחר

    קובץ זה קובע אם שאר היום שלך יעבוד.

    bash
    python -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. 4
    נסה את המיזוג וקרא את השגיאה

    merge טוען כל מערך נתונים, ואז validate_all_metadata בודק את fps, robot_type ותכונות מול הראשון ברשימה, ומעלה שגיאה בהתאמה הראשונה.

    bash
    lerobot-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.

אל תקודד robot_type באופן קשיח כדי לעקוף את הבדיקה

בגרסה הנוכחית של LeRobot main so100_follower ו-so101_follower רשומים שניהם על SOFollowerRobotConfig משותף אחד, כך שהמחרוזת מהקלטה אמיתית אינה בהכרח זו שאתה מצפה לה. קרא אותה מתוך meta/info.json שלך, והתייחס לבדיקה שנאלצת להשבית כבדיקה שאמרה לך משהו.

אז מה בעצם עובר?

משקולות, לא אפיזודות. כל מדיניות כללית מודרנית ספגה חלק מזה באימון מוקדם, וכאשר אתה מתוך אתה יורש אותו כבר מיושב על ידי אנשים עם כוח המחשוב לבצע זאת כראוי. המאמר של pi0 גלוי לגבי הפרופורציה: 9.1 אחוז מתערובת האימון המוקדם שלו, הנספרת בצעדי זמן, היא נתונים בקוד פתוח הכוללים את OXE, Bridge v2 ו-DROID. נתון זה הוא של pi0; התערובת של כל ספק שונה.

נתונים ציבוריים בין-התגלמויות בפרויקט SO-100
יתרונות
  • פרייורים ויזואליים ושפתיים: המקודד ראה אלפי מטבחים וספלים ויודע למה מתייחס "הבלוק האדום".
  • פרייור על מבנה מניפולציה: גישה, סגירה, הרמה, שינוע, שחרור, בלתי תלוי בהתגלמות גם כאשר המספרים אינם כאלה.
  • מערך נתונים ידוע וטוב לבדיקה. אם המשימה שלך לא יכולה לבצע התאמת יתר ל-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 אומן בכוונון עדין50LeRobot v2.0 or v2.1A100 or H100 80 GB152 ms לכל צעדnvidia/GR00T-N1.7-3B
GR00T N1.5~3 B50LeRobot v2.0 or v2.1A100 or H100 80 GB165 msnvidia/GR00T-N1.5-3B
Pi0.5~3 B, עמוד שדרה PaliGemma50LeRobot v3.0A100 or H100 80 GB485 mslerobot/pi05_base
SmolVLA~450 M30LeRobot v3.0RTX 4090 או כל 24 GB245 mslerobot/smolvla_base
ACT~80 M50LeRobot v3.0RTX 4090 או כל 24 GB20 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 דקות של זמן שעון קיר. ראה , ו-.

דף המדריך להקלטה של AY-Robots המציג את השלבים ללכידת מערך נתונים של LeRobot מתוך סשן טל-אופרציה
המדריך להקלטה ב-/learn/record-your-first-dataset: השלב שנתונים ציבוריים אינם יכולים להחליף.

שתי דרכים לעבור מנתונים ציבוריים למדיניות עובדת

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.

  1. 1
    Install LeRobot with the extras the scripts need

    The record and train entry points each declare their own extra.

    bash
    pip install 'lerobot[core_scripts]'   # lerobot-record
    pip install 'lerobot[training]'      # lerobot-train
    pip install gsutil tensorflow tensorflow-datasets
  2. 2
    Get a small, known-good slice

    100 DROID episodes, 2 GB.

    bash
    gsutil -m cp -r gs://gresearch/robotics/droid_100 ~/tensorflow_datasets/
  3. 3
    Convert to LeRobot form

    Writes the unified 8-D state and 7-D action, annotating robot type and control frequency.

    bash
    python openx_rlds.py \
        --raw-dir ~/tensorflow_datasets/droid_100/1.0.0 \
        --local-dir ~/lerobot_droid100 \
        --repo-id you/droid100_lerobot \
        --use-videos
  4. 4
    Check 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.

    bash
    python src/lerobot/scripts/convert_dataset_v21_to_v30.py \
        --repo-id=you/droid100_lerobot
  5. 5
    Record your own episodes

    Defaults: 30 fps, 60 s per episode, 60 s reset, 50 episodes. The teleoperator type is so100_leader.

    bash
    lerobot-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"
  6. 6
    Fine-tune on your data only

    Weights from public data, actions from your own. Do not mix the datasets.

    bash
    lerobot-train \
      --policy.path=lerobot/smolvla_base \
      --dataset.repo_id=you/so100_pick_block \
      --policy.device=cuda \
      --batch_size=4 \
      --steps=20000
Where the time actually goes

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.

דף ההורדה של לקוח שולחן העבודה של AY-Robots, הלקוח שמקליט מערכי נתונים בפורמט LeRobot מתוך סשן טל-אופרציה
לקוח שולחן העבודה ב-/download כותב מערכי נתונים של LeRobot ישירות מתוך סשן טל-אופרציה, תוך עקיפת המרה ל-RLDS.

עלות כל נתיב

נתיבאחסוןזמן אנושיעלות GPUסיכוי שיזיז את הזרוע שלך
DROID מומר בלבד392 GBימי המרה4 to 12 USDנמוך מאוד, מרחב פעולה שגוי
DROID ממוזג עם הפרקים שלךשניהםחסום על ידי validate_all_metadatan/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 שאולים אינם מורידים את המספרים הללו.

Ready for high-quality robotics data?

AY-Robots connects your robots to skilled operators worldwide.

Get Started