איך לאמן ACT על ה-SO-100 מאפס

ACT יוצא דופן בין מדיניות SO-100. GR00T N1.7 ו-N1.5 מתחילים מ-nvidia/GR00T-N1.7-3B ו-nvidia/GR00T-N1.5-3B, Pi0.5 מ-lerobot/pi05_base. ACT מתחיל מאפס: אין נקודת בדיקה בסיסית, מכיוון שזה אינו מודל יסוד. זהו טרנספורמר עם כ-80 מיליון פרמטרים שאתה מאמן מאפס על משימה אחת, על הזרוע שלך, בתנאי התאורה שלך.

זו גם הסיבה לכך שהוא מבצע שלב בקרה ב-20 אלפיות השנייה, בעוד ש-VLA עם 3 מיליארד פרמטרים זקוק ל-152 עד 485 אלפיות השנייה, ועולה 1 עד 3 דולר להרצה במקום 4 עד 12. מדריך זה מציג את המסלול הידני עם לרובוט על SO-100: הקלטה, תצורת ה-act, מה ש-chunk_size ו-n_action_steps שולטים, לוח הזמנים של 100000 צעדים, וההפצה. לאחר מכן אותה עבודה על AY-Robots, כולל היכן שהפלטפורמה אינה עוזרת.

מהו ACT למעשה

Action Chunking with Transformers מגיע מהמאמר ALOHA, למידת מניפולציה דו-ידנית עדינה עם חומרה בעלות נמוכה, מאת זאו, קומאר, לוין ופין, arXiv, 23 באפריל 2023. המתקן מקליט ב-50 הרץ עם ארבע מצלמות רשת המזרמות 480x640 ב-30 פריימים לשנייה: שתיים על התופסנים, אחת עליונה, אחת קדמית. התקציר טוען לשש מיומנויות עם 80 עד 90 אחוזי הצלחה, ביניהן פתיחת כוס רוטב שקופה והכנסת סוללה, מתוך 10 דקות של הדגמות.

גוף המאמר שימושי יותר בעת תכנון סשן הקלטה: 50 הדגמות למשימה, למעט Thread Velcro ב-100, שהם 10 עד 20 דקות של נתונים ו-30 עד 60 דקות של זמן שעון קיר לאחר ספירת איפוסים. ההצלחה אינה אחידה גם כן: Thread Velcro מסתיים ב-20 אחוז, Put On Shoe ב-92, Cup Open 84, Prep Tape 64.

קיבוץ פעולות הוא כל הרעיון

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

המאמר מבצע אבלאציה ל-k במקום לקבוע אותו. כאשר איגום זמני כבוי, בממוצע על פני ארבע הגדרות, ההצלחה עולה מ-1 אחוז ב-k = 1 ל-44 אחוז ב-k = 100, ואז מתייצבת ב-200 ו-400 ככל שהמדיניות מתקרבת לבקרת לולאה פתוחה. עקומה זו היא הסיבה לכך שברירת המחדל היא 100.

• chunk_size: כמה פעולות עתידיות המפענח חוזה בכל מעבר קדימה. ברירת מחדל 100.
• n_action_steps: כמה מהן אתה מבצע לפני שליחה חוזרת של שאילתה. ברירת מחדל 100, כך ש-lerobot מריץ את כל ה-chunk בלולאה פתוחה.
• lerobot מאמת ש-n_action_steps <= chunk_size ומעלה ValueError אם אתה מזין אותם הפוך.

מה שחשוב מבחינה תפעולית הוא chunk_size חלקי קצב הפריימים. בקצב של 30 פריימים לשנייה שבו משתמשות הדוגמאות של SO-100 ב-lerobot, chunk של 100 פעולות מחויב לכ-3.3 שניות מתצפית אחת. אם המשימה דורשת תיקון בתוך חלון זה, הורד את n_action_steps, לא את chunk_size: אתה שומר את החיזוי הארוך ומתבונן מחדש לעיתים קרובות יותר.

# predict 100 actions, re-query after 25 of them (about 0.8 s at 30 fps)
lerobot-train \
  --dataset.repo_id=${HF_USER}/so100_cube \
  --policy.type=act \
  --policy.chunk_size=100 \
  --policy.n_action_steps=25 \
  --policy.device=cuda

כאשר ACT עולה על מודל יסוד

חמשת המדיניות הניתנות לאימון זו לצד זו, עם המספרים ש-AY-Robots מודדת ומשתמשת בהם כדי לקבוע את גודל ה-GPU שהיא שוכרת.

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

מה שאתה צריך לפני שאתה מתחיל

זרוע עוקבת אחת, זרוע מובילה אחת עבור , לפחות מצלמה אחת, GPU של 24 GB. ACT קורא תמונות ומיקומי מפרקים בלבד. שתי מצלמות הן נקודת האיזון המושלמת: תצוגה קדמית קבועה עבור מיקום הדברים, מצלמת פרק כף יד עבור מה ש עומד לגעת, כמו ב-ALOHA.

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

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

1. 1
   התקן את lerobot עם התוספות הנכונות

   הקלטה דורשת core_scripts, אימון training, סרוו Feetech feetech. פייתון 3.12 ומעלה.

   bash

   conda create -y -n lerobot python=3.12
   conda activate lerobot
   conda install ffmpeg -c conda-forge
   
   pip install 'lerobot[core_scripts,training,feetech]'
   lerobot-info

2. 2
   מצא את יציאת ה-USB של כל זרוע

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

   bash

   lerobot-find-port
   # on Linux, if the port exists but is unreadable:
   sudo chmod 666 /dev/ttyACM0

3. 3
   הגדר את מזהי המנועים וקצב ה-baud

   ב-SO-100 זה קורה לפני ההרכבה: בניגוד ל-SO-101, המחברים אינם נגישים לאחר הבנייה. הסקריפט עובר על האפיק מנוע אחד בכל פעם מהתפסן, וכותב מזהים ל-EEPROM.

   bash

   lerobot-setup-motors \
       --robot.type=so100_follower \
       --robot.port=/dev/ttyACM0
   
   lerobot-setup-motors \
       --teleop.type=so100_leader \
       --teleop.port=/dev/ttyACM1

4. 4
   כייל את שתי הזרועות

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

   bash

   lerobot-calibrate \
       --robot.type=so100_follower \
       --robot.port=/dev/ttyACM0 \
       --robot.id=my_follower
   
   lerobot-calibrate \
       --teleop.type=so100_leader \
       --teleop.port=/dev/ttyACM1 \
       --teleop.id=my_leader

5. 5
   הפעל טל-אופרציה פעם אחת כשהמצלמות פועלות

   כלל האצבע של lerobot: עליך להיות מסוגל לבצע את המשימה רק על ידי התבוננות בתמונות המצלמה. אם אינך יכול, גם ACT לא יכול. זה תופס יותר מערכי נתונים גרועים מאשר ניפוי באגים מאוחר יותר.

   bash

   lerobot-teleoperate \
       --robot.type=so100_follower \
       --robot.port=/dev/ttyACM0 \
       --robot.id=my_follower \
       --robot.cameras="{ front: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30}, wrist: {type: opencv, index_or_path: 1, width: 640, height: 480, fps: 30} }" \
       --teleop.type=so100_leader \
       --teleop.port=/dev/ttyACM1 \
       --teleop.id=my_leader \
       --display_data=true

6. 6
   הקלט 50 פרקים

   50 הוא המינימום של AY-Robots ומה ש-ALOHA השתמשה בו לכל משימה. lerobot ממליץ על 10 לכל מיקום אובייקט, מצלמות קבועות, אחיזה עקבית. n מסיים פרק, r מקליט מחדש, q עוצר ומקודד.

   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_follower \
       --robot.cameras="{ front: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30}, wrist: {type: opencv, index_or_path: 1, width: 640, height: 480, fps: 30} }" \
       --teleop.type=so100_leader \
       --teleop.port=/dev/ttyACM1 \
       --teleop.id=my_leader \
       --dataset.repo_id=${HF_USER}/so100_cube \
       --dataset.num_episodes=50 \
       --dataset.single_task="Grab the black cube and put it in the bin" \
       --display_data=true

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

lerobot-replay \
    --robot.type=so100_follower \
    --robot.port=/dev/ttyACM0 \
    --robot.id=my_follower \
    --dataset.repo_id=${HF_USER}/so100_cube \
    --dataset.episode=0

אימון מדיניות ה-ACT

זוהי הפקודה המלאה. כל מה שספציפי ל-ACT הוא כבר ברירת מחדל, ולכן דף ה-ACT של lerobot ממליץ להתחיל איתם.

lerobot-train \
  --dataset.repo_id=${HF_USER}/so100_cube \
  --policy.type=act \
  --output_dir=outputs/train/act_so100_cube \
  --job_name=act_so100_cube \
  --policy.device=cuda \
  --wandb.enable=true \
  --policy.repo_id=${HF_USER}/act_so100_cube

--policy.type=act טוען את ACTConfig, אשר מתאים את עצמו למספר המנועים והמצלמות שהדאטה-סט שלך תיעד, כך שלעולם אינך צריך להצהיר על צורת התצפית. --wandb.enable=true הוא אופציונלי ומשתלם: עקומת ההפסד היא האות הזול היחיד בהרצה של 100000 צעדים. לוח הזמנים מגיע מתצורת האימון של lerobot, לא מ-ACTConfig: 100000 צעדים, אצווה 8, גרעין 1000, נקודת שמירה כל 20000 צעדים, רישום כל 200.

הרצה מלאה משאירה חמש ספריות נקודות שמירה, מ-020000 עד 100000, בתוספת קישור סימבולי last. שמור את כולן: המדיניות הטובה ביותר היא לעיתים קרובות לא האחרונה.

משך: כ-5 שעות על RTX 2080 Ti בנפח 11 GB במאמר, מספר שעות עבור 100k צעדים לפי עמוד ה-ACT של lerobot, 2 עד 5 שעות על שכבת ה-24 GB של AY-Robots. אל תקצרו. קובץ ה-README של מאגר הייחוס מציין שמדיניות קופצנית או עוצרת בדרך כלל זקוקה רק ליותר אימון, מכיוון שההצלחה והחלקות ממשיכות להשתפר לאחר שההפסד מתייצב: עבור נתונים מהעולם האמיתי נדרשים לפחות 5000 אֶפּוֹכוֹת, או פי 3 עד 4 מהאורך שוב לאחר ההתייצבות.

lerobot-train \
  --config_path=outputs/train/act_so100_cube/checkpoints/last/pretrained_model/train_config.json \
  --resume=true

הפעלת המדיניות המאומנת על הזרוע

פריסה משתמשת ב-lerobot-rollout. מפתחות המצלמה חייבים להתאים לאלו שתועדו: מדיניות שאומנה על front ו-wrist לא תקבל cam0 ו-cam1, ו-rename_map לא עוזר, מכיוון שהיא זקוקה לנקודת בדיקה מאומנת מראש. מחרוזת המשימה ניתנת להשמטה; הדוגמה של lerobot עצמה מסמנת אותה כניתנת לדילוג עבור ACT.

lerobot-rollout \
  --strategy.type=base \
  --policy.path=${HF_USER}/act_so100_cube \
  --robot.type=so100_follower \
  --robot.port=/dev/ttyACM0 \
  --robot.id=my_follower \
  --robot.cameras="{ front: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30}, wrist: {type: opencv, index_or_path: 1, width: 640, height: 480, fps: 30} }" \
  --display_data=true \
  --duration=60

כדי לקבע נקודת ביקורת (checkpoint) ולא את המודל הסופי, הוסף --policy.pretrained_revision. לשם כך, הריצה צריכה הייתה להתחיל עם --save_checkpoint_to_hub=true, כבוי כברירת מחדל: בלעדיו lerobot דוחף את המודל הסופי ורק אותו. איתו, כל נקודת ביקורת מתויגת עם מספר הצעד שלה מרופד באפסים, כך ש---policy.pretrained_revision=060000 משחזר את נקודת הביקורת של צעד 60000. השוואתה מול 100000 על הזרוע האמיתית היא הניסוי הזול ביותר הזמין.

שני מסלולים לאותה נקודת ביקורת

כל מה שלמעלה הוא המסלול הידני והוא עובד. מסלול הפלטפורמה מחליף שליטה באי-בעלות על GPU או סביבת פייתון.

# the two commands that matter, end to end
lerobot-record --robot.type=so100_follower --robot.port=/dev/ttyACM0 \
  --teleop.type=so100_leader --teleop.port=/dev/ttyACM1 \
  --dataset.repo_id=${HF_USER}/so100_cube --dataset.num_episodes=50 \
  --dataset.single_task="Grab the black cube"

lerobot-train --dataset.repo_id=${HF_USER}/so100_cube --policy.type=act \
  --output_dir=outputs/train/act_so100_cube --policy.device=cuda

מה באמת משתבש

כמעט כל הקושי אינו בפקודת האימון. הוא בדברים שמסביב לה, מסודרים לפי תדירות הבעיות בפעם הראשונה.

שתי שורות ראויות להדגשה. ACT מתאמן על LeRobot v3.0 בעוד שהטוען של GR00T קורס עליו ודורש v2.1, כך שמערך נתונים שמאמן ACT יכול לגרום לכשל בהרצת GR00T. והשורה האחרונה כוללת שני תיקונים: מחברי ACT עונים לתנועה קופצנית עם יותר אימון, בעוד שעם n_action_steps ב-100 עצירה אמיתית נוחתת בגבול מקטע, הפסקה גלויה כל 3.3 שניות ב-30 פריימים לשנייה. שני דברים נוספים שכדאי לדעת: מפרק אחד מת הוא בדרך כלל מזהה סרוו שמעולם לא נכתב, ו-תופסן שמתקרב אך לעולם לא נסגר פירושו טווח תופסן קטן מדי בהדגמות. אינדקס מלא: דפי מצבי הכשל.

כמה עולה הרצה

זוהי הטענה להתחיל עם ACT גם אם תרצו VLA מאוחר יותר. ריצת ACT כושלת עולה כמחיר של קפה ואומרת לכם תוך שעות אם מערך הנתונים שלכם מכיל את המשימה. ריצת GR00T כושלת עולה פי ארבעה עבור אותו שיעור. המעבר ל-GR00T N1.7 או SmolVLA לאחר מכן הוא שינוי צורה, לא בנייה מחדש. רקע: מודלי ראייה-שפה-פעולה, ה-מדריך SO-100 המלא, אמנו את המדיניות הראשונה שלכם ו-למידת חיקוי. אין זרוע? העמוד החי מזרים SO-100 אמיתי לנהיגה ללא הרשמה.