SO-100 पर ACT को स्क्रैच से कैसे प्रशिक्षित करें

SO-100 नीतियों में ACT सबसे अलग है। GR00T N1.7 और N1.5 यहाँ से शुरू होते हैं nvidia/GR00T-N1.7-3B और nvidia/GR00T-N1.5-3B, Pi0.5 यहाँ से lerobot/pi05_base। ACT कुछ भी नहीं से शुरू होता है: कोई बेस चेकपॉइंट नहीं है, क्योंकि यह एक फाउंडेशन मॉडल नहीं है। यह लगभग 80 मिलियन पैरामीटर वाला एक ट्रांसफार्मर है जिसे आप अपने हाथ पर, अपनी रोशनी में, एक ही कार्य पर खरोंच से प्रशिक्षित करते हैं।

यही कारण है कि यह 20 मिलीसेकंड में एक नियंत्रण चरण चलाता है जहाँ 3 बिलियन पैरामीटर वाले VLA को 152 से 485 मिलीसेकंड की आवश्यकता होती है, और प्रति रन 4 से 12 के बजाय 1 से 3 USD का खर्च आता है। यह मार्गदर्शिका लेरोबोट के साथ मैन्युअल मार्ग बताती है, एक SO-100 पर: रिकॉर्ड, act कॉन्फ़िग, क्या chunk_size और n_action_steps नियंत्रित करते हैं, 100000 स्टेप शेड्यूल, रोलआउट। फिर AY-Robots पर वही काम, जिसमें यह भी शामिल है कि प्लेटफ़ॉर्म कहाँ मदद नहीं करता है।

ACT वास्तव में क्या है

एक्शन चंकिंग विद ट्रांसफॉर्मर्स (Action Chunking with Transformers) ALOHA पेपर से आया है, Learning Fine-Grained Bimanual Manipulation with Low-Cost Hardware, झाओ, कुमार, लेविन और फिन द्वारा, arXiv, 23 अप्रैल 2023 को प्रकाशित। यह रिग 50 हर्ट्ज़ पर रिकॉर्ड करता है जिसमें चार वेबकैम 480x640 रेजोल्यूशन पर 30 एफपीएस पर स्ट्रीम करते हैं: दो ग्रिपर पर, एक ऊपर और एक सामने। एब्स्ट्रैक्ट में 10 मिनट के प्रदर्शनों से छह कौशलों में 80 से 90 प्रतिशत सफलता का दावा किया गया है, जिनमें एक पारदर्शी मसाला कप खोलना और बैटरी डालना शामिल है।

रिकॉर्डिंग सत्र की योजना बनाते समय मुख्य भाग अधिक उपयोगी होता है: प्रति कार्य 50 प्रदर्शन, थ्रेड वेल्क्रो के लिए 100 को छोड़कर, जिसमें 10 से 20 मिनट का डेटा और रीसेट गिनने के बाद 30 से 60 मिनट का वास्तविक समय लगता है। सफलता भी एक समान नहीं है: थ्रेड वेल्क्रो 20 प्रतिशत पर समाप्त होता है, पुट ऑन शू 92 पर, कप ओपन 84 पर, प्रेप टेप 64 पर।

एक्शन चंकिंग ही पूरा विचार है

सामान्य व्यवहारिक क्लोनिंग एक अवलोकन को एक क्रिया से मैप करती है, और त्रुटियां बढ़ती जाती हैं: एक विचलन हाथ को वितरण से बाहर कर देता है, जिससे एक खराब क्रिया उत्पन्न होती है, और तीस चरणों के बाद ग्रिपर वस्तु के कहीं भी पास नहीं होता है। एक्शन चंकिंग एक साथ k क्रियाओं की भविष्यवाणी करता है और उन्हें निष्पादित करता है, जिससे प्रभावी क्षितिज k के एक कारक से कम हो जाता है। यह मानव डेटा के लिए विशिष्ट एक परेशानी को भी संभालता है: टेलीऑपरेटर रुकते हैं, और एक एकल-चरण मार्कोवियन पॉलिसी एक ऐसे ठहराव को मॉडल नहीं कर सकता जो पहले क्या हुआ उस पर निर्भर करता है।

पेपर k को सिद्ध करने के बजाय उसे एब्लेट करता है। टेम्पोरल एन्सेम्बलिंग बंद होने पर, चार सेटिंग्स पर औसत, सफलता k = 1 पर 1 प्रतिशत से बढ़कर k = 100 पर 44 प्रतिशत हो जाती है, फिर 200 और 400 पर कम हो जाती है क्योंकि पॉलिसी ओपन-लूप नियंत्रण के करीब पहुंचती है। वह वक्र ही कारण है कि डिफ़ॉल्ट 100 है।

• chunk_size: डिकोडर प्रति फॉरवर्ड पास में कितने भविष्य के कार्यों की भविष्यवाणी करता है। डिफ़ॉल्ट 100।
• n_action_steps: फिर से क्वेरी करने से पहले आप उनमें से कितने निष्पादित करते हैं। डिफ़ॉल्ट 100, इसलिए lerobot पूरे चंक को ओपन लूप में चलाता है।
• lerobot n_action_steps <= chunk_size को मान्य करता है और यदि आप इसे उल्टा करते हैं तो ValueError उठाता है।

परिचालन की दृष्टि से जो मायने रखता है वह है chunk_size को फ्रेम दर से विभाजित करना। 30 fps पर lerobot के SO-100 उदाहरणों का उपयोग करते हुए, 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 चुनें जब कार्य और दृश्य निश्चित हों और गति तेज़ और सटीक होनी चाहिए। एक चुनें जब एक चेकपॉइंट को कई निर्देशों को कवर करना हो। दो पृष्ठ निर्णय को आमने-सामने रखते हैं: और । प्रकाशित बेंचमार्क के लिए, हर संख्या को उसके स्रोत से जोड़ता है।

शुरू करने से पहले आपको क्या चाहिए

एक फॉलोअर आर्म, एक लीडर आर्म के लिए, कम से कम एक कैमरा, एक 24 GB GPU। ACT केवल इमेज और जॉइंट पोजीशन पढ़ता है। दो कैमरे सबसे उपयुक्त हैं: चीजों की स्थिति के लिए एक निश्चित सामने का दृश्य, और कलाई का कैमरा यह देखने के लिए कि क्या छूने वाला है, जैसा कि ALOHA में है।

खाली आर्म से रिकॉर्ड किए गए डेटासेट तक

नीचे दिया गया प्रवाह lerobot 0.6.x है। यदि आपके पास एक कैलिब्रेटेड आर्म और एक डेटासेट है तो इसे छोड़ दें। अन्यथा SO-100 आरंभ करने की मार्गदर्शिका असेंबली को कवर करती है, रिकॉर्डिंग वॉकथ्रू कैप्चर को कवर करता है और डेटासेट दस्तावेज़ प्रारूप को कवर करते हैं।

1. 1
   सही एक्स्ट्रा के साथ लेरोबोट इंस्टॉल करें

   रिकॉर्डिंग के लिए core_scripts, ट्रेनिंग के लिए training, Feetech सर्वो के लिए feetech की आवश्यकता होती है। Python 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 पोर्ट खोजें

   दोनों आर्म्स को प्लग इन करके चलाएं, प्रॉम्प्ट होने पर एक को अनप्लग करें। Linux पर आपको नोड अनुमतियाँ खोलने की आवश्यकता हो सकती है।

   bash

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

3. 3
   मोटर आईडी और बॉडरेट सेट करें

   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
   दोनों आर्म्स को कैलिब्रेट करें

   प्रत्येक जॉइंट को उसकी रेंज के मध्य में सेट करें, एंटर दबाएं, फिर प्रत्येक को उसकी पूरी रेंज में घुमाएं। कैलिब्रेशन एक आर्म पर प्रशिक्षित पॉलिसी को दूसरे पर चलाने की अनुमति देता है। वही 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
   कैमरा चालू करके एक बार टेलीऑपरेट करें

   लेरोबोट का सामान्य नियम: आपको केवल कैमरा छवियों को देखकर कार्य करने में सक्षम होना चाहिए। यदि आप नहीं कर सकते, तो 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 ने प्रति कार्य यही उपयोग किया था। लेरोबोट प्रति वस्तु स्थान 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-विशिष्ट सब कुछ पहले से ही डिफ़ॉल्ट है, यही कारण है कि lerobot ACT पेज उन्हें शुरू करने के लिए कहता है।

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 तक) और एक अंतिम सिमलिंक छोड़ता है। उन सभी को रखें: सबसे अच्छी पॉलिसी अक्सर अंतिम वाली नहीं होती है।

अवधि: पेपर में 11 GB RTX 2080 Ti पर लगभग 5 घंटे, lerobot के ACT पेज के अनुसार 100k स्टेप्स के लिए कुछ घंटे, AY-Robots 24 GB टियर पर 2 से 5 घंटे। इसे कम न करें। संदर्भ रेपो के 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

अंतिम मॉडल के बजाय एक चेकपॉइंट को पिन करने के लिए, जोड़ें --policy.pretrained_revision। इसके लिए रन को --save_checkpoint_to_hub=true से शुरू होना चाहिए था, डिफ़ॉल्ट रूप से बंद: इसके बिना lerobot अंतिम मॉडल और कुछ भी नहीं धकेलता है। इसके साथ, प्रत्येक चेकपॉइंट को उसके शून्य-पैडेड स्टेप के साथ टैग किया जाता है, इसलिए --policy.pretrained_revision=060000 60000 स्टेप वाले को पुनर्प्राप्त करता है। वास्तविक आर्म पर इसकी 100000 के मुकाबले तुलना करना सबसे सस्ता उपलब्ध प्रयोग है।

एक ही चेकपॉइंट तक पहुँचने के दो रास्ते

ऊपर दिया गया सब कुछ मैन्युअल तरीका है और यह काम करता है। प्लेटफ़ॉर्म का तरीका GPU या Python एनवायरनमेंट का मालिक न होने के बदले नियंत्रण का त्याग करता है।

# 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 पर एक वास्तविक ठहराव एक चंक बाउंड्री पर आता है, 30 एफपीएस पर हर 3.3 सेकंड में एक दृश्यमान ठहराव। जानने के लिए दो और बातें: एक अकेला निष्क्रिय जोड़ आमतौर पर एक सर्वर आईडी जो कभी नहीं लिखी गई, और एक ग्रिपर जो पास आता है लेकिन कभी बंद नहीं होता का मतलब है प्रदर्शनों में ग्रिपर रेंज बहुत कम। पूर्ण सूचकांक: विफलता मोड पृष्ठ।

एक रन की लागत क्या है

यह ACT से शुरू करने का तर्क है, भले ही आप बाद में VLA चाहते हों। एक असफल ACT रन की लागत एक कॉफी के बराबर होती है और घंटों के भीतर आपको बता देता है कि आपके डेटासेट में कार्य शामिल है या नहीं। एक असफल GR00T रन की लागत उसी सबक के लिए चार गुना होती है। बाद में GR00T N1.7 या SmolVLA पर जाना एक रूप परिवर्तन है, पुनर्निर्माण नहीं। पृष्ठभूमि: विजन-लैंग्वेज-एक्शन मॉडल, संपूर्ण SO-100 गाइड, अपनी पहली पॉलिसी को प्रशिक्षित करें और इमिटेशन लर्निंग। कोई आर्म नहीं? लाइव पेज बिना साइन अप किए एक वास्तविक SO-100 को चलाने के लिए स्ट्रीम करता है।