דף המדריך של AY-Robots להקלטת מערך הנתונים הראשון שלך ב-LeRobot עם זרוע SO-100
LeRobotSO-100הקלטת מערך נתוניםטלאופרציהלמידת חיקוי

הקלט את מערך הנתונים הראשון שלך ב-LeRobot עם SO-100

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

הקלט מערך נתונים שמיש של 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 שלה.

מאפייןסוג נתוניםצורהתיאור
actionfloat32[6]מטרות מפרקים מזרוע המנהיג
observation.statefloat32[6]מיקומי מפרקים שהעוקב הגיע אליהם
observation.images.topvideo[480, 640, 3]מצלמת סצנה, MP4 (av1 כאן)
observation.images.wristvideo[480, 640, 3]מצלמת פרק כף היד, באותו קצב
timestampfloat32[1]שניות מתחילת הפרק
frame_index, episode_index, index, task_indexint64[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 שניות, לפרק. אם שלכם ממוצע לדקה, אתם עושים משהו קשה יותר או מקליטים זמן מת בשני הקצוות.

ערך המילון של AY-Robots עבור פורמט הנתונים של LeRobot, המציג את מבנה הספריות וקובצי המטא-נתונים
מה נמצא ב-data/, videos/ וב-meta/, ואילו מדיניות קוראות איזו גרסה.

מה שאתה צריך על השולחן

פריטפרטהערה
זרוע עוקבתSO-100, שישה סרוואים Feetech STS3215כ-110 עד 150 אירו בחלקים
זרוע מובילהSO-100 שנייה, גלגלי שיניים הוסרוגלגלי שיניים הופשטו מכל ששת מנועי הזרוע המובילה: מקודד בלבד, פחות חיכוך
ספק כוחמותאם לגרסת ה-7.4 V של STS3215 ברשימת החומריםראה את האזהרה למטה
מצלמותשתי מצלמות USB, 640x480 ב-30 פריימים לשנייהתצוגת סצנה אחת, אחת על פרק כף היד
מחשב מארחPython 3.12 או חדש יותר, ffmpegrequires-python >= 3.12
חשבון HubHugging Face אסימון כתיבהoptional with --dataset.push_to_hub=false
7.4 V, לא 12 V

ה-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

bash
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
lerobot-info מדפיס סיכום מערכת, כולל גרסת ffmpeg שהוא מוצא ב-PATH.

תוספות מבלבלות אנשים לרוב. pip install lerobot מתקין רק תלויות ליבה של למידת מכונה, שום דבר שלא מתקשר עם רובוט. זרועות Koch זקוקות ל-dynamixel במקום feetech. אם ה-shell שלכם מעולם לא שמע על lerobot-record, זו הסיבה.

פורטים, מזהי מנועים וכיול

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

  1. 1
    מצא את פורט ה-USB של כל זרוע

    הפעל אותו כששתי הזרועות מחוברות, נתק את הזרוע שאתה מזהה כאשר תתבקש, ושים לב איזה פורט נעלם. בלינוקס ייתכן שתצטרך sudo chmod 666 /dev/ttyACM0.

    bash
    lerobot-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. 2
    כתוב מזהי מנועים וקצבי העברה

    מזהים נכתבים מנוע אחד בכל פעם, והתיעוד קפדני לגבי אופן הפעולה: חבר מנוע אחד בלבד ללוח הבקר, לא מחובר עדיין בשרשרת למנוע אחר. הסקריפט עובר על השרשרת לאחור, מבקש תחילה את התופסן ונותן לו מזהה 6, לאחר מכן את wrist_roll כמזהה 5, ועד shoulder_pan כמזהה 1. בצע זאת לפני ההרכבה.

    bash
    lerobot-setup-motors \
        --robot.type=so100_follower \
        --robot.port=/dev/ttyACM0
    
    lerobot-setup-motors \
        --teleop.type=so100_leader \
        --teleop.port=/dev/ttyACM1
  3. 3
    כייל את שתי הזרועות

    הזז כל מפרק לאמצע הטווח שלו, לחץ Enter, ולאחר מכן סרוק כל אחד מהם לאורך כל הטווח שלו. ה-id הופך לשם קובץ הפרופיל.

    bash
    lerobot-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. 4
    בצע טל-אופ לפני הקלטת כל דבר

    בדיקת הקבלה לכל מה שלעיל. אם הטל-אופ קופצני, משתקף, או שמפרק אחד אינו עוקב, ההקלטה תשמר זאת ב-50 פרקים.

    bash
    lerobot-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 לביצוע מחדש. תן לו מזהה לא ידוע ואין קובץ, כך שהוא יכנס לכיול באמצע הסשן.

מצלמות קובעות מה רואה המדיניות

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

פקודת ההקלטה וכל הדגלים

bash
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
מילון המצלמה הוא מחרוזת אחת במירכאות של shell; הסוגריים המסולסלים המקוננים אינם תחביר של shell.

ברירות המחדל שלהלן מגיעות מ-src/lerobot/configs/dataset.py ב-main, לא ממדריך. כמה מהן אינן מה שאנשים מניחים.

דגלברירת מחדלמה הוא עושה
--dataset.repo_idריקשם; חותמת זמן מצורפת כברירת מחדל
--dataset.single_taskריקמחרוזת משימה הנשמרת עם כל פרק
--dataset.root$HF_LEROBOT_HOME/repo_idנתיב כתיבה, ברירת מחדל ~/.cache/huggingface/lerobot/
--dataset.fps30קצב לולאת בקרה וקצב פריימים של מערך נתונים
--dataset.episode_time_s60שניות לפני שפרק מתקדם אוטומטית
--dataset.reset_time_s60איפוס סצנה; הזרוע נעה, דבר לא נשמר
--dataset.num_episodes50פרקים שהוקלטו בסשן זה
--dataset.push_to_hubtrueהעלאה בסיום הסשן; false משאיר מקומי
--dataset.streaming_encodingfalse in the dataclass, true in the docs tableקידוד במהלך לכידה; הגדר זאת במפורש
--dataset.encoder_queue_maxsize30פריימים בחוצץ לכל מצלמה, ~1 שניה ב-30 פריימים לשניה
--dataset.encoder_threadsnull (codec decides)תהליכונים לכל מקודד; נמוך יותר אם הלכידה מגמגמת
--dataset.no_stampfalseשמור את repo_id בדיוק כפי שהוקלד
--resumefalseהוסף למערך נתונים קיים; דורש --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עלות להרצה
SmolVLA30LeRobot v3.0RTX 4090 or any 24 GB cardabout 1 to 3 USD
ACT50LeRobot v3.0RTX 4090 or any 24 GB cardabout 1 to 3 USD
GR00T N1.750LeRobot v2.0 or v2.1A100 80 GB or H100 80 GBabout 4 to 12 USD
GR00T N1.550LeRobot v2.0 or v2.1A100 80 GB or H100 80 GBabout 4 to 12 USD
Pi0.550LeRobot v3.0A100 80 GB or H100 80 GBabout 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 כפול משך הזמן. לכל פרק, לא בסך הכל.

python
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"])
פרק שבו ה-fps כפול משך הזמן חורג מהנורמה הוא מועמד למחיקה, לא לאימון.

ואז תסתכלו על זה. lerobot-dataset-viz מנגן פרק פריים אחר פריים עם עקבות מפרקים לצד תצוגות המצלמה, ב-Rerun או Foxglove. מצלמות שהוחלפו ופריימים קפואים יופיעו תוך עשר שניות. אנשים מדלגים על שלב זה.

bash
# 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]"
lerobot-edit-dataset מבצע גם פיצול, מיזוג, הסרת תכונה, שינוי משימות וחישוב מחדש של סטטיסטיקות. מחקו בנדיבות: פרק גרוע עולה פרק אחד; שמירתו עולה כל הרצה שאומנה עליו.
רשימת ספריית הנתונים של AY-Robots המציגה מערכי נתונים ציבוריים של LeRobot עם ספירת פרקים ופורמטים
כיצד מערכי נתונים דומים מוגדרים בגודלם ומסומנים.

v2.1 או v3.0: החליטו לפני שאתם מקליטים

v2.1 כתב קובץ parquet אחד וקובץ MP4 אחד לכל פרק. v3.0 משרשר פרקים רבים לשארדים משותפים ובונה מחדש גבולות מתוך מטא-דאטה, כך ש-info.json נושא תבניות נתיב כמו data/chunk-{chunk_index:03d}/file-{file_index:03d}.parquet במקום מספר פרק. ההצדקה במעלה הזרם היא פחות קבצים, גדולים יותר: אתחול מהיר יותר ופחות לחץ על מערכת הקבצים בקנה מידה גדול.

LeRobot v2.1LeRobot v3.0
פריסהקובץ parquet אחד וקובץ MP4 אחד לכל פרקפרקים רבים לכל שארד
מטא-דאטה של פרקקבצי JSONLparquet מחולק לנתחים תחת meta/episodes/, דרך ערימת ה-datasets
הזרמה מה-Hubלאכן, דרך StreamingLeRobotDataset
נכתב על ידי lerobot 0.6.1לאכן, מה שמקבלים היום
נקרא על ידי GR00T N1.7 ו-N1.5כןלא, יש להמיר כלפי מטה
הקלטה היום, אימון GR00T מחר

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.

bash
# 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
מהיר ל-50 פרקים. קנה מידה הוא עבודה אחרת: מדריך ההעברה של lerobot, עבור DROID גולמי לגרסה 3.0, מקצה 7+ ימים של עיבוד מקומי וכ-400 GB.

שני מסלולים לאותו מערך נתונים

כל האמור לעיל, במחשב שלך: אתה הבעלים של ספירת ה-USB, בניית ה-ffmpeg, כיוונון המקודד וקובצי הכיול. המסלול הנכון להבנת הצינור, הפעלת מתקן מצלמה יוצא דופן, או שמירת נתונים מקומיים.

מה עלות המסלול הזה

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

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

Ready for high-quality robotics data?

AY-Robots connects your robots to skilled operators worldwide.

Get Started