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 செலவாகிறது. இந்த வழிகாட்டி கையேடு வழியை லெரோபோட் உடன் ஒரு SO-100 இல் விவரிக்கிறது: பதிவு, act உள்ளமைவு, எதை chunk_size மற்றும் n_action_steps கட்டுப்படுத்துகின்றன, 100000 படி அட்டவணை, ரோல்அவுட். பின்னர் AY-Robots இல் அதே பணி, தளம் உதவாத இடங்கள் உட்பட.

ACT உண்மையில் என்ன?

ஆக்சன் சங்கிங் வித் டிரான்ஸ்ஃபார்மர்ஸ் (Action Chunking with Transformers) என்பது ALOHA ஆய்வுக் கட்டுரையில் இருந்து வந்தது, குறைந்த செலவிலான வன்பொருளுடன் நுட்பமான இருகைப் பயன்பாட்டைக் கற்றல், Zhao, Kumar, Levine மற்றும் Finn ஆகியோரால், arXiv, 23 ஏப்ரல் 2023 அன்று வெளியிடப்பட்டது. இந்த அமைப்பு 50 Hz வேகத்தில் பதிவு செய்கிறது, நான்கு வெப்கேம்கள் 480x640 தெளிவுத்திறனில் 30 fps வேகத்தில் ஒளிபரப்புகின்றன: இரண்டு கிரிப்பர்களில், ஒன்று மேலே, ஒன்று முன்புறம். சுருக்கம் 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 இல் குறைகிறது. அந்த வளைவுதான் இயல்புநிலை 100 ஆக இருப்பதற்கான காரணம்.

• chunk_size: ஒரு ஃபார்வர்ட் பாஸில் டீகோடர் எத்தனை எதிர்காலச் செயல்களைக் கணிக்கிறது. இயல்புநிலை 100.
• n_action_steps: மீண்டும் வினவுவதற்கு முன் அவற்றில் எத்தனை செயல்களை நீங்கள் செயல்படுத்துகிறீர்கள். இயல்புநிலை 100, எனவே lerobot முழு சங்கை திறந்த சுழற்சியில் இயக்குகிறது.
• lerobot ஆனது n_action_steps <= chunk_size என்பதைச் சரிபார்க்கிறது மற்றும் நீங்கள் அதைத் தலைகீழாகப் பெற்றால் ஒரு ValueError ஐ எழுப்புகிறது.

செயல்பாட்டு ரீதியாக முக்கியமானது chunk_size ஐ frame rate ஆல் வகுப்பது. lerobot இன் SO-100 எடுத்துக்காட்டுகள் பயன்படுத்தும் 30 fps இல், 100 செயல்களின் ஒரு சங் ஒரு அவதானிப்பிலிருந்து சுமார் 3.3 வினாடிகளை உறுதிப்படுத்துகிறது. அந்த சாளரத்திற்குள் பணிக்கு ஒரு திருத்தம் தேவைப்பட்டால், chunk_size ஐக் குறைக்காமல், n_action_steps ஐக் குறைக்கவும்: நீங்கள் நீண்ட கணிப்பைக் வைத்துக்கொண்டு அடிக்கடி மீண்டும் அவதானிக்கிறீர்கள்.

# 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
   சரியான கூடுதல் அம்சங்களுடன் lerobot ஐ நிறுவவும்

   பதிவு செய்வதற்கு 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
   இரண்டு கைகளையும் அளவீடு செய்யவும்

   ஒவ்வொரு மூட்டையும் அதன் வரம்பின் நடுப்பகுதிக்கு அமைக்கவும், 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-க்கு குறிப்பிட்ட அனைத்தும் ஏற்கனவே இயல்புநிலையாக உள்ளன, அதனால்தான் 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 படி இயக்கத்தில் இழப்பு வளைவு மட்டுமே மலிவான சமிக்ஞையாகும். அட்டவணை ACTConfig-ல் இருந்து வரவில்லை, lerobot-இன் பயிற்சி உள்ளமைவில் இருந்து வருகிறது: 100000 படிகள், தொகுதி 8, விதை 1000, ஒவ்வொரு 20000 படிகளுக்கும் ஒரு சரிபார்ப்பு புள்ளி, ஒவ்வொரு 200-க்கும் பதிவுசெய்தல்.

ஒரு முழுமையான இயக்கம் ஐந்து சரிபார்ப்பு புள்ளி கோப்பகங்களை (020000 முதல் 100000 வரை) மற்றும் ஒரு last சிம்லிங்கை விட்டுச்செல்கிறது. அனைத்தையும் வைத்திருங்கள்: சிறந்த கொள்கை பெரும்பாலும் கடைசியாக இருப்பது அல்ல.

கால அளவு: ஆய்வறிக்கையின்படி 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 வினாடிக்கும் ஒரு தெளிவான இடைநிறுத்தம். மேலும் இரண்டு தெரிந்து கொள்ள வேண்டியவை: ஒரு ஒற்றை செயலிழந்த மூட்டு பொதுவாக ஒரு servo id எழுதப்படாதது, மற்றும் அணுகும் ஆனால் ஒருபோதும் மூடப்படாத ஒரு கிரிப்பர் என்பது செயல்விளக்கங்களில் மிகக் குறைந்த கிரிப்பர் வரம்பைக் குறிக்கிறது. முழு அட்டவணை: தோல்வி முறை பக்கங்கள்.

ஒரு ஓட்டத்திற்கு என்ன செலவாகும்

நீங்கள் பின்னர் VLA விரும்பினாலும் ACT உடன் தொடங்குவதற்கான காரணம் இதுதான். ஒரு தோல்வியுற்ற ACT இயக்கம் ஒரு காபியின் விலைக்கு சமம், மேலும் உங்கள் தரவுத்தொகுப்பில் பணி உள்ளதா என்பதை சில மணிநேரங்களுக்குள் உங்களுக்குத் தெரிவிக்கும். ஒரு தோல்வியுற்ற GR00T இயக்கம் அதே பாடத்திற்கு நான்கு மடங்கு செலவாகும். மேலே நகர்வது GR00T N1.7 அல்லது SmolVLA பின்னர் ஒரு வடிவ மாற்றம், மறுசீரமைப்பு அல்ல. பின்னணி: பார்வை-மொழி-செயல் மாதிரி, தி முழுமையான SO-100 வழிகாட்டி, உங்கள் முதல் கொள்கையைப் பயிற்றுவிக்கவும் மற்றும் அனுபவக் கற்றல். கை இல்லையா? நேரடிப் பக்கம் பதிவு செய்யாமல் ஒரு உண்மையான SO-100 ஐ இயக்க ஸ்ட்ரீம் செய்கிறது.