सुरुवातीपासून 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 ms मध्ये एक नियंत्रण पायरी चालवते, जिथे 3 अब्ज पॅरामीटर VLA ला 152 ते 485 ms लागतात आणि प्रति रन 4 ते 12 USD ऐवजी 1 ते 3 USD खर्च येतो. हे मार्गदर्शक लेरोबॉट सह एसओ-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 Hz वर रेकॉर्ड करते, ज्यामध्ये चार वेबकॅम 480x640 रिझोल्यूशनवर 30 fps ने स्ट्रीम करतात: दोन ग्रिपरवर, एक वर आणि एक समोर. अमूर्त (abstract) मध्ये 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 ला सिद्ध करण्याऐवजी त्याचे ॲब्लेशन करतो. टेम्पोरल एन्सेम्बलिंग बंद असताना, चार सेटिंग्जमध्ये सरासरी काढल्यास, k = 1 असताना 1 टक्क्यांवरून k = 100 असताना 44 टक्क्यांपर्यंत यश वाढते, नंतर पॉलिसी ओपन-लूप कंट्रोलच्या जवळ आल्यावर 200 आणि 400 वर कमी होते. तो वक्र (curve) हेच कारण आहे की डिफॉल्ट 100 आहे.

• chunk_size: डिकोडर प्रति फॉरवर्ड पास किती भविष्यातील क्रियांचा अंदाज लावतो. Default 100.
• n_action_steps: पुन्हा क्वेरी करण्यापूर्वी तुम्ही त्यापैकी किती क्रिया कार्यान्वित करता. Default 100, त्यामुळे lerobot संपूर्ण चंक ओपन लूपमध्ये चालवतो.
• lerobot प्रमाणित करतो n_action_steps <= chunk_size आणि जर तुम्ही ते उलट केले तर ValueError वाढवतो.

कार्यक्षमतेच्या दृष्टीने महत्त्वाचे म्हणजे chunk_size भागिले फ्रेम दर. lerobot च्या SO-100 उदाहरणांमध्ये वापरल्या जाणाऱ्या 30 fps वर, 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 पोर्ट शोधा

   दोन्ही आर्म्स प्लग इन करून चालवा, प्रॉम्प्ट केल्यावर एक अनप्लग करा. लिनक्सवर तुम्हाला नोड परवानग्या उघडण्याची आवश्यकता असू शकते.

   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 किंवा पायथन वातावरण स्वतःकडे नसताना नियंत्रणाची अदलाबदल करतो.

# 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 fps वर दर 3.3 सेकंदांनी एक दृश्यमान विराम. आणखी दोन गोष्टी जाणून घ्या: एकच मृत जॉइंट सहसा कधीही न लिहिलेला सर्वो आयडी, आणि जवळ येणारा पण कधीही न बंद होणारा ग्रिपर म्हणजे प्रात्यक्षिकांमध्ये ग्रिपरची श्रेणी खूप कमी आहे. पूर्ण अनुक्रमणिका: अपयश मोड पृष्ठे.

एका रनचा खर्च किती

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